rustdoc: link sibling where possible, even when not One True Path

This is, first of all, a size hack aimed at the `core::arch`
modules that share items (x86-64/x86, aarch64/x86). They
inline a lot of items from shared modules, and if we can
avoid writing `../arm/WHATEVER` all over the aarch64 module,
we can shave a few bytes off every link.

Also, clicking a link in the 64 bit module and landing in
the 32 bit module makes no sense.

Author: notriddle

src/librustdoc/html/format.rs

@@ -725,13 +725,26 @@ pub(crate) fn href_with_root_path(
     }
 
     let mut is_remote = false;
-    let (fqp, shortty, url_parts) = match cache.paths.get(&did) {
-        Some(&(ref fqp, shortty)) => (fqp, shortty, {
-            let module_fqp = to_module_fqp(shortty, fqp.as_slice());
-            debug!(?fqp, ?shortty, ?module_fqp);
-            href_relative_parts(module_fqp, relative_to).collect()
-        }),
-        None => {
+    let chain_fqp: Vec<Symbol>;
+    let (fqp, shortty, url_parts) =
+        if let Some(&(shortty, name)) = cx.current_module_linkable_items.get(&did) {
+            // If this item exists in the current module, then link to that.
+            // The path within the current module might not be the One True Path,
+            // but link to it anyway, since a relative path to a sibling is shorter.
+            if shortty == ItemType::Module {
+                (relative_to, shortty, UrlPartsBuilder::singleton(name.as_str()))
+            } else {
+                chain_fqp = relative_to.iter().copied().chain([name]).collect();
+                (&chain_fqp, shortty, UrlPartsBuilder::new())
+            }
+        } else if let Some(&(ref fqp, shortty)) = cache.paths.get(&did) {
+            // If this item exists in the current crate, then link to that.
+            (fqp, shortty, {
+                let module_fqp = to_module_fqp(shortty, fqp.as_slice());
+                debug!(?fqp, ?shortty, ?module_fqp);
+                href_relative_parts(module_fqp, relative_to).collect()
+            })
+        } else {
             // Associated items are handled differently with "jump to def". The anchor is generated
             // directly here whereas for intra-doc links, we have some extra computation being
             // performed there.
@@ -746,8 +759,7 @@ pub(crate) fn href_with_root_path(
             } else {
                 return generate_item_def_id_path(did, original_did, cx, root_path, def_kind);
             }
-        }
-    };
+        };
     make_href(root_path, shortty, url_parts, fqp, is_remote)
 }
 

src/librustdoc/html/render/context.rs

@@ -49,6 +49,10 @@ pub(crate) struct Context<'tcx> {
     /// Current hierarchy of components leading down to what's currently being
     /// rendered
     pub(crate) current: Vec<Symbol>,
+    /// Set of visible DefIds in the current module.
+    /// This generates optimal link hrefs in the common case when
+    /// an entire module is glob-inlined and its children link to each other.
+    pub(crate) current_module_linkable_items: DefIdMap<(ItemType, Symbol)>,
     /// The current destination folder of where HTML artifacts should be placed.
     /// This changes as the context descends into the module hierarchy.
     pub(crate) dst: PathBuf,
@@ -79,7 +83,7 @@ pub(crate) struct Context<'tcx> {
 
 // `Context` is cloned a lot, so we don't want the size to grow unexpectedly.
 #[cfg(all(not(windows), target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Context<'_>, 160);
+rustc_data_structures::static_assert_size!(Context<'_>, 192);
 
 /// Shared mutable state used in [`Context`] and elsewhere.
 pub(crate) struct SharedContext<'tcx> {
@@ -559,6 +563,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
 
         let mut cx = Context {
             current: Vec::new(),
+            current_module_linkable_items: Default::default(),
             dst,
             render_redirect_pages: false,
             id_map,
@@ -589,6 +594,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
     fn make_child_renderer(&self) -> Self {
         Self {
             current: self.current.clone(),
+            current_module_linkable_items: self.current_module_linkable_items.clone(),
             dst: self.dst.clone(),
             render_redirect_pages: self.render_redirect_pages,
             deref_id_map: Default::default(),
@@ -783,8 +789,29 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
         info!("Recursing into {}", self.dst.display());
 
         if !item.is_stripped() {
+            // Populate a list of items that are directly in the module
+            // or inlined into it.
+            // When an intra-doc link or named type needs linked,
+            // these are preferred over more distant paths.
+            let (clean::StrippedItem(box clean::ModuleItem(ref module))
+            | clean::ModuleItem(ref module)) = *item.kind
+            else {
+                unreachable!()
+            };
+            self.current_module_linkable_items = Default::default();
+            for item in &module.items {
+                if item.is_stripped() {
+                    continue;
+                }
+                if let Some(def_id) = item.def_id()
+                    && let Some(name) = item.name
+                {
+                    self.current_module_linkable_items.insert(def_id, (item.type_(), name));
+                }
+            }
+            // Render the current module to HTML.
+            // Buf will be empty if the module is stripped and there is no redirect for it.
             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() {
                 self.shared.ensure_dir(&self.dst)?;
                 let joint_dst = self.dst.join("index.html");

tests/rustdoc/intra-doc/glob-inline-siblings.rs

@@ -0,0 +1,35 @@
+#![deny(rustdoc::broken_intra_doc_links)]
+#![allow(nonstandard_style)]
+
+// Reduced case from `core::arch::{arm, aarch64}`.
+// Both versions of arm should link to the struct that they inlined.
+// aarch64 should not link to the inlined copy in arm 32.
+
+mod arm_shared {
+    pub struct uint32x4_t;
+    pub struct uint32x4x2_t(pub uint32x4_t, pub uint32x4_t);
+    pub fn vabaq_u32(
+        _a: uint32x4_t,
+        _b: uint32x4_t,
+        _c: uint32x4_t
+    ) -> uint32x4_t {
+        uint32x4_t
+    }
+}
+
+pub mod arm {
+    pub use crate::arm_shared::*;
+    // @has glob_inline_siblings/arm/fn.vabaq_u32.html '//a[@href="struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @has glob_inline_siblings/arm/struct.uint32x4x2_t.html '//a[@href="struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @!has glob_inline_siblings/arm/fn.vabaq_u32.html '//a[@href="../aarch64/struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @!has glob_inline_siblings/arm/struct.uint32x4x2_t.html '//a[@href="../aarch64/struct.uint32x4_t.html"]' 'uint32x4_t'
+}
+
+
+pub mod aarch64 {
+    pub use crate::arm_shared::*;
+    // @has glob_inline_siblings/aarch64/fn.vabaq_u32.html '//a[@href="struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @has glob_inline_siblings/aarch64/struct.uint32x4x2_t.html '//a[@href="struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @!has glob_inline_siblings/aarch64/fn.vabaq_u32.html '//a[@href="../arm/struct.uint32x4_t.html"]' 'uint32x4_t'
+    // @!has glob_inline_siblings/aarch64/struct.uint32x4x2_t.html '//a[@href="../arm/struct.uint32x4_t.html"]' 'uint32x4_t'
+}