mbe: Initial support for macro fragment fields

This only supports a `name` field of `fn` and `adt` fragments, for now,
but it adds the infrastructure for adding more fields.

Author: joshtriplett

compiler/rustc_expand/messages.ftl

@@ -142,12 +142,13 @@ expand_mve_extra_tokens =
         *[other] these tokens
     }
 
-expand_mve_missing_paren =
-    expected `(`
-    .label = for this this metavariable expression
+expand_mve_extra_tokens_after_field = unexpected trailing tokens after field
+
+expand_mve_missing_paren_or_dot =
+    expected `(` or `.`
+    .label = after this metavariable expression
     .unexpected = unexpected token
-    .note = metavariable expressions use function-like parentheses syntax
-    .suggestion = try adding parentheses
+    .note = metavariable expressions use parentheses for functions or dot for fields
 
 expand_mve_unrecognized_expr =
     unrecognized metavariable expression
@@ -157,6 +158,8 @@ expand_mve_unrecognized_expr =
 expand_mve_unrecognized_var =
     variable `{$key}` is not recognized in meta-variable expression
 
+expand_mve_expr_has_no_field = expression of type `{$pnr_type}` has no field `{$field}`
+
 expand_non_inline_modules_in_proc_macro_input_are_unstable =
     non-inline modules in proc macro input are unstable
 

compiler/rustc_expand/src/errors.rs

@@ -487,17 +487,23 @@ mod metavar_exprs {
         pub name: String,
     }
 
+    #[derive(Diagnostic)]
+    #[diag(expand_mve_extra_tokens_after_field)]
+    pub(crate) struct MveExtraTokensAfterField {
+        #[primary_span]
+        #[suggestion(code = "", applicability = "machine-applicable")]
+        pub span: Span,
+    }
+
     #[derive(Diagnostic)]
     #[note]
-    #[diag(expand_mve_missing_paren)]
-    pub(crate) struct MveMissingParen {
+    #[diag(expand_mve_missing_paren_or_dot)]
+    pub(crate) struct MveMissingParenOrDot {
         #[primary_span]
         #[label]
         pub ident_span: Span,
         #[label(expand_unexpected)]
         pub unexpected_span: Option<Span>,
-        #[suggestion(code = "( /* ... */ )", applicability = "has-placeholders")]
-        pub insert_span: Option<Span>,
     }
 
     #[derive(Diagnostic)]
@@ -517,6 +523,15 @@ mod metavar_exprs {
         pub span: Span,
         pub key: MacroRulesNormalizedIdent,
     }
+
+    #[derive(Diagnostic)]
+    #[diag(expand_mve_expr_has_no_field)]
+    pub(crate) struct MveExprHasNoField {
+        #[primary_span]
+        pub span: Span,
+        pub pnr_type: &'static str,
+        pub field: Ident,
+    }
 }
 
 #[derive(Diagnostic)]

compiler/rustc_expand/src/mbe.rs

@@ -12,7 +12,7 @@ mod metavar_expr;
 mod quoted;
 mod transcribe;
 
-use metavar_expr::MetaVarExpr;
+use metavar_expr::{MetaVarExpr, MetaVarRecursiveExpr};
 use rustc_ast::token::{Delimiter, NonterminalKind, Token, TokenKind};
 use rustc_ast::tokenstream::{DelimSpacing, DelimSpan};
 use rustc_macros::{Decodable, Encodable};

compiler/rustc_expand/src/mbe/metavar_expr.rs

