mbe: Add fragment type adt to parse an ADT (struct, enum, or union)

Author: joshtriplett

compiler/rustc_ast/src/token.rs

@@ -1102,6 +1102,7 @@ pub enum NonterminalKind {
     Vis,
     TT,
     Fn,
+    Adt,
 }
 
 impl NonterminalKind {
@@ -1140,6 +1141,7 @@ impl NonterminalKind {
             sym::vis => NonterminalKind::Vis,
             sym::tt => NonterminalKind::TT,
             kw::Fn => NonterminalKind::Fn,
+            sym::adt => NonterminalKind::Adt,
             _ => return None,
         })
     }
@@ -1162,6 +1164,7 @@ impl NonterminalKind {
             NonterminalKind::Vis => sym::vis,
             NonterminalKind::TT => sym::tt,
             NonterminalKind::Fn => kw::Fn,
+            NonterminalKind::Adt => sym::adt,
         }
     }
 }

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -1550,7 +1550,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
         IsInFollow::Yes
     } else {
         match kind {
-            NonterminalKind::Item | NonterminalKind::Fn => {
+            NonterminalKind::Item | NonterminalKind::Fn | NonterminalKind::Adt => {
                 // since items *must* be followed by either a `;` or a `}`, we can
                 // accept anything after them
                 IsInFollow::Yes

compiler/rustc_expand/src/mbe/quoted.rs

@@ -14,7 +14,8 @@ use crate::mbe::{Delimited, KleeneOp, KleeneToken, MetaVarExpr, SequenceRepetiti
 
 pub(crate) const VALID_FRAGMENT_NAMES_MSG: &str = "valid fragment specifiers are \
     `ident`, `block`, `stmt`, `expr`, `pat`, `ty`, `lifetime`, `literal`, `path`, \
-    `meta`, `tt`, `item`, `fn`, and `vis`, along with `expr_2021` and `pat_param` for edition compatibility";
+    `meta`, `tt`, `item`, `fn`, 'adt', and `vis`, \
+    along with `expr_2021` and `pat_param` for edition compatibility";
 
 /// Which part of a macro rule we're parsing
 #[derive(Copy, Clone)]
@@ -142,7 +143,9 @@ fn parse(
                 });
                 NonterminalKind::TT
             });
-            if matches!(kind, NonterminalKind::Fn) && !features.macro_fragments_more() {
+            if matches!(kind, NonterminalKind::Fn | NonterminalKind::Adt)
+                && !features.macro_fragments_more()
+            {
                 let msg = "macro `:fn` and `:adt` fragments are unstable";
                 feature_err(sess, sym::macro_fragments_more, span, msg).emit();
             }

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -437,7 +437,7 @@ fn transcribe_pnr<'tx>(
             let kind = token::NtLifetime(*ident, *is_raw);
             TokenTree::token_alone(kind, sp)
         }
-        ParseNtResult::Item(item) | ParseNtResult::Fn(item) => {
+        ParseNtResult::Item(item) | ParseNtResult::Fn(item) | ParseNtResult::Adt(item) => {
             mk_delimited(item.span, MetaVarKind::Item, TokenStream::from_ast(item))
         }
         ParseNtResult::Block(block) => {

compiler/rustc_parse/messages.ftl

@@ -721,6 +721,7 @@ parse_no_digits_literal = no valid digits found for number
 parse_non_string_abi_literal = non-string ABI literal
     .suggestion = specify the ABI with a string literal
 
+parse_nonterminal_expected_adt = expected a struct, enum, or union
 parse_nonterminal_expected_fn = expected a function
 parse_nonterminal_expected_ident = expected ident, found `{$token}`
 parse_nonterminal_expected_item_keyword = expected an item keyword

compiler/rustc_parse/src/errors.rs

@@ -2171,6 +2171,8 @@ pub(crate) enum UnexpectedNonterminal {
     Statement(#[primary_span] Span),
     #[diag(parse_nonterminal_expected_fn)]
     Fn(#[primary_span] Span),
+    #[diag(parse_nonterminal_expected_adt)]
+    Adt(#[primary_span] Span),
     #[diag(parse_nonterminal_expected_ident)]
     Ident {
         #[primary_span]

compiler/rustc_parse/src/parser/mod.rs

@@ -1670,6 +1670,7 @@ pub enum ParseNtResult {
     Lifetime(Ident, IdentIsRaw),
     Item(Box<ast::Item>),
     Fn(Box<ast::Item>),
+    Adt(Box<ast::Item>),
     Block(Box<ast::Block>),
     Stmt(Box<ast::Stmt>),
     Pat(Box<ast::Pat>, NtPatKind),

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -105,7 +105,8 @@ impl<'a> Parser<'a> {
             NonterminalKind::TT
             | NonterminalKind::Item
             | NonterminalKind::Stmt
-            | NonterminalKind::Fn => token.kind.close_delim().is_none(),
+            | NonterminalKind::Fn
+            | NonterminalKind::Adt => token.kind.close_delim().is_none(),
         }
     }
 
@@ -133,6 +134,18 @@ impl<'a> Parser<'a> {
                     Err(self.dcx().create_err(UnexpectedNonterminal::Fn(self.token.span)))
                 }
             }
+            NonterminalKind::Adt => {
+                if let Some(item) = self.parse_item(ForceCollect::Yes)?
+                    && matches!(
+                        item.kind,
+                        ItemKind::Struct(..) | ItemKind::Enum(..) | ItemKind::Union(..)
+                    )
+                {
+                    Ok(ParseNtResult::Adt(item))
+                } else {
+                    Err(self.dcx().create_err(UnexpectedNonterminal::Adt(self.token.span)))
+                }
+            }
             NonterminalKind::Block => {
                 // While a block *expression* may have attributes (e.g. `#[my_attr] { ... }`),
                 // the ':block' matcher does not support them

compiler/rustc_span/src/symbol.rs

@@ -422,6 +422,7 @@ symbols! {
         add_assign,
         add_with_overflow,
         address,
+        adt,
         adt_const_params,
         advanced_slice_patterns,
         adx_target_feature,

tests/ui/feature-gates/feature-gate-macro-fragments-more.rs

@@ -2,3 +2,6 @@
 
 macro_rules! use_fn { ($f:fn) => {} }
 //~^ ERROR macro `:fn` and `:adt` fragments are unstable
+
+macro_rules! use_adt { ($f:adt) => {} }
+//~^ ERROR macro `:fn` and `:adt` fragments are unstable