Remove NtItem.

This requires adding `stream_pretty_printing_compatibility_hack`, which
will replace `nt_pretty_printing_compatibility_hack` once `NtStmt` is
removed.

Notable test changes:
- `tests/ui/macros/nonterminal-matching.rs` now passes. Removal of
  `Token::Interpolated` will remove the "captured metavariables except
  for `:tt`, `:ident` and `:lifetime` cannot be compared to other
  tokens" restriction.

- `tests/ui/proc-macro/expand-to-derive.rs`: the diff looks large but
  the only difference is the insertion of a single invisible-delimited
  group. I hope this doesn't cause any new `ProceduralMasquerade`-type
  problems.

Author: nnethercote

compiler/rustc_ast/src/ast_traits.rs

@@ -231,7 +231,6 @@ impl HasTokens for Attribute {
 impl HasTokens for Nonterminal {
     fn tokens(&self) -> Option<&LazyAttrTokenStream> {
         match self {
-            Nonterminal::NtItem(item) => item.tokens(),
             Nonterminal::NtStmt(stmt) => stmt.tokens(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
             Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
@@ -242,7 +241,6 @@ impl HasTokens for Nonterminal {
     }
     fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
         match self {
-            Nonterminal::NtItem(item) => item.tokens_mut(),
             Nonterminal::NtStmt(stmt) => stmt.tokens_mut(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
             Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),

compiler/rustc_ast/src/mut_visit.rs

@@ -790,12 +790,6 @@ pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
 // multiple items there....
 pub fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T) {
     match nt {
-        token::NtItem(item) => visit_clobber(item, |item| {
-            // This is probably okay, because the only visitors likely to
-            // peek inside interpolated nodes will be renamings/markings,
-            // which map single items to single items.
-            vis.flat_map_item(item).expect_one("expected visitor to produce exactly one item")
-        }),
         token::NtBlock(block) => vis.visit_block(block),
         token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
             // See reasoning above.

compiler/rustc_ast/src/token.rs

@@ -842,7 +842,6 @@ impl PartialEq<TokenKind> for Token {
 #[derive(Clone, Encodable, Decodable)]
 /// For interpolation during macro expansion.
 pub enum Nonterminal {
-    NtItem(P<ast::Item>),
     NtBlock(P<ast::Block>),
     NtStmt(P<ast::Stmt>),
     NtExpr(P<ast::Expr>),
@@ -935,7 +934,6 @@ impl fmt::Display for NonterminalKind {
 impl Nonterminal {
     pub fn span(&self) -> Span {
         match self {
-            NtItem(item) => item.span,
             NtBlock(block) => block.span,
             NtStmt(stmt) => stmt.span,
             NtExpr(expr) | NtLiteral(expr) => expr.span,
@@ -965,7 +963,6 @@ impl PartialEq for Nonterminal {
 impl fmt::Debug for Nonterminal {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
-            NtItem(..) => f.pad("NtItem(..)"),
             NtBlock(..) => f.pad("NtBlock(..)"),
             NtStmt(..) => f.pad("NtStmt(..)"),
             NtExpr(..) => f.pad("NtExpr(..)"),

compiler/rustc_ast/src/tokenstream.rs

@@ -463,7 +463,6 @@ impl TokenStream {
             Nonterminal::NtLifetime(ident) => {
                 TokenStream::token_alone(token::Lifetime(ident.name), ident.span)
             }
-            Nonterminal::NtItem(item) => TokenStream::from_ast(item),
             Nonterminal::NtBlock(block) => TokenStream::from_ast(block),
             Nonterminal::NtStmt(stmt) if let StmtKind::Empty = stmt.kind => {
                 // FIXME: Properly collect tokens for empty statements.

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -734,7 +734,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
             token::NtExpr(e) => self.expr_to_string(e),
             token::NtMeta(e) => self.attr_item_to_string(e),
             token::NtPath(e) => self.path_to_string(e),
-            token::NtItem(e) => self.item_to_string(e),
             token::NtBlock(e) => self.block_to_string(e),
             token::NtStmt(e) => self.stmt_to_string(e),
             token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(*e, *is_raw).to_string(),

compiler/rustc_expand/src/base.rs

@@ -7,7 +7,7 @@ use crate::module::DirOwnership;
 use rustc_ast::attr::MarkedAttrs;
 use rustc_ast::mut_visit::DummyAstNode;
 use rustc_ast::ptr::P;
-use rustc_ast::token::{self, Nonterminal};
+use rustc_ast::token::{self, Nonterminal, NonterminalKind};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{AssocCtxt, Visitor};
 use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind};
@@ -1498,7 +1498,6 @@ pub(crate) fn ann_pretty_printing_compatibility_hack(ann: &Annotatable, sess: &P
 
 pub(crate) fn nt_pretty_printing_compatibility_hack(nt: &Nonterminal, sess: &ParseSess) -> bool {
     let item = match nt {
-        Nonterminal::NtItem(item) => item,
         Nonterminal::NtStmt(stmt) => match &stmt.kind {
             ast::StmtKind::Item(item) => item,
             _ => return false,
@@ -1507,3 +1506,21 @@ pub(crate) fn nt_pretty_printing_compatibility_hack(nt: &Nonterminal, sess: &Par
     };
     pretty_printing_compatibility_hack(item, sess)
 }
+
+pub(crate) fn stream_pretty_printing_compatibility_hack(
+    kind: NonterminalKind,
+    stream: &TokenStream,
+    sess: &ParseSess,
+) -> bool {
+    let item = match kind {
+        NonterminalKind::Item => {
+            let mut parser = parser::Parser::new(sess, stream.clone(), None);
+            let Ok(parser::ParseNtResult::Item(item)) = parser.parse_nonterminal(kind) else {
+                panic!("failed to reparse");
+            };
+            item
+        }
+        _ => return false,
+    };
+    pretty_printing_compatibility_hack(&item, sess)
+}

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -232,6 +232,9 @@ pub(super) fn transcribe<'a>(
                             // without wrapping them into groups.
                             tt.clone()
                         }
+                        MatchedSingle(ParseNtResult::Item(ref item)) => {
+                            mk_delimited(NonterminalKind::Item, TokenStream::from_ast(item))
+                        }
                         MatchedSingle(ParseNtResult::PatParam(ref pat, inferred)) => mk_delimited(
                             NonterminalKind::PatParam { inferred: *inferred },
                             TokenStream::from_ast(pat),

compiler/rustc_expand/src/proc_macro.rs

@@ -5,7 +5,8 @@ use crate::proc_macro_server;
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token;
-use rustc_ast::tokenstream::TokenStream;
+use rustc_ast::token::{Delimiter, InvisibleSource, NonterminalKind};
+use rustc_ast::tokenstream::{DelimSpan, TokenStream};
 use rustc_data_structures::sync::Lrc;
 use rustc_errors::ErrorGuaranteed;
 use rustc_parse::parser::ForceCollect;
@@ -121,12 +122,18 @@ impl MultiItemModifier for DeriveProcMacro {
         let is_stmt = matches!(item, Annotatable::Stmt(..));
         let hack = crate::base::ann_pretty_printing_compatibility_hack(&item, &ecx.sess.parse_sess);
         let input = if hack {
-            let nt = match item {
-                Annotatable::Item(item) => token::NtItem(item),
-                Annotatable::Stmt(stmt) => token::NtStmt(stmt),
+            match item {
+                Annotatable::Item(item) => TokenStream::delimited(
+                    DelimSpan::from_single(DUMMY_SP),
+                    Delimiter::Invisible(InvisibleSource::MetaVar(NonterminalKind::Item)),
+                    TokenStream::from_ast(&item),
+                ),
+                Annotatable::Stmt(stmt) => {
+                    let nt = token::NtStmt(stmt);
+                    TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
+                }
                 _ => unreachable!(),
-            };
-            TokenStream::token_alone(token::Interpolated(Lrc::new(nt)), DUMMY_SP)
+            }
         } else {
             item.to_tokens()
         };

compiler/rustc_expand/src/proc_macro_server.rs

@@ -98,17 +98,32 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
 
         while let Some(tree) = cursor.next() {
             let (Token { kind, span }, joint) = match tree.clone() {
-                tokenstream::TokenTree::Delimited(span, delim, tts) => {
-                    let delimiter = pm::Delimiter::from_internal(delim);
-                    trees.push(TokenTree::Group(Group {
-                        delimiter,
-                        stream: Some(tts),
-                        span: DelimSpan {
-                            open: span.open,
-                            close: span.close,
-                            entire: span.entire(),
-                        },
-                    }));
+                tokenstream::TokenTree::Delimited(span, delim, stream) => {
+                    // A hack used to pass AST fragments to attribute and derive
+                    // macros as a single nonterminal token instead of a token
+                    // stream. Such token needs to be "unwrapped" and not
+                    // represented as a delimited group.
+                    // FIXME: It needs to be removed, but there are some
+                    // compatibility issues (see #73345).
+                    if let Delimiter::Invisible(InvisibleSource::MetaVar(kind)) = delim
+                        && crate::base::stream_pretty_printing_compatibility_hack(
+                            kind,
+                            &stream,
+                            rustc.sess()
+                        )
+                    {
+                        trees.extend(Self::from_internal((stream, rustc)));
+                    } else {
+                        trees.push(TokenTree::Group(Group {
+                            delimiter: pm::Delimiter::from_internal(delim),
+                            stream: Some(stream),
+                            span: DelimSpan {
+                                open: span.open,
+                                close: span.close,
+                                entire: span.entire(),
+                            },
+                        }));
+                    }
                     continue;
                 }
                 tokenstream::TokenTree::Token(token, spacing) => (token, spacing == Joint),
@@ -231,13 +246,8 @@ impl FromInternal<(TokenStream, &mut Rustc<'_, '_>)> for Vec<TokenTree<TokenStre
                 }
 
                 Interpolated(nt) => {
+                    // See the "hack" comment above.
                     let stream = TokenStream::from_nonterminal_ast(&nt);
-                    // A hack used to pass AST fragments to attribute and derive
-                    // macros as a single nonterminal token instead of a token
-                    // stream. Such token needs to be "unwrapped" and not
-                    // represented as a delimited group.
-                    // FIXME: It needs to be removed, but there are some
-                    // compatibility issues (see #73345).
                     if crate::base::nt_pretty_printing_compatibility_hack(&nt, rustc.sess()) {
                         trees.extend(Self::from_internal((stream, rustc)));
                     } else {

compiler/rustc_parse/src/parser/item.rs

@@ -1,8 +1,11 @@
 use super::diagnostics::{dummy_arg, ConsumeClosingDelim};
 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
-use super::{AttrWrapper, FollowedByType, ForceCollect, Parser, PathStyle, TrailingToken};
+use super::{
+    AttrWrapper, FollowedByType, ForceCollect, ParseNtResult, Parser, PathStyle, TrailingToken,
+};
 use crate::errors::{self, MacroExpandsToAdtField};
 use crate::fluent_generated as fluent;
+use crate::maybe_reparse_metavar_seq;
 use ast::StaticItem;
 use rustc_ast::ast::*;
 use rustc_ast::ptr::P;
@@ -116,15 +119,16 @@ impl<'a> Parser<'a> {
         fn_parse_mode: FnParseMode,
         force_collect: ForceCollect,
     ) -> PResult<'a, Option<Item>> {
-        // Don't use `maybe_whole` so that we have precise control
-        // over when we bump the parser
-        if let token::Interpolated(nt) = &self.token.kind && let token::NtItem(item) = &**nt {
-            let mut item = item.clone();
-            self.bump();
-
+        if let Some(mut item) = maybe_reparse_metavar_seq!(
+            self,
+            NonterminalKind::Item,
+            NonterminalKind::Item,
+            ParseNtResult::Item(item),
+            item
+        ) {
             attrs.prepend_to_nt_inner(&mut item.attrs);
             return Ok(Some(item.into_inner()));
-        };
+        }
 
         let item =
             self.collect_tokens_trailing_token(attrs, force_collect, |this: &mut Self, attrs| {