@@ -31,6 +31,9 @@ pub(crate) enum MetaVarExpr {
     /// The length of the repetition at a particular depth, where 0 is the innermost
     /// repetition. The `usize` is the depth.
     Len(usize),
+
+    /// An expression that can contain other expressions
+    Recursive(MetaVarRecursiveExpr),
 }
 
 impl MetaVarExpr {
@@ -41,19 +44,20 @@ impl MetaVarExpr {
         psess: &'psess ParseSess,
     ) -> PResult<'psess, MetaVarExpr> {
         let mut iter = input.iter();
+        // FIXME: Refactor this to use Parser.
+        // All macro metavariable expressions current start with an ident.
         let ident = parse_ident(&mut iter, psess, outer_span)?;
-        let next = iter.next();
-        let Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) = next else {
-            // No `()`; wrong or no delimiters. Point at a problematic span or a place to
-            // add parens if it makes sense.
-            let (unexpected_span, insert_span) = match next {
-                Some(TokenTree::Delimited(..)) => (None, None),
-                Some(tt) => (Some(tt.span()), None),
-                None => (None, Some(ident.span.shrink_to_hi())),
-            };
-            let err =
-                errors::MveMissingParen { ident_span: ident.span, unexpected_span, insert_span };
-            return Err(psess.dcx().create_err(err));
+        let args = match iter.next() {
+            Some(TokenTree::Token(Token { kind: token::Dot, .. }, _)) => {
+                return parse_field(ident, iter, psess, outer_span);
+            }
+            Some(TokenTree::Delimited(.., Delimiter::Parenthesis, args)) => args,
+            next => {
+                return Err(psess.dcx().create_err(errors::MveMissingParenOrDot {
+                    ident_span: ident.span,
+                    unexpected_span: next.map(|tt| tt.span()),
+                }));
+            }
         };
 
         // Ensure there are no trailing tokens in the braces, e.g. `${foo() extra}`
@@ -102,10 +106,55 @@ impl MetaVarExpr {
             }
             MetaVarExpr::Count(ident, _) | MetaVarExpr::Ignore(ident) => cb(aux, ident),
             MetaVarExpr::Index(..) | MetaVarExpr::Len(..) => aux,
+            MetaVarExpr::Recursive(expr) => expr.for_each_metavar(aux, cb),
+        }
+    }
+}
+
+/// A recursive meta-variable expression, which may contain other meta-variable expressions.
+#[derive(Debug, PartialEq, Encodable, Decodable)]
+pub(crate) enum MetaVarRecursiveExpr {
+    /// A single identifier, currently the only base of a recursive expression.
+    Ident(Ident),
+
+    /// A macro fragment field.
+    Field { expr: Box<MetaVarRecursiveExpr>, field: Ident },
+}
+
+impl MetaVarRecursiveExpr {
+    fn for_each_metavar<A>(&self, aux: A, mut cb: impl FnMut(A, &Ident) -> A) -> A {
+        match self {
+            Self::Ident(ident) => cb(aux, ident),
+            Self::Field { expr, field } => expr.for_each_metavar(cb(aux, field), cb),
         }
     }
 }
 
+/// Attempt to parse a meta-variable field.
+///
+/// The initial ident and dot have already been eaten.
+pub(crate) fn parse_field<'psess>(
+    base_ident: Ident,
+    mut iter: TokenStreamIter<'_>,
+    psess: &'psess ParseSess,
+    fallback_span: Span,
+) -> PResult<'psess, MetaVarExpr> {
+    let mut expr = MetaVarRecursiveExpr::Ident(base_ident);
+    let field = parse_ident(&mut iter, psess, fallback_span)?;
+    expr = MetaVarRecursiveExpr::Field { expr: Box::new(expr), field };
+    while let Some(TokenTree::Token(Token { kind: token::Dot, .. }, _)) = iter.next() {
+        let field = parse_ident(&mut iter, psess, fallback_span)?;
+        expr = MetaVarRecursiveExpr::Field { expr: Box::new(expr), field };
+    }
+
+    // Check for unexpected tokens
+    if let Some(span) = iter_span(&iter) {
+        return Err(psess.dcx().create_err(errors::MveExtraTokensAfterField { span }));
+    }
+
+    Ok(MetaVarExpr::Recursive(expr))
+}
+
 /// Checks if there are any remaining tokens (for example, `${ignore($valid, extra)}`) and create
 /// a diag with the correct arg count if so.
 fn check_trailing_tokens<'psess>(

compiler/rustc_expand/src/mbe/quoted.rs

@@ -190,6 +190,13 @@ fn maybe_emit_macro_metavar_expr_concat_feature(features: &Features, sess: &Sess
     }
 }
 
+fn maybe_emit_macro_fragment_fields_feature(features: &Features, sess: &Session, span: Span) {
+    if !features.macro_fragment_fields() {
+        let msg = "macro fragment fields are unstable";
+        feature_err(sess, sym::macro_fragment_fields, span, msg).emit();
+    }
+}
+
 /// Takes a `tokenstream::TokenTree` and returns a `self::TokenTree`. Specifically, this takes a
 /// generic `TokenTree`, such as is used in the rest of the compiler, and returns a `TokenTree`
 /// for use in parsing a macro.
