Auto merge of #95715 - nnethercote:shrink-Nonterminal, r=davidtwco

Shrink `Nonterminal`

Small consistency and performance improvements.

r? `@petrochenkov`

compiler/rustc_ast/src/attr/mod.rs

@@ -439,7 +439,7 @@ impl MetaItem {
             }
             Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. })) => match *nt {
                 token::Nonterminal::NtMeta(ref item) => return item.meta(item.path.span),
-                token::Nonterminal::NtPath(ref path) => path.clone(),
+                token::Nonterminal::NtPath(ref path) => (**path).clone(),
                 _ => return None,
             },
             _ => return None,

compiler/rustc_ast/src/mut_visit.rs

@@ -772,7 +772,9 @@ pub fn visit_interpolated<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut
         token::NtBlock(block) => vis.visit_block(block),
         token::NtStmt(stmt) => visit_clobber(stmt, |stmt| {
             // See reasoning above.
+            stmt.map(|stmt| {
                 vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
+            })
         }),
         token::NtPat(pat) => vis.visit_pat(pat),
         token::NtExpr(expr) => vis.visit_expr(expr),

compiler/rustc_ast/src/token.rs

@@ -668,7 +668,7 @@ impl PartialEq<TokenKind> for Token {
 pub enum Nonterminal {
     NtItem(P<ast::Item>),
     NtBlock(P<ast::Block>),
-    NtStmt(ast::Stmt),
+    NtStmt(P<ast::Stmt>),
     NtPat(P<ast::Pat>),
     NtExpr(P<ast::Expr>),
     NtTy(P<ast::Ty>),
@@ -677,13 +677,13 @@ pub enum Nonterminal {
     NtLiteral(P<ast::Expr>),
     /// Stuff inside brackets for attributes
     NtMeta(P<ast::AttrItem>),
-    NtPath(ast::Path),
-    NtVis(ast::Visibility),
+    NtPath(P<ast::Path>),
+    NtVis(P<ast::Visibility>),
 }
 
 // `Nonterminal` is used a lot. Make sure it doesn't unintentionally get bigger.
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Nonterminal, 48);
+rustc_data_structures::static_assert_size!(Nonterminal, 16);
 
 #[derive(Debug, Copy, Clone, PartialEq, Encodable, Decodable)]
 pub enum NonterminalKind {

compiler/rustc_expand/src/base.rs

@@ -118,7 +118,7 @@ impl Annotatable {
             Annotatable::ForeignItem(item) => {
                 token::NtItem(P(item.and_then(ast::ForeignItem::into_item)))
             }
-            Annotatable::Stmt(stmt) => token::NtStmt(stmt.into_inner()),
+            Annotatable::Stmt(stmt) => token::NtStmt(stmt),
             Annotatable::Expr(expr) => token::NtExpr(expr),
             Annotatable::Arm(..)
             | Annotatable::ExprField(..)

compiler/rustc_expand/src/proc_macro.rs

@@ -90,7 +90,7 @@ impl MultiItemModifier for ProcMacroDerive {
                 // A proc macro can't observe the fact that we're passing
                 // them an `NtStmt` - it can only see the underlying tokens
                 // of the wrapped item
-                token::NtStmt(stmt.into_inner())
+                token::NtStmt(stmt)
             }
             _ => unreachable!(),
         };

compiler/rustc_parse/src/parser/expr.rs

@@ -41,7 +41,7 @@ macro_rules! maybe_whole_expr {
                     return Ok(e);
                 }
                 token::NtPath(path) => {
-                    let path = path.clone();
+                    let path = (**path).clone();
                     $p.bump();
                     return Ok($p.mk_expr(
                         $p.prev_token.span,

compiler/rustc_parse/src/parser/mod.rs

@@ -1289,7 +1289,7 @@ impl<'a> Parser<'a> {
     /// so emit a proper diagnostic.
     // Public for rustfmt usage.
     pub fn parse_visibility(&mut self, fbt: FollowedByType) -> PResult<'a, Visibility> {
-        maybe_whole!(self, NtVis, |x| x);
+        maybe_whole!(self, NtVis, |x| x.into_inner());
 
         self.expected_tokens.push(TokenType::Keyword(kw::Crate));
         if self.is_crate_vis() {

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -118,7 +118,7 @@ impl<'a> Parser<'a> {
                 token::NtBlock(self.collect_tokens_no_attrs(|this| this.parse_block())?)
             }
             NonterminalKind::Stmt => match self.parse_stmt(ForceCollect::Yes)? {
-                Some(s) => token::NtStmt(s),
+                Some(s) => token::NtStmt(P(s)),
                 None => {
                     return Err(self.struct_span_err(self.token.span, "expected a statement"));
                 }
@@ -161,11 +161,11 @@ impl<'a> Parser<'a> {
                 return Err(self.struct_span_err(self.token.span, msg));
             }
             NonterminalKind::Path => token::NtPath(
-                self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?,
+                P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?),
             ),
             NonterminalKind::Meta => token::NtMeta(P(self.parse_attr_item(true)?)),
             NonterminalKind::Vis => token::NtVis(
-                self.collect_tokens_no_attrs(|this| this.parse_visibility(FollowedByType::Yes))?,
+                P(self.collect_tokens_no_attrs(|this| this.parse_visibility(FollowedByType::Yes))?),
             ),
             NonterminalKind::Lifetime => {
                 if self.check_lifetime() {

compiler/rustc_parse/src/parser/path.rs

@@ -165,7 +165,7 @@ impl<'a> Parser<'a> {
 
         maybe_whole!(self, NtPath, |path| {
             reject_generics_if_mod_style(self, &path);
-            path
+            path.into_inner()
         });
 
         if let token::Interpolated(nt) = &self.token.kind {

compiler/rustc_parse/src/parser/stmt.rs

@@ -54,7 +54,7 @@ impl<'a> Parser<'a> {
             stmt.visit_attrs(|stmt_attrs| {
                 attrs.prepend_to_nt_inner(stmt_attrs);
             });
-            return Ok(Some(stmt));
+            return Ok(Some(stmt.into_inner()));
         }
 
         Ok(Some(if self.token.is_keyword(kw::Let) {
@@ -535,7 +535,7 @@ impl<'a> Parser<'a> {
         recover: AttemptLocalParseRecovery,
     ) -> PResult<'a, Option<Stmt>> {
         // Skip looking for a trailing semicolon when we have an interpolated statement.
-        maybe_whole!(self, NtStmt, |x| Some(x));
+        maybe_whole!(self, NtStmt, |x| Some(x.into_inner()));
 
         let Some(mut stmt) = self.parse_stmt_without_recovery(true, ForceCollect::No)? else {
             return Ok(None);