From ee4d904cfb1b604bc8627491e05980ac43cd59e3 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Thu, 25 Oct 2018 10:57:55 +0300 Subject: Store all the data in the Salsa Database --- crates/ra_analysis/src/completion.rs | 5 +- crates/ra_analysis/src/db.rs | 136 ----------------- crates/ra_analysis/src/db/input.rs | 83 +++++++++++ crates/ra_analysis/src/db/mod.rs | 107 ++++++++++++++ crates/ra_analysis/src/descriptors/module/imp.rs | 22 +-- crates/ra_analysis/src/descriptors/module/mod.rs | 10 +- crates/ra_analysis/src/imp.rs | 179 +++++++++++++---------- crates/ra_analysis/src/lib.rs | 81 +++++++--- crates/ra_analysis/src/symbol_index.rs | 2 +- crates/ra_analysis/tests/tests.rs | 20 ++- crates/ra_lsp_server/src/path_map.rs | 13 +- crates/ra_lsp_server/src/server_world.rs | 70 ++++++--- 12 files changed, 433 insertions(+), 295 deletions(-) delete mode 100644 crates/ra_analysis/src/db.rs create mode 100644 crates/ra_analysis/src/db/input.rs create mode 100644 crates/ra_analysis/src/db/mod.rs (limited to 'crates') diff --git a/crates/ra_analysis/src/completion.rs b/crates/ra_analysis/src/completion.rs index a0fd6828d..04bb82c18 100644 --- a/crates/ra_analysis/src/completion.rs +++ b/crates/ra_analysis/src/completion.rs @@ -6,13 +6,14 @@ use ra_syntax::{ use crate::{ FileId, Cancelable, - db::{self, SyntaxDatabase}, + db::{self, SyntaxDatabase, input::FilesDatabase}, descriptors::module::{ModulesDatabase, ModuleTree, ModuleId}, }; pub(crate) fn resolve_based_completion(db: &db::RootDatabase, file_id: FileId, offset: TextUnit) -> Cancelable>> { + let source_root_id = db.file_source_root(file_id); let file = db.file_syntax(file_id); - let module_tree = db.module_tree()?; + let module_tree = db.module_tree(source_root_id)?; let file = { let edit = AtomEdit::insert(offset, "intellijRulezz".to_string()); file.reparse(&edit) diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs deleted file mode 100644 index b527cde61..000000000 --- a/crates/ra_analysis/src/db.rs +++ /dev/null @@ -1,136 +0,0 @@ -use std::{ - fmt, - hash::{Hash, Hasher}, - sync::Arc, -}; - -use ra_editor::LineIndex; -use ra_syntax::File; -use rustc_hash::FxHashSet; -use salsa; - -use crate::{ - db, - Cancelable, Canceled, - descriptors::module::{SubmodulesQuery, ModuleTreeQuery, ModulesDatabase}, - symbol_index::SymbolIndex, - FileId, FileResolverImp, -}; - -#[derive(Default)] -pub(crate) struct RootDatabase { - runtime: salsa::Runtime, -} - -impl fmt::Debug for RootDatabase { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.write_str("RootDatabase { ... }") - } -} - -impl salsa::Database for RootDatabase { - fn salsa_runtime(&self) -> &salsa::Runtime { - &self.runtime - } -} - -pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> { - if db.salsa_runtime().is_current_revision_canceled() { - Err(Canceled) - } else { - Ok(()) - } -} - -impl salsa::ParallelDatabase for RootDatabase { - fn fork(&self) -> Self { - RootDatabase { - runtime: self.runtime.fork(), - } - } -} - -impl Clone for RootDatabase { - fn clone(&self) -> RootDatabase { - salsa::ParallelDatabase::fork(self) - } -} - -salsa::database_storage! { - pub(crate) struct RootDatabaseStorage for RootDatabase { - impl FilesDatabase { - fn file_text() for FileTextQuery; - fn file_set() for FileSetQuery; - } - impl SyntaxDatabase { - fn file_syntax() for FileSyntaxQuery; - fn file_lines() for FileLinesQuery; - fn file_symbols() for FileSymbolsQuery; - } - impl ModulesDatabase { - fn module_tree() for ModuleTreeQuery; - fn module_descriptor() for SubmodulesQuery; - } - } -} - -salsa::query_group! { - pub(crate) trait FilesDatabase: salsa::Database { - fn file_text(file_id: FileId) -> Arc { - type FileTextQuery; - storage input; - } - fn file_set() -> Arc { - type FileSetQuery; - storage input; - } - } -} - -#[derive(Default, Debug, Eq)] -pub(crate) struct FileSet { - pub(crate) files: FxHashSet, - pub(crate) resolver: FileResolverImp, -} - -impl PartialEq for FileSet { - fn eq(&self, other: &FileSet) -> bool { - self.files == other.files && self.resolver == other.resolver - } -} - -impl Hash for FileSet { - fn hash(&self, hasher: &mut H) { - let mut files = self.files.iter().cloned().collect::>(); - files.sort(); - files.hash(hasher); - } -} - -salsa::query_group! { - pub(crate) trait SyntaxDatabase: FilesDatabase { - fn file_syntax(file_id: FileId) -> File { - type FileSyntaxQuery; - } - fn file_lines(file_id: FileId) -> Arc { - type FileLinesQuery; - } - fn file_symbols(file_id: FileId) -> Cancelable> { - type FileSymbolsQuery; - } - } -} - -fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> File { - let text = db.file_text(file_id); - File::parse(&*text) -} -fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc { - let text = db.file_text(file_id); - Arc::new(LineIndex::new(&*text)) -} -fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable> { - db::check_canceled(db)?; - let syntax = db.file_syntax(file_id); - Ok(Arc::new(SymbolIndex::for_file(file_id, syntax))) -} diff --git a/crates/ra_analysis/src/db/input.rs b/crates/ra_analysis/src/db/input.rs new file mode 100644 index 000000000..957d082f9 --- /dev/null +++ b/crates/ra_analysis/src/db/input.rs @@ -0,0 +1,83 @@ +use std::{ + sync::Arc, + hash::{Hasher, Hash}, +}; + +use salsa; +use rustc_hash::FxHashSet; + +use crate::{FileId, FileResolverImp, CrateGraph, symbol_index::SymbolIndex}; + +salsa::query_group! { + pub(crate) trait FilesDatabase: salsa::Database { + fn file_text(file_id: FileId) -> Arc { + type FileTextQuery; + storage input; + } + fn file_source_root(file_id: FileId) -> SourceRootId { + type FileSourceRootQuery; + storage input; + } + fn source_root(id: SourceRootId) -> Arc { + type SourceRootQuery; + storage input; + } + fn libraries() -> Arc> { + type LibrarieseQuery; + storage input; + } + fn library_symbols(id: SourceRootId) -> Arc { + type LibrarySymbolsQuery; + storage input; + } + fn crate_graph() -> Arc { + type CrateGraphQuery; + storage input; + } + } +} + +#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub(crate) struct SourceRootId(pub(crate) u32); + +#[derive(Clone, Default, Debug, Eq)] +pub(crate) struct SourceRoot { + pub(crate) file_resolver: FileResolverImp, + pub(crate) files: FxHashSet, +} + +impl PartialEq for SourceRoot { + fn eq(&self, other: &SourceRoot) -> bool { + self.file_resolver == other.file_resolver + } +} + +impl Hash for SourceRoot { + fn hash(&self, hasher: &mut H) { + self.file_resolver.hash(hasher); + } +} + +pub(crate) const WORKSPACE: SourceRootId = SourceRootId(0); + + +#[derive(Default, Debug, Eq)] +pub(crate) struct FileSet { + pub(crate) files: FxHashSet, + pub(crate) resolver: FileResolverImp, +} + +impl PartialEq for FileSet { + fn eq(&self, other: &FileSet) -> bool { + self.files == other.files && self.resolver == other.resolver + } +} + +impl Hash for FileSet { + fn hash(&self, hasher: &mut H) { + let mut files = self.files.iter().cloned().collect::>(); + files.sort(); + files.hash(hasher); + } +} + diff --git a/crates/ra_analysis/src/db/mod.rs b/crates/ra_analysis/src/db/mod.rs new file mode 100644 index 000000000..8387118ad --- /dev/null +++ b/crates/ra_analysis/src/db/mod.rs @@ -0,0 +1,107 @@ +pub(crate) mod input; + +use std::{ + fmt, + sync::Arc, +}; + +use ra_editor::LineIndex; +use ra_syntax::File; +use salsa; + +use crate::{ + db, + Cancelable, Canceled, + descriptors::module::{SubmodulesQuery, ModuleTreeQuery, ModulesDatabase}, + symbol_index::SymbolIndex, + FileId, +}; + +#[derive(Default)] +pub(crate) struct RootDatabase { + runtime: salsa::Runtime, +} + +impl fmt::Debug for RootDatabase { + fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { + fmt.write_str("RootDatabase { ... }") + } +} + +impl salsa::Database for RootDatabase { + fn salsa_runtime(&self) -> &salsa::Runtime { + &self.runtime + } +} + +pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> { + if db.salsa_runtime().is_current_revision_canceled() { + Err(Canceled) + } else { + Ok(()) + } +} + +impl salsa::ParallelDatabase for RootDatabase { + fn fork(&self) -> Self { + RootDatabase { + runtime: self.runtime.fork(), + } + } +} + +impl Clone for RootDatabase { + fn clone(&self) -> RootDatabase { + salsa::ParallelDatabase::fork(self) + } +} + +salsa::database_storage! { + pub(crate) struct RootDatabaseStorage for RootDatabase { + impl input::FilesDatabase { + fn file_text() for input::FileTextQuery; + fn file_source_root() for input::FileSourceRootQuery; + fn source_root() for input::SourceRootQuery; + fn libraries() for input::LibrarieseQuery; + fn library_symbols() for input::LibrarySymbolsQuery; + fn crate_graph() for input::CrateGraphQuery; + } + impl SyntaxDatabase { + fn file_syntax() for FileSyntaxQuery; + fn file_lines() for FileLinesQuery; + fn file_symbols() for FileSymbolsQuery; + } + impl ModulesDatabase { + fn module_tree() for ModuleTreeQuery; + fn module_descriptor() for SubmodulesQuery; + } + } +} + +salsa::query_group! { + pub(crate) trait SyntaxDatabase: input::FilesDatabase { + fn file_syntax(file_id: FileId) -> File { + type FileSyntaxQuery; + } + fn file_lines(file_id: FileId) -> Arc { + type FileLinesQuery; + } + fn file_symbols(file_id: FileId) -> Cancelable> { + type FileSymbolsQuery; + } + } +} + +fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> File { + let text = db.file_text(file_id); + File::parse(&*text) +} +fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc { + let text = db.file_text(file_id); + Arc::new(LineIndex::new(&*text)) +} +fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable> { + db::check_canceled(db)?; + let syntax = db.file_syntax(file_id); + Ok(Arc::new(SymbolIndex::for_file(file_id, syntax))) +} diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs index 22e4bd785..6a408dc89 100644 --- a/crates/ra_analysis/src/descriptors/module/imp.rs +++ b/crates/ra_analysis/src/descriptors/module/imp.rs @@ -9,7 +9,7 @@ use ra_syntax::{ use crate::{ FileId, Cancelable, FileResolverImp, - db, + db::{self, input::{SourceRoot, SourceRootId}}, }; use super::{ @@ -35,9 +35,12 @@ pub(super) fn modules(root: ast::Root<'_>) -> impl Iterator Cancelable> { +pub(super) fn module_tree( + db: &impl ModulesDatabase, + source_root: SourceRootId, +) -> Cancelable> { db::check_canceled(db)?; - let res = create_module_tree(db)?; + let res = create_module_tree(db, source_root)?; Ok(Arc::new(res)) } @@ -50,6 +53,7 @@ pub struct Submodule { fn create_module_tree<'a>( db: &impl ModulesDatabase, + source_root: SourceRootId, ) -> Cancelable { let mut tree = ModuleTree { mods: Vec::new(), @@ -59,12 +63,13 @@ fn create_module_tree<'a>( let mut roots = FxHashMap::default(); let mut visited = FxHashSet::default(); - for &file_id in db.file_set().files.iter() { + let source_root = db.source_root(source_root); + for &file_id in source_root.files.iter() { if visited.contains(&file_id) { continue; // TODO: use explicit crate_roots here } assert!(!roots.contains_key(&file_id)); - let module_id = build_subtree(db, &mut tree, &mut visited, &mut roots, None, file_id)?; + let module_id = build_subtree(db, &source_root, &mut tree, &mut visited, &mut roots, None, file_id)?; roots.insert(file_id, module_id); } Ok(tree) @@ -72,6 +77,7 @@ fn create_module_tree<'a>( fn build_subtree( db: &impl ModulesDatabase, + source_root: &SourceRoot, tree: &mut ModuleTree, visited: &mut FxHashSet, roots: &mut FxHashMap, @@ -84,10 +90,8 @@ fn build_subtree( parent, children: Vec::new(), }); - let file_set = db.file_set(); - let file_resolver = &file_set.resolver; for name in db.submodules(file_id)?.iter() { - let (points_to, problem) = resolve_submodule(file_id, name, file_resolver); + let (points_to, problem) = resolve_submodule(file_id, name, &source_root.file_resolver); let link = tree.push_link(LinkData { name: name.clone(), owner: id, @@ -102,7 +106,7 @@ fn build_subtree( tree.module_mut(module_id).parent = Some(link); Ok(module_id) } - None => build_subtree(db, tree, visited, roots, Some(link), file_id), + None => build_subtree(db, source_root, tree, visited, roots, Some(link), file_id), }) .collect::>>()?; tree.link_mut(link).points_to = points_to; diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs index 52da650b3..98024cc15 100644 --- a/crates/ra_analysis/src/descriptors/module/mod.rs +++ b/crates/ra_analysis/src/descriptors/module/mod.rs @@ -7,12 +7,12 @@ use ra_syntax::{ast::{self, NameOwner, AstNode}, SmolStr, SyntaxNode}; use crate::{ FileId, Cancelable, - db::SyntaxDatabase, + db::{SyntaxDatabase, input::SourceRootId}, }; salsa::query_group! { pub(crate) trait ModulesDatabase: SyntaxDatabase { - fn module_tree() -> Cancelable> { + fn module_tree(source_root_id: SourceRootId) -> Cancelable> { type ModuleTreeQuery; use fn imp::module_tree; } @@ -110,15 +110,9 @@ impl ModuleId { } impl LinkId { - pub(crate) fn name(self, tree: &ModuleTree) -> SmolStr { - tree.link(self).name.clone() - } pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId { tree.link(self).owner } - fn points_to(self, tree: &ModuleTree) -> &[ModuleId] { - &tree.link(self).points_to - } pub(crate) fn bind_source<'a>( self, tree: &ModuleTree, diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs index f3e5b2887..97ed55465 100644 --- a/crates/ra_analysis/src/imp.rs +++ b/crates/ra_analysis/src/imp.rs @@ -1,7 +1,5 @@ use std::{ - fmt, hash::{Hash, Hasher}, - iter, sync::Arc, }; @@ -14,12 +12,16 @@ use ra_syntax::{ }; use relative_path::RelativePath; use rustc_hash::FxHashSet; +use salsa::{ParallelDatabase, Database}; use crate::{ - db::SyntaxDatabase, + AnalysisChange, + db::{ + self, SyntaxDatabase, + input::{SourceRootId, FilesDatabase, SourceRoot, WORKSPACE} + }, descriptors::module::{ModulesDatabase, ModuleTree, Problem}, descriptors::{FnDescriptor}, - roots::{ReadonlySourceRoot, SourceRoot, WritableSourceRoot}, CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, Position, Query, SourceChange, SourceFileEdit, Cancelable, }; @@ -80,96 +82,123 @@ impl Default for FileResolverImp { } } -#[derive(Debug)] +#[derive(Debug, Default)] pub(crate) struct AnalysisHostImpl { - data: WorldData, + db: db::RootDatabase, } + impl AnalysisHostImpl { pub fn new() -> AnalysisHostImpl { - AnalysisHostImpl { - data: WorldData::default(), - } + AnalysisHostImpl::default() } pub fn analysis(&self) -> AnalysisImpl { AnalysisImpl { - data: self.data.clone(), + db: self.db.fork() // freeze revision here } } - pub fn change_files(&mut self, changes: &mut dyn Iterator)>) { - self.data_mut().root.apply_changes(changes, None); - } - pub fn set_file_resolver(&mut self, resolver: FileResolverImp) { - self.data_mut() - .root - .apply_changes(&mut iter::empty(), Some(resolver)); - } - pub fn set_crate_graph(&mut self, graph: CrateGraph) { - let mut visited = FxHashSet::default(); - for &file_id in graph.crate_roots.values() { - if !visited.insert(file_id) { - panic!("duplicate crate root: {:?}", file_id); + pub fn apply_change(&mut self, change: AnalysisChange) { + for (file_id, text) in change.files_changed { + self.db + .query(db::input::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 { + self.db + .query(db::input::FileTextQuery) + .set(file_id, Arc::new(text)); + self.db + .query(db::input::FileSourceRootQuery) + .set(file_id, db::input::WORKSPACE); + source_root.files.insert(file_id); + } + for file_id in change.files_removed { + self.db + .query(db::input::FileTextQuery) + .set(file_id, Arc::new(String::new())); + source_root.files.remove(&file_id); } + source_root.file_resolver = file_resolver; + self.db + .query(db::input::SourceRootQuery) + .set(WORKSPACE, Arc::new(source_root)) + } + if !change.libraries_added.is_empty() { + let mut libraries = Vec::clone(&self.db.libraries()); + 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); + self.db + .query(db::input::FileSourceRootQuery) + .set_constant(file_id, source_root_id); + self.db + .query(db::input::FileTextQuery) + .set_constant(file_id, Arc::new(text)); + } + let source_root = SourceRoot { + files, + file_resolver: library.file_resolver, + }; + self.db + .query(db::input::SourceRootQuery) + .set(source_root_id, Arc::new(source_root)); + self.db + .query(db::input::LibrarySymbolsQuery) + .set(source_root_id, Arc::new(library.symbol_index)); + } + self.db + .query(db::input::LibrarieseQuery) + .set((), Arc::new(libraries)); + } + if let Some(crate_graph) = change.crate_graph { + self.db.query(db::input::CrateGraphQuery) + .set((), Arc::new(crate_graph)) } - self.data_mut().crate_graph = graph; - } - pub fn add_library(&mut self, root: ReadonlySourceRoot) { - self.data_mut().libs.push(root); - } - fn data_mut(&mut self) -> &mut WorldData { - &mut self.data } } +#[derive(Debug)] pub(crate) struct AnalysisImpl { - data: WorldData, -} - -impl fmt::Debug for AnalysisImpl { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - self.data.fmt(f) - } + db: db::RootDatabase, } impl AnalysisImpl { - fn root(&self, file_id: FileId) -> &SourceRoot { - if self.data.root.contains(file_id) { - return &self.data.root; - } - self - .data - .libs - .iter() - .find(|it| it.contains(file_id)) - .unwrap() - } pub fn file_syntax(&self, file_id: FileId) -> File { - self.root(file_id).db().file_syntax(file_id) + self.db.file_syntax(file_id) } pub fn file_line_index(&self, file_id: FileId) -> Arc { - self.root(file_id).db().file_lines(file_id) + self.db.file_lines(file_id) } pub fn world_symbols(&self, query: Query) -> Cancelable> { let mut buf = Vec::new(); - if query.libs { - for lib in self.data.libs.iter() { - lib.symbols(&mut buf)?; - } - } else { - self.data.root.symbols(&mut buf)?; + for &lib_id in self.db.libraries().iter() { + buf.push(self.db.library_symbols(lib_id)); + } + for &file_id in self.db.source_root(WORKSPACE).files.iter() { + buf.push(self.db.file_symbols(file_id)?); } Ok(query.search(&buf)) } + fn module_tree(&self, file_id: FileId) -> Cancelable> { + let source_root = self.db.file_source_root(file_id); + self.db.module_tree(source_root) + } pub fn parent_module(&self, file_id: FileId) -> Cancelable> { - let root = self.root(file_id); - let module_tree = root.db().module_tree()?; + let module_tree = self.module_tree(file_id)?; let res = module_tree.modules_for_file(file_id) .into_iter() .filter_map(|module_id| { let link = module_id.parent_link(&module_tree)?; let file_id = link.owner(&module_tree).file_id(&module_tree); - let syntax = root.db().file_syntax(file_id); + let syntax = self.db.file_syntax(file_id); let decl = link.bind_source(&module_tree, syntax.ast()); let sym = FileSymbol { @@ -183,8 +212,8 @@ impl AnalysisImpl { Ok(res) } pub fn crate_for(&self, file_id: FileId) -> Cancelable> { - let module_tree = self.root(file_id).db().module_tree()?; - let crate_graph = &self.data.crate_graph; + let module_tree = self.module_tree(file_id)?; + let crate_graph = self.db.crate_graph(); let res = module_tree.modules_for_file(file_id) .into_iter() .map(|it| it.root(&module_tree)) @@ -195,7 +224,7 @@ impl AnalysisImpl { Ok(res) } pub fn crate_root(&self, crate_id: CrateId) -> FileId { - self.data.crate_graph.crate_roots[&crate_id] + self.db.crate_graph().crate_roots[&crate_id] } pub fn completions(&self, file_id: FileId, offset: TextUnit) -> Cancelable>> { let mut res = Vec::new(); @@ -205,8 +234,7 @@ impl AnalysisImpl { res.extend(scope_based); has_completions = true; } - let root = self.root(file_id); - if let Some(scope_based) = crate::completion::resolve_based_completion(root.db(), file_id, offset)? { + if let Some(scope_based) = crate::completion::resolve_based_completion(&self.db, file_id, offset)? { res.extend(scope_based); has_completions = true; } @@ -222,9 +250,8 @@ impl AnalysisImpl { file_id: FileId, offset: TextUnit, ) -> Cancelable> { - let root = self.root(file_id); - let module_tree = root.db().module_tree()?; - let file = root.db().file_syntax(file_id); + let module_tree = self.module_tree(file_id)?; + let file = self.db.file_syntax(file_id); let syntax = file.syntax(); if let Some(name_ref) = find_node_at_offset::(syntax, offset) { // First try to resolve the symbol locally @@ -273,8 +300,7 @@ impl AnalysisImpl { } pub fn find_all_refs(&self, file_id: FileId, offset: TextUnit) -> Vec<(FileId, TextRange)> { - let root = self.root(file_id); - let file = root.db().file_syntax(file_id); + let file = self.db.file_syntax(file_id); let syntax = file.syntax(); let mut ret = vec![]; @@ -305,9 +331,8 @@ impl AnalysisImpl { } pub fn diagnostics(&self, file_id: FileId) -> Cancelable> { - let root = self.root(file_id); - let module_tree = root.db().module_tree()?; - let syntax = root.db().file_syntax(file_id); + let module_tree = self.module_tree(file_id)?; + let syntax = self.db.file_syntax(file_id); let mut res = ra_editor::diagnostics(&syntax) .into_iter() @@ -396,8 +421,7 @@ impl AnalysisImpl { file_id: FileId, offset: TextUnit, ) -> Cancelable)>> { - let root = self.root(file_id); - let file = root.db().file_syntax(file_id); + let file = self.db.file_syntax(file_id); let syntax = file.syntax(); // Find the calling expression and it's NameRef @@ -491,13 +515,6 @@ impl AnalysisImpl { } } -#[derive(Default, Clone, Debug)] -struct WorldData { - crate_graph: CrateGraph, - root: WritableSourceRoot, - libs: Vec, -} - impl SourceChange { pub(crate) fn from_local_edit(file_id: FileId, label: &str, edit: LocalEdit) -> SourceChange { let file_edit = SourceFileEdit { diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs index 7078e2d31..4a1ae3b64 100644 --- a/crates/ra_analysis/src/lib.rs +++ b/crates/ra_analysis/src/lib.rs @@ -9,17 +9,23 @@ extern crate salsa; mod db; mod descriptors; mod imp; -mod roots; mod symbol_index; mod completion; -use std::{fmt::Debug, sync::Arc}; +use std::{ + fmt::Debug, + sync::Arc, + collections::BTreeMap, +}; use ra_syntax::{AtomEdit, File, TextRange, TextUnit}; use relative_path::{RelativePath, RelativePathBuf}; -use rustc_hash::FxHashMap; +use rayon::prelude::*; -use crate::imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp}; +use crate::{ + imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp}, + symbol_index::SymbolIndex, +}; pub use crate::{ descriptors::FnDescriptor, @@ -49,9 +55,9 @@ pub struct FileId(pub u32); #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct CrateId(pub u32); -#[derive(Debug, Clone, Default)] +#[derive(Debug, Clone, Default, PartialEq, Eq, Hash)] pub struct CrateGraph { - pub crate_roots: FxHashMap, + pub crate_roots: BTreeMap, } pub trait FileResolver: Debug + Send + Sync + 'static { @@ -59,6 +65,41 @@ pub trait FileResolver: Debug + Send + Sync + 'static { fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option; } +#[derive(Debug, Default)] +pub struct AnalysisChange { + files_added: Vec<(FileId, String)>, + files_changed: Vec<(FileId, String)>, + files_removed: Vec<(FileId)>, + libraries_added: Vec, + crate_graph: Option, + file_resolver: Option, +} + + +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 change_file(&mut self, file_id: FileId, new_text: 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 add_library(&mut self, data: LibraryData) { + self.libraries_added.push(data) + } + pub fn set_crate_graph(&mut self, graph: CrateGraph) { + self.crate_graph = Some(graph); + } + pub fn set_file_resolver(&mut self, file_resolver: Arc) { + self.file_resolver = Some(FileResolverImp::new(file_resolver)); + } +} + #[derive(Debug)] pub struct AnalysisHost { imp: AnalysisHostImpl, @@ -75,20 +116,8 @@ impl AnalysisHost { imp: self.imp.analysis(), } } - pub fn change_file(&mut self, file_id: FileId, text: Option) { - self.change_files(::std::iter::once((file_id, text))); - } - pub fn change_files(&mut self, mut changes: impl Iterator)>) { - self.imp.change_files(&mut changes) - } - pub fn set_file_resolver(&mut self, resolver: Arc) { - self.imp.set_file_resolver(FileResolverImp::new(resolver)); - } - pub fn set_crate_graph(&mut self, graph: CrateGraph) { - self.imp.set_crate_graph(graph) - } - pub fn add_library(&mut self, data: LibraryData) { - self.imp.add_library(data.root) + pub fn apply_change(&mut self, change: AnalysisChange) { + self.imp.apply_change(change) } } @@ -266,14 +295,18 @@ impl Analysis { #[derive(Debug)] pub struct LibraryData { - root: roots::ReadonlySourceRoot, + files: Vec<(FileId, String)>, + file_resolver: FileResolverImp, + symbol_index: SymbolIndex, } impl LibraryData { pub fn prepare(files: Vec<(FileId, String)>, file_resolver: Arc) -> LibraryData { - let file_resolver = FileResolverImp::new(file_resolver); - let root = roots::ReadonlySourceRoot::new(files, file_resolver); - LibraryData { root } + let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, text)| { + let file = File::parse(text); + (*file_id, file) + })); + LibraryData { files, file_resolver: FileResolverImp::new(file_resolver), symbol_index } } } diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs index e5c8d8870..5f302cbda 100644 --- a/crates/ra_analysis/src/symbol_index.rs +++ b/crates/ra_analysis/src/symbol_index.rs @@ -13,7 +13,7 @@ use rayon::prelude::*; use crate::{FileId, Query}; -#[derive(Debug)] +#[derive(Default, Debug)] pub(crate) struct SymbolIndex { symbols: Vec<(FileId, FileSymbol)>, map: fst::Map, diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs index 52fae71ae..198d6a263 100644 --- a/crates/ra_analysis/tests/tests.rs +++ b/crates/ra_analysis/tests/tests.rs @@ -5,15 +5,17 @@ extern crate relative_path; extern crate rustc_hash; extern crate test_utils; -use std::sync::Arc; +use std::{ + sync::Arc, + collections::BTreeMap, +}; use ra_syntax::TextRange; use relative_path::{RelativePath, RelativePathBuf}; -use rustc_hash::FxHashMap; use test_utils::{assert_eq_dbg, extract_offset}; use ra_analysis::{ - Analysis, AnalysisHost, CrateGraph, CrateId, FileId, FileResolver, FnDescriptor, + AnalysisChange, Analysis, AnalysisHost, CrateGraph, CrateId, FileId, FileResolver, FnDescriptor, }; #[derive(Debug)] @@ -45,14 +47,16 @@ impl FileResolver for FileMap { fn analysis_host(files: &[(&str, &str)]) -> AnalysisHost { let mut host = AnalysisHost::new(); let mut file_map = Vec::new(); + let mut change = AnalysisChange::new(); for (id, &(path, contents)) in files.iter().enumerate() { let file_id = FileId((id + 1) as u32); assert!(path.starts_with('/')); let path = RelativePathBuf::from_path(&path[1..]).unwrap(); - host.change_file(file_id, Some(contents.to_string())); + change.add_file(file_id, contents.to_string()); file_map.push((file_id, path)); } - host.set_file_resolver(Arc::new(FileMap(file_map))); + change.set_file_resolver(Arc::new(FileMap(file_map))); + host.apply_change(change); host } @@ -128,12 +132,14 @@ fn test_resolve_crate_root() { let crate_graph = CrateGraph { crate_roots: { - let mut m = FxHashMap::default(); + let mut m = BTreeMap::default(); m.insert(CrateId(1), FileId(1)); m }, }; - host.set_crate_graph(crate_graph); + let mut change = AnalysisChange::new(); + change.set_crate_graph(crate_graph); + host.apply_change(change); let snap = host.analysis(); assert_eq!(snap.crate_for(FileId(2)).unwrap(), vec![CrateId(1)],); diff --git a/crates/ra_lsp_server/src/path_map.rs b/crates/ra_lsp_server/src/path_map.rs index d32829382..b3d1dc3db 100644 --- a/crates/ra_lsp_server/src/path_map.rs +++ b/crates/ra_lsp_server/src/path_map.rs @@ -22,15 +22,18 @@ impl PathMap { pub fn new() -> PathMap { Default::default() } - pub fn get_or_insert(&mut self, path: PathBuf, root: Root) -> FileId { - self.path2id + pub fn get_or_insert(&mut self, path: PathBuf, root: Root) -> (bool, FileId) { + let mut inserted = false; + let file_id = self.path2id .get(path.as_path()) .map(|&id| id) .unwrap_or_else(|| { + inserted = true; let id = self.new_file_id(); self.insert(path, id, root); id - }) + }); + (inserted, file_id) } pub fn get_id(&self, path: &Path) -> Option { self.path2id.get(path).map(|&id| id) @@ -105,8 +108,8 @@ mod test { #[test] fn test_resolve() { let mut m = PathMap::new(); - let id1 = m.get_or_insert(PathBuf::from("/foo"), Root::Workspace); - let id2 = m.get_or_insert(PathBuf::from("/foo/bar.rs"), Root::Workspace); + let (_, id1) = m.get_or_insert(PathBuf::from("/foo"), Root::Workspace); + let (_, id2) = m.get_or_insert(PathBuf::from("/foo/bar.rs"), Root::Workspace); assert_eq!(m.resolve(id1, &RelativePath::new("bar.rs")), Some(id2),) } } diff --git a/crates/ra_lsp_server/src/server_world.rs b/crates/ra_lsp_server/src/server_world.rs index 69b2a1cd1..555de66ff 100644 --- a/crates/ra_lsp_server/src/server_world.rs +++ b/crates/ra_lsp_server/src/server_world.rs @@ -2,10 +2,11 @@ use std::{ fs, path::{Path, PathBuf}, sync::Arc, + collections::BTreeMap, }; use languageserver_types::Url; -use ra_analysis::{Analysis, AnalysisHost, CrateGraph, CrateId, FileId, FileResolver, LibraryData}; +use ra_analysis::{Analysis, AnalysisHost, AnalysisChange, CrateGraph, CrateId, FileId, FileResolver, LibraryData}; use rustc_hash::FxHashMap; use crate::{ @@ -39,30 +40,40 @@ impl ServerWorldState { } } pub fn apply_fs_changes(&mut self, events: Vec) { + let mut change = AnalysisChange::new(); + let mut inserted = false; { let pm = &mut self.path_map; let mm = &mut self.mem_map; - let changes = events + events .into_iter() .map(|event| { let text = match event.kind { - FileEventKind::Add(text) => Some(text), + FileEventKind::Add(text) => text, }; (event.path, text) }) - .map(|(path, text)| (pm.get_or_insert(path, Root::Workspace), text)) - .filter_map(|(id, text)| { - if mm.contains_key(&id) { - mm.insert(id, text); + .map(|(path, text)| { + let (ins, file_id) = pm.get_or_insert(path, Root::Workspace); + inserted |= ins; + (file_id, text) + }) + .filter_map(|(file_id, text)| { + if mm.contains_key(&file_id) { + mm.insert(file_id, Some(text)); None } else { - Some((id, text)) + Some((file_id, text)) } + }) + .for_each(|(file_id, text)| { + change.add_file(file_id, text) }); - self.analysis_host.change_files(changes); } - self.analysis_host - .set_file_resolver(Arc::new(self.path_map.clone())); + if inserted { + change.set_file_resolver(Arc::new(self.path_map.clone())) + } + self.analysis_host.apply_change(change); } pub fn events_to_files( &mut self, @@ -76,24 +87,31 @@ impl ServerWorldState { let FileEventKind::Add(text) = event.kind; (event.path, text) }) - .map(|(path, text)| (pm.get_or_insert(path, Root::Lib), text)) + .map(|(path, text)| (pm.get_or_insert(path, Root::Lib).1, text)) .collect() }; let resolver = Arc::new(self.path_map.clone()); (files, resolver) } pub fn add_lib(&mut self, data: LibraryData) { - self.analysis_host.add_library(data); + let mut change = AnalysisChange::new(); + change.add_library(data); + self.analysis_host.apply_change(change); } pub fn add_mem_file(&mut self, path: PathBuf, text: String) -> FileId { - let file_id = self.path_map.get_or_insert(path, Root::Workspace); - self.analysis_host - .set_file_resolver(Arc::new(self.path_map.clone())); - self.mem_map.insert(file_id, None); + let (inserted, file_id) = self.path_map.get_or_insert(path, Root::Workspace); if self.path_map.get_root(file_id) != Root::Lib { - self.analysis_host.change_file(file_id, Some(text)); + let mut change = AnalysisChange::new(); + if inserted { + change.add_file(file_id, text); + change.set_file_resolver(Arc::new(self.path_map.clone())); + } else { + change.change_file(file_id, text); + } + self.analysis_host.apply_change(change); } + self.mem_map.insert(file_id, None); file_id } @@ -103,7 +121,9 @@ impl ServerWorldState { .get_id(path) .ok_or_else(|| format_err!("change to unknown file: {}", path.display()))?; if self.path_map.get_root(file_id) != Root::Lib { - self.analysis_host.change_file(file_id, Some(text)); + let mut change = AnalysisChange::new(); + change.change_file(file_id, text); + self.analysis_host.apply_change(change); } Ok(()) } @@ -120,12 +140,16 @@ impl ServerWorldState { // Do this via file watcher ideally. let text = fs::read_to_string(path).ok(); if self.path_map.get_root(file_id) != Root::Lib { - self.analysis_host.change_file(file_id, text); + let mut change = AnalysisChange::new(); + if let Some(text) = text { + change.change_file(file_id, text); + } + self.analysis_host.apply_change(change); } Ok(file_id) } pub fn set_workspaces(&mut self, ws: Vec) { - let mut crate_roots = FxHashMap::default(); + let mut crate_roots = BTreeMap::default(); ws.iter() .flat_map(|ws| { ws.packages() @@ -140,7 +164,9 @@ impl ServerWorldState { }); let crate_graph = CrateGraph { crate_roots }; self.workspaces = Arc::new(ws); - self.analysis_host.set_crate_graph(crate_graph); + let mut change = AnalysisChange::new(); + change.set_crate_graph(crate_graph); + self.analysis_host.apply_change(change); } pub fn snapshot(&self) -> ServerWorld { ServerWorld { -- cgit v1.2.3