@@ -257,18 +264,26 @@ fn parse_tree<'a>(
                                         return TokenTree::token(token::Dollar, dollar_span);
                                     }
                                     Ok(elem) => {
-                                        if let MetaVarExpr::Concat(_) = elem {
-                                            maybe_emit_macro_metavar_expr_concat_feature(
-                                                features,
-                                                sess,
-                                                delim_span.entire(),
-                                            );
-                                        } else {
-                                            maybe_emit_macro_metavar_expr_feature(
+                                        match elem {
+                                            MetaVarExpr::Concat(..) => {
+                                                maybe_emit_macro_metavar_expr_concat_feature(
+                                                    features,
+                                                    sess,
+                                                    delim_span.entire(),
+                                                )
+                                            }
+                                            MetaVarExpr::Recursive(..) => {
+                                                maybe_emit_macro_fragment_fields_feature(
+                                                    features,
+                                                    sess,
+                                                    delim_span.entire(),
+                                                )
+                                            }
+                                            _ => maybe_emit_macro_metavar_expr_feature(
                                                 features,
                                                 sess,
                                                 delim_span.entire(),
-                                            );
+                                            ),
                                         }
                                         return TokenTree::MetaVarExpr(delim_span, elem);
                                     }

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -1,10 +1,11 @@
+use std::borrow::Cow;
 use std::mem;
 
 use rustc_ast::token::{
     self, Delimiter, IdentIsRaw, InvisibleOrigin, Lit, LitKind, MetaVarKind, Token, TokenKind,
 };
 use rustc_ast::tokenstream::{DelimSpacing, DelimSpan, Spacing, TokenStream, TokenTree};
-use rustc_ast::{ExprKind, StmtKind, TyKind, UnOp};
+use rustc_ast::{self as ast, ExprKind, ItemKind, StmtKind, TyKind, UnOp};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Diag, DiagCtxtHandle, PResult, pluralize};
 use rustc_parse::lexer::nfc_normalize;
@@ -18,12 +19,12 @@ use smallvec::{SmallVec, smallvec};
 
 use crate::errors::{
     CountRepetitionMisplaced, MacroVarStillRepeating, MetaVarsDifSeqMatchers, MustRepeatOnce,
-    MveUnrecognizedVar, NoSyntaxVarsExprRepeat,
+    MveExprHasNoField, MveUnrecognizedVar, NoSyntaxVarsExprRepeat,
 };
 use crate::mbe::macro_parser::NamedMatch;
 use crate::mbe::macro_parser::NamedMatch::*;
 use crate::mbe::metavar_expr::{MetaVarExprConcatElem, RAW_IDENT_ERR};
-use crate::mbe::{self, KleeneOp, MetaVarExpr};
+use crate::mbe::{self, KleeneOp, MetaVarExpr, MetaVarRecursiveExpr};
 
 /// Context needed to perform transcription of metavariable expressions.
 struct TranscrCtx<'psess, 'itp> {
@@ -540,11 +541,105 @@ fn transcribe_metavar_expr<'tx>(
                 return Err(out_of_bounds_err(dcx, tscx.repeats.len(), dspan.entire(), "len"));
             }
         },
+        MetaVarExpr::Recursive(ref expr) => {
+            let pnr = eval_metavar_recursive_expr(tscx, expr)?;
+            return transcribe_pnr(tscx, dspan.entire(), &pnr);
+        }
     };
     tscx.result.push(tt);
     Ok(())
 }
 
