Rollup merge of rust-lang#33841 - LeoTestard:macro-sequence-lhs, r=pnkfelix

Reject a LHS formed of a single sequence TT during `macro_rules!` checking.

This was already rejected during expansion. Encountering malformed LHS or RHS during expansion is now considered a bug.

Follow up to rust-lang#33689.

r? @pnkfelix

Note: this can break code that defines such macros but does not use them.

Author: Manishearth

src/libsyntax/ext/tt/macro_rules.rs

@@ -179,15 +179,15 @@ fn generic_extension<'cx>(cx: &'cx ExtCtxt,
     for (i, lhs) in lhses.iter().enumerate() { // try each arm's matchers
         let lhs_tt = match *lhs {
             TokenTree::Delimited(_, ref delim) => &delim.tts[..],
-            _ => cx.span_fatal(sp, "malformed macro lhs")
+            _ => cx.span_bug(sp, "malformed macro lhs")
         };
 
         match TokenTree::parse(cx, lhs_tt, arg) {
             Success(named_matches) => {
                 let rhs = match rhses[i] {
                     // ignore delimiters
                     TokenTree::Delimited(_, ref delimed) => delimed.tts.clone(),
-                    _ => cx.span_fatal(sp, "malformed macro rhs"),
+                    _ => cx.span_bug(sp, "malformed macro rhs"),
                 };
                 // rhs has holes ( `$id` and `$(...)` that need filled)
                 let trncbr = new_tt_reader(&cx.parse_sess().span_diagnostic,
@@ -326,19 +326,14 @@ pub fn compile<'cx>(cx: &'cx mut ExtCtxt,
     NormalTT(exp, Some(def.span), def.allow_internal_unstable)
 }
 
-// why is this here? because of https://github.com/rust-lang/rust/issues/27774
-fn ref_slice<A>(s: &A) -> &[A] { use std::slice::from_raw_parts; unsafe { from_raw_parts(s, 1) } }
-
 fn check_lhs_nt_follows(cx: &mut ExtCtxt, lhs: &TokenTree) -> bool {
     // lhs is going to be like TokenTree::Delimited(...), where the
     // entire lhs is those tts. Or, it can be a "bare sequence", not wrapped in parens.
     match lhs {
         &TokenTree::Delimited(_, ref tts) => check_matcher(cx, &tts.tts),
-        tt @ &TokenTree::Sequence(..) => check_matcher(cx, ref_slice(tt)),
         _ => {
-            cx.span_err(lhs.get_span(),
-                        "invalid macro matcher; matchers must be contained \
-                         in balanced delimiters or a repetition indicator");
+            cx.span_err(lhs.get_span(), "invalid macro matcher; matchers must \
+                                         be contained in balanced delimiters");
             false
         }
     }

src/test/compile-fail/malformed_macro_lhs.rs

@@ -9,9 +9,9 @@
 // except according to those terms.
 
 macro_rules! my_precioooous {
-    $($t:tt)* => (1);
+    $($t:tt)* => (1); //~ ERROR invalid macro matcher
 }
 
 fn main() {
-    my_precioooous!(); //~ ERROR malformed macro lhs
+    my_precioooous!();
 }