Rollup merge of rust-lang#61606 - petrochenkov:legclean, r=pnkfelix

Remove some legacy proc macro flavors

Namely
- `IdentTT` (`foo! ident { ... }`). Can be replaced with `foo! { ident ... }` or something similar.
- `MultiDecorator`. Can be replaced by `MultiModifier` (aka `LegacyAttr` after renaming).
- `DeclMacro`. It was a less powerful duplicate of `NormalTT` (aka `LegacyBang` after renaming) and can be replaced by it.

Stuff like this slows down any attempts to refactor the expansion infra, so it's desirable to retire it already.
I'm not sure whether a lang team decision is necessary, but would be nice to land this sooner because I have some further work in this area scheduled.

The documentation commit (rust-lang@a9397fd) describes how the remaining variants are different from each other and shows that there's actually some system behind them.

The last commit renames variants of `SyntaxExtension` in more systematic way.
- `ProcMacro` -> `Bang`
- `NormalTT` -> `LegacyBang`
- `AttrProcMacro` -> `Attr`
- `MultiModifier` -> `LegacyAttr`
- `ProcMacroDerive` -> `Derive`
- `BuiltinDerive` -> `LegacyDerive`

All the `Legacy*` variants are AST-based, as opposed to "modern" token-based variants.

Author: Centril

src/librustc_metadata/creader.rs

