Make the algorithm descend into delimited TTs.

Author: LeoTestard

src/libcollections/lib.rs

@@ -43,6 +43,7 @@
 #![feature(pattern)]
 #![feature(placement_in)]
 #![feature(placement_new_protocol)]
+#![feature(rustc_attrs)]
 #![feature(shared)]
 #![feature(slice_patterns)]
 #![feature(specialization)]

src/libcollections/macros.rs

@@ -42,6 +42,7 @@
 #[macro_export]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow_internal_unstable]
+#[rustc_unsafe_macro]
 macro_rules! vec {
     ($elem:expr; $n:expr) => (
         $crate::vec::from_elem($elem, $n)
@@ -57,6 +58,7 @@ macro_rules! vec {
 // `slice::into_vec`  function which is only available with cfg(test)
 // NB see the slice::hack module in slice.rs for more information
 #[cfg(test)]
+#[rustc_unsafe_macro]
 macro_rules! vec {
     ($elem:expr; $n:expr) => (
         $crate::vec::from_elem($elem, $n)

src/libsyntax/ext/expand.rs

@@ -279,6 +279,7 @@ fn expand_mac_invoc<T>(mac: ast::Mac, ident: Option<Ident>, attrs: Vec<ast::Attr
                     }
                 });
 
+                let check = !attr::contains_name(&attrs, "rustc_unsafe_macro");
                 // DON'T mark before expansion.
                 fld.cx.insert_macro(ast::MacroDef {
                     ident: ident,
@@ -290,7 +291,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);
+                }, check);
 
                 // macro_rules! has a side effect but expands to nothing.
                 fld.cx.bt_pop();
@@ -911,7 +912,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, true);
+                        self.cx.insert_macro(def, false);
                     }
                 } else {
                     let at_crate_root = ::std::mem::replace(&mut self.at_crate_root, false);

src/libsyntax/ext/tt/macro_rules.rs

@@ -116,7 +116,7 @@ impl<'a> MacResult for ParserAnyMacro<'a> {
 
 
     fn make_stmts(self: Box<ParserAnyMacro<'a>>)
-                 -> Option<SmallVector<ast::Stmt>> {
+                  -> Option<SmallVector<ast::Stmt>> {
         let mut ret = SmallVector::zero();
         loop {
             let mut parser = self.parser.borrow_mut();
@@ -250,7 +250,7 @@ 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,
-                    imported: bool) -> SyntaxExtension {
+                    check_macro: bool) -> SyntaxExtension {
 
     let lhs_nm =  gensym_ident("lhs");
     let rhs_nm =  gensym_ident("rhs");
@@ -306,7 +306,7 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
         MatchedSeq(ref s, _) => {
             s.iter().map(|m| match **m {
                 MatchedNonterminal(NtTT(ref tt)) => {
-                    if !imported {
+                    if check_macro {
                         valid &= check_lhs_nt_follows(cx, tt);
                     }
                     (**tt).clone()
@@ -317,17 +317,20 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
         _ => cx.span_bug(def.span, "wrong-structured lhs")
     };
 
-    if !imported {
+    if check_macro {
         '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;
+                match check_lhs_firsts(cx, lhs, lhs_) {
+                    AnalysisResult::Error => {
+                        cx.struct_span_err(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;
+                    }
+                    _ => ()
                 }
             }
         }
@@ -358,7 +361,8 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
     NormalTT(exp, Some(def.span), def.allow_internal_unstable)
 }
 
-fn check_lhs_firsts(cx: &ExtCtxt, lhs: &TokenTree, lhs_: &TokenTree) -> bool {
+fn check_lhs_firsts(cx: &ExtCtxt, lhs: &TokenTree, lhs_: &TokenTree)
+                    -> AnalysisResult {
     match (lhs, lhs_) {
         (&TokenTree::Delimited(_, ref tta),
          &TokenTree::Delimited(_, ref ttb)) =>
@@ -578,7 +582,20 @@ fn first_sets_disjoints(ma: &TokenTree, mb: &TokenTree,
     }
 }
 
-fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree]) -> bool {
+// the result of the FIRST set analysis.
+// * Ok -> an obvious disambiguation has been found
+// * Unsure -> no problem between those matchers but analysis should continue
+// * Error -> maybe a problem. should be accepted only if an obvious
+//   disambiguation is found later
+enum AnalysisResult {
+    Ok,
+    Unsure,
+    Error
+}
+
+fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree])
+                        -> AnalysisResult {
+    use self::AnalysisResult::*;
     let mut need_disambiguation = false;
 
     // first compute the FIRST sets. FIRST sets for tokens, delimited TTs and NT
@@ -601,7 +618,7 @@ fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree]) -> boo
 
         if first_sets_disjoints(&ta, &tb, &firsts_a, &firsts_b) {
             // accept the macro
-            return true
+            return Ok
         }
 
         // i.e. A or B is either a repeated sequence or a NT matcher that is
@@ -611,22 +628,26 @@ fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree]) -> boo
             (&TokenTree::Token(_, MatchNt(_, nta)),
              &TokenTree::Token(_, MatchNt(_, ntb))) =>
                 if !(nt_is_single_tt(nta) && nt_is_single_tt(ntb)) {
-                    return false
+                    return Error
                 },
 
             (&TokenTree::Token(_, MatchNt(_, nt)), _) if !nt_is_single_tt(nt) =>
-                return false,
+                return Error,
 
             // super specific corner case: if one arm is always one token,
             // followed by the end of the macro invocation, then we can accept
             // it.
 
             (&TokenTree::Sequence(_, _), _) |
             (_, &TokenTree::Sequence(_, _)) =>
-                return only_simple_tokens(&ma[idx_a..]) && !need_disambiguation,
+                return if only_simple_tokens(&ma[idx_a..]) && !need_disambiguation {
+                    Unsure
+                } else { Error },
 
             (_ ,&TokenTree::Token(_, MatchNt(_, nt))) if !nt_is_single_tt(nt) =>
-                return only_simple_tokens(&ma[idx_a..]) && !need_disambiguation,
+                return if only_simple_tokens(&ma[idx_a..]) && !need_disambiguation {
+                    Unsure
+                } else { Error },
 
             _ => ()
         }
@@ -690,12 +711,17 @@ fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree]) -> boo
                 continue
             }
 
-            (&TokenTree::Delimited(..), &TokenTree::Delimited(..)) => {
+            (&TokenTree::Delimited(_, ref d1),
+             &TokenTree::Delimited(_, ref d2)) => {
                 // they have the same delim. as above.
-                // FIXME: we could search for disambiguation *inside* the
-                // delimited TTs
-                need_disambiguation = true;
-                continue
+                match check_matcher_firsts(cx, &d1.tts, &d2.tts) {
+                    Ok => return Ok,
+                    Unsure => continue,
+                    Error => {
+                        need_disambiguation = true;
+                        continue
+                    }
+                }
             }
 
             // cannot happen. either they're the same token or their FIRST sets
@@ -713,12 +739,12 @@ fn check_matcher_firsts(cx: &ExtCtxt, ma: &[TokenTree], mb: &[TokenTree]) -> boo
         // reject conservatively.
         // FIXME: if we are not at the end of the other arm, and that the other
         // arm cannot derive empty, I think we could accept...?
-        false
+        Error
     } else {
         // either A is strictly included in B and the other inputs that match B
         // will never match A, or B is included in or equal to A, which means
         // it's unreachable. this is not our problem. accept.
-        true
+        Unsure
     }
 }
 

src/libsyntax/feature_gate.rs

@@ -510,6 +510,11 @@ pub const KNOWN_ATTRIBUTES: &'static [(&'static str, AttributeType, AttributeGat
                                                           across crates and will never be stable",
                                                           cfg_fn!(rustc_attrs))),
 
+    ("unsafe_macro", Normal, Gated("rustc_attrs",
+                                   "unsafe_macro allows to write \
+                                    non-future proof macros",
+                                   cfg_fn!(rustc_attrs))),
+
     ("allow_internal_unstable", Normal, Gated("allow_internal_unstable",
                                               EXPLAIN_ALLOW_INTERNAL_UNSTABLE,
                                               cfg_fn!(allow_internal_unstable))),