+/// Evaluate recursive metavariable expressions into a `ParseNtResult`.
+///
+/// This does not do any transcription; that's handled in the caller.
+///
+/// It's okay to recurse here for now, because we expect a limited degree of nested fields. More
+/// complex expressions may require translating this into a proper interpreter.
+fn eval_metavar_recursive_expr<'psess, 'interp>(
+    tscx: &TranscrCtx<'psess, 'interp>,
+    expr: &MetaVarRecursiveExpr,
+) -> PResult<'psess, Cow<'interp, ParseNtResult>> {
+    let dcx = tscx.psess.dcx();
+    match expr {
+        MetaVarRecursiveExpr::Ident(ident) => {
+            let span = ident.span;
+            let ident = MacroRulesNormalizedIdent::new(*ident);
+            match matched_from_mrn_ident(dcx, span, ident, tscx.interp)? {
+                NamedMatch::MatchedSingle(pnr) => Ok(Cow::Borrowed(pnr)),
+                NamedMatch::MatchedSeq(named_matches) => {
+                    let Some((curr_idx, _)) = tscx.repeats.last() else {
+                        return Err(dcx.struct_span_err(span, "invalid syntax"));
+                    };
+                    match &named_matches[*curr_idx] {
+                        MatchedSeq(_) => {
+                            Err(dcx.create_err(MacroVarStillRepeating { span, ident }))
+                        }
+                        MatchedSingle(pnr) => Ok(Cow::Borrowed(pnr)),
+                    }
+                }
+            }
+        }
+        MetaVarRecursiveExpr::Field { expr: base_expr, field } => {
+            let base_pnr = eval_metavar_recursive_expr(tscx, base_expr)?;
+            let err_unknown_field = || {
+                Err(dcx.create_err(MveExprHasNoField {
+                    span: field.span,
+                    pnr_type: pnr_type(&base_pnr),
+                    field: *field,
+                }))
+            };
+            match (base_pnr.as_ref(), field.name) {
+                (ParseNtResult::Adt(adt_item), sym::name) => {
+                    let ident = match adt_item.kind {
+                        ItemKind::Struct(ident, ..)
+                        | ItemKind::Enum(ident, ..)
+                        | ItemKind::Union(ident, ..) => ident,
+                        _ => dcx.span_bug(field.span, "`adt` item was not an adt"),
+                    };
+                    Ok(ident_pnr(ident))
+                }
+                (ParseNtResult::Fn(fn_item), sym::name) => {
+                    let f = require_fn_item(fn_item);
+                    Ok(ident_pnr(f.ident))
+                }
+                (_, _) => err_unknown_field(),
+            }
+        }
+    }
+}
+
+fn ident_pnr(ident: Ident) -> Cow<'static, ParseNtResult> {
+    Cow::Owned(ParseNtResult::Ident(ident, ident.is_raw_guess().into()))
+}
+
+fn pnr_type(pnr: &ParseNtResult) -> &'static str {
+    match pnr {
+        ParseNtResult::Tt(..) => "tt",
+        ParseNtResult::Ident(..) => "ident",
+        ParseNtResult::Lifetime(..) => "lifetime",
+        ParseNtResult::Item(..) => "item",
+        ParseNtResult::Fn(..) => "fn",
+        ParseNtResult::Adt(..) => "adt",
+        ParseNtResult::Block(..) => "block",
+        ParseNtResult::Stmt(..) => "stmt",
+        ParseNtResult::Pat(..) => "pat",
+        ParseNtResult::Expr(..) => "expr",
+        ParseNtResult::Literal(..) => "literal",
+        ParseNtResult::Ty(..) => "ty",
+        ParseNtResult::Meta(..) => "meta",
+        ParseNtResult::Path(..) => "path",
+        ParseNtResult::Vis(..) => "vis",
+    }
+}
+
+fn require_fn_item(item: &ast::Item) -> &ast::Fn {
+    match item.kind {
+        ItemKind::Fn(ref f) => &f,
+        _ => panic!("`fn` item was not a fn"),
+    }
+}
+
 /// Handle the `${concat(...)}` metavariable expression.
 fn metavar_expr_concat<'tx>(
     tscx: &mut TranscrCtx<'tx, '_>,
@@ -891,8 +986,19 @@ fn matched_from_ident<'ctx, 'interp, 'rslt>(
 where
     'interp: 'rslt,
 {
-    let span = ident.span;
-    let key = MacroRulesNormalizedIdent::new(ident);
+    matched_from_mrn_ident(dcx, ident.span, MacroRulesNormalizedIdent::new(ident), interp)
+}
+
+/// Returns a `NamedMatch` item declared on the LHS given an arbitrary [MacroRulesNormalizedIdent]
+fn matched_from_mrn_ident<'ctx, 'interp, 'rslt>(
+    dcx: DiagCtxtHandle<'ctx>,
+    span: Span,
+    key: MacroRulesNormalizedIdent,
+    interp: &'interp FxHashMap<MacroRulesNormalizedIdent, NamedMatch>,
+) -> PResult<'ctx, &'rslt NamedMatch>
+where
+    'interp: 'rslt,
+{
     interp.get(&key).ok_or_else(|| dcx.create_err(MveUnrecognizedVar { span, key }))
 }
 

compiler/rustc_feature/src/unstable.rs

@@ -553,6 +553,8 @@ declare_features! (
     (unstable, macro_attr, "1.91.0", Some(143547)),
     /// Allow `macro_rules!` derive rules
     (unstable, macro_derive, "1.91.0", Some(143549)),
+    /// Allow macro fragment fields: `${fragment.field}`
+    (incomplete, macro_fragment_fields, "CURRENT_RUSTC_VERSION", Some(147023)),
     /// Allow `macro_rules!` fragments `:fn` and `:adt`
     (incomplete, macro_fragments_more, "CURRENT_RUSTC_VERSION", Some(147023)),
     /// Give access to additional metadata about declarative macro meta-variables.