Merge pull request rust-lang#21944 from Veykril/push-spxqtymwtzvk

Remove `RootQueryDb`

Author: Veykril

src/tools/rust-analyzer/crates/base-db/src/change.rs

@@ -9,7 +9,8 @@ use triomphe::Arc;
 use vfs::FileId;
 
 use crate::{
-    CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, RootQueryDb, SourceRoot, SourceRootId,
+    CrateGraphBuilder, CratesIdMap, LibraryRoots, LocalRoots, SourceDatabase, SourceRoot,
+    SourceRootId,
 };
 
 /// Encapsulate a bunch of raw `.set` calls on the database.
@@ -49,7 +50,7 @@ impl FileChange {
         self.crate_graph = Some(graph);
     }
 
-    pub fn apply(self, db: &mut dyn RootQueryDb) -> Option<CratesIdMap> {
+    pub fn apply(self, db: &mut dyn SourceDatabase) -> Option<CratesIdMap> {
         let _p = tracing::info_span!("FileChange::apply").entered();
         if let Some(roots) = self.roots {
             let mut local_roots = FxHashSet::default();

src/tools/rust-analyzer/crates/base-db/src/editioned_file_id.rs

@@ -5,14 +5,71 @@ use std::hash::Hash;
 
 use salsa::Database;
 use span::Edition;
+use syntax::{SyntaxError, ast};
 use vfs::FileId;
 
+use crate::SourceDatabase;
+
 #[salsa::interned(debug, constructor = from_span_file_id, no_lifetime)]
 #[derive(PartialOrd, Ord)]
 pub struct EditionedFileId {
     field: span::EditionedFileId,
 }
 
+// Currently does not work due to a salsa bug
+// #[salsa::tracked]
+// impl EditionedFileId {
+//     #[salsa::tracked(lru = 128)]
+//     pub fn parse(self, db: &dyn SourceDatabase) -> syntax::Parse<ast::SourceFile> {
+//         let _p = tracing::info_span!("parse", ?self).entered();
+//         let (file_id, edition) = self.unpack(db);
+//         let text = db.file_text(file_id).text(db);
+//         ast::SourceFile::parse(text, edition)
+//     }
+
+//     // firewall query
+//     #[salsa::tracked(returns(as_deref))]
+//     pub fn parse_errors(self, db: &dyn SourceDatabase) -> Option<Box<[SyntaxError]>> {
+//         let errors = self.parse(db).errors();
+//         match &*errors {
+//             [] => None,
+//             [..] => Some(errors.into()),
+//         }
+//     }
+// }
+
+impl EditionedFileId {
+    pub fn parse(self, db: &dyn SourceDatabase) -> syntax::Parse<ast::SourceFile> {
+        #[salsa::tracked(lru = 128)]
+        pub fn parse(
+            db: &dyn SourceDatabase,
+            file_id: EditionedFileId,
+        ) -> syntax::Parse<ast::SourceFile> {
+            let _p = tracing::info_span!("parse", ?file_id).entered();
+            let (file_id, edition) = file_id.unpack(db);
+            let text = db.file_text(file_id).text(db);
+            ast::SourceFile::parse(text, edition)
+        }
+        parse(db, self)
+    }
+
+    // firewall query
+    pub fn parse_errors(self, db: &dyn SourceDatabase) -> Option<&[SyntaxError]> {
+        #[salsa::tracked(returns(as_deref))]
+        pub fn parse_errors(
+            db: &dyn SourceDatabase,
+            file_id: EditionedFileId,
+        ) -> Option<Box<[SyntaxError]>> {
+            let errors = file_id.parse(db).errors();
+            match &*errors {
+                [] => None,
+                [..] => Some(errors.into()),
+            }
+        }
+        parse_errors(db, self)
+    }
+}
+
 impl EditionedFileId {
     #[inline]
     pub fn new(db: &dyn Database, file_id: FileId, edition: Edition) -> Self {

src/tools/rust-analyzer/crates/base-db/src/input.rs

@@ -21,7 +21,10 @@ use span::Edition;
 use triomphe::Arc;
 use vfs::{AbsPathBuf, AnchoredPath, FileId, VfsPath, file_set::FileSet};
 
-use crate::{CrateWorkspaceData, EditionedFileId, FxIndexSet, RootQueryDb};
+use crate::{
+    CrateWorkspaceData, EditionedFileId, FxIndexSet, SourceDatabase, all_crates,
+    set_all_crates_with_durability,
+};
 
 pub type ProcMacroPaths =
     FxHashMap<CrateBuilderId, Result<(String, AbsPathBuf), ProcMacroLoadingError>>;
@@ -490,13 +493,13 @@ impl Crate {
     /// including the crate itself.
     ///
     /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
-    pub fn transitive_rev_deps(self, db: &dyn RootQueryDb) -> Box<[Crate]> {
+    pub fn transitive_rev_deps(self, db: &dyn SourceDatabase) -> Box<[Crate]> {
         let mut worklist = vec![self];
         let mut rev_deps = FxHashSet::default();
         rev_deps.insert(self);
 
         let mut inverted_graph = FxHashMap::<_, Vec<_>>::default();
-        db.all_crates().iter().for_each(|&krate| {
+        all_crates(db).iter().for_each(|&krate| {
             krate
                 .data(db)
                 .dependencies
@@ -586,15 +589,15 @@ impl CrateGraphBuilder {
         Ok(())
     }
 
-    pub fn set_in_db(self, db: &mut dyn RootQueryDb) -> CratesIdMap {
+    pub fn set_in_db(self, db: &mut dyn SourceDatabase) -> CratesIdMap {
+        let old_all_crates = all_crates(db);
+
         // For some reason in some repositories we have duplicate crates, so we use a set and not `Vec`.
         // We use an `IndexSet` because the list needs to be topologically sorted.
         let mut all_crates = FxIndexSet::with_capacity_and_hasher(self.arena.len(), FxBuildHasher);
         let mut visited = FxHashMap::default();
         let mut visited_root_files = FxHashSet::default();
 
-        let old_all_crates = db.all_crates();
-
         let crates_map = db.crates_map();
         // salsa doesn't compare new input to old input to see if they are the same, so here we are doing all the work ourselves.
         for krate in self.iter() {
@@ -612,17 +615,14 @@ impl CrateGraphBuilder {
         if old_all_crates.len() != all_crates.len()
             || old_all_crates.iter().any(|&krate| !all_crates.contains(&krate))
         {
-            db.set_all_crates_with_durability(
-                Arc::new(Vec::from_iter(all_crates).into_boxed_slice()),
-                Durability::MEDIUM,
-            );
+            set_all_crates_with_durability(db, all_crates, Durability::MEDIUM);
         }
 
         return visited;
 
         fn go(
             graph: &CrateGraphBuilder,
-            db: &mut dyn RootQueryDb,
+            db: &mut dyn SourceDatabase,
             crates_map: &CratesMap,
             visited: &mut FxHashMap<CrateBuilderId, Crate>,
             visited_root_files: &mut FxHashSet<FileId>,

src/tools/rust-analyzer/crates/base-db/src/lib.rs

@@ -36,7 +36,6 @@ pub use query_group;
 use rustc_hash::{FxHashSet, FxHasher};
 use salsa::{Durability, Setter};
 pub use semver::{BuildMetadata, Prerelease, Version, VersionReq};
-use syntax::{Parse, SyntaxError, ast};
 use triomphe::Arc;
 pub use vfs::{AnchoredPath, AnchoredPathBuf, FileId, VfsPath, file_set::FileSet};
 
@@ -236,36 +235,6 @@ pub struct SourceRootInput {
     pub source_root: Arc<SourceRoot>,
 }
 
-/// Database which stores all significant input facts: source code and project
-/// model. Everything else in rust-analyzer is derived from these queries.
-#[query_group::query_group]
-pub trait RootQueryDb: SourceDatabase + salsa::Database {
-    /// Parses the file into the syntax tree.
-    #[salsa::invoke(parse)]
-    #[salsa::lru(128)]
-    fn parse(&self, file_id: EditionedFileId) -> Parse<ast::SourceFile>;
-
-    /// Returns the set of errors obtained from parsing the file including validation errors.
-    #[salsa::transparent]
-    fn parse_errors(&self, file_id: EditionedFileId) -> Option<&[SyntaxError]>;
-
-    #[salsa::transparent]
-    fn toolchain_channel(&self, krate: Crate) -> Option<ReleaseChannel>;
-
-    /// Crates whose root file is in `id`.
-    #[salsa::invoke_interned(source_root_crates)]
-    fn source_root_crates(&self, id: SourceRootId) -> Arc<[Crate]>;
-
-    #[salsa::transparent]
-    fn relevant_crates(&self, file_id: FileId) -> Arc<[Crate]>;
-
-    /// Returns the crates in topological order.
-    ///
-    /// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
-    #[salsa::input]
-    fn all_crates(&self) -> Arc<Box<[Crate]>>;
-}
-
 #[salsa_macros::db]
 pub trait SourceDatabase: salsa::Database {
     /// Text of the file.
@@ -353,46 +322,67 @@ impl CrateWorkspaceData {
     }
 }
 
-fn toolchain_channel(db: &dyn RootQueryDb, krate: Crate) -> Option<ReleaseChannel> {
+pub fn toolchain_channel(db: &dyn salsa::Database, krate: Crate) -> Option<ReleaseChannel> {
     krate.workspace_data(db).toolchain.as_ref().and_then(|v| ReleaseChannel::from_str(&v.pre))
 }
 
-fn parse(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Parse<ast::SourceFile> {
-    let _p = tracing::info_span!("parse", ?file_id).entered();
-    let (file_id, edition) = file_id.unpack(db.as_dyn_database());
-    let text = db.file_text(file_id).text(db);
-    ast::SourceFile::parse(text, edition)
+#[salsa::input(singleton, debug)]
+struct AllCrates {
+    crates: std::sync::Arc<[Crate]>,
 }
 
-fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<&[SyntaxError]> {
-    #[salsa_macros::tracked(returns(ref))]
-    fn parse_errors(db: &dyn RootQueryDb, file_id: EditionedFileId) -> Option<Box<[SyntaxError]>> {
-        let errors = db.parse(file_id).errors();
-        match &*errors {
-            [] => None,
-            [..] => Some(errors.into()),
-        }
-    }
-    parse_errors(db, file_id).as_ref().map(|it| &**it)
+pub fn set_all_crates_with_durability(
+    db: &mut dyn salsa::Database,
+    crates: impl IntoIterator<Item = Crate>,
+    durability: Durability,
+) {
+    AllCrates::try_get(db)
+        .unwrap_or_else(|| AllCrates::new(db, std::sync::Arc::default()))
+        .set_crates(db)
+        .with_durability(durability)
+        .to(crates.into_iter().collect());
 }
 
-fn source_root_crates(db: &dyn RootQueryDb, id: SourceRootId) -> Arc<[Crate]> {
-    let crates = db.all_crates();
-    crates
-        .iter()
-        .copied()
-        .filter(|&krate| {
-            let root_file = krate.data(db).root_file_id;
-            db.file_source_root(root_file).source_root_id(db) == id
-        })
-        .collect()
+/// Returns the crates in topological order.
+///
+/// **Warning**: do not use this query in `hir-*` crates! It kills incrementality across crate metadata modifications.
+pub fn all_crates(db: &dyn salsa::Database) -> std::sync::Arc<[Crate]> {
+    AllCrates::try_get(db).map_or(std::sync::Arc::default(), |all_crates| all_crates.crates(db))
+}
+
+// FIXME: VFS rewrite should allow us to get rid of this wrapper
+#[doc(hidden)]
+#[salsa::interned]
+pub struct InternedSourceRootId {
+    pub id: SourceRootId,
+}
+
+/// Crates whose root file is in `id`.
+pub fn source_root_crates(db: &dyn SourceDatabase, id: SourceRootId) -> &[Crate] {
+    #[salsa::tracked(returns(deref))]
+    pub fn source_root_crates<'db>(
+        db: &'db dyn SourceDatabase,
+        id: InternedSourceRootId<'db>,
+    ) -> Box<[Crate]> {
+        let crates = AllCrates::get(db).crates(db);
+        let id = id.id(db);
+        crates
+            .iter()
+            .copied()
+            .filter(|&krate| {
+                let root_file = krate.data(db).root_file_id;
+                db.file_source_root(root_file).source_root_id(db) == id
+            })
+            .collect()
+    }
+    source_root_crates(db, InternedSourceRootId::new(db, id))
 }
 
-fn relevant_crates(db: &dyn RootQueryDb, file_id: FileId) -> Arc<[Crate]> {
+pub fn relevant_crates(db: &dyn SourceDatabase, file_id: FileId) -> &[Crate] {
     let _p = tracing::info_span!("relevant_crates").entered();
 
     let source_root = db.file_source_root(file_id);
-    db.source_root_crates(source_root.source_root_id(db))
+    source_root_crates(db, source_root.source_root_id(db))
 }
 
 #[must_use]

src/tools/rust-analyzer/crates/hir-def/src/attrs.rs

@@ -351,13 +351,13 @@ fn attrs_source(
             let krate = def_map.krate();
             let (definition, declaration, extra_crate_attrs) = match def_map[id].origin {
                 ModuleOrigin::CrateRoot { definition } => {
-                    let definition_source = db.parse(definition).tree();
+                    let definition_source = definition.parse(db).tree();
                     let definition = InFile::new(definition.into(), definition_source.into());
                     let extra_crate_attrs = parse_extra_crate_attrs(db, krate);
                     (definition, None, extra_crate_attrs)
                 }
                 ModuleOrigin::File { declaration, declaration_tree_id, definition, .. } => {
-                    let definition_source = db.parse(definition).tree();
+                    let definition_source = definition.parse(db).tree();
                     let definition = InFile::new(definition.into(), definition_source.into());
                     let declaration = InFile::new(declaration_tree_id.file_id(), declaration);
                     let declaration = declaration.with_value(declaration.to_node(db));
@@ -742,7 +742,7 @@ impl AttrFlags {
     #[salsa::tracked(returns(ref))]
     pub fn doc_html_root_url(db: &dyn DefDatabase, krate: Crate) -> Option<SmolStr> {
         let root_file_id = krate.root_file_id(db);
-        let syntax = db.parse(root_file_id).tree();
+        let syntax = root_file_id.parse(db).tree();
         let extra_crate_attrs =
             parse_extra_crate_attrs(db, krate).into_iter().flat_map(|src| src.attrs());
 

src/tools/rust-analyzer/crates/hir-def/src/db.rs

@@ -1,5 +1,5 @@
 //! Defines database & queries for name resolution.
-use base_db::{Crate, RootQueryDb, SourceDatabase};
+use base_db::{Crate, SourceDatabase};
 use hir_expand::{
     EditionedFileId, HirFileId, InFile, Lookup, MacroCallId, MacroDefId, MacroDefKind,
     db::ExpandDatabase,
@@ -22,7 +22,7 @@ use crate::{
 use salsa::plumbing::AsId;
 
 #[query_group::query_group(InternDatabaseStorage)]
-pub trait InternDatabase: RootQueryDb {
+pub trait InternDatabase: SourceDatabase {
     // region: items
     #[salsa::interned]
     fn intern_use(&self, loc: UseLoc) -> UseId;

src/tools/rust-analyzer/crates/hir-def/src/expr_store/scope.rs

@@ -371,7 +371,6 @@ fn compute_expr_scopes(
 
 #[cfg(test)]
 mod tests {
-    use base_db::RootQueryDb;
     use hir_expand::{InFile, name::AsName};
     use span::FileId;
     use syntax::{AstNode, algo::find_node_at_offset, ast};
@@ -414,7 +413,7 @@ mod tests {
 
         let (file_id, _) = editioned_file_id.unpack(&db);
 
-        let file_syntax = db.parse(editioned_file_id).syntax_node();
+        let file_syntax = editioned_file_id.parse(&db).syntax_node();
         let marker: ast::PathExpr = find_node_at_offset(&file_syntax, offset).unwrap();
         let function = find_function(&db, file_id);
 
@@ -570,7 +569,7 @@ fn foo() {
 
         let (file_id, _) = editioned_file_id.unpack(&db);
 
-        let file = db.parse(editioned_file_id).ok().unwrap();
+        let file = editioned_file_id.parse(&db).ok().unwrap();
         let expected_name = find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into())
             .expect("failed to find a name at the target offset");
         let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), offset).unwrap();

src/tools/rust-analyzer/crates/hir-def/src/expr_store/tests/body/block.rs

@@ -190,13 +190,13 @@ fn f() {
     "#,
         expect![[r#"
             ModuleIdLt {
-                [salsa id]: Id(3803),
+                [salsa id]: Id(3403),
                 krate: Crate(
-                    Id(2400),
+                    Id(2000),
                 ),
                 block: Some(
                     BlockId(
-                        4801,
+                        4401,
                     ),
                 ),
             }"#]],