Remove NtMeta.

Note: there was an existing code path involving `Interpolated` in
`MetaItem::from_tokens` that was dead. This commit transfers that to the
new form, but puts an `unreachable!` call inside it.

Author: nnethercote

compiler/rustc_ast/src/ast_traits.rs

@@ -232,7 +232,6 @@ impl HasTokens for Nonterminal {
     fn tokens(&self) -> Option<&LazyAttrTokenStream> {
         match self {
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
             Nonterminal::NtPath(path) => path.tokens(),
             Nonterminal::NtBlock(block) => block.tokens(),
             Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) => None,
@@ -241,7 +240,6 @@ impl HasTokens for Nonterminal {
     fn tokens_mut(&mut self) -> Option<&mut Option<LazyAttrTokenStream>> {
         match self {
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
             Nonterminal::NtPath(path) => path.tokens_mut(),
             Nonterminal::NtBlock(block) => block.tokens_mut(),
             Nonterminal::NtIdent(..) | Nonterminal::NtLifetime(..) => None,

compiler/rustc_ast/src/attr/mod.rs

@@ -5,7 +5,7 @@ use crate::ast::{DelimArgs, Expr, ExprKind, LitKind, MetaItemLit};
 use crate::ast::{MetaItem, MetaItemKind, NestedMetaItem, NormalAttr};
 use crate::ast::{Path, PathSegment, DUMMY_NODE_ID};
 use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter, Token};
+use crate::token::{self, CommentKind, Delimiter, InvisibleSource, NonterminalKind, Token};
 use crate::tokenstream::{DelimSpan, Spacing, TokenTree};
 use crate::tokenstream::{LazyAttrTokenStream, TokenStream};
 use crate::util::comments;
@@ -327,10 +327,17 @@ impl MetaItem {
                 Path { span, segments, tokens: None }
             }
             Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. }, _)) => match &**nt {
-                token::Nonterminal::NtMeta(item) => return item.meta(item.path.span),
                 token::Nonterminal::NtPath(path) => (**path).clone(),
                 _ => return None,
             },
+            Some(TokenTree::Delimited(
+                _span,
+                Delimiter::Invisible(InvisibleSource::MetaVar(NonterminalKind::Meta)),
+                _stream,
+            )) => {
+                // njn: this pre-existing (equivalent) path is unreachable in the test suite
+                unreachable!()
+            }
             _ => return None,
         };
         let list_closing_paren_pos = tokens.peek().map(|tt| tt.span().hi());

compiler/rustc_ast/src/mut_visit.rs

@@ -794,12 +794,6 @@ pub fn visit_nonterminal<T: MutVisitor>(nt: &mut token::Nonterminal, vis: &mut T
         token::NtIdent(ident, _is_raw) => vis.visit_ident(ident),
         token::NtLifetime(ident) => vis.visit_ident(ident),
         token::NtLiteral(expr) => vis.visit_expr(expr),
-        token::NtMeta(item) => {
-            let AttrItem { path, args, tokens } = item.deref_mut();
-            vis.visit_path(path);
-            visit_attr_args(args, vis);
-            visit_lazy_tts(tokens, vis);
-        }
         token::NtPath(path) => vis.visit_path(path),
     }
 }

compiler/rustc_ast/src/token.rs

@@ -847,8 +847,6 @@ pub enum Nonterminal {
     NtIdent(Ident, /* is_raw */ bool),
     NtLifetime(Ident),
     NtLiteral(P<ast::Expr>),
-    /// Stuff inside brackets for attributes
-    NtMeta(P<ast::AttrItem>),
     NtPath(P<ast::Path>),
 }
 
@@ -936,7 +934,6 @@ impl Nonterminal {
             NtBlock(block) => block.span,
             NtExpr(expr) | NtLiteral(expr) => expr.span,
             NtIdent(ident, _) | NtLifetime(ident) => ident.span,
-            NtMeta(attr_item) => attr_item.span(),
             NtPath(path) => path.span,
         }
     }
