Fix link to attr/derive bang macros

Author: GuillaumeGomez

src/librustdoc/formats/item_type.rs

@@ -99,6 +99,8 @@ item_type! {
     // This number is reserved for use in JavaScript
     // Generic = 26,
     Attribute = 27,
+    BangMacroAttribute = 28,
+    BangMacroDerive = 29,
 }
 
 impl<'a> From<&'a clean::Item> for ItemType {
@@ -128,10 +130,8 @@ impl<'a> From<&'a clean::Item> for ItemType {
             clean::ForeignFunctionItem(..) => ItemType::Function, // no ForeignFunction
             clean::ForeignStaticItem(..) => ItemType::Static,     // no ForeignStatic
             clean::MacroItem(..) => ItemType::Macro,
-            // Is this a good idea?
-            clean::AttrMacroItem => ItemType::ProcAttribute,
-            // Is this a good idea?
-            clean::DeriveMacroItem => ItemType::ProcDerive,
+            clean::AttrMacroItem => ItemType::BangMacroAttribute,
+            clean::DeriveMacroItem => ItemType::BangMacroDerive,
             clean::PrimitiveItem(..) => ItemType::Primitive,
             clean::RequiredAssocConstItem(..)
             | clean::ProvidedAssocConstItem(..)
@@ -225,8 +225,8 @@ impl ItemType {
             ItemType::AssocConst => "associatedconstant",
             ItemType::ForeignType => "foreigntype",
             ItemType::Keyword => "keyword",
-            ItemType::ProcAttribute => "attr",
-            ItemType::ProcDerive => "derive",
+            ItemType::ProcAttribute | ItemType::BangMacroAttribute => "attr",
+            ItemType::ProcDerive | ItemType::BangMacroDerive => "derive",
             ItemType::TraitAlias => "traitalias",
             ItemType::Attribute => "attribute",
         }

src/librustdoc/html/render/mod.rs

@@ -523,10 +523,12 @@ impl AllTypes {
                 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::ProcAttribute | ItemType::BangMacroAttribute => {
                     self.attribute_macros.insert(ItemEntry::new(new_url, name))
                 }
-                ItemType::ProcDerive => self.derive_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,
             };
@@ -2610,8 +2612,8 @@ fn item_ty_to_section(ty: ItemType) -> ItemSection {
         ItemType::ForeignType => ItemSection::ForeignTypes,
         ItemType::Keyword => ItemSection::Keywords,
         ItemType::Attribute => ItemSection::Attributes,
-        ItemType::ProcAttribute => ItemSection::AttributeMacros,
-        ItemType::ProcDerive => ItemSection::DeriveMacros,
+        ItemType::ProcAttribute | ItemType::BangMacroAttribute => ItemSection::AttributeMacros,
+        ItemType::ProcDerive | ItemType::BangMacroDerive => ItemSection::DeriveMacros,
         ItemType::TraitAlias => ItemSection::TraitAliases,
     }
 }

src/librustdoc/html/render/print_item.rs

@@ -314,7 +314,14 @@ fn item_module(cx: &Context<'_>, item: &clean::Item, items: &[clean::Item]) -> i
             FxHashMap::default();
 
         for (index, item) in items.iter().filter(|i| !i.is_stripped()).enumerate() {
-            not_stripped_items.entry(item.type_()).or_default().push((index, item));
+            // To prevent having new "bang macro attribute/derive" sections in the module,
+            // we cheat by turning them into their "proc-macro equivalent".
+            let type_ = match item.type_() {
+                ItemType::BangMacroAttribute => ItemType::ProcAttribute,
+                ItemType::BangMacroDerive => ItemType::ProcDerive,
+                type_ => type_,
+            };
+            not_stripped_items.entry(type_).or_default().push((index, item));
         }
 
         // the order of item types in the listing

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

@@ -244,6 +244,27 @@ declare namespace rustdoc {
         traitParent: number?,
         deprecated: boolean,
         associatedItemDisambiguator: string?,
+        /**
+         * If `true`, this item is a `macro_rules!` macro that supports
+         * multiple usage syntaxes, as described in RFC 3697 and 3698.
+         * The syntax for such a macro looks like this:
+         *
+         * ```rust
+         * /// Doc Comment.
+         * macro_rules! NAME {
+         *     attr(key = $value:literal) ($attached:item) => { ... };
+         *     derive() ($attached:item) => { ... };
+         *     ($bang:tt) => { ... };
+         *  }
+         * ```
+         *
+         * Each usage syntax gets a separate EntryData---one for the attr,
+         * one for the derive, and one for the bang syntax---with a corresponding
+         * `ty` field that can be used for filtering and presenting results.
+         * But the documentation lives in a single `macro.NAME.html` page, and
+         * this boolean flag is used for generating that HREF.
+         */
+        isBangMacro: boolean,
     }
 
     /**
@@ -300,7 +321,7 @@ declare namespace rustdoc {
 
     type ItemType = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |
         11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 |
-        21 | 22 | 23 | 24 | 25 | 26;
+        21 | 22 | 23 | 24 | 25 | 26 | 28 | 29;
 
     /**
      * The viewmodel for the search engine results page.

src/librustdoc/html/static/js/search.js

@@ -120,6 +120,8 @@ const itemTypes = [
     "traitalias", // 25
     "generic",
     "attribute",
+    null, // bang macro attribute
+    null, // bang macro derive
 ];
 
 // used for special search precedence
@@ -1640,7 +1642,7 @@ class DocSearch {
          * ], [string]>}
          */
         const raw = JSON.parse(encoded);
-        return {
+        const item = {
             krate: raw[0],
             ty: raw[1],
             modulePath: raw[2] === 0 ? null : raw[2] - 1,
@@ -1649,7 +1651,15 @@ class DocSearch {
             traitParent: raw[5] === 0 ? null : raw[5] - 1,
             deprecated: raw[6] === 1 ? true : false,
             associatedItemDisambiguator: raw.length === 7 ? null : raw[7],
+            isBangMacro: false,
         };
+        if (item.ty === 28 || item.ty === 29) {
+            // "proc attribute" is 23, "proc derive" is 24 whereas "bang macro attribute" is 28 and
+            // "bang macro derive" is 29, so 5 of difference to go from the latter to the former.
+            item.ty -= 5;
+            item.isBangMacro = true;
+        }
+        return item;
     }
 
     /**
@@ -2146,7 +2156,7 @@ class DocSearch {
             let displayPath;
             let href;
             let traitPath = null;
-            const type = itemTypes[item.ty];
+            const type = item.entry && item.entry.isBangMacro ? "macro" : itemTypes[item.ty];
             const name = item.name;
             let path = item.modulePath;
             let exactPath = item.exactModulePath;
@@ -3949,7 +3959,7 @@ class DocSearch {
                  * @param {Promise<rustdoc.PlainResultObject|null>[]} data
                  * @returns {AsyncGenerator<rustdoc.ResultObject, boolean>}
                  */
-                const flush = async function* (data) {
+                const flush = async function*(data) {
                     const satr = sortAndTransformResults(
                         await Promise.all(data),
                         null,

src/librustdoc/json/conversions.rs

@@ -898,8 +898,8 @@ impl FromClean<ItemType> for ItemKind {
             Keyword => ItemKind::Keyword,
             Attribute => ItemKind::Attribute,
             TraitAlias => ItemKind::TraitAlias,
-            ProcAttribute => ItemKind::ProcAttribute,
-            ProcDerive => ItemKind::ProcDerive,
+            ProcAttribute | BangMacroAttribute => ItemKind::ProcAttribute,
+            ProcDerive | BangMacroDerive => ItemKind::ProcDerive,
         }
     }
 }

tests/rustdoc-gui/attr-macros.goml

@@ -2,38 +2,75 @@
 // the sidebar and in the module.
 
 go-to: "file://" + |DOC_PATH| + "/test_docs/macro.b.html"
-// It should be present twice in the sidebar.
-assert-count: ("#rustdoc-modnav a[href='macro.attr_macro.html']", 2)
-assert-count: ("//*[@id='rustdoc-modnav']//a[text()='attr_macro']", 2)
 // We check that the current item in the sidebar is the correct one.
 assert-text: ("#rustdoc-modnav .block.macro .current", "b")
 
-// We now go to the attribute macro page.
-click: "#rustdoc-modnav a[href='macro.attr_macro.html']"
-// It should be present twice in the sidebar.
-assert-count: ("#rustdoc-modnav a[href='macro.attr_macro.html']", 2)
-assert-count: ("//*[@id='rustdoc-modnav']//a[text()='attr_macro']", 2)
-// We check that the current item is the "attr_macro".
-assert-text: ("#rustdoc-modnav .block.macro .current", "attr_macro")
-// Since the item is present twice in the sidebar, we should have two "current" items.
-assert-count: ("#rustdoc-modnav .current", 2)
-// We check it has the expected information.
-assert-text: ("h3.macro-info", "ⓘ This is an attribute/function macro")
+define-function: (
+    "check_macro",
+    [name, info],
+    block {
+        // It should be present twice in the sidebar.
+        assert-count: ("#rustdoc-modnav a[href='macro." + |name| + ".html']", 2)
+        assert-count: ("//*[@id='rustdoc-modnav']//a[text()='" + |name| + "']", 2)
+
+        // We now go to the macro page.
+        click: "#rustdoc-modnav a[href='macro." + |name| + ".html']"
+        // It should be present twice in the sidebar.
+        assert-count: ("#rustdoc-modnav a[href='macro." + |name| + ".html']", 2)
+        assert-count: ("//*[@id='rustdoc-modnav']//a[text()='" + |name| + "']", 2)
+        // We check that the current item is the macro.
+        assert-text: ("#rustdoc-modnav .block.macro .current", |name|)
+        // Since the item is present twice in the sidebar, we should have two "current" items.
+        assert-count: ("#rustdoc-modnav .current", 2)
+        // We check it has the expected information.
+        assert-text: ("h3.macro-info", "ⓘ This is " + |info| + "/function macro")
+    }
+)
+
+call-function: ("check_macro", {"name": "attr_macro", "info": "an attribute"})
+call-function: ("check_macro", {"name": "derive_macro", "info": "a derive"})
+
+define-function: (
+    "crate_page",
+    [name, section_id],
+    block {
+        // It should be only present twice.
+        assert-count: ("#main-content a[href='macro." + |name| + ".html']", 2)
+        // First in the "Macros" section.
+        assert-text: ("#macros + .item-table a[href='macro." + |name| + ".html']", |name|)
+        // Then in the other macro section.
+        assert-text: (
+            "#" + |section_id| + " + .item-table a[href='macro." + |name| + ".html']",
+            |name|,
+        )
+    }
+)
 
 // Now we check it's correctly listed in the crate page.
 go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
-// It should be only present twice.
-assert-count: ("#main-content a[href='macro.attr_macro.html']", 2)
-// First in the "Macros" section.
-assert-text: ("#macros + .item-table a[href='macro.attr_macro.html']", "attr_macro")
-// Then in the "Attribute Macros" section.
-assert-text: ("#attribute-macros + .item-table a[href='macro.attr_macro.html']", "attr_macro")
+call-function: ("crate_page", {"name": "attr_macro", "section_id": "attribute-macros"})
+call-function: ("crate_page", {"name": "derive_macro", "section_id": "derives"})
+// We also check we don't have duplicated sections.
+assert-count: ("//*[@id='main-content']/h2[text()='Attribute Macros']", 1)
+assert-count: ("//*[@id='main-content']/h2[text()='Derive Macros']", 1)
+
+define-function: (
+    "all_items_page",
+    [name, section_id],
+    block {
+        // It should be only present twice.
+        assert-count: ("#main-content a[href='macro." + |name| + ".html']", 2)
+        // First in the "Macros" section.
+        assert-text: ("#macros + .all-items a[href='macro." + |name| + ".html']", |name|)
+        // Then in the "Attribute Macros" section.
+        assert-text: (
+            "#" + |section_id| + " + .all-items a[href='macro." + |name| + ".html']",
+            |name|,
+        )
+    }
+)
 
 // And finally we check it's correctly listed in the "all items" page.
 go-to: "file://" + |DOC_PATH| + "/test_docs/all.html"
-// It should be only present twice.
-assert-count: ("#main-content a[href='macro.attr_macro.html']", 2)
-// First in the "Macros" section.
-assert-text: ("#macros + .all-items a[href='macro.attr_macro.html']", "attr_macro")
-// Then in the "Attribute Macros" section.
-assert-text: ("#attribute-macros + .all-items a[href='macro.attr_macro.html']", "attr_macro")
+call-function: ("all_items_page", {"name": "attr_macro", "section_id": "attribute-macros"})
+call-function: ("all_items_page", {"name": "derive_macro", "section_id": "derives"})

tests/rustdoc-gui/src/test_docs/lib.rs

@@ -9,6 +9,7 @@
 #![feature(doc_cfg)]
 #![feature(associated_type_defaults)]
 #![feature(macro_attr)]
+#![feature(macro_derive)]
 
 /*!
 Enable the feature <span class="stab portability"><code>some-feature</code></span> to enjoy

tests/rustdoc-gui/src/test_docs/macros.rs

@@ -9,3 +9,17 @@ macro_rules! attr_macro {
     attr() () => {};
     () => {};
 }
+
+/// An attribute bang macro.
+#[macro_export]
+macro_rules! derive_macro {
+    derive() () => {};
+    () => {};
+}
+
+#[macro_export]
+macro_rules! one_for_all_macro {
+    attr() () => {};
+    derive() () => {};
+    () => {};
+}

tests/rustdoc-js/macro-kinds.js

@@ -4,15 +4,24 @@ const EXPECTED = [
     {
         'query': 'macro:macro',
         'others': [
-            { 'path': 'macro_kinds', 'name': 'macro1' },
-            { 'path': 'macro_kinds', 'name': 'macro3' },
+            { 'path': 'macro_kinds', 'name': 'macro1', 'href': '../macro_kinds/macro.macro1.html' },
+            { 'path': 'macro_kinds', 'name': 'macro3', 'href': '../macro_kinds/macro.macro3.html' },
         ],
     },
     {
         'query': 'attr:macro',
         'others': [
-            { 'path': 'macro_kinds', 'name': 'macro1' },
-            { 'path': 'macro_kinds', 'name': 'macro2' },
+            { 'path': 'macro_kinds', 'name': 'macro1', 'href': '../macro_kinds/macro.macro1.html' },
+            { 'path': 'macro_kinds', 'name': 'macro2', 'href': '../macro_kinds/attr.macro2.html' },
+        ],
+    },
+    {
+        'query': 'derive:macro',
+        'others': [
+            { 'path': 'macro_kinds', 'name': 'macro1', 'href': '../macro_kinds/macro.macro1.html' },
+            {
+                'path': 'macro_kinds', 'name': 'macro4', 'href': '../macro_kinds/derive.macro4.html'
+            },
         ],
     },
 ];