Do not future-proof check imported macros.

Author: LeoTestard

src/libsyntax/ext/base.rs

@@ -715,12 +715,12 @@ impl<'a> ExtCtxt<'a> {
         }
     }
 
-    pub fn insert_macro(&mut self, def: ast::MacroDef) {
+    pub fn insert_macro(&mut self, def: ast::MacroDef, imported: bool) {
         if def.export {
             self.exported_macros.push(def.clone());
         }
         if def.use_locally {
-            let ext = macro_rules::compile(self, &def);
+            let ext = macro_rules::compile(self, &def, imported);
             self.syntax_env.insert(def.ident.name, ext);
         }
     }

src/libsyntax/ext/expand.rs

@@ -290,7 +290,7 @@ fn expand_mac_invoc<T>(mac: ast::Mac, ident: Option<Ident>, attrs: Vec<ast::Attr
                     export: attr::contains_name(&attrs, "macro_export"),
                     allow_internal_unstable: attr::contains_name(&attrs, "allow_internal_unstable"),
                     attrs: attrs,
-                });
+                }, false);
 
                 // macro_rules! has a side effect but expands to nothing.
                 fld.cx.bt_pop();
@@ -911,7 +911,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
                     // We need to error on `#[macro_use] extern crate` when it isn't at the
                     // crate root, because `$crate` won't work properly.
                     for def in self.cx.loader.load_crate(item, self.at_crate_root) {
-                        self.cx.insert_macro(def);
+                        self.cx.insert_macro(def, true);
                     }
                 } else {
                     let at_crate_root = ::std::mem::replace(&mut self.at_crate_root, false);

src/libsyntax/ext/tt/macro_rules.rs

@@ -249,7 +249,8 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt,
 
 /// Converts a `macro_rules!` invocation into a syntax extension.
 pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
-                    def: &ast::MacroDef) -> SyntaxExtension {
+                    def: &ast::MacroDef,
+                    imported: bool) -> SyntaxExtension {
 
     let lhs_nm =  gensym_ident("lhs");
     let rhs_nm =  gensym_ident("rhs");
@@ -305,7 +306,9 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
         MatchedSeq(ref s, _) => {
             s.iter().map(|m| match **m {
                 MatchedNonterminal(NtTT(ref tt)) => {
-                    valid &= check_lhs_nt_follows(cx, tt);
+                    if !imported {
+                        valid &= check_lhs_nt_follows(cx, tt);
+                    }
                     (**tt).clone()
                 }
                 _ => cx.span_bug(def.span, "wrong-structured lhs")
@@ -314,16 +317,18 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
         _ => cx.span_bug(def.span, "wrong-structured lhs")
     };
 
-    'a: for (i, lhs) in lhses.iter().enumerate() {
-        for lhs_ in lhses[i + 1 ..].iter() {
-            if !check_lhs_firsts(cx, lhs, lhs_) {
-                cx.struct_span_warn(def.span, "macro is not future-proof")
-                    .span_help(lhs.get_span(), "parsing of this arm is ambiguous...")
-                    .span_help(lhs_.get_span(), "with the parsing of this arm.")
-                    .help("the behaviour of this macro might change in the future")
-                    .emit();
-                //valid = false;
-                break 'a;
+    if !imported {
+        'a: for (i, lhs) in lhses.iter().enumerate() {
+            for lhs_ in lhses[i + 1 ..].iter() {
+                if !check_lhs_firsts(cx, lhs, lhs_) {
+                    cx.struct_span_warn(def.span, "macro is not future-proof")
+                        .span_help(lhs.get_span(), "parsing of this arm is ambiguous...")
+                        .span_help(lhs_.get_span(), "with the parsing of this arm.")
+                        .help("the behaviour of this macro might change in the future")
+                        .emit();
+                    //valid = false;
+                    break 'a;
+                }
             }
         }
     }