[rustdoc] Inline reexport item

Signed-off-by: xizheyin <[email protected]>

Author: xizheyin

src/librustdoc/passes/strip_hidden.rs

@@ -89,6 +89,10 @@ impl Stripper<'_, '_> {
 impl DocFolder for Stripper<'_, '_> {
     fn fold_item(&mut self, i: Item) -> Option<Item> {
         let has_doc_hidden = i.is_doc_hidden();
+        debug!(
+            "item: {:?}, has_doc_hidden: {}, is_in_hidden_item: {}",
+            i, has_doc_hidden, self.is_in_hidden_item
+        );
         let is_impl_or_exported_macro = match i.kind {
             clean::ImplItem(..) => true,
             // If the macro has the `#[macro_export]` attribute, it means it's accessible at the
@@ -119,7 +123,7 @@ impl DocFolder for Stripper<'_, '_> {
                     .unwrap_or(false);
             }
         }
-        if !is_hidden {
+        if !is_hidden || i.inline_stmt_id.is_some() {
             if self.update_retained {
                 self.retained.insert(i.item_id);
             }
@@ -144,23 +148,26 @@ impl DocFolder for Stripper<'_, '_> {
                 // strip things like impl methods but when doing so
                 // we must not add any items to the `retained` set.
                 let old = mem::replace(&mut self.update_retained, false);
-                let ret = self.set_is_in_hidden_item_and_fold(true, i);
+                let ret = self.set_is_in_hidden_item_and_fold(true, i.clone());
                 self.update_retained = old;
                 if ret.item_id == clean::ItemId::DefId(CRATE_DEF_ID.into()) {
                     // We don't strip the current crate, even if it has `#[doc(hidden)]`.
-                    debug!("strip_hidden: Not strippping local crate");
+                    debug!("strip_hidden0: Not strippping local crate");
                     Some(ret)
                 } else {
+                    debug!("strip_hidden1: stripping(strip_item) {:?} {:?}", i.type_(), i.name);
                     Some(strip_item(ret))
                 }
             }
             _ => {
-                let ret = self.set_is_in_hidden_item_and_fold(true, i);
+                let ret = self.set_is_in_hidden_item_and_fold(true, i.clone());
                 if has_doc_hidden {
                     // If the item itself has `#[doc(hidden)]`, then we simply remove it.
+                    debug!("strip_hidden2: stripping(remove) {:?} {:?}", i.type_(), i.name);
                     None
                 } else {
                     // However if it's a "descendant" of a `#[doc(hidden)]` item, then we strip it.
+                    debug!("strip_hidden3: stripping(strip_item) {:?} {:?}", i.type_(), i.name);
                     Some(strip_item(ret))
                 }
             }

src/librustdoc/visit_ast.rs

@@ -251,6 +251,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             || (document_hidden && hir_attr_lists(use_attrs, sym::doc).has_word(sym::hidden));
 
         if is_no_inline {
+            debug!("maybe_inline_local: is_no_inline, (renamed: {renamed:?}) res: {res:?}");
             return false;
         }
 
@@ -277,20 +278,33 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             return true;
         };
 
-        let is_private = !self.cx.cache.effective_visibilities.is_directly_public(tcx, ori_res_did);
         let item = tcx.hir_node_by_def_id(res_did);
 
         if !please_inline {
+            // Check if item is private
+            let is_private =
+                !self.cx.cache.effective_visibilities.is_directly_public(tcx, ori_res_did);
+            // Check if item inherits #[doc(hidden)] from a parent
             let inherits_hidden = !document_hidden && inherits_doc_hidden(tcx, res_did, None);
-            // Only inline if requested or if the item would otherwise be stripped.
-            if (!is_private && !inherits_hidden) || (
-                is_hidden &&
-                // If it's a doc hidden module, we need to keep it in case some of its inner items
-                // are re-exported.
-                !matches!(item, Node::Item(&hir::Item { kind: hir::ItemKind::Mod(_), .. }))
-            ) ||
-                // The imported item is public and not `doc(hidden)` so no need to inline it.
-                self.reexport_public_and_not_hidden(def_id, res_did)
+
+            // Don't inline if the item is public and visible (not hidden)
+            // This preserves the original import for public items that should be documented
+            let is_public_and_visible = !is_private && !inherits_hidden && !is_hidden;
+
+            // Don't inline if the item is hidden but not a module, and not publicly re-exported
+            // We skip modules since their items may be re-exported elsewhere
+            let is_hidden_and_non_module_non_reexported = is_hidden
+                && !self.is_reexport_public(def_id, res_did)
+                && !matches!(item, Node::Item(&hir::Item { kind: hir::ItemKind::Mod(_), .. }));
+
+            // Don't inline if this is a public re-export of a non-hidden item
+            // This preserves the re-export path in the documentation
+            let is_public_reexport = self.reexport_public_and_not_hidden(def_id, res_did);
+
+            // Return false to prevent inlining if any of these conditions are met
+            if is_public_and_visible
+                || is_hidden_and_non_module_non_reexported
+                || is_public_reexport
             {
                 return false;
             }
@@ -339,9 +353,26 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
         if inlined {
             self.cx.cache.inlined_items.insert(ori_res_did);
         }
+        debug!("maybe_inline_local: inlined: {inlined}, (renamed: {renamed:?}) res: {res:?}");
         inlined
     }
 
+    fn is_reexport_public(&self, import_def_id: LocalDefId, target_def_id: LocalDefId) -> bool {
+        if self.cx.render_options.document_hidden {
+            return true;
+        }
+        let tcx = self.cx.tcx;
+        let item_def_id = reexport_chain(tcx, import_def_id, target_def_id.to_def_id())
+            .iter()
+            .flat_map(|reexport| reexport.id())
+            .map(|id| id.expect_local())
+            .nth(1)
+            .unwrap_or(target_def_id);
+
+        item_def_id != import_def_id
+            && self.cx.cache.effective_visibilities.is_directly_public(tcx, item_def_id.to_def_id())
+    }
+
     /// Returns `true` if the item is visible, meaning it's not `#[doc(hidden)]` or private.
     ///
     /// This function takes into account the entire re-export `use` chain, so it needs the