mbe: Add fragment type fn to parse a function

Author: joshtriplett

compiler/rustc_ast/src/token.rs

@@ -1101,6 +1101,7 @@ pub enum NonterminalKind {
     Path,
     Vis,
     TT,
+    Fn,
 }
 
 impl NonterminalKind {
@@ -1138,6 +1139,7 @@ impl NonterminalKind {
             sym::path => NonterminalKind::Path,
             sym::vis => NonterminalKind::Vis,
             sym::tt => NonterminalKind::TT,
+            kw::Fn => NonterminalKind::Fn,
             _ => return None,
         })
     }
@@ -1159,6 +1161,7 @@ impl NonterminalKind {
             NonterminalKind::Path => sym::path,
             NonterminalKind::Vis => sym::vis,
             NonterminalKind::TT => sym::tt,
+            NonterminalKind::Fn => kw::Fn,
         }
     }
 }

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::Item | NonterminalKind::Fn => {
                 // 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,7 @@ 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` and `vis`, along with `expr_2021` and `pat_param` for edition compatibility";
+    `meta`, `tt`, `item`, `fn`, 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,6 +142,10 @@ fn parse(
                 });
                 NonterminalKind::TT
             });
+            if matches!(kind, NonterminalKind::Fn) && !features.macro_fragments_more() {
+                let msg = "macro `:fn` and `:adt` fragments are unstable";
+                feature_err(sess, sym::macro_fragments_more, span, msg).emit();
+            }
             result.push(TokenTree::MetaVarDecl { span, name: ident, kind });
         } else {
             // Whether it's none or some other tree, it doesn't belong to

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::Item(item) | ParseNtResult::Fn(item) => {
             mk_delimited(item.span, MetaVarKind::Item, TokenStream::from_ast(item))
         }
         ParseNtResult::Block(block) => {

compiler/rustc_feature/src/unstable.rs

@@ -557,6 +557,8 @@ declare_features! (
     (unstable, macro_attr, "CURRENT_RUSTC_VERSION", Some(83527)),
     /// Allow `macro_rules!` derive rules
     (unstable, macro_derive, "CURRENT_RUSTC_VERSION", Some(143549)),
+    /// 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.
     (unstable, macro_metavar_expr, "1.61.0", Some(83527)),
     /// Provides a way to concatenate identifiers using metavariable expressions.

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_fn = expected a function
 parse_nonterminal_expected_ident = expected ident, found `{$token}`
 parse_nonterminal_expected_item_keyword = expected an item keyword
 parse_nonterminal_expected_lifetime = expected a lifetime, found `{$token}`

compiler/rustc_parse/src/errors.rs

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

compiler/rustc_parse/src/parser/mod.rs

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

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -1,3 +1,4 @@
+use rustc_ast::ItemKind;
 use rustc_ast::token::NtExprKind::*;
 use rustc_ast::token::NtPatKind::*;
 use rustc_ast::token::{self, InvisibleOrigin, MetaVarKind, NonterminalKind, Token};
@@ -101,9 +102,10 @@ impl<'a> Parser<'a> {
                 token::Lifetime(..) | token::NtLifetime(..) => true,
                 _ => false,
             },
-            NonterminalKind::TT | NonterminalKind::Item | NonterminalKind::Stmt => {
-                token.kind.close_delim().is_none()
-            }
+            NonterminalKind::TT
+            | NonterminalKind::Item
+            | NonterminalKind::Stmt
+            | NonterminalKind::Fn => token.kind.close_delim().is_none(),
         }
     }
 
@@ -122,6 +124,15 @@ impl<'a> Parser<'a> {
                 Some(item) => Ok(ParseNtResult::Item(item)),
                 None => Err(self.dcx().create_err(UnexpectedNonterminal::Item(self.token.span))),
             },
+            NonterminalKind::Fn => {
+                if let Some(item) = self.parse_item(ForceCollect::Yes)?
+                    && let ItemKind::Fn(_) = item.kind
+                {
+                    Ok(ParseNtResult::Fn(item))
+                } else {
+                    Err(self.dcx().create_err(UnexpectedNonterminal::Fn(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

@@ -1345,6 +1345,7 @@ symbols! {
         macro_derive,
         macro_escape,
         macro_export,
+        macro_fragments_more,
         macro_lifetime_matcher,
         macro_literal_matcher,
         macro_metavar_expr,