@@ -614,7 +614,7 @@ impl<'a> CrateLoader<'a> {
             match decl {
                 ProcMacro::CustomDerive { trait_name, attributes, client } => {
                     let attrs = attributes.iter().cloned().map(Symbol::intern).collect::<Vec<_>>();
-                    (trait_name, SyntaxExtension::ProcMacroDerive(
+                    (trait_name, SyntaxExtension::Derive(
                         Box::new(ProcMacroDerive {
                             client,
                             attrs: attrs.clone(),
@@ -624,13 +624,13 @@ impl<'a> CrateLoader<'a> {
                     ))
                 }
                 ProcMacro::Attr { name, client } => {
-                    (name, SyntaxExtension::AttrProcMacro(
+                    (name, SyntaxExtension::Attr(
                         Box::new(AttrProcMacro { client }),
                         root.edition,
                     ))
                 }
                 ProcMacro::Bang { name, client } => {
-                    (name, SyntaxExtension::ProcMacro {
+                    (name, SyntaxExtension::Bang {
                         expander: Box::new(BangProcMacro { client }),
                         allow_internal_unstable: None,
                         edition: root.edition,

src/librustc_metadata/cstore_impl.rs

@@ -430,7 +430,7 @@ impl cstore::CStore {
             use syntax_ext::proc_macro_impl::BangProcMacro;
 
             let client = proc_macro::bridge::client::Client::expand1(proc_macro::quote);
-            let ext = SyntaxExtension::ProcMacro {
+            let ext = SyntaxExtension::Bang {
                 expander: Box::new(BangProcMacro { client }),
                 allow_internal_unstable: Some(vec![sym::proc_macro_def_site].into()),
                 edition: data.root.edition,

src/librustc_plugin/registry.rs

@@ -4,8 +4,9 @@ use rustc::lint::{EarlyLintPassObject, LateLintPassObject, LintId, Lint};
 use rustc::session::Session;
 use rustc::util::nodemap::FxHashMap;
 
-use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension, NormalTT, IdentTT};
+use syntax::ext::base::{SyntaxExtension, NamedSyntaxExtension};
 use syntax::ext::base::MacroExpanderFn;
+use syntax::ext::hygiene::Transparency;
 use syntax::symbol::{Symbol, sym};
 use syntax::ast;
 use syntax::feature_gate::AttributeType;
@@ -84,47 +85,26 @@ impl<'a> Registry<'a> {
     /// Register a syntax extension of any kind.
     ///
     /// This is the most general hook into `libsyntax`'s expansion behavior.
-    pub fn register_syntax_extension(&mut self, name: ast::Name, extension: SyntaxExtension) {
+    pub fn register_syntax_extension(&mut self, name: ast::Name, mut extension: SyntaxExtension) {
         if name == sym::macro_rules {
             panic!("user-defined macros may not be named `macro_rules`");
         }
-        self.syntax_exts.push((name, match extension {
-            NormalTT {
-                expander,
-                def_info: _,
-                allow_internal_unstable,
-                allow_internal_unsafe,
-                local_inner_macros,
-                unstable_feature,
-                edition,
-            } => {
-                let nid = ast::CRATE_NODE_ID;
-                NormalTT {
-                    expander,
-                    def_info: Some((nid, self.krate_span)),
-                    allow_internal_unstable,
-                    allow_internal_unsafe,
-                    local_inner_macros,
-                    unstable_feature,
-                    edition,
-                }
-            }
-            IdentTT { expander, span: _, allow_internal_unstable } => {
-                IdentTT { expander, span: Some(self.krate_span), allow_internal_unstable }
-            }
-            _ => extension,
-        }));
+        if let SyntaxExtension::LegacyBang { def_info: ref mut def_info @ None, .. } = extension {
+            *def_info = Some((ast::CRATE_NODE_ID, self.krate_span));
+        }
+        self.syntax_exts.push((name, extension));
     }
 
     /// Register a macro of the usual kind.
     ///
     /// This is a convenience wrapper for `register_syntax_extension`.
-    /// It builds for you a `NormalTT` that calls `expander`,
+    /// It builds for you a `SyntaxExtension::LegacyBang` that calls `expander`,
     /// and also takes care of interning the macro's name.
     pub fn register_macro(&mut self, name: &str, expander: MacroExpanderFn) {
-        self.register_syntax_extension(Symbol::intern(name), NormalTT {
+        self.register_syntax_extension(Symbol::intern(name), SyntaxExtension::LegacyBang {
             expander: Box::new(expander),
             def_info: None,
+            transparency: Transparency::SemiTransparent,
             allow_internal_unstable: None,
             allow_internal_unsafe: false,
             local_inner_macros: false,

src/librustc_resolve/macros.rs

@@ -242,8 +242,7 @@ impl<'a> base::Resolver for Resolver<'a> {
     fn check_unused_macros(&self) {
         for did in self.unused_macros.iter() {
             let id_span = match *self.macro_map[did] {
-                SyntaxExtension::NormalTT { def_info, .. } |
-                SyntaxExtension::DeclMacro { def_info, .. } => def_info,
+                SyntaxExtension::LegacyBang { def_info, .. } => def_info,
                 _ => None,
             };
             if let Some((id, span)) = id_span {
@@ -587,7 +586,7 @@ impl<'a> Resolver<'a> {
                         match self.resolve_macro_to_res(derive, MacroKind::Derive,
                                                         &parent_scope, true, force) {
                             Ok((_, ext)) => {
-                                if let SyntaxExtension::ProcMacroDerive(_, helpers, _) = &*ext {
+                                if let SyntaxExtension::Derive(_, helpers, _) = &*ext {
                                     if helpers.contains(&ident.name) {
                                         let binding =
                                             (Res::NonMacroAttr(NonMacroAttrKind::DeriveHelper),

src/librustdoc/clean/inline.rs

@@ -471,7 +471,7 @@ fn build_macro(cx: &DocContext<'_>, did: DefId, name: ast::Name) -> clean::ItemE
         }
         LoadedMacro::ProcMacro(ext) => {
             let helpers = match &*ext {
-                &SyntaxExtension::ProcMacroDerive(_, ref syms, ..) => { syms.clean(cx) }
+                &SyntaxExtension::Derive(_, ref syms, ..) => { syms.clean(cx) }
                 _ => Vec::new(),
             };
 

src/librustdoc/passes/collect_intra_doc_links.rs

@@ -433,7 +433,7 @@ fn macro_resolve(cx: &DocContext<'_>, path_str: &str) -> Option<Res> {
             if let Res::Def(DefKind::Macro(MacroKind::ProcMacroStub), _) = res {
                 // skip proc-macro stubs, they'll cause `get_macro` to crash
             } else {
-                if let SyntaxExtension::DeclMacro { .. } = *resolver.get_macro(res) {
+                if let SyntaxExtension::LegacyBang { .. } = *resolver.get_macro(res) {
                     return Some(res.map_id(|_| panic!("unexpected id")));
                 }
             }