Merge #292

292: Vfs r=matklad a=matklad

closes #243



Co-authored-by: Aleksey Kladov <[email protected]>

4 files changed, 164 insertions, 99 deletions

diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index b8d774eb5..3d0f13f34 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -30,11 +30,11 @@ impl Default for RootDatabase {
             runtime: salsa::Runtime::default(),
             id_maps: Default::default(),
         };
-        db.query_mut(ra_db::SourceRootQuery)
-            .set(ra_db::WORKSPACE, Default::default());
         db.query_mut(ra_db::CrateGraphQuery)
             .set((), Default::default());
-        db.query_mut(ra_db::LibrariesQuery)
+        db.query_mut(ra_db::LocalRootsQuery)
+            .set((), Default::default());
+        db.query_mut(ra_db::LibraryRootsQuery)
             .set((), Default::default());
         db
     }
@@ -61,9 +61,11 @@ salsa::database_storage! {
     pub(crate) struct RootDatabaseStorage for RootDatabase {
         impl ra_db::FilesDatabase {
             fn file_text() for ra_db::FileTextQuery;
+            fn file_relative_path() for ra_db::FileRelativePathQuery;
             fn file_source_root() for ra_db::FileSourceRootQuery;
             fn source_root() for ra_db::SourceRootQuery;
-            fn libraries() for ra_db::LibrariesQuery;
+            fn local_roots() for ra_db::LocalRootsQuery;
+            fn library_roots() for ra_db::LibraryRootsQuery;
             fn crate_graph() for ra_db::CrateGraphQuery;
         }
         impl ra_db::SyntaxDatabase {
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 0de0e2645..c4291885a 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -10,9 +10,8 @@ use ra_syntax::{
     SyntaxKind::*,
     SyntaxNodeRef, TextRange, TextUnit,
 };
-use ra_db::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE, SyntaxDatabase};
+use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
 use rayon::prelude::*;
-use rustc_hash::FxHashSet;
 use salsa::{Database, ParallelDatabase};
 use hir::{
     self,
@@ -24,8 +23,8 @@ use hir::{
 use crate::{
     completion::{completions, CompletionItem},
     db,
-    symbol_index::{SymbolIndex, SymbolsDatabase},
-    AnalysisChange, Cancelable, CrateId, Diagnostic, FileId,
+    symbol_index::{SymbolIndex, SymbolsDatabase, LibrarySymbolsQuery},
+    AnalysisChange, RootChange, Cancelable, CrateId, Diagnostic, FileId,
     FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
     ReferenceResolution,
 };
@@ -44,70 +43,41 @@ impl AnalysisHostImpl {
     pub fn apply_change(&mut self, change: AnalysisChange) {
         log::info!("apply_change {:?}", change);
         // self.gc_syntax_trees();
-
-        for (file_id, text) in change.files_changed {
-            self.db
-                .query_mut(ra_db::FileTextQuery)
-                .set(file_id, Arc::new(text))
-        }
-        if !(change.files_added.is_empty() && change.files_removed.is_empty()) {
-            let file_resolver = change
-                .file_resolver
-                .expect("change resolver when changing set of files");
-            let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE));
-            for (file_id, text) in change.files_added {
+        if !change.new_roots.is_empty() {
+            let mut local_roots = Vec::clone(&self.db.local_roots());
+            for (root_id, is_local) in change.new_roots {
                 self.db
-                    .query_mut(ra_db::FileTextQuery)
-                    .set(file_id, Arc::new(text));
-                self.db
-                    .query_mut(ra_db::FileSourceRootQuery)
-                    .set(file_id, ra_db::WORKSPACE);
-                source_root.files.insert(file_id);
-            }
-            for file_id in change.files_removed {
-                self.db
-                    .query_mut(ra_db::FileTextQuery)
-                    .set(file_id, Arc::new(String::new()));
-                source_root.files.remove(&file_id);
+                    .query_mut(ra_db::SourceRootQuery)
+                    .set(root_id, Default::default());
+                if is_local {
+                    local_roots.push(root_id);
+                }
             }
-            source_root.file_resolver = file_resolver;
             self.db
-                .query_mut(ra_db::SourceRootQuery)
-                .set(WORKSPACE, Arc::new(source_root))
+                .query_mut(ra_db::LocalRootsQuery)
+                .set((), Arc::new(local_roots));
+        }
+
+        for (root_id, root_change) in change.roots_changed {
+            self.apply_root_change(root_id, root_change);
+        }
+        for (file_id, text) in change.files_changed {
+            self.db.query_mut(ra_db::FileTextQuery).set(file_id, text)
         }
         if !change.libraries_added.is_empty() {
-            let mut libraries = Vec::clone(&self.db.libraries());
+            let mut libraries = Vec::clone(&self.db.library_roots());
             for library in change.libraries_added {
-                let source_root_id = SourceRootId(1 + libraries.len() as u32);
-                libraries.push(source_root_id);
-                let mut files = FxHashSet::default();
-                for (file_id, text) in library.files {
-                    files.insert(file_id);
-                    log::debug!(
-                        "library file: {:?} {:?}",
-                        file_id,
-                        library.file_resolver.debug_path(file_id)
-                    );
-                    self.db
-                        .query_mut(ra_db::FileSourceRootQuery)
-                        .set_constant(file_id, source_root_id);
-                    self.db
-                        .query_mut(ra_db::FileTextQuery)
-                        .set_constant(file_id, Arc::new(text));
-                }
-                let source_root = SourceRoot {
-                    files,
-                    file_resolver: library.file_resolver,
-                };
+                libraries.push(library.root_id);
                 self.db
                     .query_mut(ra_db::SourceRootQuery)
-                    .set(source_root_id, Arc::new(source_root));
+                    .set(library.root_id, Default::default());
                 self.db
-                    .query_mut(crate::symbol_index::LibrarySymbolsQuery)
-                    .set(source_root_id, Arc::new(library.symbol_index));
+                    .query_mut(LibrarySymbolsQuery)
+                    .set_constant(library.root_id, Arc::new(library.symbol_index));
+                self.apply_root_change(library.root_id, library.root_change);
             }
             self.db
-                .query_mut(ra_db::LibrariesQuery)
+                .query_mut(ra_db::LibraryRootsQuery)
                 .set((), Arc::new(libraries));
         }
         if let Some(crate_graph) = change.crate_graph {
@@ -117,6 +87,34 @@ impl AnalysisHostImpl {
         }
     }
 
+    fn apply_root_change(&mut self, root_id: SourceRootId, root_change: RootChange) {
+        let mut source_root = SourceRoot::clone(&self.db.source_root(root_id));
+        for add_file in root_change.added {
+            self.db
+                .query_mut(ra_db::FileTextQuery)
+                .set(add_file.file_id, add_file.text);
+            self.db
+                .query_mut(ra_db::FileRelativePathQuery)
+                .set(add_file.file_id, add_file.path.clone());
+            self.db
+                .query_mut(ra_db::FileSourceRootQuery)
+                .set(add_file.file_id, root_id);
+            source_root.files.insert(add_file.path, add_file.file_id);
+        }
+        for remove_file in root_change.removed {
+            self.db
+                .query_mut(ra_db::FileTextQuery)
+                .set(remove_file.file_id, Default::default());
+            self.db
+                .query_mut(ra_db::FileRelativePathQuery)
+                .set(remove_file.file_id, Default::default());
+            source_root.files.remove(&remove_file.path);
+        }
+        self.db
+            .query_mut(ra_db::SourceRootQuery)
+            .set(root_id, Arc::new(source_root));
+    }
+
     #[allow(unused)]
     /// Ideally, we should call this function from time to time to collect heavy
     /// syntax trees. However, if we actually do that, everything is recomputed
@@ -156,21 +154,26 @@ impl AnalysisImpl {
         self.db.file_lines(file_id)
     }
     pub fn world_symbols(&self, query: Query) -> Cancelable<Vec<(FileId, FileSymbol)>> {
+        /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
+        struct Snap(salsa::Snapshot<db::RootDatabase>);
+        impl Clone for Snap {
+            fn clone(&self) -> Snap {
+                Snap(self.0.snapshot())
+            }
+        }
+
         let buf: Vec<Arc<SymbolIndex>> = if query.libs {
+            let snap = Snap(self.db.snapshot());
             self.db
-                .libraries()
-                .iter()
-                .map(|&lib_id| self.db.library_symbols(lib_id))
+                .library_roots()
+                .par_iter()
+                .map_with(snap, |db, &lib_id| db.0.library_symbols(lib_id))
                 .collect()
         } else {
-            let files = &self.db.source_root(WORKSPACE).files;
-
-            /// Need to wrap Snapshot to provide `Clone` impl for `map_with`
-            struct Snap(salsa::Snapshot<db::RootDatabase>);
-            impl Clone for Snap {
-                fn clone(&self) -> Snap {
-                    Snap(self.0.snapshot())
-                }
+            let mut files = Vec::new();
+            for &root in self.db.local_roots().iter() {
+                let sr = self.db.source_root(root);
+                files.extend(sr.files.values().map(|&it| it))
             }
 
             let snap = Snap(self.db.snapshot());
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 22fff71ab..a1d462528 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -18,9 +18,9 @@ pub mod mock_analysis;
 
 use std::{fmt, sync::Arc};
 
+use rustc_hash::FxHashMap;
 use ra_syntax::{SourceFileNode, TextRange, TextUnit};
 use ra_text_edit::AtomTextEdit;
-use ra_db::FileResolverImp;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
 
@@ -39,28 +39,54 @@ pub use hir::FnSignatureInfo;
 
 pub use ra_db::{
     Canceled, Cancelable, FilePosition,
-    CrateGraph, CrateId, FileId, FileResolver
+    CrateGraph, CrateId, SourceRootId, FileId
 };
 
 #[derive(Default)]
 pub struct AnalysisChange {
-    files_added: Vec<(FileId, String)>,
-    files_changed: Vec<(FileId, String)>,
-    files_removed: Vec<(FileId)>,
+    new_roots: Vec<(SourceRootId, bool)>,
+    roots_changed: FxHashMap<SourceRootId, RootChange>,
+    files_changed: Vec<(FileId, Arc<String>)>,
     libraries_added: Vec<LibraryData>,
     crate_graph: Option<CrateGraph>,
-    file_resolver: Option<FileResolverImp>,
+}
+
+#[derive(Default)]
+struct RootChange {
+    added: Vec<AddFile>,
+    removed: Vec<RemoveFile>,
+}
+
+#[derive(Debug)]
+struct AddFile {
+    file_id: FileId,
+    path: RelativePathBuf,
+    text: Arc<String>,
+}
+
+#[derive(Debug)]
+struct RemoveFile {
+    file_id: FileId,
+    path: RelativePathBuf,
 }
 
 impl fmt::Debug for AnalysisChange {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("AnalysisChange")
-            .field("files_added", &self.files_added.len())
+            .field("new_roots", &self.new_roots)
+            .field("roots_changed", &self.roots_changed)
             .field("files_changed", &self.files_changed.len())
-            .field("files_removed", &self.files_removed.len())
             .field("libraries_added", &self.libraries_added.len())
             .field("crate_graph", &self.crate_graph)
-            .field("file_resolver", &self.file_resolver)
+            .finish()
+    }
+}
+
+impl fmt::Debug for RootChange {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("AnalysisChange")
+            .field("added", &self.added.len())
+            .field("removed", &self.removed.len())
             .finish()
     }
 }
@@ -69,14 +95,37 @@ impl AnalysisChange {
     pub fn new() -> AnalysisChange {
         AnalysisChange::default()
     }
-    pub fn add_file(&mut self, file_id: FileId, text: String) {
-        self.files_added.push((file_id, text))
+    pub fn add_root(&mut self, root_id: SourceRootId, is_local: bool) {
+        self.new_roots.push((root_id, is_local));
     }
-    pub fn change_file(&mut self, file_id: FileId, new_text: String) {
+    pub fn add_file(
+        &mut self,
+        root_id: SourceRootId,
+        file_id: FileId,
+        path: RelativePathBuf,
+        text: Arc<String>,
+    ) {
+        let file = AddFile {
+            file_id,
+            path,
+            text,
+        };
+        self.roots_changed
+            .entry(root_id)
+            .or_default()
+            .added
+            .push(file);
+    }
+    pub fn change_file(&mut self, file_id: FileId, new_text: Arc<String>) {
         self.files_changed.push((file_id, new_text))
     }
-    pub fn remove_file(&mut self, file_id: FileId) {
-        self.files_removed.push(file_id)
+    pub fn remove_file(&mut self, root_id: SourceRootId, file_id: FileId, path: RelativePathBuf) {
+        let file = RemoveFile { file_id, path };
+        self.roots_changed
+            .entry(root_id)
+            .or_default()
+            .removed
+            .push(file);
     }
     pub fn add_library(&mut self, data: LibraryData) {
         self.libraries_added.push(data)
@@ -84,9 +133,6 @@ impl AnalysisChange {
     pub fn set_crate_graph(&mut self, graph: CrateGraph) {
         self.crate_graph = Some(graph);
     }
-    pub fn set_file_resolver(&mut self, file_resolver: Arc<FileResolver>) {
-        self.file_resolver = Some(FileResolverImp::new(file_resolver));
-    }
 }
 
 /// `AnalysisHost` stores the current state of the world.
@@ -313,20 +359,32 @@ impl Analysis {
 
 #[derive(Debug)]
 pub struct LibraryData {
-    files: Vec<(FileId, String)>,
-    file_resolver: FileResolverImp,
+    root_id: SourceRootId,
+    root_change: RootChange,
     symbol_index: SymbolIndex,
 }
 
 impl LibraryData {
-    pub fn prepare(files: Vec<(FileId, String)>, file_resolver: Arc<FileResolver>) -> LibraryData {
-        let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, text)| {
+    pub fn prepare(
+        root_id: SourceRootId,
+        files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
+    ) -> LibraryData {
+        let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, _, text)| {
             let file = SourceFileNode::parse(text);
             (*file_id, file)
         }));
+        let mut root_change = RootChange::default();
+        root_change.added = files
+            .into_iter()
+            .map(|(file_id, path, text)| AddFile {
+                file_id,
+                path,
+                text,
+            })
+            .collect();
         LibraryData {
-            files,
-            file_resolver: FileResolverImp::new(file_resolver),
+            root_id,
+            root_change,
             symbol_index,
         }
     }
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 0d9a7a147..7cbdfb953 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -4,7 +4,7 @@ use relative_path::{RelativePathBuf};
 use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
 use ra_db::mock::FileMap;
 
-use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition};
+use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition, SourceRootId};
 
 /// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
 /// from a set of in-memory files.
@@ -78,14 +78,16 @@ impl MockAnalysis {
     pub fn analysis_host(self) -> AnalysisHost {
         let mut host = AnalysisHost::default();
         let mut file_map = FileMap::default();
+        let source_root = SourceRootId(0);
         let mut change = AnalysisChange::new();
+        change.add_root(source_root, true);
         for (path, contents) in self.files.into_iter() {
             assert!(path.starts_with('/'));
             let path = RelativePathBuf::from_path(&path[1..]).unwrap();
-            let file_id = file_map.add(path);
-            change.add_file(file_id, contents);
+            let file_id = file_map.add(path.clone());
+            change.add_file(source_root, file_id, path, Arc::new(contents));
         }
-        change.set_file_resolver(Arc::new(file_map));
+        // change.set_file_resolver(Arc::new(file_map));
         host.apply_change(change);
         host
     }