Turn transitive dependencies into a query

Author: Veykril

crates/base-db/src/input.rs

@@ -460,6 +460,32 @@ pub struct Crate {
     pub env: Env,
 }
 
+#[salsa::tracked]
+impl Crate {
+    /// Returns an iterator over all transitive dependencies of the given crate,
+    /// including the crate itself.
+    ///
+    /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
+    #[salsa::tracked(returns(deref))]
+    pub fn transitive_deps(self, db: &dyn salsa::Database) -> Box<[Crate]> {
+        // There is a bit of duplication here and in `CrateGraphBuilder` in the same method, but it's not terrible
+        // and removing that is a bit difficult.
+        let mut worklist = vec![self];
+        let mut deps_seen = FxHashSet::default();
+        let mut deps = Vec::new();
+
+        while let Some(krate) = worklist.pop() {
+            if !deps_seen.insert(krate) {
+                continue;
+            }
+            deps.push(krate);
+
+            worklist.extend(krate.data(db).dependencies.iter().map(|dep| dep.crate_id));
+        }
+        deps.into_boxed_slice()
+    }
+}
+
 /// The mapping from [`UniqueCrateData`] to their [`Crate`] input.
 #[derive(Debug, Default)]
 pub struct CratesMap(DashMap<UniqueCrateData, Crate, BuildHasherDefault<FxHasher>>);

crates/base-db/src/lib.rs