@@ -965,7 +962,6 @@ impl fmt::Debug for Nonterminal {
             NtExpr(..) => f.pad("NtExpr(..)"),
             NtIdent(..) => f.pad("NtIdent(..)"),
             NtLiteral(..) => f.pad("NtLiteral(..)"),
-            NtMeta(..) => f.pad("NtMeta(..)"),
             NtPath(..) => f.pad("NtPath(..)"),
             NtLifetime(..) => f.pad("NtLifetime(..)"),
         }

compiler/rustc_ast/src/tokenstream.rs

@@ -464,7 +464,6 @@ impl TokenStream {
                 TokenStream::token_alone(token::Lifetime(ident.name), ident.span)
             }
             Nonterminal::NtBlock(block) => TokenStream::from_ast(block),
-            Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),
             Nonterminal::NtPath(path) => TokenStream::from_ast(path),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),
         }

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -727,7 +727,6 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     fn nonterminal_to_string(&self, nt: &Nonterminal) -> String {
         match nt {
             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::NtBlock(e) => self.block_to_string(e),
             token::NtIdent(e, is_raw) => IdentPrinter::for_ast_ident(*e, *is_raw).to_string(),

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -255,6 +255,9 @@ pub(super) fn transcribe<'a>(
                         MatchedSingle(ParseNtResult::Ty(ref ty)) => {
                             mk_delimited(NonterminalKind::Ty, TokenStream::from_ast(ty))
                         }
+                        MatchedSingle(ParseNtResult::Meta(ref meta)) => {
+                            mk_delimited(NonterminalKind::Meta, TokenStream::from_ast(meta))
+                        }
                         MatchedSingle(ParseNtResult::Vis(ref vis)) => {
                             mk_delimited(NonterminalKind::Vis, TokenStream::from_ast(vis))
                         }

compiler/rustc_parse/src/parser/attr.rs

@@ -1,10 +1,11 @@
 use crate::errors::{InvalidMetaItem, SuffixedLiteralInAttribute};
 use crate::fluent_generated as fluent;
+use crate::maybe_reparse_metavar_seq;
 
-use super::{AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, PathStyle};
+use super::{AttrWrapper, Capturing, FnParseMode, ForceCollect, ParseNtResult, Parser, PathStyle};
 use rustc_ast as ast;
 use rustc_ast::attr;
-use rustc_ast::token::{self, Delimiter, Nonterminal};
+use rustc_ast::token::{self, Delimiter, NonterminalKind};
 use rustc_errors::{error_code, Diagnostic, IntoDiagnostic, PResult};
 use rustc_span::{sym, BytePos, Span};
 use std::convert::TryInto;
@@ -248,25 +249,23 @@ impl<'a> Parser<'a> {
     ///     PATH `=` UNSUFFIXED_LIT
     /// The delimiters or `=` are still put into the resulting token stream.
     pub fn parse_attr_item(&mut self, capture_tokens: bool) -> PResult<'a, ast::AttrItem> {
-        let item = match &self.token.kind {
-            token::Interpolated(nt) => match &**nt {
-                Nonterminal::NtMeta(item) => Some(item.clone().into_inner()),
-                _ => None,
-            },
-            _ => None,
-        };
-        Ok(if let Some(item) = item {
-            self.bump();
+        if let Some(item) = maybe_reparse_metavar_seq!(
+            self,
+            NonterminalKind::Meta,
+            NonterminalKind::Meta,
+            ParseNtResult::Meta(item),
             item
-        } else {
-            let do_parse = |this: &mut Self| {
-                let path = this.parse_path(PathStyle::Mod)?;
-                let args = this.parse_attr_args()?;
-                Ok(ast::AttrItem { path, args, tokens: None })
-            };
-            // Attr items don't have attributes
-            if capture_tokens { self.collect_tokens_no_attrs(do_parse) } else { do_parse(self) }?
-        })
+        ) {
+            return Ok(item.into_inner());
+        }
+
+        let do_parse = |this: &mut Self| {
+            let path = this.parse_path(PathStyle::Mod)?;
+            let args = this.parse_attr_args()?;
+            Ok(ast::AttrItem { path, args, tokens: None })
+        };
+        // Attr items don't have attributes
+        if capture_tokens { self.collect_tokens_no_attrs(do_parse) } else { do_parse(self) }
     }
 
     /// Parses attributes that appear after the opening of an item. These should
@@ -368,20 +367,15 @@ impl<'a> Parser<'a> {
     /// meta_item_inner : (meta_item | UNSUFFIXED_LIT) (',' meta_item_inner)? ;
     /// ```
     pub fn parse_meta_item(&mut self) -> PResult<'a, ast::MetaItem> {
-        let nt_meta = match &self.token.kind {
-            token::Interpolated(nt) => match &**nt {
-                token::NtMeta(e) => Some(e.clone()),
-                _ => None,
-            },
-            _ => None,
-        };
-
-        if let Some(item) = nt_meta {
+        if let Some(item) = maybe_reparse_metavar_seq!(
+            self,
+            NonterminalKind::Meta,
+            NonterminalKind::Meta,
+            ParseNtResult::Meta(item),
+            item
+        ) {
             return match item.meta(item.path.span) {
-                Some(meta) => {
-                    self.bump();
-                    Ok(meta)
-                }
+                Some(meta) => Ok(meta),
                 None => self.unexpected(),
             };
         }

compiler/rustc_parse/src/parser/mod.rs

@@ -1587,6 +1587,7 @@ pub enum ParseNtResult {
     PatParam(P<ast::Pat>, /* inferred */ bool),
     PatWithOr(P<ast::Pat>),
     Ty(P<ast::Ty>),
+    Meta(P<ast::AttrItem>),
     Vis(P<ast::Visibility>),
 
     /// This case will eventually be removed, along with `Token::Interpolate`.

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -48,7 +48,6 @@ impl<'a> Parser<'a> {
                 NtExpr(_)
                 | NtIdent(..)
                 | NtLiteral(_) // `true`, `false`
-                | NtMeta(_)
                 | NtPath(_) => true,
 
                 NtBlock(_)
@@ -79,7 +78,7 @@ impl<'a> Parser<'a> {
                 token::OpenDelim(Delimiter::Brace) => true,
                 token::Interpolated(nt) => match **nt {
                     NtBlock(_) | NtLifetime(_) | NtExpr(_) | NtLiteral(_) => true,
-                    NtIdent(..) | NtMeta(_) | NtPath(_) => false,
+                    NtIdent(..) | NtPath(_) => false,
                 },
                 token::OpenDelim(Delimiter::Invisible(InvisibleSource::MetaVar(k))) => match k {
                     NonterminalKind::Block
@@ -217,7 +216,7 @@ impl<'a> Parser<'a> {
             NonterminalKind::Path => NtPath(
                 P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?),
             ),
-            NonterminalKind::Meta => NtMeta(P(self.parse_attr_item(true)?)),
+            NonterminalKind::Meta => return Ok(ParseNtResult::Meta(P(self.parse_attr_item(true)?))),
             NonterminalKind::Vis => return Ok(ParseNtResult::Vis(
                 P(self.collect_tokens_no_attrs(|this| this.parse_visibility(FollowedByType::Yes))?),
             )),

tests/ui/macros/stringify.rs

@@ -641,7 +641,7 @@ fn test_meta() {
     assert_eq!(stringify_meta!(k), "k");
     assert_eq!(stringify_meta!(k = "v"), "k = \"v\"");
     assert_eq!(stringify_meta!(list(k1, k2 = "v")), "list(k1, k2 = \"v\")");
-    assert_eq!(stringify_meta!(serde::k), "serde::k");
+    assert_eq!(stringify_meta!(serde::k), "serde :: k");
 }
 
 #[test]