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 +- 9 files changed, 364 insertions(+), 261 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/ra_analysis/src') 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, -- cgit v1.2.3