Fix type display names, cross-crate re-export links, and derive macro paths

Three fixes for broken links in generated API docs:

1. Strip internal module paths from type signatures - use only the
   last segment of path.path (e.g., "JoinHandle" not
   "super::join_handle::JoinHandle"). Fixes 328 pages.

2. Update global index to redirect canonical (definition) path
   lookups to re-export locations. Prefers shorter re-export paths
   to avoid prelude locations. Fixes cross-crate links like
   FnOnce pointing to core/ops/function/ instead of core/ops/.

3. Add ProcDerive/ProcAttribute handling to all kind-prefix
   mappings (types.rs, mod.rs, output.rs) so derive macro pages
   are written as derive.Clone.html and links match. Fixes 82
   pages with broken derive macro links.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: brson

crates/rustmax-rustdoc/src/lib.rs

@@ -327,11 +327,35 @@ impl RustDocSet {
                     };
 
                     // Only insert if not already present (prefer canonical paths).
-                    index.items.entry(path_str).or_insert_with(|| ItemLocation {
-                        crate_name: target_crate,
-                        path: target_path,
+                    index.items.entry(path_str.clone()).or_insert_with(|| ItemLocation {
+                        crate_name: target_crate.clone(),
+                        path: target_path.clone(),
                         kind,
                     });
+
+                    // For local re-exports, also update the canonical (definition)
+                    // path entry to point to the re-export location. This ensures
+                    // cross-crate lookups by definition path (e.g.,
+                    // "core::ops::function::FnOnce") resolve to the public re-export
+                    // location (e.g., "core::ops::FnOnce" → core/ops/trait.FnOnce.html).
+                    // Prefer shorter re-export paths to avoid prelude re-exports.
+                    if path_info.crate_id == 0 {
+                        let canonical_path_str = path_info.path.join("::");
+                        if canonical_path_str != path_str {
+                            let new_loc = ItemLocation {
+                                crate_name: target_crate,
+                                path: target_path,
+                                kind,
+                            };
+                            index.items.entry(canonical_path_str)
+                                .and_modify(|existing| {
+                                    if new_loc.path.len() < existing.path.len() {
+                                        *existing = new_loc.clone();
+                                    }
+                                })
+                                .or_insert(new_loc);
+                        }
+                    }
                 }
             }
         }

crates/rustmax-rustdoc/src/output.rs

@@ -120,6 +120,11 @@ fn build_reexport_html_path(path: &[String], inner: &ItemEnum) -> PathBuf {
         ItemEnum::Constant { .. } => Some(ItemKind::Constant),
         ItemEnum::Static(_) => Some(ItemKind::Static),
         ItemEnum::Macro(_) => Some(ItemKind::Macro),
+        ItemEnum::ProcMacro(pm) => Some(match pm.kind {
+            rustdoc_types::MacroKind::Derive => ItemKind::ProcDerive,
+            rustdoc_types::MacroKind::Attr => ItemKind::ProcAttribute,
+            rustdoc_types::MacroKind::Bang => ItemKind::Macro,
+        }),
         ItemEnum::Union(_) => Some(ItemKind::Union),
         _ => None,
     };
@@ -133,6 +138,8 @@ fn build_reexport_html_path(path: &[String], inner: &ItemEnum) -> PathBuf {
         Some(ItemKind::Constant) => "constant.",
         Some(ItemKind::Static) => "static.",
         Some(ItemKind::Macro) => "macro.",
+        Some(ItemKind::ProcDerive) => "derive.",
+        Some(ItemKind::ProcAttribute) => "attr.",
         Some(ItemKind::Union) => "union.",
         _ => "",
     };

crates/rustmax-rustdoc/src/render/mod.rs

@@ -135,6 +135,8 @@ impl<'a> RenderContext<'a> {
             ItemKind::Constant => "constant.",
             ItemKind::Static => "static.",
             ItemKind::Macro => "macro.",
+            ItemKind::ProcDerive => "derive.",
+            ItemKind::ProcAttribute => "attr.",
             ItemKind::Module => "",
             _ => return None, // Don't link to other kinds.
         };

crates/rustmax-rustdoc/src/render/signature.rs

@@ -467,7 +467,11 @@ impl<'a, 'ctx> LinkedRenderer<'a, 'ctx> {
     }
 
     fn render_resolved_path(&self, path: &Path) -> String {
-        let name = html_escape(&path.path);
+        // Use only the last segment as the display name. Rustdoc JSON
+        // stores source-level paths like "super::join_handle::JoinHandle"
+        // but we want to show just "JoinHandle".
+        let simple_name = path.path.rsplit("::").next().unwrap_or(&path.path);
+        let name = html_escape(simple_name);
         let args = path.args.as_ref()
             .map(|a| self.render_generic_args(a))
             .unwrap_or_default();

crates/rustmax-rustdoc/src/types.rs

@@ -208,6 +208,8 @@ fn path_to_html(path: &[String], kind: Option<ItemKind>) -> PathBuf {
         Some(ItemKind::Static) => "static.",
         Some(ItemKind::Macro) => "macro.",
         Some(ItemKind::Union) => "union.",
+        Some(ItemKind::ProcDerive) => "derive.",
+        Some(ItemKind::ProcAttribute) => "attr.",
         _ => "",
     };
 
@@ -240,6 +242,11 @@ fn item_kind(inner: &ItemEnum) -> Option<ItemKind> {
         ItemEnum::Constant { .. } => Some(ItemKind::Constant),
         ItemEnum::Static(_) => Some(ItemKind::Static),
         ItemEnum::Macro(_) => Some(ItemKind::Macro),
+        ItemEnum::ProcMacro(pm) => Some(match pm.kind {
+            rustdoc_types::MacroKind::Derive => ItemKind::ProcDerive,
+            rustdoc_types::MacroKind::Attr => ItemKind::ProcAttribute,
+            rustdoc_types::MacroKind::Bang => ItemKind::Macro,
+        }),
         ItemEnum::Union(_) => Some(ItemKind::Union),
         _ => None,
     }