Typecheck the plugin registrar

Fixes rust-lang#14841.

Author: kmcallister

src/librustc/driver/driver.rs

@@ -376,11 +376,6 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
     time(time_passes, "looking for entry point", (),
          |_| middle::entry::find_entry_point(&sess, &ast_map));
 
-    sess.plugin_registrar_fn.set(
-        time(time_passes, "looking for plugin registrar", (), |_|
-            plugin::build::find_plugin_registrar(
-                sess.diagnostic(), krate)));
-
     let (freevars, capture_modes) =
         time(time_passes, "freevar finding", (), |_|
              freevars::annotate_freevars(&def_map, krate));
@@ -454,6 +449,9 @@ pub fn phase_3_run_analysis_passes<'tcx>(sess: Session,
                                   &reachable_map)
     });
 
+    time(time_passes, "looking for plugin registrar", (), |_|
+        plugin::build::find_plugin_registrar(&ty_cx, krate));
+
     time(time_passes, "lint checking", (), |_|
          lint::check_crate(&ty_cx, &exported_items));
 

src/librustc/plugin/build.rs

@@ -10,11 +10,10 @@
 
 //! Used by `rustc` when compiling a plugin crate.
 
-use syntax::ast;
-use syntax::attr;
+use middle::ty;
+
+use syntax::{ast, abi, attr, visit};
 use syntax::codemap::Span;
-use syntax::diagnostic;
-use syntax::visit;
 use syntax::visit::Visitor;
 
 struct RegistrarFinder {
@@ -38,24 +37,64 @@ impl<'v> Visitor<'v> for RegistrarFinder {
 }
 
 /// Find the function marked with `#[plugin_registrar]`, if any.
-pub fn find_plugin_registrar(diagnostic: &diagnostic::SpanHandler,
-                             krate: &ast::Crate) -> Option<ast::NodeId> {
+pub fn find_plugin_registrar(tcx: &ty::ctxt, krate: &ast::Crate) {
     let mut finder = RegistrarFinder { registrars: Vec::new() };
     visit::walk_crate(&mut finder, krate);
 
     match finder.registrars.len() {
-        0 => None,
+        0 => (),
         1 => {
-            let (node_id, _) = finder.registrars.pop().unwrap();
-            Some(node_id)
-        },
+            let (id, span) = finder.registrars.pop().unwrap();
+            tcx.sess.plugin_registrar_fn.set(Some(id));
+            typecheck_plugin_registrar(tcx, id, span);
+        }
         _ => {
-            diagnostic.handler().err("multiple plugin registration functions found");
+            tcx.sess.err("multiple plugin registration functions found");
             for &(_, span) in finder.registrars.iter() {
-                diagnostic.span_note(span, "one is here");
+                tcx.sess.span_note(span, "one is here");
+            }
+        }
+    }
+
+    tcx.sess.abort_if_errors();
+}
+
+/// Typecheck the plugin registrar.
+fn typecheck_plugin_registrar(tcx: &ty::ctxt, id: ast::NodeId, span: Span) {
+    match ty::get(ty::node_id_to_type(tcx, id)).sty {
+        ty::ty_bare_fn(ty::BareFnTy { fn_style: ast::NormalFn, abi: abi::Rust, ref sig }) => {
+            match sig.inputs.as_slice() {
+                [arg_t] => match ty::get(arg_t).sty {
+                    ty::ty_rptr(_, ty::mt { mutbl: ast::MutMutable, ty })
+                        if ty_is_registry(tcx, ty) => (),
+                    _ => tcx.sess.span_err(span, "plugin registrar arg should be \
+                                                  &mut rustc::plugin::Registry"),
+                },
+                _ => tcx.sess.span_err(span, "plugin registrar should have one argument"),
             }
-            diagnostic.handler().abort_if_errors();
-            unreachable!();
+            match ty::get(sig.output).sty {
+                ty::ty_nil => (),
+                _ => tcx.sess.span_err(span, "plugin registrar should not return anything"),
+            }
+        }
+
+        _ => tcx.sess.span_err(span, "plugin registrar should be a normal Rust function"),
+    }
+}
+
+/// Check if the given type is rustc::plugin::Registry.
+fn ty_is_registry(tcx: &ty::ctxt, ty: ty::t) -> bool {
+    match ty::get(ty).sty {
+        ty::ty_struct(def, ref sub) => {
+            if !sub.is_noop() {
+                return false;
+            }
+
+            // Because users can bind any crate at any name, this check is
+            // neither sound nor complete. But it will catch the vast majority
+            // of mistakes.
+            ty::item_path_str(tcx, def).as_slice() == "rustc::plugin::registry::Registry"
         }
+        _ => false,
     }
 }

src/librustc/plugin/mod.rs

@@ -38,9 +38,6 @@
  * fn expand_mymacro(...) {  // details elided
  * ```
  *
- * WARNING: We currently don't check that the registrar function
- * has the appropriate type!
- *
  * To use a plugin while compiling another crate:
  *
  * ```rust

src/test/compile-fail/plugin-registrar-wrong-type-1.rs

@@ -0,0 +1,18 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: plugin registrar
+
+#![feature(plugin_registrar)]
+
+#[plugin_registrar]
+pub fn reg() {}
+
+fn main() {}

src/test/compile-fail/plugin-registrar-wrong-type-2.rs

@@ -0,0 +1,20 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: plugin registrar
+
+#![feature(plugin_registrar)]
+
+extern crate rustc;
+
+#[plugin_registrar]
+pub fn reg(r: &mut rustc::plugin::Registry, x: int) {}
+
+fn main() {}

src/test/compile-fail/plugin-registrar-wrong-type-3.rs

@@ -0,0 +1,20 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: plugin registrar
+
+#![feature(plugin_registrar)]
+
+pub struct Registry;
+
+#[plugin_registrar]
+pub fn reg(x: &mut Registry) {}
+
+fn main() {}

src/test/compile-fail/plugin-registrar-wrong-type-4.rs

@@ -0,0 +1,20 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// error-pattern: plugin registrar
+
+#![feature(plugin_registrar)]
+
+extern crate rustc;
+
+#[plugin_registrar]
+pub fn reg(x: &mut rustc::plugin::Registry) -> int { 3 }
+
+fn main() {}