Improve code and apply suggestions

Author: GuillaumeGomez

src/librustdoc/clean/inline.rs

@@ -780,7 +780,7 @@ fn build_macro(
                         source: utils::display_macro_source(cx, name, &def),
                         macro_rules: def.macro_rules,
                     },
-                    None,
+                    MacroKinds::BANG,
                 ),
                 None,
             ),
@@ -804,7 +804,7 @@ fn build_macro(
                         source: utils::display_macro_source(cx, name, &def),
                         macro_rules: def.macro_rules,
                     },
-                    Some(macro_kinds),
+                    macro_kinds,
                 );
                 let mut ret = vec![];
                 for kind in macro_kinds.iter().filter(|kind| *kind != MacroKinds::BANG) {

src/librustdoc/clean/mod.rs

@@ -2849,7 +2849,7 @@ fn clean_maybe_renamed_item<'tcx>(
                         source: display_macro_source(cx, name, macro_def),
                         macro_rules: macro_def.macro_rules,
                     },
-                    None,
+                    MacroKinds::BANG,
                 ),
                 MacroKinds::ATTR => clean_proc_macro(item, &mut name, MacroKind::Attr, cx),
                 MacroKinds::DERIVE => clean_proc_macro(item, &mut name, MacroKind::Derive, cx),
@@ -2859,7 +2859,7 @@ fn clean_maybe_renamed_item<'tcx>(
                             source: display_macro_source(cx, name, macro_def),
                             macro_rules: macro_def.macro_rules,
                         },
