refactor: Remove CrateRegistry

LukeMathWalker · LukeMathWalker · commit b0c8a5d14755 · 2026-03-10T11:23:54.000+01:00
diff --git a/compiler/pavexc/src/compiler/analyses/components/db/diagnostics.rs b/compiler/pavexc/src/compiler/analyses/components/db/diagnostics.rs
@@ -18,7 +18,6 @@ use crate::utils::comma_separated_list;
 use guppy::graph::PackageGraph;
 use indexmap::IndexSet;
 use miette::{NamedSource, Severity};
-use rustdoc_processor::queries::CrateRegistry;
 use rustdoc_types::ItemEnum;
 use syn::spanned::Spanned;
 
diff --git a/compiler/pavexc/src/compiler/analyses/user_components/annotations/mod.rs b/compiler/pavexc/src/compiler/analyses/user_components/annotations/mod.rs
@@ -40,7 +40,6 @@ use crate::{
 use pavex_bp_schema::{CloningPolicy, Lifecycle, Lint, LintSetting};
 use pavexc_attr_parser::{AnnotationKind, AnnotationProperties};
 use rustdoc_ext::RustdocKindExt;
-use rustdoc_processor::queries::CrateRegistry;
 use rustdoc_types::{GenericArgs, Item, ItemEnum};
 
 /// An id pointing at the coordinates of an annotated component.
diff --git a/compiler/pavexc/src/compiler/path_parameters.rs b/compiler/pavexc/src/compiler/path_parameters.rs
@@ -19,7 +19,6 @@ use crate::diagnostic::DiagnosticSink;
 use crate::language::{GenericArgument, Type};
 use crate::rustdoc::{CrateCollection, GlobalItemId};
 use crate::utils::comma_separated_list;
-use rustdoc_processor::queries::CrateRegistry;
 
 use super::analyses::route_path::RoutePath;
 use super::traits::assert_trait_is_implemented;
diff --git a/compiler/pavexc/src/compiler/resolvers.rs b/compiler/pavexc/src/compiler/resolvers.rs
@@ -19,7 +19,6 @@ use crate::language::{
 };
 use crate::rustdoc::{CannotGetCrateData, CrateCollection, ResolvedItem};
 use rustdoc_ext::RustdocKindExt;
-use rustdoc_processor::queries::CrateRegistry;
 
 #[derive(Default)]
 pub(crate) struct GenericBindings {
diff --git a/compiler/pavexc/src/compiler/traits.rs b/compiler/pavexc/src/compiler/traits.rs
@@ -6,7 +6,6 @@ use rustdoc_types::{GenericParamDefKind, ItemEnum, Type as RustdocType};
 use crate::compiler::resolvers::resolve_type;
 use crate::language::{PathType, Type};
 use crate::rustdoc::{Crate, CrateCollection};
-use rustdoc_processor::queries::CrateRegistry;
 
 use super::resolvers::GenericBindings;
 
diff --git a/compiler/pavexc/src/diagnostic/callable_definition.rs b/compiler/pavexc/src/diagnostic/callable_definition.rs
@@ -5,7 +5,6 @@ use crate::rustdoc::CrateCollection;
 use guppy::graph::PackageGraph;
 use miette::{NamedSource, SourceSpan};
 use pavex_cli_diagnostic::AnnotatedSource;
-use rustdoc_processor::queries::CrateRegistry;
 use rustdoc_types::ItemEnum;
 use syn::spanned::Spanned;
 
diff --git a/compiler/pavexc/src/language/fq_path_resolution.rs b/compiler/pavexc/src/language/fq_path_resolution.rs
@@ -13,7 +13,6 @@ use crate::rustdoc::{
     CannotGetCrateData, CrateCollection, CrateCollectionExt, GlobalItemId, ResolvedItem,
 };
 use rustdoc_ext::RustdocKindExt;
-use rustdoc_processor::queries::CrateRegistry;
 
 use super::RawIdentifiers;
 use super::fq_path::*;
diff --git a/compiler/pavexc/src/rustdoc/cache.rs b/compiler/pavexc/src/rustdoc/cache.rs
diff --git a/compiler/pavexc/src/rustdoc/compute/mod.rs b/compiler/pavexc/src/rustdoc/compute/mod.rs
diff --git a/compiler/pavexc/src/rustdoc/mod.rs b/compiler/pavexc/src/rustdoc/mod.rs
@@ -9,13 +9,11 @@ pub use rustdoc_processor::{
 };
 
 pub(crate) use annotations::{AnnotatedItem, AnnotationCoordinates, ImplInfo};
-pub use queries::{
-    Crate, CrateCollection, CrateCollectionExt, CrateRegistry, GlobalItemId, ResolvedItem,
-};
+pub use queries::{Crate, CrateCollection, CrateCollectionExt, GlobalItemId, ResolvedItem};
 pub use rustdoc_processor::compute::CannotGetCrateData;
 
 mod annotations;
-mod compute;
+mod cache;
 pub(crate) mod indexer;
 mod progress_reporter;
 mod queries;
diff --git a/compiler/pavexc/src/rustdoc/queries/collection.rs b/compiler/pavexc/src/rustdoc/queries/collection.rs
@@ -15,7 +15,7 @@ use super::super::annotations::AnnotationCoordinates;
 use super::super::indexer::PavexIndexer;
 use super::super::progress_reporter::ShellProgress;
 use super::CrateCollection;
-use rustdoc_processor::queries::{Crate, CrateRegistry};
+use rustdoc_processor::queries::Crate;
 use rustdoc_processor::{GlobalItemId, UnknownItemPath};
 
 /// Extension trait adding Pavex-specific methods to `CrateCollection`.
@@ -57,7 +57,7 @@ impl CrateCollectionExt for CrateCollection {
         cache_workspace_package_docs: bool,
         diagnostic_sink: crate::diagnostic::DiagnosticSink,
     ) -> Result<CrateCollection, anyhow::Error> {
-        let disk_cache = super::super::compute::pavex_rustdoc_cache(
+        let disk_cache = super::super::cache::pavex_rustdoc_cache(
             &toolchain_name,
             cache_workspace_package_docs,
             &package_graph,
diff --git a/compiler/pavexc/src/rustdoc/queries/mod.rs b/compiler/pavexc/src/rustdoc/queries/mod.rs
@@ -5,4 +5,4 @@ pub type CrateCollection = rustdoc_processor::CrateCollection<super::indexer::Pa
 
 pub use collection::{CrateCollectionExt, ResolvedItem};
 pub use rustdoc_processor::GlobalItemId;
-pub use rustdoc_processor::queries::{Crate, CrateRegistry};
+pub use rustdoc_processor::queries::Crate;
diff --git a/rustdoc/rustdoc_processor/src/collection.rs b/rustdoc/rustdoc_processor/src/collection.rs
@@ -1,18 +1,21 @@
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::sync::Arc;
 
 use ahash::{HashMap, HashSet, HashSetExt};
 use elsa::FrozenMap;
 use guppy::PackageId;
 use guppy::graph::PackageGraph;
+use rustdoc_types::Item;
 use tracing::Span;
 use tracing_log_error::log_error;
 
 use crate::TOOLCHAIN_CRATES;
 use crate::cache::{CacheEntry, HydratedCacheEntry, RustdocCacheKey, RustdocGlobalFsCache};
 use crate::compute::{CannotGetCrateData, ComputeProgress, compute_crate_docs};
 use crate::indexing::CrateIndexer;
-use crate::queries::{Crate, CrateRegistry};
+use crate::queries::Crate;
+use rustdoc_ext::GlobalItemId;
 
 use rayon::iter::IntoParallelRefIterator;
 
@@ -429,15 +432,63 @@ impl<I: CrateIndexer> CrateCollection<I> {
     pub fn get_annotated_items(&self, package_id: &PackageId) -> Option<&I::Annotations> {
         self.annotated_items.get(package_id)
     }
-}
 
-impl<I: CrateIndexer> CrateRegistry for CrateCollection<I> {
-    fn package_graph(&self) -> &PackageGraph {
-        &self.package_graph
+    /// Retrieve type information given its [`GlobalItemId`].
+    ///
+    /// It panics if no item is found for the specified [`GlobalItemId`].
+    pub fn get_item_by_global_type_id(&self, type_id: &GlobalItemId) -> Cow<'_, Item> {
+        let krate = self.get_or_compute(&type_id.package_id).unwrap();
+        krate.get_item_by_local_type_id(&type_id.rustdoc_item_id)
+    }
+
+    /// Retrieve the canonical path for a struct, enum or function given its [`GlobalItemId`].
+    ///
+    /// It panics if no item is found for the specified [`GlobalItemId`].
+    pub fn get_canonical_path_by_global_type_id(
+        &self,
+        type_id: &GlobalItemId,
+    ) -> Result<&[String], anyhow::Error> {
+        let krate = self.get_or_compute(&type_id.package_id).unwrap();
+        krate.get_canonical_path(type_id)
     }
 
-    fn get_or_compute_crate(&self, package_id: &PackageId) -> Result<&Crate, CannotGetCrateData> {
-        self.get_or_compute(package_id)
+    /// Retrieve the canonical path and the [`GlobalItemId`] for a struct, enum or function given
+    /// its **local** id.
+    pub fn get_canonical_path_by_local_type_id(
+        &self,
+        used_by_package_id: &PackageId,
+        item_id: &rustdoc_types::Id,
+        // The item might come from a transitive dependency via a re-export
+        // done by a direct dependency.
+        // We don't have a bulletproof way of finding the re-exporter name, but we can
+        // try to infer it (e.g. via the `name` property).
+        re_exporter_crate_name: Option<&str>,
+    ) -> Result<(GlobalItemId, &[String]), anyhow::Error> {
+        let (definition_package_id, path) = {
+            let used_by_krate = self.get_or_compute(used_by_package_id)?;
+            let local_type_summary = used_by_krate.get_summary_by_local_type_id(item_id)?;
+            (
+                used_by_krate.compute_package_id_for_crate_id_with_hint(
+                    local_type_summary.crate_id,
+                    self,
+                    // If the type was re-exported from another crate, the two names here should not match.
+                    // The one coming from the summary is the name of the crate where the type was defined.
+                    // The one coming from the `maybe_reexport_from` is the name of the crate where the type
+                    // was re-exported from and used by the crate we are currently processing.
+                    if local_type_summary.path.first().map(|s| s.as_str()) != re_exporter_crate_name
+                    {
+                        re_exporter_crate_name
+                    } else {
+                        None
+                    },
+                )?,
+                local_type_summary.path.clone(),
+            )
+        };
+        let definition_krate = self.get_or_compute(&definition_package_id)?;
+        let type_id = definition_krate.get_item_id_by_path(&path, self)??;
+        let canonical_path = self.get_canonical_path_by_global_type_id(&type_id)?;
+        Ok((type_id.clone(), canonical_path))
     }
 }
 
diff --git a/rustdoc/rustdoc_processor/src/indexing/re_exports.rs b/rustdoc/rustdoc_processor/src/indexing/re_exports.rs
@@ -2,10 +2,11 @@
 
 use ahash::HashMap;
 
+use crate::CrateCollection;
 use crate::compute::CannotGetCrateData;
 use crate::crate_data::CrateData;
+use crate::indexing::CrateIndexer;
 use crate::queries::Crate;
-use crate::queries::registry::CrateRegistry;
 use rustdoc_ext::GlobalItemId;
 
 /// Track re-exports of types (or entire modules!) from other crates.
@@ -60,11 +61,11 @@ impl ExternalReExports {
     /// # Panics
     ///
     /// Panics if the provided `use_id` doesn't exist as a key in the re-export registry.
-    pub fn get_target_item_id(
+    pub fn get_target_item_id<I: CrateIndexer>(
         &self,
         // The crate associated with these re-exports.
         re_exported_from: &Crate,
-        registry: &impl CrateRegistry,
+        collection: &CrateCollection<I>,
         use_id: rustdoc_types::Id,
     ) -> Result<Option<GlobalItemId>, CannotGetCrateData> {
         let re_export = self
@@ -74,12 +75,13 @@ impl ExternalReExports {
             .core
             .compute_package_id_for_crate_id(
                 re_export.external_crate_id,
-                registry.package_graph(),
+                collection.package_graph(),
                 None,
             )
             .expect("Failed to compute the package id for a given external crate id");
-        let source_krate = registry.get_or_compute_crate(&source_package_id)?;
-        let Ok(Ok(source_id)) = source_krate.get_item_id_by_path(&re_export.source_path, registry)
+        let source_krate = collection.get_or_compute(&source_package_id)?;
+        let Ok(Ok(source_id)) =
+            source_krate.get_item_id_by_path(&re_export.source_path, collection)
         else {
             return Ok(None);
         };
diff --git a/rustdoc/rustdoc_processor/src/lib.rs b/rustdoc/rustdoc_processor/src/lib.rs
@@ -8,7 +8,7 @@
 //!    in a SQLite database at `{cache_dir}/{fingerprint}.db`.
 //! 3. **Index** ([`index_local_types`]): build secondary indexes — import paths, item lookups,
 //!    and external re-export tracking.
-//! 4. **Query** ([`Crate`], [`CrateRegistry`]): look up items by path, resolve
+//! 4. **Query** ([`Crate`], [`CrateCollection`]): look up items by path, resolve
 //!    cross-crate references, and retrieve canonical import paths.
 
 pub mod cache;
diff --git a/rustdoc/rustdoc_processor/src/queries/mod.rs b/rustdoc/rustdoc_processor/src/queries/mod.rs
@@ -1,11 +1,9 @@
 //! Query layer for looking up items across crates.
 
 pub(crate) mod core;
-pub(crate) mod registry;
 pub(crate) mod resolution;
 
 pub use self::core::CrateCore;
-pub use registry::CrateRegistry;
 
 use resolution::CrateIdNeedle;
 use std::borrow::Cow;
@@ -17,11 +15,12 @@ use guppy::PackageId;
 use guppy::graph::PackageGraph;
 use rustdoc_types::Item;
 
+use crate::CrateCollection;
 use crate::compute::CannotGetCrateData;
 use crate::crate_data::CrateData;
 use crate::indexing::{
-    EagerImportPath2Id, ExternalReExport, ExternalReExports, ImportIndex, ImportPath2Id,
-    IndexingVisitor, NoopVisitor, index_local_types,
+    CrateIndexer, EagerImportPath2Id, ExternalReExport, ExternalReExports, ImportIndex,
+    ImportPath2Id, IndexingVisitor, NoopVisitor, index_local_types,
 };
 use crate::unknown_item_path::UnknownItemPath;
 use rustdoc_ext::GlobalItemId;
@@ -165,12 +164,12 @@ impl Crate {
     ///
     /// It panics if the provided crate id doesn't appear in the JSON documentation
     /// for this crate—i.e. if it's not `0` or assigned to one of its transitive dependencies.
-    pub fn compute_package_id_for_crate_id(
+    pub fn compute_package_id_for_crate_id<I: CrateIndexer>(
         &self,
         crate_id: u32,
-        registry: &(impl CrateRegistry + ?Sized),
+        collection: &CrateCollection<I>,
     ) -> Result<PackageId, anyhow::Error> {
-        self.compute_package_id_for_crate_id_with_hint(crate_id, registry, None)
+        self.compute_package_id_for_crate_id_with_hint(crate_id, collection, None)
     }
 
     /// Given a crate id, return the corresponding [`PackageId`].
@@ -188,10 +187,10 @@ impl Crate {
     ///
     /// It panics if the provided crate id doesn't appear in the JSON documentation
     /// for this crate—i.e. if it's not `0` or assigned to one of its transitive dependencies.
-    pub fn compute_package_id_for_crate_id_with_hint(
+    pub fn compute_package_id_for_crate_id_with_hint<I: CrateIndexer>(
         &self,
         crate_id: u32,
-        registry: &(impl CrateRegistry + ?Sized),
+        collection: &CrateCollection<I>,
         maybe_dependent_crate_name: Option<&str>,
     ) -> Result<PackageId, anyhow::Error> {
         let needle = CrateIdNeedle {
@@ -206,7 +205,7 @@ impl Crate {
         // If we don't have a cached entry, perform the graph traversal.
         let outcome = self.core.compute_package_id_for_crate_id(
             crate_id,
-            registry.package_graph(),
+            collection.package_graph(),
             maybe_dependent_crate_name,
         );
 
@@ -220,10 +219,10 @@ impl Crate {
         outcome
     }
 
-    pub fn get_item_id_by_path(
+    pub fn get_item_id_by_path<I: CrateIndexer>(
         &self,
         path: &[String],
-        registry: &(impl CrateRegistry + ?Sized),
+        collection: &CrateCollection<I>,
     ) -> Result<Result<GlobalItemId, UnknownItemPath>, CannotGetCrateData> {
         if let Some(id) = self.import_path2id.get(path) {
             return Ok(Ok(GlobalItemId::new(id, self.core.package_id.to_owned())));
@@ -252,13 +251,13 @@ impl Crate {
                     .core
                     .compute_package_id_for_crate_id(
                         *external_crate_id,
-                        registry.package_graph(),
+                        collection.package_graph(),
                         None,
                     )
                     .unwrap();
-                let source_krate = registry.get_or_compute_crate(&source_package_id).unwrap();
+                let source_krate = collection.get_or_compute(&source_package_id).unwrap();
                 if let Ok(source_id) =
-                    source_krate.get_item_id_by_path(&original_source_path, registry)
+                    source_krate.get_item_id_by_path(&original_source_path, collection)
                 {
                     return Ok(source_id);
                 }
diff --git a/rustdoc/rustdoc_processor/src/queries/registry.rs b/rustdoc/rustdoc_processor/src/queries/registry.rs
