mbe: Refactor diagnostics for invalid metavar expression syntax

Give a more user-friendly diagnostic about the following:

* Invalid syntax within the `${...}` braces, including missing
  parentheses or trailing tokens.
* Incorrect number of arguments passed to specific metavariable
  expressions.

Author: tgross35

compiler/rustc_expand/messages.ftl

@@ -141,6 +141,25 @@ expand_mve_expected_ident =
     .ignore_expr_note = `ignore` takes a metavariable argument
     .count_expr_note = `count` takes a metavariable argument
 
+expand_mve_extra_tokens_in_braces =
+    unexpected trailing tokens in metavariable expression braces
+    .suggestion = try removing these tokens
+
+expand_mve_extra_tokens_in_expr =
+    unexpected trailing tokens in metavariable expression
+    .label = for this metavariable expression
+    .note= the `{$name}` metavariable expression takes up to {$max} arguments
+    .suggestion = try removing {$count ->
+        [one] this token
+        *[other] these tokens
+    }
+
+expand_mve_missing_paren =
+    expected `(`
+    .label = for this this metavariable expression
+    .note = metavariable expressions use function-like parentheses syntax
+    .suggestion = try adding parentheses
+
 expand_mve_unrecognized_var =
     variable `{$key}` is not recognized in meta-variable expression
 

compiler/rustc_expand/src/errors.rs

@@ -520,6 +520,38 @@ mod metavar_exprs {
         Count,
     }
 
+    #[derive(Diagnostic)]
+    #[diag(expand_mve_extra_tokens_in_braces)]
+    pub(crate) struct MveExtraTokensInBraces {
+        #[primary_span]
+        #[suggestion(code = "", applicability = "machine-applicable")]
+        pub span: Span,
+    }
+
+    #[derive(Diagnostic)]
+    #[note]
+    #[diag(expand_mve_extra_tokens_in_expr)]
+    pub(crate) struct MveExtraTokensInExpr {
+        #[primary_span]
+        #[suggestion(code = "", applicability = "machine-applicable")]
+        pub span: Span,
+        #[label]
+        pub ident_span: Span,
+        pub count: usize,
+        pub max: usize,
+        pub name: &'static str,
+    }
+
+    #[derive(Diagnostic)]
+    #[note]
+    #[diag(expand_mve_missing_paren)]
+    pub(crate) struct MveMissingParen {
+        #[primary_span]
+        pub span: Span,
+        #[suggestion(code = "( /* ... */ )", applicability = "has-placeholders")]
+        pub insert_span: Option<Span>,
+    }
+
     #[derive(Diagnostic)]
     #[diag(expand_mve_unrecognized_var)]
     pub(crate) struct MveUnrecognizedVar {

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -12,8 +12,18 @@ use crate::errors::{self, MveExpectedIdentContext};
 pub(crate) const RAW_IDENT_ERR: &str = "`${concat(..)}` currently does not support raw identifiers";
 pub(crate) const UNSUPPORTED_CONCAT_ELEM_ERR: &str = "expected identifier or string literal";
 
+/// List of the below list for diagnostics.
 const VALID_METAVAR_EXPR_NAMES: &str = "`count`, `ignore`, `index`, `len`, and `concat`";
 
+/// Map from expression names to the maximum arg count.
+const EXPR_NAME_ARG_MAP: &[(&str, Option<usize>)] = &[
+    ("concat", None),
+    ("count", Some(2)),
+    ("ignore", Some(1)),
+    ("index", Some(2)),
+    ("len", Some(2)),
+];
+
 /// A meta-variable expression, for expansions based on properties of meta-variables.
 #[derive(Debug, PartialEq, Encodable, Decodable)]
 pub(crate) enum MetaVarExpr {
@@ -49,11 +59,26 @@ impl MetaVarExpr {
             outer_span,
             MveExpectedIdentContext::ExprName { valid_expr_list: VALID_METAVAR_EXPR_NAMES },
         )?;
-        let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = iter.next() else {
-            let msg = "meta-variable expression parameter must be wrapped in parentheses";
-            return Err(psess.dcx().struct_span_err(ident.span, msg));
+
+        let next = iter.next();
+        let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = next else {
+            // No `()`; wrong or no delimiters
+            let (span, insert_span) = match next {
+                Some(TokenTree::Delimited(delim, ..)) => (delim.open, None),
+                Some(tt) => (tt.span(), Some(ident.span.shrink_to_hi())),
+                None => (ident.span.shrink_to_hi(), Some(ident.span.shrink_to_hi())),
+            };
+            let err = errors::MveMissingParen { span, insert_span };
+            return Err(psess.dcx().create_err(err));
         };
-        check_trailing_token(&mut iter, psess)?;
+
+        // Ensure there are no other tokens in the
+        if iter.peek().is_some() {
+            let span = iter_span(&iter).expect("checked is_some above");
+            let err = errors::MveExtraTokensInBraces { span };
+            return Err(psess.dcx().create_err(err));
+        }
+
         let mut iter = args.iter();
         let rslt = match ident.as_str() {
             "concat" => parse_concat(&mut iter, psess, outer_span, ident.span)?,
@@ -78,7 +103,7 @@ impl MetaVarExpr {
                 return Err(err);
             }
         };
-        check_trailing_token(&mut iter, psess)?;
+        check_trailing_tokens(&mut iter, psess, ident)?;
         Ok(rslt)
     }
 
@@ -98,20 +123,44 @@ impl MetaVarExpr {
     }
 }
 
-// Checks if there are any remaining tokens. For example, `${ignore(ident ... a b c ...)}`
-fn check_trailing_token<'psess>(
+/// Checks if there are any remaining tokens. For example, `${ignore(ident ... a b c ...)}`
+fn check_trailing_tokens<'psess>(
     iter: &mut TokenStreamIter<'_>,
     psess: &'psess ParseSess,
+    ident: Ident,
 ) -> PResult<'psess, ()> {
