tweaks

Author: estebank

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -67,6 +67,12 @@ pub(super) fn failed_to_match_macro<'cx>(
         && (matches!(expected_token.kind, TokenKind::Interpolated(_))
             || matches!(token.kind, TokenKind::Interpolated(_)))
     {
+        if let TokenKind::Interpolated(node) = &expected_token.kind {
+            err.span_label(node.def_span(), "");
+        }
+        if let TokenKind::Interpolated(node) = &token.kind {
+            err.span_label(node.def_span(), "");
+        }
         err.note("captured metavariables except for `:tt`, `:ident` and `:lifetime` cannot be compared to other tokens");
         err.note("see <https://doc.rust-lang.org/nightly/reference/macros-by-example.html#forwarding-a-matched-fragment> for more information");
 

compiler/rustc_expand/src/mbe/macro_parser.rs

@@ -397,7 +397,7 @@ pub(crate) enum NamedMatch {
     MatchedTokenTree(rustc_ast::tokenstream::TokenTree),
 
     // A metavar match of any type other than `tt`.
-    MatchedNonterminal(Lrc<Nonterminal>, Span),
+    MatchedNonterminal(Lrc<Nonterminal>),
 }
 
 /// Performs a token equality check, ignoring syntax context (that is, an unhygienic comparison)
@@ -694,7 +694,7 @@ impl TtParser {
                             Ok(nt) => nt,
                         };
                         let m = match nt {
-                            ParseNtResult::Nt(nt) => MatchedNonterminal(Lrc::new(nt), span),
+                            ParseNtResult::Nt(nt) => MatchedNonterminal(Lrc::new(nt)),
                             ParseNtResult::Tt(tt) => MatchedTokenTree(tt),
                         };
                         mp.push_match(next_metavar, seq_depth, m);

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -225,23 +225,11 @@ pub(super) fn transcribe<'a>(
                             // without wrapping them into groups.
                             result.push(tt.clone());
                         }
-                        MatchedNonterminal(nt, span) => {
-                            info!(?span, ?nt, "nt, span: {:?} {:?}", nt.use_span(), nt.def_span());
+                        MatchedNonterminal(nt) => {
                             // Other variables are emitted into the output stream as groups with
                             // `Delimiter::Invisible` to maintain parsing priorities.
                             // `Interpolated` is currently used for such groups in rustc parser.
                             marker.visit_span(&mut sp);
-                            // let mut data = span.expn_data();
-                            // let mut span = *span;
-                            // marker.visit_span(&mut span);
-                            // data.call_site = span;
-                            // // let mut span = *span;
-                            // // span = span.apply_mark(marker.0.to_expn_id(), marker.1);
-                            // // marker.visit_span(&mut span);
-                            // let expn_id = LocalExpnId::fresh(
-                            //     data,
-                            //     self.create_stable_hashing_context(),
-                            // );
                             result
                                 .push(TokenTree::token_alone(token::Interpolated(nt.clone()), sp));
                         }
@@ -313,7 +301,7 @@ fn lookup_cur_matched<'a>(
     interpolations.get(&ident).map(|mut matched| {
         for &(idx, _) in repeats {
             match matched {
-                MatchedTokenTree(_) | MatchedNonterminal(_, _) => break,
+                MatchedTokenTree(_) | MatchedNonterminal(_) => break,
                 MatchedSeq(ads) => matched = ads.get(idx).unwrap(),
             }
         }
@@ -403,7 +391,7 @@ fn lockstep_iter_size(
             let name = MacroRulesNormalizedIdent::new(*name);
             match lookup_cur_matched(name, interpolations, repeats) {
                 Some(matched) => match matched {
-                    MatchedTokenTree(_) | MatchedNonterminal(_, _) => {
+                    MatchedTokenTree(_) | MatchedNonterminal(_) => {
                         LockstepIterSize::Unconstrained
                     }
                     MatchedSeq(ads) => LockstepIterSize::Constraint(ads.len(), name),
@@ -454,7 +442,7 @@ fn count_repetitions<'a>(
         sp: &DelimSpan,
     ) -> PResult<'a, usize> {
         match matched {
-            MatchedTokenTree(_) | MatchedNonterminal(_, _) => {
+            MatchedTokenTree(_) | MatchedNonterminal(_) => {
                 if declared_lhs_depth == 0 {
                     return Err(cx.create_err(CountRepetitionMisplaced { span: sp.entire() }));
                 }

tests/ui/macros/nonterminal-matching.stderr

@@ -1,6 +1,8 @@
 error: no rules expected the token `enum E {}`
   --> $DIR/nonterminal-matching.rs:19:10
    |
+LL | macro complex_nonterminal($nt_item: item) {
+   |                           --------------
 LL |     macro n(a $nt_item b) {
    |     --------------------- when calling this macro
 ...