compiler/rustc_expand/src/mbe/macro_rules.rs

   1 use crate::base::{DummyResult, ExtCtxt, MacResult, TTMacroExpander};
   2 use crate::base::{SyntaxExtension, SyntaxExtensionKind};
   3 use crate::expand::{ensure_complete_parse, parse_ast_fragment, AstFragment, AstFragmentKind};
   4 use crate::mbe;
   5 use crate::mbe::macro_check;
   6 use crate::mbe::macro_parser::parse_tt;
   7 use crate::mbe::macro_parser::{Error, ErrorReported, Failure, Success};
   8 use crate::mbe::macro_parser::{MatchedNonterminal, MatchedSeq};
   9 use crate::mbe::transcribe::transcribe;
  10
  11 use rustc_ast as ast;
  12 use rustc_ast::token::{self, NonterminalKind, NtTT, Token, TokenKind::*};
  13 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
  14 use rustc_ast::{NodeId, DUMMY_NODE_ID};
  15 use rustc_ast_pretty::pprust;
  16 use rustc_attr::{self as attr, TransparencyError};
  17 use rustc_data_structures::fx::FxHashMap;
  18 use rustc_data_structures::sync::Lrc;
  19 use rustc_errors::{Applicability, DiagnosticBuilder};
  20 use rustc_feature::Features;
  21 use rustc_lint_defs::builtin::{
  22     RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
  23 };
  24 use rustc_lint_defs::BuiltinLintDiagnostics;
  25 use rustc_parse::parser::Parser;
  26 use rustc_session::parse::ParseSess;
  27 use rustc_session::Session;
  28 use rustc_span::edition::Edition;
  29 use rustc_span::hygiene::Transparency;
  30 use rustc_span::symbol::{kw, sym, Ident, MacroRulesNormalizedIdent};
  31 use rustc_span::Span;
  32
  33 use std::borrow::Cow;
  34 use std::collections::hash_map::Entry;
  35 use std::{mem, slice};
  36 use tracing::debug;
  37
  38 crate struct ParserAnyMacro<'a> {
  39     parser: Parser<'a>,
  40
  41     /// Span of the expansion site of the macro this parser is for
  42     site_span: Span,
  43     /// The ident of the macro we're parsing
  44     macro_ident: Ident,
  45     lint_node_id: NodeId,
  46     arm_span: Span,
  47 }
  48
  49 crate fn annotate_err_with_kind(
  50     err: &mut DiagnosticBuilder<'_>,
  51     kind: AstFragmentKind,
  52     span: Span,
  53 ) {
  54     match kind {
  55         AstFragmentKind::Ty => {
  56             err.span_label(span, "this macro call doesn't expand to a type");
  57         }
  58         AstFragmentKind::Pat => {
  59             err.span_label(span, "this macro call doesn't expand to a pattern");
  60         }
  61         _ => {}
  62     };
  63 }
  64
  65 fn emit_frag_parse_err(
  66     mut e: DiagnosticBuilder<'_>,
  67     parser: &Parser<'_>,
  68     orig_parser: &mut Parser<'_>,
  69     site_span: Span,
  70     arm_span: Span,
  71     kind: AstFragmentKind,
  72 ) {
  73     if parser.token == token::Eof && e.message().ends_with(", found `<eof>`") {
  74         if !e.span.is_dummy() {
  75             // early end of macro arm (#52866)
  76             e.replace_span_with(parser.sess.source_map().next_point(parser.token.span));
  77         }
  78         let msg = &e.message[0];
  79         e.message[0] = (
  80             format!(
  81                 "macro expansion ends with an incomplete expression: {}",
  82                 msg.0.replace(", found `<eof>`", ""),
  83             ),
  84             msg.1,
  85         );
  86     }
  87     if e.span.is_dummy() {
  88         // Get around lack of span in error (#30128)
  89         e.replace_span_with(site_span);
  90         if !parser.sess.source_map().is_imported(arm_span) {
  91             e.span_label(arm_span, "in this macro arm");
  92         }
  93     } else if parser.sess.source_map().is_imported(parser.token.span) {
  94         e.span_label(site_span, "in this macro invocation");
  95     }
  96     match kind {
  97         // Try a statement if an expression is wanted but failed and suggest adding `;` to call.
  98         AstFragmentKind::Expr => match parse_ast_fragment(orig_parser, AstFragmentKind::Stmts) {
  99             Err(mut err) => err.cancel(),
 100             Ok(_) => {
 101                 e.note(
 102                     "the macro call doesn't expand to an expression, but it can expand to a statement",
 103                 );
 104                 e.span_suggestion_verbose(
 105                     site_span.shrink_to_hi(),
 106                     "add `;` to interpret the expansion as a statement",
 107                     ";".to_string(),
 108                     Applicability::MaybeIncorrect,
 109                 );
 110             }
 111         },
 112         _ => annotate_err_with_kind(&mut e, kind, site_span),
 113     };
 114     e.emit();
 115 }
 116
 117 impl<'a> ParserAnyMacro<'a> {
 118     crate fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
 119         let ParserAnyMacro { site_span, macro_ident, ref mut parser, lint_node_id, arm_span } =
 120             *self;
 121         let snapshot = &mut parser.clone();
 122         let fragment = match parse_ast_fragment(parser, kind) {
 123             Ok(f) => f,
 124             Err(err) => {
 125                 emit_frag_parse_err(err, parser, snapshot, site_span, arm_span, kind);
 126                 return kind.dummy(site_span);
 127             }
 128         };
 129
 130         // We allow semicolons at the end of expressions -- e.g., the semicolon in
 131         // `macro_rules! m { () => { panic!(); } }` isn't parsed by `.parse_expr()`,
 132         // but `m!()` is allowed in expression positions (cf. issue #34706).
 133         if kind == AstFragmentKind::Expr && parser.token == token::Semi {
 134             parser.sess.buffer_lint(
 135                 SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
 136                 parser.token.span,
 137                 lint_node_id,
 138                 "trailing semicolon in macro used in expression position",
 139             );
 140             parser.bump();
 141         }
 142
 143         // Make sure we don't have any tokens left to parse so we don't silently drop anything.
 144         let path = ast::Path::from_ident(macro_ident.with_span_pos(site_span));
 145         ensure_complete_parse(parser, &path, kind.name(), site_span);
 146         fragment
 147     }
 148 }
 149
 150 struct MacroRulesMacroExpander {
 151     name: Ident,
 152     span: Span,
 153     transparency: Transparency,
 154     lhses: Vec<mbe::TokenTree>,
 155     rhses: Vec<mbe::TokenTree>,
 156     valid: bool,
 157 }
 158
 159 impl TTMacroExpander for MacroRulesMacroExpander {
 160     fn expand<'cx>(
 161         &self,
 162         cx: &'cx mut ExtCtxt<'_>,
 163         sp: Span,
 164         input: TokenStream,
 165     ) -> Box<dyn MacResult + 'cx> {
 166         if !self.valid {
 167             return DummyResult::any(sp);
 168         }
 169         generic_extension(
 170             cx,
 171             sp,
 172             self.span,
 173             self.name,
 174             self.transparency,
 175             input,
 176             &self.lhses,
 177             &self.rhses,
 178         )
 179     }
 180 }
 181
 182 fn macro_rules_dummy_expander<'cx>(
 183     _: &'cx mut ExtCtxt<'_>,
 184     span: Span,
 185     _: TokenStream,
 186 ) -> Box<dyn MacResult + 'cx> {
 187     DummyResult::any(span)
 188 }
 189
 190 fn trace_macros_note(cx_expansions: &mut FxHashMap<Span, Vec<String>>, sp: Span, message: String) {
 191     let sp = sp.macro_backtrace().last().map_or(sp, |trace| trace.call_site);
 192     cx_expansions.entry(sp).or_default().push(message);
 193 }
 194
 195 /// Given `lhses` and `rhses`, this is the new macro we create
 196 fn generic_extension<'cx>(
 197     cx: &'cx mut ExtCtxt<'_>,
 198     sp: Span,
 199     def_span: Span,
 200     name: Ident,
 201     transparency: Transparency,
 202     arg: TokenStream,
 203     lhses: &[mbe::TokenTree],
 204     rhses: &[mbe::TokenTree],
 205 ) -> Box<dyn MacResult + 'cx> {
 206     let sess = &cx.sess.parse_sess;
 207
 208     if cx.trace_macros() {
 209         let msg = format!("expanding `{}! {{ {} }}`", name, pprust::tts_to_string(&arg));
 210         trace_macros_note(&mut cx.expansions, sp, msg);
 211     }
 212
 213     // Which arm's failure should we report? (the one furthest along)
 214     let mut best_failure: Option<(Token, &str)> = None;
 215
 216     // We create a base parser that can be used for the "black box" parts.
 217     // Every iteration needs a fresh copy of that parser. However, the parser
 218     // is not mutated on many of the iterations, particularly when dealing with
 219     // macros like this:
 220     //
 221     // macro_rules! foo {
 222     //     ("a") => (A);
 223     //     ("b") => (B);
 224     //     ("c") => (C);
 225     //     // ... etc. (maybe hundreds more)
 226     // }
 227     //
 228     // as seen in the `html5ever` benchmark. We use a `Cow` so that the base
 229     // parser is only cloned when necessary (upon mutation). Furthermore, we
 230     // reinitialize the `Cow` with the base parser at the start of every
 231     // iteration, so that any mutated parsers are not reused. This is all quite
 232     // hacky, but speeds up the `html5ever` benchmark significantly. (Issue
 233     // 68836 suggests a more comprehensive but more complex change to deal with
 234     // this situation.)
 235     let parser = parser_from_cx(sess, arg.clone());
 236
 237     for (i, lhs) in lhses.iter().enumerate() {
 238         // try each arm's matchers
 239         let lhs_tt = match *lhs {
 240             mbe::TokenTree::Delimited(_, ref delim) => &delim.tts[..],
 241             _ => cx.span_bug(sp, "malformed macro lhs"),
 242         };
 243
 244         // Take a snapshot of the state of pre-expansion gating at this point.
 245         // This is used so that if a matcher is not `Success(..)`ful,
 246         // then the spans which became gated when parsing the unsuccessful matcher
 247         // are not recorded. On the first `Success(..)`ful matcher, the spans are merged.
 248         let mut gated_spans_snapshot = mem::take(&mut *sess.gated_spans.spans.borrow_mut());
 249
 250         match parse_tt(&mut Cow::Borrowed(&parser), lhs_tt, name) {
 251             Success(named_matches) => {
 252                 // The matcher was `Success(..)`ful.
 253                 // Merge the gated spans from parsing the matcher with the pre-existing ones.
 254                 sess.gated_spans.merge(gated_spans_snapshot);
 255
 256                 let rhs = match rhses[i] {
 257                     // ignore delimiters
 258                     mbe::TokenTree::Delimited(_, ref delimed) => delimed.tts.clone(),
 259                     _ => cx.span_bug(sp, "malformed macro rhs"),
 260                 };
 261                 let arm_span = rhses[i].span();
 262
 263                 let rhs_spans = rhs.iter().map(|t| t.span()).collect::<Vec<_>>();
 264                 // rhs has holes ( `$id` and `$(...)` that need filled)
 265                 let mut tts = match transcribe(cx, &named_matches, rhs, transparency) {
 266                     Ok(tts) => tts,
 267                     Err(mut err) => {
 268                         err.emit();
 269                         return DummyResult::any(arm_span);
 270                     }
 271                 };
 272
 273                 // Replace all the tokens for the corresponding positions in the macro, to maintain
 274                 // proper positions in error reporting, while maintaining the macro_backtrace.
 275                 if rhs_spans.len() == tts.len() {
 276                     tts = tts.map_enumerated(|i, tt| {
 277                         let mut tt = tt.clone();
 278                         let mut sp = rhs_spans[i];
 279                         sp = sp.with_ctxt(tt.span().ctxt());
 280                         tt.set_span(sp);
 281                         tt
 282                     });
 283                 }
 284
 285                 if cx.trace_macros() {
 286                     let msg = format!("to `{}`", pprust::tts_to_string(&tts));
 287                     trace_macros_note(&mut cx.expansions, sp, msg);
 288                 }
 289
 290                 let mut p = Parser::new(sess, tts, false, None);
 291                 p.last_type_ascription = cx.current_expansion.prior_type_ascription;
 292
 293                 // Let the context choose how to interpret the result.
 294                 // Weird, but useful for X-macros.
 295                 return Box::new(ParserAnyMacro {
 296                     parser: p,
 297
 298                     // Pass along the original expansion site and the name of the macro
 299                     // so we can print a useful error message if the parse of the expanded
 300                     // macro leaves unparsed tokens.
 301                     site_span: sp,
 302                     macro_ident: name,
 303                     lint_node_id: cx.current_expansion.lint_node_id,
 304                     arm_span,
 305                 });
 306             }
 307             Failure(token, msg) => match best_failure {
 308                 Some((ref best_token, _)) if best_token.span.lo() >= token.span.lo() => {}
 309                 _ => best_failure = Some((token, msg)),
 310             },
 311             Error(err_sp, ref msg) => {
 312                 let span = err_sp.substitute_dummy(sp);
 313                 cx.struct_span_err(span, &msg).emit();
 314                 return DummyResult::any(span);
 315             }
 316             ErrorReported => return DummyResult::any(sp),
 317         }
 318
 319         // The matcher was not `Success(..)`ful.
 320         // Restore to the state before snapshotting and maybe try again.
 321         mem::swap(&mut gated_spans_snapshot, &mut sess.gated_spans.spans.borrow_mut());
 322     }
 323     drop(parser);
 324
 325     let (token, label) = best_failure.expect("ran no matchers");
 326     let span = token.span.substitute_dummy(sp);
 327     let mut err = cx.struct_span_err(span, &parse_failure_msg(&token));
 328     err.span_label(span, label);
 329     if !def_span.is_dummy() && !cx.source_map().is_imported(def_span) {
 330         err.span_label(cx.source_map().guess_head_span(def_span), "when calling this macro");
 331     }
 332
 333     // Check whether there's a missing comma in this macro call, like `println!("{}" a);`
 334     if let Some((arg, comma_span)) = arg.add_comma() {
 335         for lhs in lhses {
 336             // try each arm's matchers
 337             let lhs_tt = match *lhs {
 338                 mbe::TokenTree::Delimited(_, ref delim) => &delim.tts[..],
 339                 _ => continue,
 340             };
 341             if let Success(_) =
 342                 parse_tt(&mut Cow::Borrowed(&parser_from_cx(sess, arg.clone())), lhs_tt, name)
 343             {
 344                 if comma_span.is_dummy() {
 345                     err.note("you might be missing a comma");
 346                 } else {
 347                     err.span_suggestion_short(
 348                         comma_span,
 349                         "missing comma here",
 350                         ", ".to_string(),
 351                         Applicability::MachineApplicable,
 352                     );
 353                 }
 354             }
 355         }
 356     }
 357     err.emit();
 358     cx.trace_macros_diag();
 359     DummyResult::any(sp)
 360 }
 361
 362 // Note that macro-by-example's input is also matched against a token tree:
 363 //                   $( $lhs:tt => $rhs:tt );+
 364 //
 365 // Holy self-referential!
 366
 367 /// Converts a macro item into a syntax extension.
 368 pub fn compile_declarative_macro(
 369     sess: &Session,
 370     features: &Features,
 371     def: &ast::Item,
 372     edition: Edition,
 373 ) -> SyntaxExtension {
 374     debug!("compile_declarative_macro: {:?}", def);
 375     let mk_syn_ext = |expander| {
 376         SyntaxExtension::new(
 377             sess,
 378             SyntaxExtensionKind::LegacyBang(expander),
 379             def.span,
 380             Vec::new(),
 381             edition,
 382             def.ident.name,
 383             &def.attrs,
 384         )
 385     };
 386
 387     let diag = &sess.parse_sess.span_diagnostic;
 388     let lhs_nm = Ident::new(sym::lhs, def.span);
 389     let rhs_nm = Ident::new(sym::rhs, def.span);
 390     let tt_spec = Some(NonterminalKind::TT);
 391
 392     // Parse the macro_rules! invocation
 393     let (macro_rules, body) = match &def.kind {
 394         ast::ItemKind::MacroDef(def) => (def.macro_rules, def.body.inner_tokens()),
 395         _ => unreachable!(),
 396     };
 397
 398     // The pattern that macro_rules matches.
 399     // The grammar for macro_rules! is:
 400     // $( $lhs:tt => $rhs:tt );+
 401     // ...quasiquoting this would be nice.
 402     // These spans won't matter, anyways
 403     let argument_gram = vec![
 404         mbe::TokenTree::Sequence(
 405             DelimSpan::dummy(),
 406             Lrc::new(mbe::SequenceRepetition {
 407                 tts: vec![
 408                     mbe::TokenTree::MetaVarDecl(def.span, lhs_nm, tt_spec),
 409                     mbe::TokenTree::token(token::FatArrow, def.span),
 410                     mbe::TokenTree::MetaVarDecl(def.span, rhs_nm, tt_spec),
 411                 ],
 412                 separator: Some(Token::new(
 413                     if macro_rules { token::Semi } else { token::Comma },
 414                     def.span,
 415                 )),
 416                 kleene: mbe::KleeneToken::new(mbe::KleeneOp::OneOrMore, def.span),
 417                 num_captures: 2,
 418             }),
 419         ),
 420         // to phase into semicolon-termination instead of semicolon-separation
 421         mbe::TokenTree::Sequence(
 422             DelimSpan::dummy(),
 423             Lrc::new(mbe::SequenceRepetition {
 424                 tts: vec![mbe::TokenTree::token(
 425                     if macro_rules { token::Semi } else { token::Comma },
 426                     def.span,
 427                 )],
 428                 separator: None,
 429                 kleene: mbe::KleeneToken::new(mbe::KleeneOp::ZeroOrMore, def.span),
 430                 num_captures: 0,
 431             }),
 432         ),
 433     ];
 434
 435     let parser = Parser::new(&sess.parse_sess, body, true, rustc_parse::MACRO_ARGUMENTS);
 436     let argument_map = match parse_tt(&mut Cow::Borrowed(&parser), &argument_gram, def.ident) {
 437         Success(m) => m,
 438         Failure(token, msg) => {
 439             let s = parse_failure_msg(&token);
 440             let sp = token.span.substitute_dummy(def.span);
 441             sess.parse_sess.span_diagnostic.struct_span_err(sp, &s).span_label(sp, msg).emit();
 442             return mk_syn_ext(Box::new(macro_rules_dummy_expander));
 443         }
 444         Error(sp, msg) => {
 445             sess.parse_sess
 446                 .span_diagnostic
 447                 .struct_span_err(sp.substitute_dummy(def.span), &msg)
 448                 .emit();
 449             return mk_syn_ext(Box::new(macro_rules_dummy_expander));
 450         }
 451         ErrorReported => {
 452             return mk_syn_ext(Box::new(macro_rules_dummy_expander));
 453         }
 454     };
 455
 456     let mut valid = true;
 457
 458     // Extract the arguments:
 459     let lhses = match argument_map[&MacroRulesNormalizedIdent::new(lhs_nm)] {
 460         MatchedSeq(ref s) => s
 461             .iter()
 462             .map(|m| {
 463                 if let MatchedNonterminal(ref nt) = *m {
 464                     if let NtTT(ref tt) = **nt {
 465                         let tt = mbe::quoted::parse(
 466                             tt.clone().into(),
 467                             true,
 468                             &sess.parse_sess,
 469                             def.id,
 470                             features,
 471                             edition,
 472                         )
 473                         .pop()
 474                         .unwrap();
 475                         valid &= check_lhs_nt_follows(&sess.parse_sess, features, &def, &tt);
 476                         return tt;
 477                     }
 478                 }
 479                 sess.parse_sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
 480             })
 481             .collect::<Vec<mbe::TokenTree>>(),
 482         _ => sess.parse_sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs"),
 483     };
 484
 485     let rhses = match argument_map[&MacroRulesNormalizedIdent::new(rhs_nm)] {
 486         MatchedSeq(ref s) => s
 487             .iter()
 488             .map(|m| {
 489                 if let MatchedNonterminal(ref nt) = *m {
 490                     if let NtTT(ref tt) = **nt {
 491                         return mbe::quoted::parse(
 492                             tt.clone().into(),
 493                             false,
 494                             &sess.parse_sess,
 495                             def.id,
 496                             features,
 497                             edition,
 498                         )
 499                         .pop()
 500                         .unwrap();
 501                     }
 502                 }
 503                 sess.parse_sess.span_diagnostic.span_bug(def.span, "wrong-structured lhs")
 504             })
 505             .collect::<Vec<mbe::TokenTree>>(),
 506         _ => sess.parse_sess.span_diagnostic.span_bug(def.span, "wrong-structured rhs"),
 507     };
 508
 509     for rhs in &rhses {
 510         valid &= check_rhs(&sess.parse_sess, rhs);
 511     }
 512
 513     // don't abort iteration early, so that errors for multiple lhses can be reported
 514     for lhs in &lhses {
 515         valid &= check_lhs_no_empty_seq(&sess.parse_sess, slice::from_ref(lhs));
 516     }
 517
 518     valid &= macro_check::check_meta_variables(&sess.parse_sess, def.id, def.span, &lhses, &rhses);
 519
 520     let (transparency, transparency_error) = attr::find_transparency(sess, &def.attrs, macro_rules);
 521     match transparency_error {
 522         Some(TransparencyError::UnknownTransparency(value, span)) => {
 523             diag.span_err(span, &format!("unknown macro transparency: `{}`", value))
 524         }
 525         Some(TransparencyError::MultipleTransparencyAttrs(old_span, new_span)) => {
 526             diag.span_err(vec![old_span, new_span], "multiple macro transparency attributes")
 527         }
 528         None => {}
 529     }
 530
 531     mk_syn_ext(Box::new(MacroRulesMacroExpander {
 532         name: def.ident,
 533         span: def.span,
 534         transparency,
 535         lhses,
 536         rhses,
 537         valid,
 538     }))
 539 }
 540
 541 fn check_lhs_nt_follows(
 542     sess: &ParseSess,
 543     features: &Features,
 544     def: &ast::Item,
 545     lhs: &mbe::TokenTree,
 546 ) -> bool {
 547     // lhs is going to be like TokenTree::Delimited(...), where the
 548     // entire lhs is those tts. Or, it can be a "bare sequence", not wrapped in parens.
 549     if let mbe::TokenTree::Delimited(_, ref tts) = *lhs {
 550         check_matcher(sess, features, def, &tts.tts)
 551     } else {
 552         let msg = "invalid macro matcher; matchers must be contained in balanced delimiters";
 553         sess.span_diagnostic.span_err(lhs.span(), msg);
 554         false
 555     }
 556     // we don't abort on errors on rejection, the driver will do that for us
 557     // after parsing/expansion. we can report every error in every macro this way.
 558 }
 559
 560 /// Checks that the lhs contains no repetition which could match an empty token
 561 /// tree, because then the matcher would hang indefinitely.
 562 fn check_lhs_no_empty_seq(sess: &ParseSess, tts: &[mbe::TokenTree]) -> bool {
 563     use mbe::TokenTree;
 564     for tt in tts {
 565         match *tt {
 566             TokenTree::Token(..) | TokenTree::MetaVar(..) | TokenTree::MetaVarDecl(..) => (),
 567             TokenTree::Delimited(_, ref del) => {
 568                 if !check_lhs_no_empty_seq(sess, &del.tts) {
 569                     return false;
 570                 }
 571             }
 572             TokenTree::Sequence(span, ref seq) => {
 573                 if seq.separator.is_none()
 574                     && seq.tts.iter().all(|seq_tt| match *seq_tt {
 575                         TokenTree::MetaVarDecl(_, _, Some(NonterminalKind::Vis)) => true,
 576                         TokenTree::Sequence(_, ref sub_seq) => {
 577                             sub_seq.kleene.op == mbe::KleeneOp::ZeroOrMore
 578                                 || sub_seq.kleene.op == mbe::KleeneOp::ZeroOrOne
 579                         }
 580                         _ => false,
 581                     })
 582                 {
 583                     let sp = span.entire();
 584                     sess.span_diagnostic.span_err(sp, "repetition matches empty token tree");
 585                     return false;
 586                 }
 587                 if !check_lhs_no_empty_seq(sess, &seq.tts) {
 588                     return false;
 589                 }
 590             }
 591         }
 592     }
 593
 594     true
 595 }
 596
 597 fn check_rhs(sess: &ParseSess, rhs: &mbe::TokenTree) -> bool {
 598     match *rhs {
 599         mbe::TokenTree::Delimited(..) => return true,
 600         _ => sess.span_diagnostic.span_err(rhs.span(), "macro rhs must be delimited"),
 601     }
 602     false
 603 }
 604
 605 fn check_matcher(
 606     sess: &ParseSess,
 607     features: &Features,
 608     def: &ast::Item,
 609     matcher: &[mbe::TokenTree],
 610 ) -> bool {
 611     let first_sets = FirstSets::new(matcher);
 612     let empty_suffix = TokenSet::empty();
 613     let err = sess.span_diagnostic.err_count();
 614     check_matcher_core(sess, features, def, &first_sets, matcher, &empty_suffix);
 615     err == sess.span_diagnostic.err_count()
 616 }
 617
 618 // `The FirstSets` for a matcher is a mapping from subsequences in the
 619 // matcher to the FIRST set for that subsequence.
 620 //
 621 // This mapping is partially precomputed via a backwards scan over the
 622 // token trees of the matcher, which provides a mapping from each
 623 // repetition sequence to its *first* set.
 624 //
 625 // (Hypothetically, sequences should be uniquely identifiable via their
 626 // spans, though perhaps that is false, e.g., for macro-generated macros
 627 // that do not try to inject artificial span information. My plan is
 628 // to try to catch such cases ahead of time and not include them in
 629 // the precomputed mapping.)
 630 struct FirstSets {
 631     // this maps each TokenTree::Sequence `$(tt ...) SEP OP` that is uniquely identified by its
 632     // span in the original matcher to the First set for the inner sequence `tt ...`.
 633     //
 634     // If two sequences have the same span in a matcher, then map that
 635     // span to None (invalidating the mapping here and forcing the code to
 636     // use a slow path).
 637     first: FxHashMap<Span, Option<TokenSet>>,
 638 }
 639
 640 impl FirstSets {
 641     fn new(tts: &[mbe::TokenTree]) -> FirstSets {
 642         use mbe::TokenTree;
 643
 644         let mut sets = FirstSets { first: FxHashMap::default() };
 645         build_recur(&mut sets, tts);
 646         return sets;
 647
 648         // walks backward over `tts`, returning the FIRST for `tts`
 649         // and updating `sets` at the same time for all sequence
 650         // substructure we find within `tts`.
 651         fn build_recur(sets: &mut FirstSets, tts: &[TokenTree]) -> TokenSet {
 652             let mut first = TokenSet::empty();
 653             for tt in tts.iter().rev() {
 654                 match *tt {
 655                     TokenTree::Token(..) | TokenTree::MetaVar(..) | TokenTree::MetaVarDecl(..) => {
 656                         first.replace_with(tt.clone());
 657                     }
 658                     TokenTree::Delimited(span, ref delimited) => {
 659                         build_recur(sets, &delimited.tts[..]);
 660                         first.replace_with(delimited.open_tt(span));
 661                     }
 662                     TokenTree::Sequence(sp, ref seq_rep) => {
 663                         let subfirst = build_recur(sets, &seq_rep.tts[..]);
 664
 665                         match sets.first.entry(sp.entire()) {
 666                             Entry::Vacant(vac) => {
 667                                 vac.insert(Some(subfirst.clone()));
 668                             }
 669                             Entry::Occupied(mut occ) => {
 670                                 // if there is already an entry, then a span must have collided.
 671                                 // This should not happen with typical macro_rules macros,
 672                                 // but syntax extensions need not maintain distinct spans,
 673                                 // so distinct syntax trees can be assigned the same span.
 674                                 // In such a case, the map cannot be trusted; so mark this
 675                                 // entry as unusable.
 676                                 occ.insert(None);
 677                             }
 678                         }
 679
 680                         // If the sequence contents can be empty, then the first
 681                         // token could be the separator token itself.
 682
 683                         if let (Some(sep), true) = (&seq_rep.separator, subfirst.maybe_empty) {
 684                             first.add_one_maybe(TokenTree::Token(sep.clone()));
 685                         }
 686
 687                         // Reverse scan: Sequence comes before `first`.
 688                         if subfirst.maybe_empty
 689                             || seq_rep.kleene.op == mbe::KleeneOp::ZeroOrMore
 690                             || seq_rep.kleene.op == mbe::KleeneOp::ZeroOrOne
 691                         {
 692                             // If sequence is potentially empty, then
 693                             // union them (preserving first emptiness).
 694                             first.add_all(&TokenSet { maybe_empty: true, ..subfirst });
 695                         } else {
 696                             // Otherwise, sequence guaranteed
 697                             // non-empty; replace first.
 698                             first = subfirst;
 699                         }
 700                     }
 701                 }
 702             }
 703
 704             first
 705         }
 706     }
 707
 708     // walks forward over `tts` until all potential FIRST tokens are
 709     // identified.
 710     fn first(&self, tts: &[mbe::TokenTree]) -> TokenSet {
 711         use mbe::TokenTree;
 712
 713         let mut first = TokenSet::empty();
 714         for tt in tts.iter() {
 715             assert!(first.maybe_empty);
 716             match *tt {
 717                 TokenTree::Token(..) | TokenTree::MetaVar(..) | TokenTree::MetaVarDecl(..) => {
 718                     first.add_one(tt.clone());
 719                     return first;
 720                 }
 721                 TokenTree::Delimited(span, ref delimited) => {
 722                     first.add_one(delimited.open_tt(span));
 723                     return first;
 724                 }
 725                 TokenTree::Sequence(sp, ref seq_rep) => {
 726                     let subfirst_owned;
 727                     let subfirst = match self.first.get(&sp.entire()) {
 728                         Some(&Some(ref subfirst)) => subfirst,
 729                         Some(&None) => {
 730                             subfirst_owned = self.first(&seq_rep.tts[..]);
 731                             &subfirst_owned
 732                         }
 733                         None => {
 734                             panic!("We missed a sequence during FirstSets construction");
 735                         }
 736                     };
 737
 738                     // If the sequence contents can be empty, then the first
 739                     // token could be the separator token itself.
 740                     if let (Some(sep), true) = (&seq_rep.separator, subfirst.maybe_empty) {
 741                         first.add_one_maybe(TokenTree::Token(sep.clone()));
 742                     }
 743
 744                     assert!(first.maybe_empty);
 745                     first.add_all(subfirst);
 746                     if subfirst.maybe_empty
 747                         || seq_rep.kleene.op == mbe::KleeneOp::ZeroOrMore
 748                         || seq_rep.kleene.op == mbe::KleeneOp::ZeroOrOne
 749                     {
 750                         // Continue scanning for more first
 751                         // tokens, but also make sure we
 752                         // restore empty-tracking state.
 753                         first.maybe_empty = true;
 754                         continue;
 755                     } else {
 756                         return first;
 757                     }
 758                 }
 759             }
 760         }
 761
 762         // we only exit the loop if `tts` was empty or if every
 763         // element of `tts` matches the empty sequence.
 764         assert!(first.maybe_empty);
 765         first
 766     }
 767 }
 768
 769 // A set of `mbe::TokenTree`s, which may include `TokenTree::Match`s
 770 // (for macro-by-example syntactic variables). It also carries the
 771 // `maybe_empty` flag; that is true if and only if the matcher can
 772 // match an empty token sequence.
 773 //
 774 // The First set is computed on submatchers like `$($a:expr b),* $(c)* d`,
 775 // which has corresponding FIRST = {$a:expr, c, d}.
 776 // Likewise, `$($a:expr b),* $(c)+ d` has FIRST = {$a:expr, c}.
 777 //
 778 // (Notably, we must allow for *-op to occur zero times.)
 779 #[derive(Clone, Debug)]
 780 struct TokenSet {
 781     tokens: Vec<mbe::TokenTree>,
 782     maybe_empty: bool,
 783 }
 784
 785 impl TokenSet {
 786     // Returns a set for the empty sequence.
 787     fn empty() -> Self {
 788         TokenSet { tokens: Vec::new(), maybe_empty: true }
 789     }
 790
 791     // Returns the set `{ tok }` for the single-token (and thus
 792     // non-empty) sequence [tok].
 793     fn singleton(tok: mbe::TokenTree) -> Self {
 794         TokenSet { tokens: vec![tok], maybe_empty: false }
 795     }
 796
 797     // Changes self to be the set `{ tok }`.
 798     // Since `tok` is always present, marks self as non-empty.
 799     fn replace_with(&mut self, tok: mbe::TokenTree) {
 800         self.tokens.clear();
 801         self.tokens.push(tok);
 802         self.maybe_empty = false;
 803     }
 804
 805     // Changes self to be the empty set `{}`; meant for use when
 806     // the particular token does not matter, but we want to
 807     // record that it occurs.
 808     fn replace_with_irrelevant(&mut self) {
 809         self.tokens.clear();
 810         self.maybe_empty = false;
 811     }
 812
 813     // Adds `tok` to the set for `self`, marking sequence as non-empy.
 814     fn add_one(&mut self, tok: mbe::TokenTree) {
 815         if !self.tokens.contains(&tok) {
 816             self.tokens.push(tok);
 817         }
 818         self.maybe_empty = false;
 819     }
 820
 821     // Adds `tok` to the set for `self`. (Leaves `maybe_empty` flag alone.)
 822     fn add_one_maybe(&mut self, tok: mbe::TokenTree) {
 823         if !self.tokens.contains(&tok) {
 824             self.tokens.push(tok);
 825         }
 826     }
 827
 828     // Adds all elements of `other` to this.
 829     //
 830     // (Since this is a set, we filter out duplicates.)
 831     //
 832     // If `other` is potentially empty, then preserves the previous
 833     // setting of the empty flag of `self`. If `other` is guaranteed
 834     // non-empty, then `self` is marked non-empty.
 835     fn add_all(&mut self, other: &Self) {
 836         for tok in &other.tokens {
 837             if !self.tokens.contains(tok) {
 838                 self.tokens.push(tok.clone());
 839             }
 840         }
 841         if !other.maybe_empty {
 842             self.maybe_empty = false;
 843         }
 844     }
 845 }
 846
 847 // Checks that `matcher` is internally consistent and that it
 848 // can legally be followed by a token `N`, for all `N` in `follow`.
 849 // (If `follow` is empty, then it imposes no constraint on
 850 // the `matcher`.)
 851 //
 852 // Returns the set of NT tokens that could possibly come last in
 853 // `matcher`. (If `matcher` matches the empty sequence, then
 854 // `maybe_empty` will be set to true.)
 855 //
 856 // Requires that `first_sets` is pre-computed for `matcher`;
 857 // see `FirstSets::new`.
 858 fn check_matcher_core(
 859     sess: &ParseSess,
 860     features: &Features,
 861     def: &ast::Item,
 862     first_sets: &FirstSets,
 863     matcher: &[mbe::TokenTree],
 864     follow: &TokenSet,
 865 ) -> TokenSet {
 866     use mbe::TokenTree;
 867
 868     let mut last = TokenSet::empty();
 869
 870     // 2. For each token and suffix  [T, SUFFIX] in M:
 871     // ensure that T can be followed by SUFFIX, and if SUFFIX may be empty,
 872     // then ensure T can also be followed by any element of FOLLOW.
 873     'each_token: for i in 0..matcher.len() {
 874         let token = &matcher[i];
 875         let suffix = &matcher[i + 1..];
 876
 877         let build_suffix_first = || {
 878             let mut s = first_sets.first(suffix);
 879             if s.maybe_empty {
 880                 s.add_all(follow);
 881             }
 882             s
 883         };
 884
 885         // (we build `suffix_first` on demand below; you can tell
 886         // which cases are supposed to fall through by looking for the
 887         // initialization of this variable.)
 888         let suffix_first;
 889
 890         // First, update `last` so that it corresponds to the set
 891         // of NT tokens that might end the sequence `... token`.
 892         match *token {
 893             TokenTree::Token(..) | TokenTree::MetaVar(..) | TokenTree::MetaVarDecl(..) => {
 894                 if token_can_be_followed_by_any(token) {
 895                     // don't need to track tokens that work with any,
 896                     last.replace_with_irrelevant();
 897                     // ... and don't need to check tokens that can be
 898                     // followed by anything against SUFFIX.
 899                     continue 'each_token;
 900                 } else {
 901                     last.replace_with(token.clone());
 902                     suffix_first = build_suffix_first();
 903                 }
 904             }
 905             TokenTree::Delimited(span, ref d) => {
 906                 let my_suffix = TokenSet::singleton(d.close_tt(span));
 907                 check_matcher_core(sess, features, def, first_sets, &d.tts, &my_suffix);
 908                 // don't track non NT tokens
 909                 last.replace_with_irrelevant();
 910
 911                 // also, we don't need to check delimited sequences
 912                 // against SUFFIX
 913                 continue 'each_token;
 914             }
 915             TokenTree::Sequence(_, ref seq_rep) => {
 916                 suffix_first = build_suffix_first();
 917                 // The trick here: when we check the interior, we want
 918                 // to include the separator (if any) as a potential
 919                 // (but not guaranteed) element of FOLLOW. So in that
 920                 // case, we make a temp copy of suffix and stuff
 921                 // delimiter in there.
 922                 //
 923                 // FIXME: Should I first scan suffix_first to see if
 924                 // delimiter is already in it before I go through the
 925                 // work of cloning it? But then again, this way I may
 926                 // get a "tighter" span?
 927                 let mut new;
 928                 let my_suffix = if let Some(sep) = &seq_rep.separator {
 929                     new = suffix_first.clone();
 930                     new.add_one_maybe(TokenTree::Token(sep.clone()));
 931                     &new
 932                 } else {
 933                     &suffix_first
 934                 };
 935
 936                 // At this point, `suffix_first` is built, and
 937                 // `my_suffix` is some TokenSet that we can use
 938                 // for checking the interior of `seq_rep`.
 939                 let next =
 940                     check_matcher_core(sess, features, def, first_sets, &seq_rep.tts, my_suffix);
 941                 if next.maybe_empty {
 942                     last.add_all(&next);
 943                 } else {
 944                     last = next;
 945                 }
 946
 947                 // the recursive call to check_matcher_core already ran the 'each_last
 948                 // check below, so we can just keep going forward here.
 949                 continue 'each_token;
 950             }
 951         }
 952
 953         // (`suffix_first` guaranteed initialized once reaching here.)
 954
 955         // Now `last` holds the complete set of NT tokens that could
 956         // end the sequence before SUFFIX. Check that every one works with `suffix`.
 957         for token in &last.tokens {
 958             if let TokenTree::MetaVarDecl(span, name, Some(kind)) = *token {
 959                 for next_token in &suffix_first.tokens {
 960                     // Check if the old pat is used and the next token is `|`
 961                     // to warn about incompatibility with Rust 2021.
 962                     // We only emit this lint if we're parsing the original
 963                     // definition of this macro_rules, not while (re)parsing
 964                     // the macro when compiling another crate that is using the
 965                     // macro. (See #86567.)
 966                     // Macros defined in the current crate have a real node id,
 967                     // whereas macros from an external crate have a dummy id.
 968                     if def.id != DUMMY_NODE_ID
 969                         && matches!(kind, NonterminalKind::PatParam { inferred: true })
 970                         && matches!(next_token, TokenTree::Token(token) if token.kind == BinOp(token::BinOpToken::Or))
 971                     {
 972                         // It is suggestion to use pat_param, for example: $x:pat -> $x:pat_param.
 973                         let suggestion = quoted_tt_to_string(&TokenTree::MetaVarDecl(
 974                             span,
 975                             name,
 976                             Some(NonterminalKind::PatParam { inferred: false }),
 977                         ));
 978                         sess.buffer_lint_with_diagnostic(
 979                             &RUST_2021_INCOMPATIBLE_OR_PATTERNS,
 980                             span,
 981                             ast::CRATE_NODE_ID,
 982                             "the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro",
 983                             BuiltinLintDiagnostics::OrPatternsBackCompat(span, suggestion),
 984                         );
 985                     }
 986                     match is_in_follow(next_token, kind) {
 987                         IsInFollow::Yes => {}
 988                         IsInFollow::No(possible) => {
 989                             let may_be = if last.tokens.len() == 1 && suffix_first.tokens.len() == 1
 990                             {
 991                                 "is"
 992                             } else {
 993                                 "may be"
 994                             };
 995
 996                             let sp = next_token.span();
 997                             let mut err = sess.span_diagnostic.struct_span_err(
 998                                 sp,
 999                                 &format!(
1000                                     "`${name}:{frag}` {may_be} followed by `{next}`, which \
1001                                      is not allowed for `{frag}` fragments",
1002                                     name = name,
1003                                     frag = kind,
1004                                     next = quoted_tt_to_string(next_token),
1005                                     may_be = may_be
1006                                 ),
1007                             );
1008                             err.span_label(sp, format!("not allowed after `{}` fragments", kind));
1009                             let msg = "allowed there are: ";
1010                             match possible {
1011                                 &[] => {}
1012                                 &[t] => {
1013                                     err.note(&format!(
1014                                         "only {} is allowed after `{}` fragments",
1015                                         t, kind,
1016                                     ));
1017                                 }
1018                                 ts => {
1019                                     err.note(&format!(
1020                                         "{}{} or {}",
1021                                         msg,
1022                                         ts[..ts.len() - 1]
1023                                             .iter()
1024                                             .copied()
1025                                             .collect::<Vec<_>>()
1026                                             .join(", "),
1027                                         ts[ts.len() - 1],
1028                                     ));
1029                                 }
1030                             }
1031                             err.emit();
1032                         }
1033                     }
1034                 }
1035             }
1036         }
1037     }
1038     last
1039 }
1040
1041 fn token_can_be_followed_by_any(tok: &mbe::TokenTree) -> bool {
1042     if let mbe::TokenTree::MetaVarDecl(_, _, Some(kind)) = *tok {
1043         frag_can_be_followed_by_any(kind)
1044     } else {
1045         // (Non NT's can always be followed by anything in matchers.)
1046         true
1047     }
1048 }
1049
1050 /// Returns `true` if a fragment of type `frag` can be followed by any sort of
1051 /// token. We use this (among other things) as a useful approximation
1052 /// for when `frag` can be followed by a repetition like `$(...)*` or
1053 /// `$(...)+`. In general, these can be a bit tricky to reason about,
1054 /// so we adopt a conservative position that says that any fragment
1055 /// specifier which consumes at most one token tree can be followed by
1056 /// a fragment specifier (indeed, these fragments can be followed by
1057 /// ANYTHING without fear of future compatibility hazards).
1058 fn frag_can_be_followed_by_any(kind: NonterminalKind) -> bool {
1059     matches!(
1060         kind,
1061         NonterminalKind::Item           // always terminated by `}` or `;`
1062         | NonterminalKind::Block        // exactly one token tree
1063         | NonterminalKind::Ident        // exactly one token tree
1064         | NonterminalKind::Literal      // exactly one token tree
1065         | NonterminalKind::Meta         // exactly one token tree
1066         | NonterminalKind::Lifetime     // exactly one token tree
1067         | NonterminalKind::TT // exactly one token tree
1068     )
1069 }
1070
1071 enum IsInFollow {
1072     Yes,
1073     No(&'static [&'static str]),
1074 }
1075
1076 /// Returns `true` if `frag` can legally be followed by the token `tok`. For
1077 /// fragments that can consume an unbounded number of tokens, `tok`
1078 /// must be within a well-defined follow set. This is intended to
1079 /// guarantee future compatibility: for example, without this rule, if
1080 /// we expanded `expr` to include a new binary operator, we might
1081 /// break macros that were relying on that binary operator as a
1082 /// separator.
1083 // when changing this do not forget to update doc/book/macros.md!
1084 fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
1085     use mbe::TokenTree;
1086
1087     if let TokenTree::Token(Token { kind: token::CloseDelim(_), .. }) = *tok {
1088         // closing a token tree can never be matched by any fragment;
1089         // iow, we always require that `(` and `)` match, etc.
1090         IsInFollow::Yes
1091     } else {
1092         match kind {
1093             NonterminalKind::Item => {
1094                 // since items *must* be followed by either a `;` or a `}`, we can
1095                 // accept anything after them
1096                 IsInFollow::Yes
1097             }
1098             NonterminalKind::Block => {
1099                 // anything can follow block, the braces provide an easy boundary to
1100                 // maintain
1101                 IsInFollow::Yes
1102             }
1103             NonterminalKind::Stmt | NonterminalKind::Expr => {
1104                 const TOKENS: &[&str] = &["`=>`", "`,`", "`;`"];
1105                 match tok {
1106                     TokenTree::Token(token) => match token.kind {
1107                         FatArrow | Comma | Semi => IsInFollow::Yes,
1108                         _ => IsInFollow::No(TOKENS),
1109                     },
1110                     _ => IsInFollow::No(TOKENS),
1111                 }
1112             }
1113             NonterminalKind::PatParam { .. } => {
1114                 const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`|`", "`if`", "`in`"];
1115                 match tok {
1116                     TokenTree::Token(token) => match token.kind {
1117                         FatArrow | Comma | Eq | BinOp(token::Or) => IsInFollow::Yes,
1118                         Ident(name, false) if name == kw::If || name == kw::In => IsInFollow::Yes,
1119                         _ => IsInFollow::No(TOKENS),
1120                     },
1121                     _ => IsInFollow::No(TOKENS),
1122                 }
1123             }
1124             NonterminalKind::PatWithOr { .. } => {
1125                 const TOKENS: &[&str] = &["`=>`", "`,`", "`=`", "`if`", "`in`"];
1126                 match tok {
1127                     TokenTree::Token(token) => match token.kind {
1128                         FatArrow | Comma | Eq => IsInFollow::Yes,
1129                         Ident(name, false) if name == kw::If || name == kw::In => IsInFollow::Yes,
1130                         _ => IsInFollow::No(TOKENS),
1131                     },
1132                     _ => IsInFollow::No(TOKENS),
1133                 }
1134             }
1135             NonterminalKind::Path | NonterminalKind::Ty => {
1136                 const TOKENS: &[&str] = &[
1137                     "`{`", "`[`", "`=>`", "`,`", "`>`", "`=`", "`:`", "`;`", "`|`", "`as`",
1138                     "`where`",
1139                 ];
1140                 match tok {
1141                     TokenTree::Token(token) => match token.kind {
1142                         OpenDelim(token::DelimToken::Brace)
1143                         | OpenDelim(token::DelimToken::Bracket)
1144                         | Comma
1145                         | FatArrow
1146                         | Colon
1147                         | Eq
1148                         | Gt
1149                         | BinOp(token::Shr)
1150                         | Semi
1151                         | BinOp(token::Or) => IsInFollow::Yes,
1152                         Ident(name, false) if name == kw::As || name == kw::Where => {
1153                             IsInFollow::Yes
1154                         }
1155                         _ => IsInFollow::No(TOKENS),
1156                     },
1157                     TokenTree::MetaVarDecl(_, _, Some(NonterminalKind::Block)) => IsInFollow::Yes,
1158                     _ => IsInFollow::No(TOKENS),
1159                 }
1160             }
1161             NonterminalKind::Ident | NonterminalKind::Lifetime => {
1162                 // being a single token, idents and lifetimes are harmless
1163                 IsInFollow::Yes
1164             }
1165             NonterminalKind::Literal => {
1166                 // literals may be of a single token, or two tokens (negative numbers)
1167                 IsInFollow::Yes
1168             }
1169             NonterminalKind::Meta | NonterminalKind::TT => {
1170                 // being either a single token or a delimited sequence, tt is
1171                 // harmless
1172                 IsInFollow::Yes
1173             }
1174             NonterminalKind::Vis => {
1175                 // Explicitly disallow `priv`, on the off chance it comes back.
1176                 const TOKENS: &[&str] = &["`,`", "an ident", "a type"];
1177                 match tok {
1178                     TokenTree::Token(token) => match token.kind {
1179                         Comma => IsInFollow::Yes,
1180                         Ident(name, is_raw) if is_raw || name != kw::Priv => IsInFollow::Yes,
1181                         _ => {
1182                             if token.can_begin_type() {
1183                                 IsInFollow::Yes
1184                             } else {
1185                                 IsInFollow::No(TOKENS)
1186                             }
1187                         }
1188                     },
1189                     TokenTree::MetaVarDecl(
1190                         _,
1191                         _,
1192                         Some(NonterminalKind::Ident | NonterminalKind::Ty | NonterminalKind::Path),
1193                     ) => IsInFollow::Yes,
1194                     _ => IsInFollow::No(TOKENS),
1195                 }
1196             }
1197         }
1198     }
1199 }
1200
1201 fn quoted_tt_to_string(tt: &mbe::TokenTree) -> String {
1202     match *tt {
1203         mbe::TokenTree::Token(ref token) => pprust::token_to_string(&token),
1204         mbe::TokenTree::MetaVar(_, name) => format!("${}", name),
1205         mbe::TokenTree::MetaVarDecl(_, name, Some(kind)) => format!("${}:{}", name, kind),
1206         mbe::TokenTree::MetaVarDecl(_, name, None) => format!("${}:", name),
1207         _ => panic!(
1208             "{}",
1209             "unexpected mbe::TokenTree::{Sequence or Delimited} \
1210              in follow set checker"
1211         ),
1212     }
1213 }
1214
1215 fn parser_from_cx(sess: &ParseSess, tts: TokenStream) -> Parser<'_> {
1216     Parser::new(sess, tts, true, rustc_parse::MACRO_ARGUMENTS)
1217 }
1218
1219 /// Generates an appropriate parsing failure message. For EOF, this is "unexpected end...". For
1220 /// other tokens, this is "unexpected token...".
1221 fn parse_failure_msg(tok: &Token) -> String {
1222     match tok.kind {
1223         token::Eof => "unexpected end of macro invocation".to_string(),
1224         _ => format!("no rules expected the token `{}`", pprust::token_to_string(tok),),
1225     }
1226 }