@@ -257,13 +257,6 @@ pub trait RootQueryDb: SourceDatabase + salsa::Database {
     #[salsa::input]
     fn all_crates(&self) -> Arc<Box<[Crate]>>;
 
-    /// Returns an iterator over all transitive dependencies of the given crate,
-    /// including the crate itself.
-    ///
-    /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
-    #[salsa::transparent]
-    fn transitive_deps(&self, crate_id: Crate) -> FxHashSet<Crate>;
-
     /// Returns all transitive reverse dependencies of the given crate,
     /// including the crate itself.
     ///
@@ -273,23 +266,6 @@ pub trait RootQueryDb: SourceDatabase + salsa::Database {
     fn transitive_rev_deps(&self, of: Crate) -> FxHashSet<Crate>;
 }
 
-fn transitive_deps(db: &dyn SourceDatabase, crate_id: Crate) -> FxHashSet<Crate> {
-    // There is a bit of duplication here and in `CrateGraphBuilder` in the same method, but it's not terrible
-    // and removing that is a bit difficult.
-    let mut worklist = vec![crate_id];
-    let mut deps = FxHashSet::default();
-
-    while let Some(krate) = worklist.pop() {
-        if !deps.insert(krate) {
-            continue;
-        }
-
-        worklist.extend(krate.data(db).dependencies.iter().map(|dep| dep.crate_id));
-    }
-
-    deps
-}
-
 #[salsa_macros::db]
 pub trait SourceDatabase: salsa::Database {
     /// Text of the file.

crates/hir-def/src/db.rs

@@ -273,10 +273,9 @@ pub trait DefDatabase: InternDatabase + ExpandDatabase + SourceDatabase {
 
     // endregion:visibilities
 
-    #[salsa::invoke(crate::lang_item::notable_traits_in_deps)]
-    fn notable_traits_in_deps(&self, krate: Crate) -> Arc<[Arc<[TraitId]>]>;
     #[salsa::invoke(crate::lang_item::crate_notable_traits)]
-    fn crate_notable_traits(&self, krate: Crate) -> Option<Arc<[TraitId]>>;
+    #[salsa::transparent]
+    fn crate_notable_traits(&self, krate: Crate) -> Option<&[TraitId]>;
 
     #[salsa::invoke(crate_supports_no_std)]
     fn crate_supports_no_std(&self, crate_id: Crate) -> bool;

crates/hir-def/src/lang_item.rs

@@ -5,7 +5,6 @@
 use hir_expand::name::Name;
 use intern::{Symbol, sym};
 use rustc_hash::FxHashMap;
-use triomphe::Arc;
 
 use crate::{
     AdtId, AssocItemId, AttrDefId, Crate, EnumId, EnumVariantId, FunctionId, ImplId, ModuleDefId,
@@ -223,16 +222,8 @@ pub(crate) fn lang_attr(db: &dyn DefDatabase, item: AttrDefId) -> Option<LangIte
     db.attrs(item).lang_item()
 }
 
-pub(crate) fn notable_traits_in_deps(db: &dyn DefDatabase, krate: Crate) -> Arc<[Arc<[TraitId]>]> {
-    let _p = tracing::info_span!("notable_traits_in_deps", ?krate).entered();
-    Arc::from_iter(
-        db.transitive_deps(krate).into_iter().filter_map(|krate| db.crate_notable_traits(krate)),
-    )
-}
-
-pub(crate) fn crate_notable_traits(db: &dyn DefDatabase, krate: Crate) -> Option<Arc<[TraitId]>> {
-    let _p = tracing::info_span!("crate_notable_traits", ?krate).entered();
-
+#[salsa::tracked(returns(as_deref))]
+pub(crate) fn crate_notable_traits(db: &dyn DefDatabase, krate: Crate) -> Option<Box<[TraitId]>> {
     let mut traits = Vec::new();
 
     let crate_def_map = crate_def_map(db, krate);

crates/hir-ty/src/drop.rs

@@ -28,10 +28,10 @@ fn has_destructor(db: &dyn HirDatabase, adt: AdtId) -> bool {
     };
     let impls = match module.containing_block() {
         Some(block) => match TraitImpls::for_block(db, block) {
-            Some(it) => it,
+            Some(it) => &**it,
             None => return false,
         },
-        None => &**TraitImpls::for_crate(db, module.krate()),
+        None => TraitImpls::for_crate(db, module.krate()),
     };
     !impls.for_trait_and_self_ty(drop_trait, &SimplifiedType::Adt(adt.into())).is_empty()
 }

crates/hir-ty/src/method_resolution.rs

@@ -667,31 +667,31 @@ pub struct TraitImpls {
 
 #[salsa::tracked]
 impl TraitImpls {
-    #[salsa::tracked(returns(ref))]
-    pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Arc<Self> {
+    #[salsa::tracked(returns(deref))]
+    pub fn for_crate(db: &dyn HirDatabase, krate: Crate) -> Box<Self> {
         let _p = tracing::info_span!("inherent_impls_in_crate_query", ?krate).entered();
 
         let crate_def_map = crate_def_map(db, krate);
         let result = Self::collect_def_map(db, crate_def_map);
-        Arc::new(result)
+        Box::new(result)
     }
 
     #[salsa::tracked(returns(ref))]
+    // #[salsa::tracked(returns(as_deref))] // FIXME this does not compile
     pub fn for_block(db: &dyn HirDatabase, block: BlockId) -> Option<Box<Self>> {
         let _p = tracing::info_span!("inherent_impls_in_block_query").entered();
 
         let block_def_map = block_def_map(db, block);
         let result = Self::collect_def_map(db, block_def_map);
         if result.map.is_empty() { None } else { Some(Box::new(result)) }
     }
-
-    #[salsa::tracked(returns(ref))]
-    pub fn for_crate_and_deps(db: &dyn HirDatabase, krate: Crate) -> Box<[Arc<Self>]> {
-        db.transitive_deps(krate).iter().map(|&dep| Self::for_crate(db, dep).clone()).collect()
-    }
 }
 
 impl TraitImpls {
+    pub fn for_crate_and_deps(db: &dyn HirDatabase, krate: Crate) -> impl Iterator<Item = &Self> {
+        krate.transitive_deps(db).iter().map(|&dep| Self::for_crate(db, dep))
+    }
+
     fn collect_def_map(db: &dyn HirDatabase, def_map: &DefMap) -> Self {
         let mut map = FxHashMap::default();
         collect(db, def_map, &mut map);
@@ -794,7 +794,7 @@ impl TraitImpls {
     ) {
         let blocks = std::iter::successors(block, |block| block.loc(db).module.containing_block());
         blocks.filter_map(|block| Self::for_block(db, block).as_deref()).for_each(&mut *for_each);
-        Self::for_crate_and_deps(db, krate).iter().map(|it| &**it).for_each(for_each);
+        Self::for_crate_and_deps(db, krate).for_each(for_each);
     }
 
     /// Like [`Self::for_each_crate_and_block()`], but takes in account two blocks, one for a trait and one for a self type.
@@ -806,7 +806,7 @@ impl TraitImpls {
         for_each: &mut dyn FnMut(&TraitImpls),
     ) {
         let in_self_and_deps = TraitImpls::for_crate_and_deps(db, krate);
-        in_self_and_deps.iter().for_each(|impls| for_each(impls));
+        in_self_and_deps.for_each(|impls| for_each(impls));
 
         // We must not provide duplicate impls to the solver. Therefore we work with the following strategy:
         // start from each block, and walk ancestors until you meet the other block. If they never meet,

crates/hir/src/lib.rs

@@ -250,6 +250,14 @@ impl Crate {
         db.transitive_rev_deps(self.id).into_iter().map(|id| Crate { id })
     }
 
+    pub fn notable_traits_in_deps(self, db: &dyn HirDatabase) -> impl Iterator<Item = &TraitId> {
+        self.id
+            .transitive_deps(db)
+            .into_iter()
+            .filter_map(|&krate| db.crate_notable_traits(krate))
+            .flatten()
+    }
+
     pub fn root_module(self) -> Module {
         Module { id: CrateRootModuleId::from(self.id).into() }
     }

crates/ide/src/hover.rs

@@ -8,7 +8,6 @@ use std::{iter, ops::Not};
 use either::Either;
 use hir::{
     DisplayTarget, GenericDef, GenericSubstitution, HasCrate, HasSource, LangItem, Semantics,
-    db::DefDatabase,
 };
 use ide_db::{
     FileRange, FxIndexSet, MiniCore, Ranker, RootDatabase,
@@ -522,9 +521,8 @@ fn notable_traits<'db>(
         return Vec::new();
     }
 
-    db.notable_traits_in_deps(ty.krate(db).into())
-        .iter()
-        .flat_map(|it| &**it)
+    ty.krate(db)
+        .notable_traits_in_deps(db)
         .filter_map(move |&trait_| {
             let trait_ = trait_.into();
             ty.impls_trait(db, trait_, &[]).then(|| {