rustdoc-json-types: Id(String) -> Id(u32)

rustdoc: Add a `TyCtxt` handle to `Cache`

Author: its-the-shrimp

src/librustdoc/clean/inline.rs

@@ -151,7 +151,6 @@ pub(crate) fn try_inline(
         _ => return None,
     };
 
-    cx.inlined.insert(did.into());
     let mut item = crate::clean::generate_item_with_correct_attrs(
         cx,
         kind,
@@ -160,6 +159,7 @@ pub(crate) fn try_inline(
         import_def_id.and_then(|def_id| def_id.as_local()),
         None,
     );
+    cx.inlined.insert(item.item_id);
     // The visibility needs to reflect the one from the reexport and not from the "source" DefId.
     item.inline_stmt_id = import_def_id;
     ret.push(item);
@@ -434,7 +434,7 @@ pub(crate) fn build_impl(
     attrs: Option<(&[ast::Attribute], Option<DefId>)>,
     ret: &mut Vec<clean::Item>,
 ) {
-    if !cx.inlined.insert(did.into()) {
+    if !cx.inlined.insert(ItemId::DefId(did, None)) {
         return;
     }
 
@@ -676,7 +676,7 @@ fn build_module_items(
                     attrs: Box::default(),
                     // We can use the item's `DefId` directly since the only information ever used
                     // from it is `DefId.krate`.
-                    item_id: ItemId::DefId(did),
+                    item_id: ItemId::DefId(did, None),
                     kind: Box::new(clean::ImportItem(clean::Import::new_simple(
                         item.ident.name,
                         clean::ImportSource {

src/librustdoc/clean/types.rs

@@ -11,7 +11,7 @@ use rustc_ast_pretty::pprust;
 use rustc_attr::{ConstStability, Deprecation, Stability, StabilityLevel, StableSince};
 use rustc_const_eval::const_eval::is_unstable_const_fn;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir::def::{CtorKind, DefKind, Res};
+use rustc_hir::def::{CtorKind, DefKind, Namespace, Res};
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE};
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{BodyId, Mutability};
@@ -57,20 +57,34 @@ pub(crate) type ItemIdSet = FxHashSet<ItemId>;
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Copy)]
 pub(crate) enum ItemId {
     /// A "normal" item that uses a [`DefId`] for identification.
-    DefId(DefId),
+    DefId(DefId, Option<Namespace>),
     /// Identifier that is used for auto traits.
     Auto { trait_: DefId, for_: DefId },
     /// Identifier that is used for blanket implementations.
     Blanket { impl_id: DefId, for_: DefId },
 }
 
 impl ItemId {
+    pub(crate) fn type_ns(did: DefId) -> Self {
+        Self::DefId(did, Some(Namespace::TypeNS))
+    }
+
+    pub(crate) fn opt_from_res<Id>(res: &Res<Id>) -> Option<Self> {
+        res.opt_def_id().map(|did| Self::DefId(did, res.ns()))
+    }
+
+    #[track_caller]
+    pub(crate) fn from_res<Id: std::fmt::Debug>(res: &Res<Id>) -> Self {
+        Self::opt_from_res(res)
+            .unwrap_or_else(|| panic!("attempted to get the ItemId of a wrong Res: `{res:?}`"))
+    }
+
     #[inline]
     pub(crate) fn is_local(self) -> bool {
         match self {
             ItemId::Auto { for_: id, .. }
             | ItemId::Blanket { for_: id, .. }
-            | ItemId::DefId(id) => id.is_local(),
+            | ItemId::DefId(id, _) => id.is_local(),
         }
     }
 
@@ -84,7 +98,7 @@ impl ItemId {
     #[inline]
     pub(crate) fn as_def_id(self) -> Option<DefId> {
         match self {
-            ItemId::DefId(id) => Some(id),
+            ItemId::DefId(id, _) => Some(id),
             _ => None,
         }
     }
@@ -99,17 +113,11 @@ impl ItemId {
         match self {
             ItemId::Auto { for_: id, .. }
             | ItemId::Blanket { for_: id, .. }
-            | ItemId::DefId(id) => id.krate,
+            | ItemId::DefId(id, _) => id.krate,
         }
     }
 }
 
-impl From<DefId> for ItemId {
-    fn from(id: DefId) -> Self {
-        Self::DefId(id)
-    }
-}
-
 /// The crate currently being documented.
 #[derive(Clone, Debug)]
 pub(crate) struct Crate {
@@ -136,6 +144,11 @@ pub(crate) struct ExternalCrate {
 impl ExternalCrate {
     const LOCAL: Self = Self { crate_num: LOCAL_CRATE };
 
+    #[inline]
+    pub(crate) fn item_id(&self) -> ItemId {
+        ItemId::type_ns(self.crate_num.as_def_id())
+    }
+
     #[inline]
     pub(crate) fn def_id(&self) -> DefId {
         self.crate_num.as_def_id()
@@ -450,8 +463,15 @@ impl Item {
     ) -> Item {
         trace!("name={name:?}, def_id={def_id:?} cfg={cfg:?}");
 
+        let ns = if let ItemKind::ImportItem(i) = &kind
+            && let ImportKind::Simple(_) = i.kind
+        {
+            i.source.path.res.ns()
+        } else {
+            ItemType::from(&kind).ns()
+        };
         Item {
-            item_id: def_id.into(),
+            item_id: ItemId::DefId(def_id, ns),
             kind: Box::new(kind),
             name,
             attrs,
@@ -466,7 +486,7 @@ impl Item {
         let Some(links) = cx.cache().intra_doc_links.get(&self.item_id) else { return vec![] };
         links
             .iter()
-            .filter_map(|ItemLink { link: s, link_text, page_id: id, ref fragment }| {
+            .filter_map(|ItemLink { link: s, link_text, page_id: id, ref fragment, .. }| {
                 debug!(?id);
                 if let Ok((mut href, ..)) = href(*id, cx) {
                     debug!(?href);
@@ -491,7 +511,7 @@ impl Item {
     /// This is used for generating summary text, which does not include
     /// the link text, but does need to know which `[]`-bracketed names
     /// are actually links.
-    pub(crate) fn link_names(&self, cache: &Cache) -> Vec<RenderedLink> {
+    pub(crate) fn link_names(&self, cache: &Cache<'_>) -> Vec<RenderedLink> {
         let Some(links) = cache.intra_doc_links.get(&self.item_id) else {
             return vec![];
         };
@@ -675,7 +695,7 @@ impl Item {
         let def_id = match self.item_id {
             // Anything but DefId *shouldn't* matter, but return a reasonable value anyway.
             ItemId::Auto { .. } | ItemId::Blanket { .. } => return None,
-            ItemId::DefId(def_id) => def_id,
+            ItemId::DefId(def_id, _) => def_id,
         };
 
         match *self.kind {
@@ -714,17 +734,13 @@ impl Item {
         Some(tcx.visibility(def_id))
     }
 
-    pub(crate) fn attributes(
-        &self,
-        tcx: TyCtxt<'_>,
-        cache: &Cache,
-        keep_as_is: bool,
-    ) -> Vec<String> {
+    pub(crate) fn attributes(&self, cache: &Cache<'_>, keep_as_is: bool) -> Vec<String> {
         const ALLOWED_ATTRIBUTES: &[Symbol] =
             &[sym::export_name, sym::link_section, sym::no_mangle, sym::non_exhaustive];
 
         use rustc_abi::IntegerType;
 
+        let tcx = cache.tcx;
         let mut attrs: Vec<String> = self
             .attrs
             .other_attrs
@@ -1113,6 +1129,8 @@ pub(crate) struct ItemLink {
     /// linked to. This will be different to `item_id` on item's that don't
     /// have their own page, such as struct fields and enum variants.
     pub(crate) page_id: DefId,
+    /// The type of the item pointed to by this link
+    pub(crate) item_type: ItemType,
     /// The url fragment to append to the link
     pub(crate) fragment: Option<UrlFragment>,
 }
@@ -1532,7 +1550,7 @@ impl Type {
     ///
     /// An owned type is also the same as its borrowed variants (this is commutative),
     /// but `&T` is not the same as `&mut T`.
-    pub(crate) fn is_doc_subtype_of(&self, other: &Self, cache: &Cache) -> bool {
+    pub(crate) fn is_doc_subtype_of(&self, other: &Self, cache: &Cache<'_>) -> bool {
         // Strip the references so that it can compare the actual types, unless both are references.
         // If both are references, leave them alone and compare the mutabilities later.
         let (self_cleared, other_cleared) = if !self.is_borrowed_ref() || !other.is_borrowed_ref() {
@@ -1668,7 +1686,7 @@ impl Type {
     /// Use this method to get the [DefId] of a [clean] AST node, including [PrimitiveType]s.
     ///
     /// [clean]: crate::clean
-    pub(crate) fn def_id(&self, cache: &Cache) -> Option<DefId> {
+    pub(crate) fn def_id(&self, cache: &Cache<'_>) -> Option<DefId> {
         let t: PrimitiveType = match *self {
             Type::Path { ref path } => return Some(path.def_id()),
             DynTrait(ref bounds, _) => return bounds.first().map(|b| b.trait_.def_id()),
@@ -1692,6 +1710,10 @@ impl Type {
         };
         Primitive(t).def_id(cache)
     }
+
+    pub(crate) fn item_id(&self, cache: &Cache<'_>) -> Option<ItemId> {
+        self.def_id(cache).map(ItemId::type_ns)
+    }
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
@@ -2164,6 +2186,10 @@ pub(crate) struct Path {
 }
 
 impl Path {
+    pub(crate) fn item_id(&self) -> ItemId {
+        ItemId::from_res(&self.res)
+    }
+
     pub(crate) fn def_id(&self) -> DefId {
         self.res.def_id()
     }

src/librustdoc/core.rs

@@ -35,6 +35,8 @@ use crate::passes::Condition::*;
 use crate::passes::{self};
 
 pub(crate) struct DocContext<'tcx> {
+    // FIXME: remove me from here and access me via `self.cache` instead
+    // And anywhere a Cache & a TyCtxt are expected, remove the TyCtxt param
     pub(crate) tcx: TyCtxt<'tcx>,
     /// Used for normalization.
     ///
@@ -62,7 +64,7 @@ pub(crate) struct DocContext<'tcx> {
     /// The options given to rustdoc that could be relevant to a pass.
     pub(crate) render_options: RenderOptions,
     /// This same cache is used throughout rustdoc, including in [`crate::html::render`].
-    pub(crate) cache: Cache,
+    pub(crate) cache: Cache<'tcx>,
     /// Used by [`clean::inline`] to tell if an item has already been inlined.
     pub(crate) inlined: FxHashSet<ItemId>,
     /// Used by `calculate_doc_coverage`.
@@ -115,7 +117,7 @@ impl<'tcx> DocContext<'tcx> {
     /// (This avoids a slice-index-out-of-bounds panic.)
     pub(crate) fn as_local_hir_id(tcx: TyCtxt<'_>, item_id: ItemId) -> Option<HirId> {
         match item_id {
-            ItemId::DefId(real_id) => {
+            ItemId::DefId(real_id, _) => {
                 real_id.as_local().map(|def_id| tcx.local_def_id_to_hir_id(def_id))
             }
             // FIXME: Can this be `Some` for `Auto` or `Blanket`?
@@ -301,12 +303,12 @@ pub(crate) fn create_config(
     }
 }
 
-pub(crate) fn run_global_ctxt(
-    tcx: TyCtxt<'_>,
+pub(crate) fn run_global_ctxt<'tcx>(
+    tcx: TyCtxt<'tcx>,
     show_coverage: bool,
     render_options: RenderOptions,
     output_format: OutputFormat,
-) -> Result<(clean::Crate, RenderOptions, Cache), ErrorGuaranteed> {
+) -> Result<(clean::Crate, RenderOptions, Cache<'tcx>), ErrorGuaranteed> {
     // Certain queries assume that some checks were run elsewhere
     // (see https://github.com/rust-lang/rust/pull/73566#issuecomment-656954425),
     // so type-check everything other than function bodies in this crate before running lints.
@@ -343,7 +345,7 @@ pub(crate) fn run_global_ctxt(
         impl_trait_bounds: Default::default(),
         generated_synthetics: Default::default(),
         auto_traits,
-        cache: Cache::new(render_options.document_private, render_options.document_hidden),
+        cache: Cache::new(tcx, render_options.document_private, render_options.document_hidden),
         inlined: FxHashSet::default(),
         output_format,
         render_options,