-                        Some(kinds),
+                        kinds,
                     );
                     let mac = generate_item_with_correct_attrs(
                         cx,

src/librustdoc/clean/types.rs

@@ -965,8 +965,12 @@ pub(crate) enum ItemKind {
     ForeignStaticItem(Static, hir::Safety),
     /// `type`s from an extern block
     ForeignTypeItem,
-    MacroItem(Macro, Option<MacroKinds>),
+    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),

src/librustdoc/html/markdown.rs

@@ -2035,7 +2035,7 @@ fn is_default_id(id: &str) -> bool {
         | "crate-search"
         | "crate-search-div"
         // This is the list of IDs used in HTML generated in Rust (including the ones
-        // used in tera template files).
+        // used in askama template files).
         | "themeStyle"
         | "settings-menu"
         | "help-button"
@@ -2074,7 +2074,7 @@ fn is_default_id(id: &str) -> bool {
         | "blanket-implementations-list"
         | "deref-methods"
         | "layout"
-        | "aliased-type"
+        | "aliased-type",
     )
 }
 

src/librustdoc/html/render/context.rs

@@ -168,15 +168,18 @@ impl SharedContext<'_> {
 
 struct SidebarItem {
     name: String,
-    is_actually_macro: bool,
+    /// Bang macros can now be used as attribute/derive macros, making it tricky to correctly
+    /// handle all their cases at once, which means that even if they are categorized as
+    /// derive/attribute macros, they should still link to a "macro_rules" URL.
+    is_macro_rules: bool,
 }
 
 impl serde::Serialize for SidebarItem {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        if self.is_actually_macro {
+        if self.is_macro_rules {
             let mut seq = serializer.serialize_seq(Some(2))?;
             seq.serialize_element(&self.name)?;
             seq.serialize_element(&1)?;
@@ -348,7 +351,7 @@ impl<'tcx> Context<'tcx> {
                 let name = name.to_string();
                 map.entry(type_)
                     .or_default()
-                    .push(SidebarItem { name, is_actually_macro: item.is_macro_placeholder() });
+                    .push(SidebarItem { name, is_macro_rules: item.is_macro_placeholder() });
             }
         }
 

src/librustdoc/html/render/mod.rs

@@ -2600,7 +2600,7 @@ impl ItemSection {
             Self::ForeignTypes => "foreign-types",
             Self::Keywords => "keywords",
             Self::Attributes => "attributes",
-            Self::AttributeMacros => "attributes",
+            Self::AttributeMacros => "attribute-macros",
             Self::DeriveMacros => "derives",
             Self::TraitAliases => "trait-aliases",
         }

src/librustdoc/html/render/print_item.rs

@@ -406,13 +406,15 @@ fn item_module(cx: &Context<'_>, item: &clean::Item, items: &[clean::Item]) -> i
 
         for type_ in types {
             let my_section = item_ty_to_section(type_);
-            let section_id = my_section.id();
-            let tag =
-                if section_id == "reexports" { REEXPORTS_TABLE_OPEN } else { ITEM_TABLE_OPEN };
+            let tag = if my_section == super::ItemSection::Reexports {
+                REEXPORTS_TABLE_OPEN
+            } else {
+                ITEM_TABLE_OPEN
+            };
             write!(
                 w,
                 "{}",
-                write_section_heading(my_section.name(), &cx.derive_id(section_id), None, tag)
+                write_section_heading(my_section.name(), &cx.derive_id(my_section.id()), None, tag)
             )?;
 
             for (_, myitem) in &not_stripped_items[&type_] {
@@ -1889,7 +1891,7 @@ fn item_macro(
     cx: &Context<'_>,
     it: &clean::Item,
     t: &clean::Macro,
-    kinds: Option<MacroKinds>,
+    kinds: MacroKinds,
 ) -> impl fmt::Display {
     fmt::from_fn(move |w| {
         wrap_item(w, |w| {
@@ -1900,7 +1902,7 @@ fn item_macro(
             }
             write!(w, "{}", Escape(&t.source))
         })?;
-        if let Some(kinds) = kinds {
+        if kinds != MacroKinds::BANG {
             write!(
                 w,
                 "<h3 class='macro-info'>ⓘ This is {} {}</h3>",

src/librustdoc/html/static/js/rustdoc.d.ts

@@ -27,7 +27,7 @@ declare global {
         /** Make the current theme easy to find */
         currentTheme: HTMLLinkElement|null;
         /** Generated in `render/context.rs` */
-        SIDEBAR_ITEMS?: { [key: string]: string[] };
+        SIDEBAR_ITEMS?: { [key: string]: (string | [string, 1])[] };
         /** Notable trait data */
         NOTABLE_TRAITS?: { [key: string]: string };
         CURRENT_TOOLTIP_ELEMENT?: HTMLElement & { TOOLTIP_BASE: HTMLElement };

src/librustdoc/json/conversions.rs

@@ -52,7 +52,12 @@ impl JsonRenderer<'_> {
         let clean::ItemInner { name, item_id, .. } = *item.inner;
         let id = self.id_from_item(item);
         let inner = match item.kind {
-            clean::KeywordItem | clean::AttributeItem => return None,
+            clean::KeywordItem
+            | clean::AttributeItem
+            // Placeholder so no need to handle it.
+            | clean::AttrMacroItem
+            // Placeholder so no need to handle it.
+            | clean::DeriveMacroItem => return None,
             clean::StrippedItem(ref inner) => {
                 match &**inner {
                     // We document stripped modules as with `Module::is_stripped` set to
@@ -61,12 +66,12 @@ impl JsonRenderer<'_> {
                     clean::ModuleItem(_)
                         if self.imported_items.contains(&item_id.expect_def_id()) =>
                     {
-                        from_clean_item(item, self)?
+                        from_clean_item(item, self)
                     }
                     _ => return None,
                 }
             }
-            _ => from_clean_item(item, self)?,
+            _ => from_clean_item(item, self),
         };
         Some(Item {
             id,
@@ -268,13 +273,13 @@ impl FromClean<clean::AssocItemConstraintKind> for AssocItemConstraintKind {
     }
 }
 
-fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> Option<ItemEnum> {
+fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> ItemEnum {
     use clean::ItemKind::*;
     let name = item.name;
     let is_crate = item.is_crate();
     let header = item.fn_header(renderer.tcx);
 
-    Some(match &item.inner.kind {
+    match &item.inner.kind {
         ModuleItem(m) => {
             ItemEnum::Module(Module { is_crate, items: renderer.ids(&m.items), is_stripped: false })
         }
@@ -309,8 +314,6 @@ fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> Option<It
             const_: ci.kind.into_json(renderer),
         },
         MacroItem(m, _) => ItemEnum::Macro(m.source.clone()),
-        // They are just placeholders so no need to handle them.
-        AttrMacroItem | DeriveMacroItem => return None,
         ProcMacroItem(m) => ItemEnum::ProcMacro(m.into_json(renderer)),
         PrimitiveItem(p) => {
             ItemEnum::Primitive(Primitive {
@@ -337,8 +340,9 @@ fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> Option<It
             bounds: b.into_json(renderer),
             type_: Some(t.item_type.as_ref().unwrap_or(&t.type_).into_json(renderer)),
         },
-        // `convert_item` early returns `None` for stripped items, keywords and attributes.
-        KeywordItem | AttributeItem => unreachable!(),
+        // `convert_item` early returns `None` for stripped items, keywords, attributes and
+        // "special" macro rules.
+        KeywordItem | AttributeItem | AttrMacroItem | DeriveMacroItem => unreachable!(),
         StrippedItem(inner) => {
             match inner.as_ref() {
                 ModuleItem(m) => ItemEnum::Module(Module {
@@ -354,7 +358,7 @@ fn from_clean_item(item: &clean::Item, renderer: &JsonRenderer<'_>) -> Option<It
             name: name.as_ref().unwrap().to_string(),
             rename: src.map(|x| x.to_string()),
         },
-    })
+    }
 }
 
 impl FromClean<clean::Struct> for Struct {