Auto merge of #37732 - jseyfried:use_extern_macros, r=nrc

Support `use`ing externally defined macros behind `#![feature(use_extern_macros)]`

With `#![feature(use_extern_macros)]`,
 - A name collision between macros from different upstream crates is much less of an issue since we can `use` the macros in different submodules or rename with `as`.
 - We can reexport macros with `pub use`, so `#![feature(macro_reexport)]` is no longer needed.
 - These reexports are allowed in any module, so crates can expose a macro-modular interface.

If a macro invocation can resolve to both a `use` import and a `macro_rules!` or `#[macro_use]`, it is an ambiguity error.

r? @nrc

src/test/compile-fail/blind-item-block-item-shadow.rs

@@ -14,6 +14,6 @@ fn main() {
     {
         struct Bar;
         use foo::Bar;
-        //~^ ERROR a value named `Bar` has already been defined in this block
+        //~^ ERROR a type named `Bar` has already been defined in this block
     }
 }

src/test/compile-fail/double-type-import.rs

@@ -11,7 +11,7 @@
 mod foo {
     pub use self::bar::X;
     use self::bar::X;
-    //~^ ERROR a value named `X` has already been imported in this module
+    //~^ ERROR a type named `X` has already been imported in this module
 
     mod bar {
         pub struct X;

src/test/compile-fail/imports/auxiliary/two_macros.rs

@@ -0,0 +1,15 @@
+// Copyright 2016 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.
+
+#[macro_export]
+macro_rules! m { ($($t:tt)*) => { $($t)* } }
+
+#[macro_export]
+macro_rules! n { ($($t:tt)*) => { $($t)* } }

src/test/compile-fail/imports/duplicate.rs

@@ -46,9 +46,9 @@ mod g {
 fn main() {
     e::foo();
     f::foo(); //~ ERROR `foo` is ambiguous
-              //~| NOTE Consider adding an explicit import of `foo` to disambiguate
+              //~| NOTE consider adding an explicit import of `foo` to disambiguate
     g::foo(); //~ ERROR `foo` is ambiguous
-              //~| NOTE Consider adding an explicit import of `foo` to disambiguate
+              //~| NOTE consider adding an explicit import of `foo` to disambiguate
 }
 
 mod ambiguous_module_errors {

src/test/compile-fail/imports/macros.rs

@@ -0,0 +1,55 @@
+// Copyright 2016 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.
+
+// aux-build:two_macros.rs
+
+#![feature(item_like_imports, use_extern_macros)]
+
+extern crate two_macros; // two identity macros `m` and `n`
+
+mod foo {
+    pub use two_macros::n as m;
+}
+
+mod m1 {
+    m!(use two_macros::*;);
+    use foo::m; // This shadows the glob import
+}
+
+mod m2 {
+    use two_macros::*; //~ NOTE could also resolve
+    m! { //~ ERROR ambiguous
+         //~| NOTE macro-expanded macro imports do not shadow
+        use foo::m; //~ NOTE could resolve to the name imported here
+                    //~^^^ NOTE in this expansion
+    }
+}
+
+mod m3 {
+    use two_macros::m; //~ NOTE could also resolve
+    fn f() {
+        use two_macros::n as m; // This shadows the above import
+        m!();
+    }
+
+    fn g() {
+        m! { //~ ERROR ambiguous
+             //~| NOTE macro-expanded macro imports do not shadow
+            use two_macros::n as m; //~ NOTE could resolve to the name imported here
+                                    //~^^^ NOTE in this expansion
+        }
+    }
+}
+
+mod m4 {
+    macro_rules! m { () => {} } //~ NOTE could resolve to the macro defined here
+    use two_macros::m; //~ NOTE could also resolve to the macro imported here
+    m!(); //~ ERROR ambiguous
+}