-    if let Some(tt) = iter.next() {
-        let mut diag = psess
-            .dcx()
-            .struct_span_err(tt.span(), format!("unexpected token: {}", pprust::tt_to_string(tt)));
-        diag.span_note(tt.span(), "meta-variable expression must not have trailing tokens");
-        Err(diag)
-    } else {
-        Ok(())
+    if iter.peek().is_none() {
+        // All tokens used, no problem
+        return Ok(());
     }
+
+    let (name, max) = EXPR_NAME_ARG_MAP
+        .iter()
+        .find(|(name, _)| *name == ident.as_str())
+        .expect("called with an invalid name");
+
+    let Some(max) = *max else {
+        // For expressions like `concat`, all tokens should be consumed already
+        panic!("{name} takes unlimited tokens but didn't eat them all");
+    };
+
+    let err = errors::MveExtraTokensInExpr {
+        span: iter_span(iter).expect("checked is_none above"),
+        ident_span: ident.span,
+        count: iter.count(),
+        max,
+        name,
+    };
+    Err(psess.dcx().create_err(err))
+}
+
+/// Returns a span encompassing all tokens in the iterator if there is at least one item.
+fn iter_span(iter: &TokenStreamIter<'_>) -> Option<Span> {
+    let mut iter = iter.clone(); // cloning is cheap
+    let first_sp = iter.next()?.span();
+    let last_sp = iter.last().map(TokenTree::span).unwrap_or(first_sp);
+    let span = first_sp.with_hi(last_sp.hi());
+    Some(span)
 }
 
 /// Indicates what is placed in a `concat` parameter. For example, literals

tests/ui/macros/metavar-expressions/syntax-errors.rs

@@ -30,7 +30,7 @@ macro_rules! metavar_with_literal_suffix {
 
 macro_rules! mve_without_parens {
     ( $( $i:ident ),* ) => { ${ count } };
-    //~^ ERROR meta-variable expression parameter must be wrapped in parentheses
+    //~^ ERROR expected `(`
 }
 
 #[rustfmt::skip]
@@ -47,7 +47,7 @@ macro_rules! open_brackets_with_lit {
 
 macro_rules! mve_wrong_delim {
     ( $( $i:ident ),* ) => { ${ count{i} } };
-    //~^ ERROR meta-variable expression parameter must be wrapped in parentheses
+    //~^ ERROR expected `(`
 }
 
 macro_rules! invalid_metavar {
@@ -64,28 +64,28 @@ macro_rules! open_brackets_with_group {
 macro_rules! extra_garbage_after_metavar {
     ( $( $i:ident ),* ) => {
         ${count() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i, 1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${count($i) a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${ignore($i) a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${ignore($i a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${index() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${index(1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
 
         ${index() a b c}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
         ${index(1 a b c)}
-        //~^ ERROR unexpected token: a
+        //~^ ERROR unexpected trailing tokens
     };
 }