Revert "Properly handle macro_rules"

This reverts commit 7e32657.

compiler/rustc_ast/src/token.rs

@@ -883,7 +883,6 @@ pub enum NonterminalKind {
     Lifetime,
     Literal,
     Meta,
-    Meta2021,
     Path,
     Vis,
     TT,
@@ -912,7 +911,7 @@ impl NonterminalKind {
             sym::ident => NonterminalKind::Ident,
             sym::lifetime => NonterminalKind::Lifetime,
             sym::literal => NonterminalKind::Literal,
-            sym::meta => NonterminalKind::Meta2021,
+            sym::meta => NonterminalKind::Meta,
             sym::path => NonterminalKind::Path,
             sym::vis => NonterminalKind::Vis,
             sym::tt => NonterminalKind::TT,
@@ -932,7 +931,6 @@ impl NonterminalKind {
             NonterminalKind::Lifetime => sym::lifetime,
             NonterminalKind::Literal => sym::literal,
             NonterminalKind::Meta => sym::meta,
-            NonterminalKind::Meta2021 => sym::meta,
             NonterminalKind::Path => sym::path,
             NonterminalKind::Vis => sym::vis,
             NonterminalKind::TT => sym::tt,

compiler/rustc_expand/src/mbe/macro_rules.rs

@@ -1358,7 +1358,7 @@ fn is_in_follow(tok: &mbe::TokenTree, kind: NonterminalKind) -> IsInFollow {
                 // literals may be of a single token, or two tokens (negative numbers)
                 IsInFollow::Yes
             }
-            NonterminalKind::Meta2021 | NonterminalKind::Meta | NonterminalKind::TT => {
+            NonterminalKind::Meta | NonterminalKind::TT => {
                 // being either a single token or a delimited sequence, tt is
                 // harmless
                 IsInFollow::Yes

compiler/rustc_parse/src/parser/attr.rs

@@ -250,11 +250,6 @@ impl<'a> Parser<'a> {
     ///     PATH `{` TOKEN_STREAM `}`
     ///     PATH
     ///     PATH `=` UNSUFFIXED_LIT
-    ///     `unsafe` `(` PATH `(` TOKEN_STREAM `)` `)`
-    ///     `unsafe` `(` PATH `[` TOKEN_STREAM `]` `)`
-    ///     `unsafe` `(` PATH `{` TOKEN_STREAM `}` `)`
-    ///     `unsafe` `(` PATH                      `)`
-    ///     `unsafe` `(` 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> {
         maybe_whole!(self, NtMeta, |attr| attr.into_inner());
@@ -282,30 +277,6 @@ impl<'a> Parser<'a> {
         if capture_tokens { self.collect_tokens_no_attrs(do_parse) } else { do_parse(self) }
     }
 
-    /// Parses an inner part of an attribute (the path and following tokens), disallowing `unsafe()`.
-    /// The tokens must be either a delimited token stream, or empty token stream,
-    /// or the "legacy" key-value form.
-    ///     PATH `(` TOKEN_STREAM `)`
-    ///     PATH `[` TOKEN_STREAM `]`
-    ///     PATH `{` TOKEN_STREAM `}`
-    ///     PATH
-    ///     PATH `=` UNSUFFIXED_LIT
-    /// The delimiters or `=` are still put into the resulting token stream.
-    pub fn parse_attr_item_no_unsafe(
-        &mut self,
-        capture_tokens: bool,
-    ) -> PResult<'a, ast::AttrItem> {
-        maybe_whole!(self, NtMeta, |attr| attr.into_inner());
-
-        let do_parse = |this: &mut Self| {
-            let path = this.parse_path(PathStyle::Mod)?;
-            let args = this.parse_attr_args()?;
-            Ok(ast::AttrItem { unsafety: ast::Unsafe::No, 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
     /// be preceded by an exclamation mark, but we accept and warn about one
     /// terminated by a semicolon.

compiler/rustc_parse/src/parser/nonterminal.rs

@@ -61,12 +61,7 @@ impl<'a> Parser<'a> {
                 },
                 _ => false,
             },
-            NonterminalKind::Meta => match &token.kind {
-                token::PathSep | token::Ident(..) => true,
-                token::Interpolated(nt) => may_be_ident(&nt.0),
-                _ => token.is_keyword(kw::Unsafe),
-            },
-            NonterminalKind::Path | NonterminalKind::Meta2021 => match &token.kind {
+            NonterminalKind::Path | NonterminalKind::Meta => match &token.kind {
                 token::PathSep | token::Ident(..) => true,
                 token::Interpolated(nt) => may_be_ident(&nt.0),
                 _ => false,
@@ -175,7 +170,6 @@ impl<'a> Parser<'a> {
                 NtPath(P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?))
             }
             NonterminalKind::Meta => NtMeta(P(self.parse_attr_item(true)?)),
-            NonterminalKind::Meta2021 => NtMeta(P(self.parse_attr_item_no_unsafe(true)?)),
             NonterminalKind::Vis => {
                 NtVis(P(self
                     .collect_tokens_no_attrs(|this| this.parse_visibility(FollowedByType::Yes))?))