Revert "rustc_expand: improve diagnostics for non-repeatable metavars"

compiler/rustc_expand/src/base.rs

@@ -277,16 +277,7 @@ impl<'cx> MacroExpanderResult<'cx> {
         // Emit the SEMICOLON_IN_EXPRESSIONS_FROM_MACROS deprecation lint.
         let is_local = true;
 
-        let parser = ParserAnyMacro::from_tts(
-            cx,
-            tts,
-            site_span,
-            arm_span,
-            is_local,
-            macro_ident,
-            vec![],
-            vec![],
-        );
+        let parser = ParserAnyMacro::from_tts(cx, tts, site_span, arm_span, is_local, macro_ident);
         ExpandResult::Ready(Box::new(parser))
     }
 }

compiler/rustc_expand/src/mbe/diagnostics.rs

@@ -222,13 +222,11 @@ impl<'dcx> CollectTrackerAndEmitter<'dcx, '_> {
 
 pub(super) fn emit_frag_parse_err(
     mut e: Diag<'_>,
-    parser: &mut Parser<'_>,
+    parser: &Parser<'_>,
     orig_parser: &mut Parser<'_>,
     site_span: Span,
     arm_span: Span,
     kind: AstFragmentKind,
-    bindings: Vec<Ident>,
-    matched_rule_bindings: Vec<Ident>,
 ) -> ErrorGuaranteed {
     // FIXME(davidtwco): avoid depending on the error message text
     if parser.token == token::Eof
@@ -287,54 +285,6 @@ pub(super) fn emit_frag_parse_err(
         },
         _ => annotate_err_with_kind(&mut e, kind, site_span),
     };
-
-    let matched_rule_bindings_names: Vec<_> =
-        matched_rule_bindings.iter().map(|bind| bind.name).collect();
-    let bindings_name: Vec<_> = bindings.iter().map(|bind| bind.name).collect();
-    if parser.token.kind == token::Dollar {
-        parser.bump();
-        if let token::Ident(name, _) = parser.token.kind {
-            if let Some(matched_name) = rustc_span::edit_distance::find_best_match_for_name(
-                &matched_rule_bindings_names[..],
-                name,
-                None,
-            ) {
-                e.span_suggestion_verbose(
-                    parser.token.span,
-                    "there is a macro metavariable with similar name",
-                    format!("{matched_name}"),
-                    Applicability::MaybeIncorrect,
-                );
-            } else if bindings_name.contains(&name) {
-                e.span_label(
-                    parser.token.span,
-                    format!(
-                        "there is an macro metavariable with this name in another macro matcher"
-                    ),
-                );
-            } else if let Some(matched_name) =
-                rustc_span::edit_distance::find_best_match_for_name(&bindings_name[..], name, None)
-            {
-                e.span_suggestion_verbose(
-                    parser.token.span,
-                    "there is a macro metavariable with a similar name in another macro matcher",
-                    format!("{matched_name}"),
-                    Applicability::MaybeIncorrect,
-                );
-            } else {
-                let msg = matched_rule_bindings_names
-                    .iter()
-                    .map(|sym| format!("${}", sym))
-                    .collect::<Vec<_>>()
-                    .join(", ");
-
-                e.span_label(parser.token.span, format!("macro metavariable not found"));
-                if !matched_rule_bindings_names.is_empty() {
-                    e.note(format!("available metavariable names are: {msg}"));
-                }
-            }
-        }
-    }
     e.emit()
 }
 

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -56,8 +56,6 @@ pub(crate) struct ParserAnyMacro<'a> {
     arm_span: Span,
     /// Whether or not this macro is defined in the current crate
     is_local: bool,
-    bindings: Vec<Ident>,
-    matched_rule_bindings: Vec<Ident>,
 }
 
 impl<'a> ParserAnyMacro<'a> {
@@ -70,22 +68,13 @@ impl<'a> ParserAnyMacro<'a> {
             arm_span,
             is_trailing_mac,
             is_local,
-            bindings,
-            matched_rule_bindings,
         } = *self;
         let snapshot = &mut parser.create_snapshot_for_diagnostic();
         let fragment = match parse_ast_fragment(parser, kind) {
             Ok(f) => f,
             Err(err) => {
                 let guar = diagnostics::emit_frag_parse_err(
-                    err,
-                    parser,
-                    snapshot,
-                    site_span,
-                    arm_span,
-                    kind,
-                    bindings,
-                    matched_rule_bindings,
+                    err, parser, snapshot, site_span, arm_span, kind,
                 );
                 return kind.dummy(site_span, guar);
             }
@@ -120,9 +109,6 @@ impl<'a> ParserAnyMacro<'a> {
         arm_span: Span,
         is_local: bool,
         macro_ident: Ident,
-        // bindings and lhs is for diagnostics
-        bindings: Vec<Ident>,
-        matched_rule_bindings: Vec<Ident>,
     ) -> Self {
         Self {
             parser: Parser::new(&cx.sess.psess, tts, None),
@@ -136,8 +122,6 @@ impl<'a> ParserAnyMacro<'a> {
             is_trailing_mac: cx.current_expansion.is_trailing_mac,
             arm_span,
             is_local,
-            bindings,
-            matched_rule_bindings,
         }
     }
 }
@@ -376,7 +360,7 @@ fn expand_macro<'cx>(
 
     match try_success_result {
         Ok((rule_index, rule, named_matches)) => {
-            let MacroRule::Func { lhs, rhs, .. } = rule else {
+            let MacroRule::Func { rhs, .. } = rule else {
                 panic!("try_match_macro returned non-func rule");
             };
             let mbe::TokenTree::Delimited(rhs_span, _, rhs) = rhs else {
@@ -404,32 +388,8 @@ fn expand_macro<'cx>(
                 cx.resolver.record_macro_rule_usage(node_id, rule_index);
             }
 
-            let mut bindings = vec![];
-            for rule in rules {
-                let MacroRule::Func { lhs, .. } = rule else { continue };
-                for param in lhs {
-                    let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
-                    bindings.push(*bind);
-                }
-            }
-
-            let mut matched_rule_bindings = vec![];
-            for param in lhs {
-                let MatcherLoc::MetaVarDecl { bind, .. } = param else { continue };
-                matched_rule_bindings.push(*bind);
-            }
-
             // Let the context choose how to interpret the result. Weird, but useful for X-macros.
-            Box::new(ParserAnyMacro::from_tts(
-                cx,
-                tts,
-                sp,
-                arm_span,
-                is_local,
-                name,
-                bindings,
-                matched_rule_bindings,
-            ))
+            Box::new(ParserAnyMacro::from_tts(cx, tts, sp, arm_span, is_local, name))
         }
         Err(CanRetry::No(guar)) => {
             debug!("Will not retry matching as an error was emitted already");

tests/ui/macros/issue-6596-1.stderr

@@ -2,15 +2,11 @@ error: expected expression, found `$`
   --> $DIR/issue-6596-1.rs:3:9
    |
 LL |         $nonexistent
-   |         ^-----------
-   |         ||
-   |         |macro metavariable not found
-   |         expected expression
+   |         ^^^^^^^^^^^^ expected expression
 ...
 LL |     e!(foo);
    |     ------- in this macro invocation
    |
-   = note: available metavariable names are: $inp
    = note: this error originates in the macro `e` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error