Simplify bang macro handling by merging all into one type

Author: GuillaumeGomez

src/librustdoc/clean/inline.rs

@@ -158,7 +158,7 @@ pub(crate) fn try_inline(
             })
         }
         Res::Def(DefKind::Macro(kinds), did) => {
-            let (mac, others) = build_macro(cx.tcx, did, name, kinds);
+            let mac = build_macro(cx.tcx, did, name, kinds);
 
             let type_kind = match kinds {
                 MacroKinds::BANG => ItemType::Macro,
@@ -168,15 +168,7 @@ pub(crate) fn try_inline(
                 _ => ItemType::Macro,
             };
             record_extern_fqn(cx, did, type_kind);
-            let first = try_inline_inner(cx, mac, did, name, import_def_id);
-            if let Some(others) = others {
-                for mac_kind in others {
-                    let mut mac = first.clone();
-                    mac.inner.kind = mac_kind;
-                    ret.push(mac);
-                }
-            }
-            ret.push(first);
+            ret.push(try_inline_inner(cx, mac, did, name, import_def_id));
             return Some(ret);
         }
         _ => return None,
@@ -793,52 +785,24 @@ fn build_macro(
     def_id: DefId,
     name: Symbol,
     macro_kinds: MacroKinds,
-) -> (clean::ItemKind, Option<Vec<clean::ItemKind>>) {
+) -> clean::ItemKind {
     match CStore::from_tcx(tcx).load_macro_untracked(tcx, def_id) {
         LoadedMacro::MacroDef { def, .. } => match macro_kinds {
-            MacroKinds::BANG => (
-                clean::MacroItem(
-                    clean::Macro {
-                        source: utils::display_macro_source(tcx, name, &def),
-                        macro_rules: def.macro_rules,
-                    },
-                    MacroKinds::BANG,
-                ),
-                None,
-            ),
-            MacroKinds::DERIVE => (
-                clean::ProcMacroItem(clean::ProcMacro {
-                    kind: MacroKind::Derive,
-                    helpers: Vec::new(),
-                }),
-                None,
-            ),
-            MacroKinds::ATTR => (
-                clean::ProcMacroItem(clean::ProcMacro {
-                    kind: MacroKind::Attr,
-                    helpers: Vec::new(),
-                }),
-                None,
+            MacroKinds::DERIVE => clean::ProcMacroItem(clean::ProcMacro {
+                kind: MacroKind::Derive,
+                helpers: Vec::new(),
+            }),
+            MacroKinds::ATTR => clean::ProcMacroItem(clean::ProcMacro {
+                kind: MacroKind::Attr,
+                helpers: Vec::new(),
+            }),
+            _ => clean::MacroItem(
+                clean::Macro {
+                    source: utils::display_macro_source(tcx, name, &def),
+                    macro_rules: def.macro_rules,
+                },
+                macro_kinds,
             ),
-            _ => {
-                let mut kinds = Vec::new();
-                kinds.push(clean::MacroItem(
-                    clean::Macro {
-                        source: utils::display_macro_source(tcx, name, &def),
-                        macro_rules: def.macro_rules,
-                    },
-                    macro_kinds,
-                ));
-                for kind in macro_kinds.iter().filter(|kind| *kind != MacroKinds::BANG) {
-                    match kind {
-                        MacroKinds::ATTR => kinds.push(clean::AttrMacroItem),
-                        MacroKinds::DERIVE => kinds.push(clean::DeriveMacroItem),
-                        _ => panic!("unsupported macro kind {kind:?}"),
-                    }
-                }
-                let kind = kinds.pop().expect("no supported macro kind found");
-                (kind, Some(kinds))
-            }
         },
         LoadedMacro::ProcMacro(ext) => {
             // Proc macros can only have a single kind
@@ -848,7 +812,7 @@ fn build_macro(
                 MacroKinds::DERIVE => MacroKind::Derive,
                 _ => unreachable!(),
             };
-            (clean::ProcMacroItem(clean::ProcMacro { kind, helpers: ext.helper_attrs }), None)
+            clean::ProcMacroItem(clean::ProcMacro { kind, helpers: ext.helper_attrs })
         }
     }
 }

src/librustdoc/clean/mod.rs

@@ -2869,42 +2869,13 @@ fn clean_maybe_renamed_item<'tcx>(
                 ),
                 MacroKinds::ATTR => clean_proc_macro(item, &mut name, MacroKind::Attr, cx.tcx),
                 MacroKinds::DERIVE => clean_proc_macro(item, &mut name, MacroKind::Derive, cx.tcx),
-                _ => {
-                    let kind = MacroItem(
-                        Macro {
-                            source: display_macro_source(cx.tcx, name, macro_def),
-                            macro_rules: macro_def.macro_rules,
-                        },
-                        kinds,
-                    );
-                    let mac = generate_item_with_correct_attrs(
-                        cx,
-                        kind,
-                        item.owner_id.def_id.to_def_id(),
-                        name,
-                        import_ids,
-                        renamed,
-                    );
-
-                    let mut ret = Vec::with_capacity(3);
-                    for kind in kinds.iter().filter(|kind| *kind != MacroKinds::BANG) {
-                        match kind {
-                            MacroKinds::ATTR => {
-                                let mut attr = mac.clone();
-                                attr.inner.kind = AttrMacroItem;
-                                ret.push(attr);
-                            }
-                            MacroKinds::DERIVE => {
-                                let mut derive = mac.clone();
-                                derive.inner.kind = DeriveMacroItem;
-                                ret.push(derive);
-                            }
-                            _ => panic!("unsupported macro kind {kind:?}"),
-                        }
-                    }
-                    ret.push(mac);
-                    return ret;
-                }
+                _ => MacroItem(
+                    Macro {
+                        source: display_macro_source(cx.tcx, name, macro_def),
+                        macro_rules: macro_def.macro_rules,
+                    },
+                    kinds,
+                ),
             },
             // proc macros can have a name set by attributes
             ItemKind::Fn { ref sig, generics, body: body_id, .. } => {

src/librustdoc/clean/types.rs

@@ -750,6 +750,29 @@ impl Item {
         ItemType::from(self)
     }
 
+    // FIXME: Return an iterator instead of a `ThinVec`.
+    pub(crate) fn types(&self) -> ThinVec<ItemType> {
+        if let ItemKind::MacroItem(_, macro_kinds) = self.kind {
+            let mut types = ThinVec::with_capacity(3);
+            for kind in macro_kinds.iter() {
+                match kind {
+                    MacroKinds::ATTR => types.push(ItemType::BangMacroAttribute),
+                    MacroKinds::DERIVE => types.push(ItemType::BangMacroDerive),
+                    MacroKinds::BANG => types.push(ItemType::Macro),
+                    _ => panic!("unsupported macro kind {kind:?}"),
+                }
+            }
+            return types;
+        }
+        let mut types = ThinVec::with_capacity(1);
+        types.push(self.type_());
+        types
+    }
+
+    pub(crate) fn is_macro_rules(&self) -> bool {
+        matches!(self.kind, ItemKind::MacroItem(..))
+    }
+
     pub(crate) fn defaultness(&self) -> Option<Defaultness> {
         match self.kind {
             ItemKind::MethodItem(_, defaultness) | ItemKind::RequiredMethodItem(_, defaultness) => {
@@ -761,14 +784,7 @@ impl Item {
 
     /// Generates the HTML file name based on the item kind.
     pub(crate) fn html_filename(&self) -> String {
-        let type_ = if self.is_macro_placeholder() { ItemType::Macro } else { self.type_() };
-        format!("{type_}.{}.html", self.name.unwrap())
-    }
-
-    /// If the current item is a "fake" macro (ie, `AttrMacroItem | ItemKind::DeriveMacroItem` which
-    /// don't hold any data), it returns `true`.
-    pub(crate) fn is_macro_placeholder(&self) -> bool {
-        matches!(self.kind, ItemKind::AttrMacroItem | ItemKind::DeriveMacroItem)
+        format!("{type_}.{name}.html", type_ = self.type_(), name = self.name.unwrap())
     }
 
     /// Returns a `FnHeader` if `self` is a function item, otherwise returns `None`.
@@ -930,13 +946,9 @@ pub(crate) enum ItemKind {
     ForeignStaticItem(Static, hir::Safety),
     /// `type`s from an extern block
     ForeignTypeItem,
+    /// A bang macro. it can be multiple things (macro, derive and attribute, potentially multiple
+    /// at once). Don't forget to look into the `MacroKinds` values.
     MacroItem(Macro, MacroKinds),
-    /// This is NOT an attribute proc-macro but a bang macro with support for being used as an
-    /// attribute macro.
-    AttrMacroItem,
-    /// This is NOT an attribute proc-macro but a bang macro with support for being used as a
-    /// derive macro.
-    DeriveMacroItem,
     ProcMacroItem(ProcMacro),
     PrimitiveItem(PrimitiveType),
     /// A required associated constant in a trait declaration.
@@ -992,8 +1004,6 @@ impl ItemKind {
             | ForeignStaticItem(_, _)
             | ForeignTypeItem
             | MacroItem(..)
-            | AttrMacroItem
-            | DeriveMacroItem
             | ProcMacroItem(_)
             | PrimitiveItem(_)
             | RequiredAssocConstItem(..)

src/librustdoc/fold.rs

@@ -89,8 +89,6 @@ pub(crate) trait DocFolder: Sized {
             | ForeignStaticItem(..)
             | ForeignTypeItem
             | MacroItem(..)
-            | AttrMacroItem
-            | DeriveMacroItem
             | ProcMacroItem(_)
             | PrimitiveItem(_)
             | RequiredAssocConstItem(..)

src/librustdoc/formats/cache.rs

@@ -384,8 +384,6 @@ impl DocFolder for CacheBuilder<'_, '_> {
             | clean::AssocTypeItem(..)
             | clean::StrippedItem(..)
             | clean::AttributeItem
-            | clean::AttrMacroItem
-            | clean::DeriveMacroItem
             | clean::KeywordItem => {
                 // FIXME: Do these need handling?
                 // The person writing this comment doesn't know.

src/librustdoc/formats/item_type.rs

@@ -132,8 +132,6 @@ impl<'a> From<&'a clean::Item> for ItemType {
             clean::ForeignFunctionItem(..) => ItemType::Function, // no ForeignFunction
             clean::ForeignStaticItem(..) => ItemType::Static,     // no ForeignStatic
             clean::MacroItem(..) => ItemType::Macro,
-            clean::AttrMacroItem => ItemType::BangMacroAttribute,
-            clean::DeriveMacroItem => ItemType::BangMacroDerive,
             clean::PrimitiveItem(..) => ItemType::Primitive,
             clean::RequiredAssocConstItem(..)
             | clean::ProvidedAssocConstItem(..)
@@ -167,10 +165,9 @@ impl ItemType {
             DefKind::Trait => Self::Trait,
             DefKind::TyAlias => Self::TypeAlias,
             DefKind::TraitAlias => Self::TraitAlias,
-            DefKind::Macro(MacroKinds::BANG) => ItemType::Macro,
             DefKind::Macro(MacroKinds::ATTR) => ItemType::ProcAttribute,
             DefKind::Macro(MacroKinds::DERIVE) => ItemType::ProcDerive,
-            DefKind::Macro(_) => todo!("Handle macros with multiple kinds"),
+            DefKind::Macro(_) => ItemType::Macro,
             DefKind::ForeignTy => Self::ForeignType,
             DefKind::Variant => Self::Variant,
             DefKind::Field => Self::StructField,

src/librustdoc/html/render/context.rs

@@ -10,7 +10,6 @@ use rustc_ast::join_path_syms;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_hir::Attribute;
 use rustc_hir::attrs::AttributeKind;
-use rustc_hir::def::MacroKinds;
 use rustc_hir::def_id::{DefIdMap, LOCAL_CRATE};
 use rustc_middle::ty::TyCtxt;
 use rustc_session::Session;
@@ -352,14 +351,13 @@ impl<'tcx> Context<'tcx> {
                 Some(s) => s,
             };
 
-            let type_ = item.type_();
-
-            if inserted.entry(type_).or_default().insert(name) {
-                let type_ = type_.to_string();
-                let name = name.to_string();
-                map.entry(type_)
-                    .or_default()
-                    .push(SidebarItem { name, is_macro_rules: item.is_macro_placeholder() });
+            let is_macro_rules = item.is_macro_rules();
+            for type_ in item.types() {
+                if inserted.entry(type_).or_default().insert(name) {
+                    let type_ = type_.to_string();
+                    let name = name.to_string();
+                    map.entry(type_).or_default().push(SidebarItem { name, is_macro_rules });
+                }
             }
         }
 
@@ -840,7 +838,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
 
         info!("Recursing into {}", self.dst.display());
 
-        if !item.is_stripped() && !item.is_macro_placeholder() {
+        if !item.is_stripped() {
             let buf = self.render_item(item, true);
             // buf will be empty if the module is stripped and there is no redirect for it
             if !buf.is_empty() {
@@ -896,19 +894,10 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
             self.info.render_redirect_pages = item.is_stripped();
         }
 
-        if item.is_macro_placeholder() {
-            if !self.info.render_redirect_pages {
-                self.shared.all.borrow_mut().append(full_path(self, item), &item);
-            }
-            return Ok(());
-        }
-
         let buf = self.render_item(item, false);
         // buf will be empty if the item is stripped and there is no redirect for it
         if !buf.is_empty() {
-            if !self.info.render_redirect_pages
-                && !matches!(item.kind, clean::ItemKind::MacroItem(_, kinds) if !kinds.contains(MacroKinds::BANG))
-            {
+            if !self.info.render_redirect_pages {
                 self.shared.all.borrow_mut().append(full_path(self, item), &item);
             }
 

src/librustdoc/html/render/mod.rs

@@ -507,33 +507,43 @@ impl AllTypes {
         }
     }
 
+    fn add_item_entry(&mut self, item_type: ItemType, new_url: String, name: String) {
+        match item_type {
+            ItemType::Struct => self.structs.insert(ItemEntry::new(new_url, name)),
+            ItemType::Enum => self.enums.insert(ItemEntry::new(new_url, name)),
+            ItemType::Union => self.unions.insert(ItemEntry::new(new_url, name)),
+            ItemType::Primitive => self.primitives.insert(ItemEntry::new(new_url, name)),
+            ItemType::Trait => self.traits.insert(ItemEntry::new(new_url, name)),
+            ItemType::Macro => self.macros.insert(ItemEntry::new(new_url, name)),
+            ItemType::Function => self.functions.insert(ItemEntry::new(new_url, name)),
+            ItemType::TypeAlias => self.type_aliases.insert(ItemEntry::new(new_url, name)),
+            ItemType::Static => self.statics.insert(ItemEntry::new(new_url, name)),
+            ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)),
+            ItemType::ProcAttribute | ItemType::BangMacroAttribute => {
+                self.attribute_macros.insert(ItemEntry::new(new_url, name))
+            }
+            ItemType::ProcDerive | ItemType::BangMacroDerive => {
+                self.derive_macros.insert(ItemEntry::new(new_url, name))
+            }
+            ItemType::TraitAlias => self.trait_aliases.insert(ItemEntry::new(new_url, name)),
+            _ => true,
+        };
+    }
+
     fn append(&mut self, item_name: String, item: &clean::Item) {
         let mut url: Vec<_> = item_name.split("::").skip(1).collect();
         if let Some(name) = url.pop() {
             let new_url = format!("{}/{}", url.join("/"), item.html_filename());
             url.push(name);
-            let item_type = item.type_();
             let name = url.join("::");
-            match item_type {
-                ItemType::Struct => self.structs.insert(ItemEntry::new(new_url, name)),
-                ItemType::Enum => self.enums.insert(ItemEntry::new(new_url, name)),
-                ItemType::Union => self.unions.insert(ItemEntry::new(new_url, name)),
-                ItemType::Primitive => self.primitives.insert(ItemEntry::new(new_url, name)),
-                ItemType::Trait => self.traits.insert(ItemEntry::new(new_url, name)),
-                ItemType::Macro => self.macros.insert(ItemEntry::new(new_url, name)),
-                ItemType::Function => self.functions.insert(ItemEntry::new(new_url, name)),
-                ItemType::TypeAlias => self.type_aliases.insert(ItemEntry::new(new_url, name)),
-                ItemType::Static => self.statics.insert(ItemEntry::new(new_url, name)),
-                ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)),
-                ItemType::ProcAttribute | ItemType::BangMacroAttribute => {
-                    self.attribute_macros.insert(ItemEntry::new(new_url, name))
-                }
-                ItemType::ProcDerive | ItemType::BangMacroDerive => {
-                    self.derive_macros.insert(ItemEntry::new(new_url, name))
+            let mut types = item.types();
+            if types.len() == 1 {
+                self.add_item_entry(types.pop().unwrap(), new_url, name);
+            } else {
+                for type_ in types {
+                    self.add_item_entry(type_, new_url.clone(), name.clone());
                 }
-                ItemType::TraitAlias => self.trait_aliases.insert(ItemEntry::new(new_url, name)),
-                _ => true,
-            };
+            }
         }
     }