aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_analysis
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_analysis')
-rw-r--r--crates/ra_analysis/Cargo.toml3
-rw-r--r--crates/ra_analysis/src/completion/mod.rs54
-rw-r--r--crates/ra_analysis/src/completion/reference_completion.rs106
-rw-r--r--crates/ra_analysis/src/db.rs125
-rw-r--r--crates/ra_analysis/src/descriptors/function/imp.rs21
-rw-r--r--crates/ra_analysis/src/descriptors/function/mod.rs136
-rw-r--r--crates/ra_analysis/src/descriptors/function/scope.rs430
-rw-r--r--crates/ra_analysis/src/descriptors/mod.rs92
-rw-r--r--crates/ra_analysis/src/descriptors/module/imp.rs249
-rw-r--r--crates/ra_analysis/src/descriptors/module/mod.rs236
-rw-r--r--crates/ra_analysis/src/descriptors/module/scope.rs124
-rw-r--r--crates/ra_analysis/src/imp.rs376
-rw-r--r--crates/ra_analysis/src/input.rs76
-rw-r--r--crates/ra_analysis/src/lib.rs44
-rw-r--r--crates/ra_analysis/src/mock_analysis.rs40
-rw-r--r--crates/ra_analysis/src/symbol_index.rs28
-rw-r--r--crates/ra_analysis/src/syntax_ptr.rs84
-rw-r--r--crates/ra_analysis/tests/tests.rs14
18 files changed, 310 insertions, 1928 deletions
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index 908ee1c81..fe9765a66 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -11,6 +11,9 @@ rayon = "1.0.2"
11fst = "0.3.1" 11fst = "0.3.1"
12salsa = "0.8.0" 12salsa = "0.8.0"
13rustc-hash = "1.0" 13rustc-hash = "1.0"
14parking_lot = "0.6.4"
14ra_syntax = { path = "../ra_syntax" } 15ra_syntax = { path = "../ra_syntax" }
15ra_editor = { path = "../ra_editor" } 16ra_editor = { path = "../ra_editor" }
17ra_db = { path = "../ra_db" }
18hir = { path = "../ra_hir", package = "ra_hir" }
16test_utils = { path = "../test_utils" } 19test_utils = { path = "../test_utils" }
diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index 2e082705e..e5ba92acd 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -2,18 +2,16 @@ mod reference_completion;
2 2
3use ra_editor::find_node_at_offset; 3use ra_editor::find_node_at_offset;
4use ra_syntax::{ 4use ra_syntax::{
5 algo::find_leaf_at_offset,
6 algo::visit::{visitor_ctx, VisitorCtx}, 5 algo::visit::{visitor_ctx, VisitorCtx},
7 ast, 6 ast,
8 AstNode, AtomEdit, 7 AstNode, AtomEdit,
9 SyntaxNodeRef, 8 SyntaxNodeRef,
10}; 9};
10use ra_db::SyntaxDatabase;
11use rustc_hash::{FxHashMap}; 11use rustc_hash::{FxHashMap};
12 12
13use crate::{ 13use crate::{
14 db::{self, SyntaxDatabase}, 14 db,
15 descriptors::{DescriptorDatabase, module::ModuleSource},
16 input::{FilesDatabase},
17 Cancelable, FilePosition 15 Cancelable, FilePosition
18}; 16};
19 17
@@ -31,39 +29,21 @@ pub(crate) fn completions(
31 db: &db::RootDatabase, 29 db: &db::RootDatabase,
32 position: FilePosition, 30 position: FilePosition,
33) -> Cancelable<Option<Vec<CompletionItem>>> { 31) -> Cancelable<Option<Vec<CompletionItem>>> {
34 let original_file = db.file_syntax(position.file_id); 32 let original_file = db.source_file(position.file_id);
35 // Insert a fake ident to get a valid parse tree 33 // Insert a fake ident to get a valid parse tree
36 let file = { 34 let file = {
37 let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string()); 35 let edit = AtomEdit::insert(position.offset, "intellijRulezz".to_string());
38 original_file.reparse(&edit) 36 original_file.reparse(&edit)
39 }; 37 };
40 38
41 let leaf = match find_leaf_at_offset(original_file.syntax(), position.offset).left_biased() { 39 let module = ctry!(hir::Module::guess_from_position(db, position)?);
42 None => return Ok(None),
43 Some(it) => it,
44 };
45 let source_root_id = db.file_source_root(position.file_id);
46 let module_tree = db.module_tree(source_root_id)?;
47 let module_source = ModuleSource::for_node(position.file_id, leaf);
48 let module_id = match module_tree.any_module_for_source(module_source) {
49 None => return Ok(None),
50 Some(it) => it,
51 };
52 40
53 let mut res = Vec::new(); 41 let mut res = Vec::new();
54 let mut has_completions = false; 42 let mut has_completions = false;
55 // First, let's try to complete a reference to some declaration. 43 // First, let's try to complete a reference to some declaration.
56 if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) { 44 if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(file.syntax(), position.offset) {
57 has_completions = true; 45 has_completions = true;
58 reference_completion::completions( 46 reference_completion::completions(&mut res, db, &module, &file, name_ref)?;
59 &mut res,
60 db,
61 source_root_id,
62 &module_tree,
63 module_id,
64 &file,
65 name_ref,
66 )?;
67 // special case, `trait T { fn foo(i_am_a_name_ref) {} }` 47 // special case, `trait T { fn foo(i_am_a_name_ref) {} }`
68 if is_node::<ast::Param>(name_ref.syntax()) { 48 if is_node::<ast::Param>(name_ref.syntax()) {
69 param_completions(name_ref.syntax(), &mut res); 49 param_completions(name_ref.syntax(), &mut res);
@@ -219,9 +199,9 @@ mod tests {
219 <|> 199 <|>
220 } 200 }
221 ", 201 ",
222 r#"[CompletionItem { label: "Foo", lookup: None, snippet: None }, 202 r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
223 CompletionItem { label: "Baz", lookup: None, snippet: None }, 203 CompletionItem { label: "Foo", lookup: None, snippet: None },
224 CompletionItem { label: "quux", lookup: None, snippet: None }]"#, 204 CompletionItem { label: "Baz", lookup: None, snippet: None }]"#,
225 ); 205 );
226 } 206 }
227 207
@@ -236,6 +216,20 @@ mod tests {
236 } 216 }
237 217
238 #[test] 218 #[test]
219 fn test_completion_self_path() {
220 check_scope_completion(
221 r"
222 use self::m::<|>;
223
224 mod m {
225 struct Bar;
226 }
227 ",
228 r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
229 );
230 }
231
232 #[test]
239 fn test_completion_mod_scope_nested() { 233 fn test_completion_mod_scope_nested() {
240 check_scope_completion( 234 check_scope_completion(
241 r" 235 r"
@@ -245,8 +239,8 @@ mod tests {
245 fn quux() { <|> } 239 fn quux() { <|> }
246 } 240 }
247 ", 241 ",
248 r#"[CompletionItem { label: "Bar", lookup: None, snippet: None }, 242 r#"[CompletionItem { label: "quux", lookup: None, snippet: None },
249 CompletionItem { label: "quux", lookup: None, snippet: None }]"#, 243 CompletionItem { label: "Bar", lookup: None, snippet: None }]"#,
250 ); 244 );
251 } 245 }
252 246
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
index 6c5fd0be6..e1a2d5241 100644
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -6,23 +6,23 @@ use ra_syntax::{
6 ast::{self, LoopBodyOwner}, 6 ast::{self, LoopBodyOwner},
7 SyntaxKind::*, 7 SyntaxKind::*,
8}; 8};
9use hir::{
10 self,
11 FnScopes,
12 Def,
13 Path,
14};
9 15
10use crate::{ 16use crate::{
11 db::RootDatabase, 17 db::RootDatabase,
12 input::{SourceRootId},
13 completion::CompletionItem, 18 completion::CompletionItem,
14 descriptors::module::{ModuleId, ModuleTree},
15 descriptors::function::FnScopes,
16 descriptors::DescriptorDatabase,
17 Cancelable 19 Cancelable
18}; 20};
19 21
20pub(super) fn completions( 22pub(super) fn completions(
21 acc: &mut Vec<CompletionItem>, 23 acc: &mut Vec<CompletionItem>,
22 db: &RootDatabase, 24 db: &RootDatabase,
23 source_root_id: SourceRootId, 25 module: &hir::Module,
24 module_tree: &ModuleTree,
25 module_id: ModuleId,
26 file: &SourceFileNode, 26 file: &SourceFileNode,
27 name_ref: ast::NameRef, 27 name_ref: ast::NameRef,
28) -> Cancelable<()> { 28) -> Cancelable<()> {
@@ -40,25 +40,28 @@ pub(super) fn completions(
40 complete_expr_snippets(acc); 40 complete_expr_snippets(acc);
41 } 41 }
42 42
43 let module_scope = db.module_scope(source_root_id, module_id)?; 43 let module_scope = module.scope(db)?;
44 acc.extend( 44 acc.extend(
45 module_scope 45 module_scope
46 .entries() 46 .entries()
47 .iter() 47 .filter(|(_name, res)| {
48 .filter(|entry| {
49 // Don't expose this item 48 // Don't expose this item
50 !entry.ptr().range().is_subrange(&name_ref.syntax().range()) 49 match res.import {
50 None => true,
51 Some(import) => {
52 let range = import.range(db, module.source().file_id());
53 !range.is_subrange(&name_ref.syntax().range())
54 }
55 }
51 }) 56 })
52 .map(|entry| CompletionItem { 57 .map(|(name, _res)| CompletionItem {
53 label: entry.name().to_string(), 58 label: name.to_string(),
54 lookup: None, 59 lookup: None,
55 snippet: None, 60 snippet: None,
56 }), 61 }),
57 ); 62 );
58 } 63 }
59 NameRefKind::CratePath(path) => { 64 NameRefKind::Path(path) => complete_path(acc, db, module, path)?,
60 complete_path(acc, db, source_root_id, module_tree, module_id, path)?
61 }
62 NameRefKind::BareIdentInMod => { 65 NameRefKind::BareIdentInMod => {
63 let name_range = name_ref.syntax().range(); 66 let name_range = name_ref.syntax().range();
64 let top_node = name_ref 67 let top_node = name_ref
@@ -82,8 +85,8 @@ enum NameRefKind<'a> {
82 LocalRef { 85 LocalRef {
83 enclosing_fn: Option<ast::FnDef<'a>>, 86 enclosing_fn: Option<ast::FnDef<'a>>,
84 }, 87 },
85 /// NameRef is the last segment in crate:: path 88 /// NameRef is the last segment in some path
86 CratePath(Vec<ast::NameRef<'a>>), 89 Path(Path),
87 /// NameRef is bare identifier at the module's root. 90 /// NameRef is bare identifier at the module's root.
88 /// Used for keyword completion 91 /// Used for keyword completion
89 BareIdentInMod, 92 BareIdentInMod,
@@ -105,8 +108,10 @@ fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
105 let parent = name_ref.syntax().parent()?; 108 let parent = name_ref.syntax().parent()?;
106 if let Some(segment) = ast::PathSegment::cast(parent) { 109 if let Some(segment) = ast::PathSegment::cast(parent) {
107 let path = segment.parent_path(); 110 let path = segment.parent_path();
108 if let Some(crate_path) = crate_path(path) { 111 if let Some(path) = Path::from_ast(path) {
109 return Some(NameRefKind::CratePath(crate_path)); 112 if !path.is_ident() {
113 return Some(NameRefKind::Path(path));
114 }
110 } 115 }
111 if path.qualifier().is_none() { 116 if path.qualifier().is_none() {
112 let enclosing_fn = name_ref 117 let enclosing_fn = name_ref
@@ -120,32 +125,6 @@ fn classify_name_ref(name_ref: ast::NameRef) -> Option<NameRefKind> {
120 None 125 None
121} 126}
122 127
123fn crate_path(mut path: ast::Path) -> Option<Vec<ast::NameRef>> {
124 let mut res = Vec::new();
125 loop {
126 let segment = path.segment()?;
127 match segment.kind()? {
128 ast::PathSegmentKind::Name(name) => res.push(name),
129 ast::PathSegmentKind::CrateKw => break,
130 ast::PathSegmentKind::SelfKw | ast::PathSegmentKind::SuperKw => return None,
131 }
132 path = qualifier(path)?;
133 }
134 res.reverse();
135 return Some(res);
136
137 fn qualifier(path: ast::Path) -> Option<ast::Path> {
138 if let Some(q) = path.qualifier() {
139 return Some(q);
140 }
141 // TODO: this bottom up traversal is not too precise.
142 // Should we handle do a top-down analysiss, recording results?
143 let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
144 let use_tree = use_tree_list.parent_use_tree();
145 use_tree.path()
146 }
147}
148
149fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) { 128fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<CompletionItem>) {
150 let mut shadowed = FxHashSet::default(); 129 let mut shadowed = FxHashSet::default();
151 acc.extend( 130 acc.extend(
@@ -171,18 +150,24 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
171fn complete_path( 150fn complete_path(
172 acc: &mut Vec<CompletionItem>, 151 acc: &mut Vec<CompletionItem>,
173 db: &RootDatabase, 152 db: &RootDatabase,
174 source_root_id: SourceRootId, 153 module: &hir::Module,
175 module_tree: &ModuleTree, 154 mut path: Path,
176 module_id: ModuleId,
177 crate_path: Vec<ast::NameRef>,
178) -> Cancelable<()> { 155) -> Cancelable<()> {
179 let target_module_id = match find_target_module(module_tree, module_id, crate_path) { 156 if path.segments.is_empty() {
157 return Ok(());
158 }
159 path.segments.pop();
160 let def_id = match module.resolve_path(db, path)? {
180 None => return Ok(()), 161 None => return Ok(()),
181 Some(it) => it, 162 Some(it) => it,
182 }; 163 };
183 let module_scope = db.module_scope(source_root_id, target_module_id)?; 164 let target_module = match def_id.resolve(db)? {
184 let completions = module_scope.entries().iter().map(|entry| CompletionItem { 165 Def::Module(it) => it,
185 label: entry.name().to_string(), 166 Def::Item => return Ok(()),
167 };
168 let module_scope = target_module.scope(db)?;
169 let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
170 label: name.to_string(),
186 lookup: None, 171 lookup: None,
187 snippet: None, 172 snippet: None,
188 }); 173 });
@@ -190,19 +175,6 @@ fn complete_path(
190 Ok(()) 175 Ok(())
191} 176}
192 177
193fn find_target_module(
194 module_tree: &ModuleTree,
195 module_id: ModuleId,
196 mut crate_path: Vec<ast::NameRef>,
197) -> Option<ModuleId> {
198 crate_path.pop();
199 let mut target_module = module_id.root(&module_tree);
200 for name in crate_path {
201 target_module = target_module.child(module_tree, name.text().as_str())?;
202 }
203 Some(target_module)
204}
205
206fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) { 178fn complete_mod_item_snippets(acc: &mut Vec<CompletionItem>) {
207 acc.push(CompletionItem { 179 acc.push(CompletionItem {
208 label: "tfn".to_string(), 180 label: "tfn".to_string(),
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 194f1a6b0..df2ef293d 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,23 +1,22 @@
1use std::sync::Arc; 1use std::sync::Arc;
2
3use ra_editor::LineIndex;
4use ra_syntax::{SourceFileNode, SyntaxNode};
5use salsa::{self, Database}; 2use salsa::{self, Database};
3use ra_db::{LocationIntener, BaseDatabase};
4use hir::{self, DefId, DefLoc, FnId, SourceItemId};
6 5
7use crate::{ 6use crate::{
8 db, 7 symbol_index,
9 descriptors::{
10 DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleScopeQuery, ModuleTreeQuery,
11 SubmodulesQuery,
12 },
13 symbol_index::SymbolIndex,
14 syntax_ptr::SyntaxPtr,
15 Cancelable, Canceled, FileId,
16}; 8};
17 9
18#[derive(Debug)] 10#[derive(Debug)]
19pub(crate) struct RootDatabase { 11pub(crate) struct RootDatabase {
20 runtime: salsa::Runtime<RootDatabase>, 12 runtime: salsa::Runtime<RootDatabase>,
13 id_maps: Arc<IdMaps>,
14}
15
16#[derive(Debug, Default)]
17struct IdMaps {
18 fns: LocationIntener<SourceItemId, FnId>,
19 defs: LocationIntener<DefLoc, DefId>,
21} 20}
22 21
23impl salsa::Database for RootDatabase { 22impl salsa::Database for RootDatabase {
@@ -29,90 +28,68 @@ impl salsa::Database for RootDatabase {
29impl Default for RootDatabase { 28impl Default for RootDatabase {
30 fn default() -> RootDatabase { 29 fn default() -> RootDatabase {
31 let mut db = RootDatabase { 30 let mut db = RootDatabase {
32 runtime: Default::default(), 31 runtime: salsa::Runtime::default(),
32 id_maps: Default::default(),
33 }; 33 };
34 db.query_mut(crate::input::SourceRootQuery) 34 db.query_mut(ra_db::SourceRootQuery)
35 .set(crate::input::WORKSPACE, Default::default()); 35 .set(ra_db::WORKSPACE, Default::default());
36 db.query_mut(crate::input::CrateGraphQuery) 36 db.query_mut(ra_db::CrateGraphQuery)
37 .set((), Default::default()); 37 .set((), Default::default());
38 db.query_mut(crate::input::LibrariesQuery) 38 db.query_mut(ra_db::LibrariesQuery)
39 .set((), Default::default()); 39 .set((), Default::default());
40 db 40 db
41 } 41 }
42} 42}
43 43
44pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
45 if db.salsa_runtime().is_current_revision_canceled() {
46 Err(Canceled)
47 } else {
48 Ok(())
49 }
50}
51
52impl salsa::ParallelDatabase for RootDatabase { 44impl salsa::ParallelDatabase for RootDatabase {
53 fn snapshot(&self) -> salsa::Snapshot<RootDatabase> { 45 fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
54 salsa::Snapshot::new(RootDatabase { 46 salsa::Snapshot::new(RootDatabase {
55 runtime: self.runtime.snapshot(self), 47 runtime: self.runtime.snapshot(self),
48 id_maps: self.id_maps.clone(),
56 }) 49 })
57 } 50 }
58} 51}
59 52
60salsa::database_storage! { 53impl BaseDatabase for RootDatabase {}
61 pub(crate) struct RootDatabaseStorage for RootDatabase { 54
62 impl crate::input::FilesDatabase { 55impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
63 fn file_text() for crate::input::FileTextQuery; 56 fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
64 fn file_source_root() for crate::input::FileSourceRootQuery; 57 &self.id_maps.defs
65 fn source_root() for crate::input::SourceRootQuery;
66 fn libraries() for crate::input::LibrariesQuery;
67 fn library_symbols() for crate::input::LibrarySymbolsQuery;
68 fn crate_graph() for crate::input::CrateGraphQuery;
69 }
70 impl SyntaxDatabase {
71 fn file_syntax() for FileSyntaxQuery;
72 fn file_lines() for FileLinesQuery;
73 fn file_symbols() for FileSymbolsQuery;
74 fn resolve_syntax_ptr() for ResolveSyntaxPtrQuery;
75 }
76 impl DescriptorDatabase {
77 fn module_tree() for ModuleTreeQuery;
78 fn module_descriptor() for SubmodulesQuery;
79 fn module_scope() for ModuleScopeQuery;
80 fn fn_syntax() for FnSyntaxQuery;
81 fn fn_scopes() for FnScopesQuery;
82 }
83 } 58 }
84} 59}
85 60
86salsa::query_group! { 61impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
87 pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase { 62 fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
88 fn file_syntax(file_id: FileId) -> SourceFileNode { 63 &self.id_maps.fns
89 type FileSyntaxQuery; 64 }
65}
66
67salsa::database_storage! {
68 pub(crate) struct RootDatabaseStorage for RootDatabase {
69 impl ra_db::FilesDatabase {
70 fn file_text() for ra_db::FileTextQuery;
71 fn file_source_root() for ra_db::FileSourceRootQuery;
72 fn source_root() for ra_db::SourceRootQuery;
73 fn libraries() for ra_db::LibrariesQuery;
74 fn crate_graph() for ra_db::CrateGraphQuery;
90 } 75 }
91 fn file_lines(file_id: FileId) -> Arc<LineIndex> { 76 impl ra_db::SyntaxDatabase {
92 type FileLinesQuery; 77 fn source_file() for ra_db::SourceFileQuery;
78 fn file_lines() for ra_db::FileLinesQuery;
93 } 79 }
94 fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> { 80 impl symbol_index::SymbolsDatabase {
95 type FileSymbolsQuery; 81 fn file_symbols() for symbol_index::FileSymbolsQuery;
82 fn library_symbols() for symbol_index::LibrarySymbolsQuery;
96 } 83 }
97 fn resolve_syntax_ptr(ptr: SyntaxPtr) -> SyntaxNode { 84 impl hir::db::HirDatabase {
98 type ResolveSyntaxPtrQuery; 85 fn module_tree() for hir::db::ModuleTreeQuery;
99 // Don't retain syntax trees in memory 86 fn fn_scopes() for hir::db::FnScopesQuery;
100 storage volatile; 87 fn file_items() for hir::db::SourceFileItemsQuery;
101 use fn crate::syntax_ptr::resolve_syntax_ptr; 88 fn file_item() for hir::db::FileItemQuery;
89 fn input_module_items() for hir::db::InputModuleItemsQuery;
90 fn item_map() for hir::db::ItemMapQuery;
91 fn fn_syntax() for hir::db::FnSyntaxQuery;
92 fn submodules() for hir::db::SubmodulesQuery;
102 } 93 }
103 } 94 }
104} 95}
105
106fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
107 let text = db.file_text(file_id);
108 SourceFileNode::parse(&*text)
109}
110fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
111 let text = db.file_text(file_id);
112 Arc::new(LineIndex::new(&*text))
113}
114fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
115 db::check_canceled(db)?;
116 let syntax = db.file_syntax(file_id);
117 Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
118}
diff --git a/crates/ra_analysis/src/descriptors/function/imp.rs b/crates/ra_analysis/src/descriptors/function/imp.rs
deleted file mode 100644
index a989a04cd..000000000
--- a/crates/ra_analysis/src/descriptors/function/imp.rs
+++ /dev/null
@@ -1,21 +0,0 @@
1use std::sync::Arc;
2
3use ra_syntax::ast::{AstNode, FnDef, FnDefNode};
4
5use crate::descriptors::{
6 function::{FnId, FnScopes},
7 DescriptorDatabase,
8};
9
10/// Resolve `FnId` to the corresponding `SyntaxNode`
11/// TODO: this should return something more type-safe then `SyntaxNode`
12pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode {
13 let syntax = db.resolve_syntax_ptr(fn_id.0);
14 FnDef::cast(syntax.borrowed()).unwrap().owned()
15}
16
17pub(crate) fn fn_scopes(db: &impl DescriptorDatabase, fn_id: FnId) -> Arc<FnScopes> {
18 let syntax = db.fn_syntax(fn_id);
19 let res = FnScopes::new(syntax.borrowed());
20 Arc::new(res)
21}
diff --git a/crates/ra_analysis/src/descriptors/function/mod.rs b/crates/ra_analysis/src/descriptors/function/mod.rs
deleted file mode 100644
index d5db28a64..000000000
--- a/crates/ra_analysis/src/descriptors/function/mod.rs
+++ /dev/null
@@ -1,136 +0,0 @@
1pub(super) mod imp;
2mod scope;
3
4use std::cmp::{max, min};
5
6use ra_syntax::{
7 ast::{self, AstNode, DocCommentsOwner, NameOwner},
8 TextRange, TextUnit,
9};
10
11use crate::{syntax_ptr::SyntaxPtr, FileId};
12
13pub(crate) use self::scope::{resolve_local_name, FnScopes};
14
15#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
16pub(crate) struct FnId(SyntaxPtr);
17
18impl FnId {
19 pub(crate) fn new(file_id: FileId, fn_def: ast::FnDef) -> FnId {
20 let ptr = SyntaxPtr::new(file_id, fn_def.syntax());
21 FnId(ptr)
22 }
23}
24
25#[derive(Debug, Clone)]
26pub struct FnDescriptor {
27 pub name: String,
28 pub label: String,
29 pub ret_type: Option<String>,
30 pub params: Vec<String>,
31 pub doc: Option<String>,
32}
33
34impl FnDescriptor {
35 pub fn new(node: ast::FnDef) -> Option<Self> {
36 let name = node.name()?.text().to_string();
37
38 let mut doc = None;
39
40 // Strip the body out for the label.
41 let mut label: String = if let Some(body) = node.body() {
42 let body_range = body.syntax().range();
43 let label: String = node
44 .syntax()
45 .children()
46 .filter(|child| !child.range().is_subrange(&body_range))
47 .map(|node| node.text().to_string())
48 .collect();
49 label
50 } else {
51 node.syntax().text().to_string()
52 };
53
54 if let Some((comment_range, docs)) = FnDescriptor::extract_doc_comments(node) {
55 let comment_range = comment_range
56 .checked_sub(node.syntax().range().start())
57 .unwrap();
58 let start = comment_range.start().to_usize();
59 let end = comment_range.end().to_usize();
60
61 // Remove the comment from the label
62 label.replace_range(start..end, "");
63
64 // Massage markdown
65 let mut processed_lines = Vec::new();
66 let mut in_code_block = false;
67 for line in docs.lines() {
68 if line.starts_with("```") {
69 in_code_block = !in_code_block;
70 }
71
72 let line = if in_code_block && line.starts_with("```") && !line.contains("rust") {
73 "```rust".into()
74 } else {
75 line.to_string()
76 };
77
78 processed_lines.push(line);
79 }
80
81 if !processed_lines.is_empty() {
82 doc = Some(processed_lines.join("\n"));
83 }
84 }
85
86 let params = FnDescriptor::param_list(node);
87 let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
88
89 Some(FnDescriptor {
90 name,
91 ret_type,
92 params,
93 label: label.trim().to_owned(),
94 doc,
95 })
96 }
97
98 fn extract_doc_comments(node: ast::FnDef) -> Option<(TextRange, String)> {
99 if node.doc_comments().count() == 0 {
100 return None;
101 }
102
103 let comment_text = node.doc_comment_text();
104
105 let (begin, end) = node
106 .doc_comments()
107 .map(|comment| comment.syntax().range())
108 .map(|range| (range.start().to_usize(), range.end().to_usize()))
109 .fold((std::usize::MAX, std::usize::MIN), |acc, range| {
110 (min(acc.0, range.0), max(acc.1, range.1))
111 });
112
113 let range = TextRange::from_to(TextUnit::from_usize(begin), TextUnit::from_usize(end));
114
115 Some((range, comment_text))
116 }
117
118 fn param_list(node: ast::FnDef) -> Vec<String> {
119 let mut res = vec![];
120 if let Some(param_list) = node.param_list() {
121 if let Some(self_param) = param_list.self_param() {
122 res.push(self_param.syntax().text().to_string())
123 }
124
125 // Maybe use param.pat here? See if we can just extract the name?
126 //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
127 res.extend(
128 param_list
129 .params()
130 .filter_map(|p| p.pat())
131 .map(|pat| pat.syntax().text().to_string()),
132 );
133 }
134 res
135 }
136}
diff --git a/crates/ra_analysis/src/descriptors/function/scope.rs b/crates/ra_analysis/src/descriptors/function/scope.rs
deleted file mode 100644
index bbe16947c..000000000
--- a/crates/ra_analysis/src/descriptors/function/scope.rs
+++ /dev/null
@@ -1,430 +0,0 @@
1use rustc_hash::{FxHashMap, FxHashSet};
2
3use ra_syntax::{
4 algo::generate,
5 ast::{self, ArgListOwner, LoopBodyOwner, NameOwner},
6 AstNode, SmolStr, SyntaxNodeRef,
7};
8
9use crate::syntax_ptr::LocalSyntaxPtr;
10
11#[derive(Clone, Copy, PartialEq, Eq, Debug)]
12pub(crate) struct ScopeId(u32);
13
14#[derive(Debug, PartialEq, Eq)]
15pub struct FnScopes {
16 pub(crate) self_param: Option<LocalSyntaxPtr>,
17 scopes: Vec<ScopeData>,
18 scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
19}
20
21#[derive(Debug, PartialEq, Eq)]
22pub struct ScopeEntry {
23 name: SmolStr,
24 ptr: LocalSyntaxPtr,
25}
26
27#[derive(Debug, PartialEq, Eq)]
28struct ScopeData {
29 parent: Option<ScopeId>,
30 entries: Vec<ScopeEntry>,
31}
32
33impl FnScopes {
34 pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
35 let mut scopes = FnScopes {
36 self_param: fn_def
37 .param_list()
38 .and_then(|it| it.self_param())
39 .map(|it| LocalSyntaxPtr::new(it.syntax())),
40 scopes: Vec::new(),
41 scope_for: FxHashMap::default(),
42 };
43 let root = scopes.root_scope();
44 scopes.add_params_bindings(root, fn_def.param_list());
45 if let Some(body) = fn_def.body() {
46 compute_block_scopes(body, &mut scopes, root)
47 }
48 scopes
49 }
50 pub(crate) fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
51 &self.get(scope).entries
52 }
53 pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
54 generate(self.scope_for(node), move |&scope| self.get(scope).parent)
55 }
56 fn root_scope(&mut self) -> ScopeId {
57 let res = ScopeId(self.scopes.len() as u32);
58 self.scopes.push(ScopeData {
59 parent: None,
60 entries: vec![],
61 });
62 res
63 }
64 fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
65 let res = ScopeId(self.scopes.len() as u32);
66 self.scopes.push(ScopeData {
67 parent: Some(parent),
68 entries: vec![],
69 });
70 res
71 }
72 fn add_bindings(&mut self, scope: ScopeId, pat: ast::Pat) {
73 let entries = pat
74 .syntax()
75 .descendants()
76 .filter_map(ast::BindPat::cast)
77 .filter_map(ScopeEntry::new);
78 self.get_mut(scope).entries.extend(entries);
79 }
80 fn add_params_bindings(&mut self, scope: ScopeId, params: Option<ast::ParamList>) {
81 params
82 .into_iter()
83 .flat_map(|it| it.params())
84 .filter_map(|it| it.pat())
85 .for_each(|it| self.add_bindings(scope, it));
86 }
87 fn set_scope(&mut self, node: SyntaxNodeRef, scope: ScopeId) {
88 self.scope_for.insert(LocalSyntaxPtr::new(node), scope);
89 }
90 fn scope_for(&self, node: SyntaxNodeRef) -> Option<ScopeId> {
91 node.ancestors()
92 .map(LocalSyntaxPtr::new)
93 .filter_map(|it| self.scope_for.get(&it).map(|&scope| scope))
94 .next()
95 }
96 fn get(&self, scope: ScopeId) -> &ScopeData {
97 &self.scopes[scope.0 as usize]
98 }
99 fn get_mut(&mut self, scope: ScopeId) -> &mut ScopeData {
100 &mut self.scopes[scope.0 as usize]
101 }
102}
103
104impl ScopeEntry {
105 fn new(pat: ast::BindPat) -> Option<ScopeEntry> {
106 let name = pat.name()?;
107 let res = ScopeEntry {
108 name: name.text(),
109 ptr: LocalSyntaxPtr::new(pat.syntax()),
110 };
111 Some(res)
112 }
113 pub(crate) fn name(&self) -> &SmolStr {
114 &self.name
115 }
116 pub(crate) fn ptr(&self) -> LocalSyntaxPtr {
117 self.ptr
118 }
119}
120
121fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
122 for stmt in block.statements() {
123 match stmt {
124 ast::Stmt::LetStmt(stmt) => {
125 if let Some(expr) = stmt.initializer() {
126 scopes.set_scope(expr.syntax(), scope);
127 compute_expr_scopes(expr, scopes, scope);
128 }
129 scope = scopes.new_scope(scope);
130 if let Some(pat) = stmt.pat() {
131 scopes.add_bindings(scope, pat);
132 }
133 }
134 ast::Stmt::ExprStmt(expr_stmt) => {
135 if let Some(expr) = expr_stmt.expr() {
136 scopes.set_scope(expr.syntax(), scope);
137 compute_expr_scopes(expr, scopes, scope);
138 }
139 }
140 }
141 }
142 if let Some(expr) = block.expr() {
143 scopes.set_scope(expr.syntax(), scope);
144 compute_expr_scopes(expr, scopes, scope);
145 }
146}
147
148fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
149 match expr {
150 ast::Expr::IfExpr(e) => {
151 let cond_scope = e
152 .condition()
153 .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
154 if let Some(block) = e.then_branch() {
155 compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
156 }
157 if let Some(block) = e.else_branch() {
158 compute_block_scopes(block, scopes, scope);
159 }
160 }
161 ast::Expr::BlockExpr(e) => {
162 if let Some(block) = e.block() {
163 compute_block_scopes(block, scopes, scope);
164 }
165 }
166 ast::Expr::LoopExpr(e) => {
167 if let Some(block) = e.loop_body() {
168 compute_block_scopes(block, scopes, scope);
169 }
170 }
171 ast::Expr::WhileExpr(e) => {
172 let cond_scope = e
173 .condition()
174 .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
175 if let Some(block) = e.loop_body() {
176 compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
177 }
178 }
179 ast::Expr::ForExpr(e) => {
180 if let Some(expr) = e.iterable() {
181 compute_expr_scopes(expr, scopes, scope);
182 }
183 let mut scope = scope;
184 if let Some(pat) = e.pat() {
185 scope = scopes.new_scope(scope);
186 scopes.add_bindings(scope, pat);
187 }
188 if let Some(block) = e.loop_body() {
189 compute_block_scopes(block, scopes, scope);
190 }
191 }
192 ast::Expr::LambdaExpr(e) => {
193 let scope = scopes.new_scope(scope);
194 scopes.add_params_bindings(scope, e.param_list());
195 if let Some(body) = e.body() {
196 scopes.set_scope(body.syntax(), scope);
197 compute_expr_scopes(body, scopes, scope);
198 }
199 }
200 ast::Expr::CallExpr(e) => {
201 compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
202 }
203 ast::Expr::MethodCallExpr(e) => {
204 compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
205 }
206 ast::Expr::MatchExpr(e) => {
207 if let Some(expr) = e.expr() {
208 compute_expr_scopes(expr, scopes, scope);
209 }
210 for arm in e.match_arm_list().into_iter().flat_map(|it| it.arms()) {
211 let scope = scopes.new_scope(scope);
212 for pat in arm.pats() {
213 scopes.add_bindings(scope, pat);
214 }
215 if let Some(expr) = arm.expr() {
216 compute_expr_scopes(expr, scopes, scope);
217 }
218 }
219 }
220 _ => expr
221 .syntax()
222 .children()
223 .filter_map(ast::Expr::cast)
224 .for_each(|expr| compute_expr_scopes(expr, scopes, scope)),
225 };
226
227 fn compute_call_scopes(
228 receiver: Option<ast::Expr>,
229 arg_list: Option<ast::ArgList>,
230 scopes: &mut FnScopes,
231 scope: ScopeId,
232 ) {
233 arg_list
234 .into_iter()
235 .flat_map(|it| it.args())
236 .chain(receiver)
237 .for_each(|expr| compute_expr_scopes(expr, scopes, scope));
238 }
239
240 fn compute_cond_scopes(
241 cond: ast::Condition,
242 scopes: &mut FnScopes,
243 scope: ScopeId,
244 ) -> Option<ScopeId> {
245 if let Some(expr) = cond.expr() {
246 compute_expr_scopes(expr, scopes, scope);
247 }
248 if let Some(pat) = cond.pat() {
249 let s = scopes.new_scope(scope);
250 scopes.add_bindings(s, pat);
251 Some(s)
252 } else {
253 None
254 }
255 }
256}
257
258pub fn resolve_local_name<'a>(
259 name_ref: ast::NameRef,
260 scopes: &'a FnScopes,
261) -> Option<&'a ScopeEntry> {
262 let mut shadowed = FxHashSet::default();
263 let ret = scopes
264 .scope_chain(name_ref.syntax())
265 .flat_map(|scope| scopes.entries(scope).iter())
266 .filter(|entry| shadowed.insert(entry.name()))
267 .filter(|entry| entry.name() == &name_ref.text())
268 .nth(0);
269 ret
270}
271
272#[cfg(test)]
273mod tests {
274 use ra_editor::find_node_at_offset;
275 use ra_syntax::SourceFileNode;
276 use test_utils::extract_offset;
277
278 use super::*;
279
280 fn do_check(code: &str, expected: &[&str]) {
281 let (off, code) = extract_offset(code);
282 let code = {
283 let mut buf = String::new();
284 let off = u32::from(off) as usize;
285 buf.push_str(&code[..off]);
286 buf.push_str("marker");
287 buf.push_str(&code[off..]);
288 buf
289 };
290 let file = SourceFileNode::parse(&code);
291 let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
292 let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
293 let scopes = FnScopes::new(fn_def);
294 let actual = scopes
295 .scope_chain(marker.syntax())
296 .flat_map(|scope| scopes.entries(scope))
297 .map(|it| it.name())
298 .collect::<Vec<_>>();
299 assert_eq!(actual.as_slice(), expected);
300 }
301
302 #[test]
303 fn test_lambda_scope() {
304 do_check(
305 r"
306 fn quux(foo: i32) {
307 let f = |bar, baz: i32| {
308 <|>
309 };
310 }",
311 &["bar", "baz", "foo"],
312 );
313 }
314
315 #[test]
316 fn test_call_scope() {
317 do_check(
318 r"
319 fn quux() {
320 f(|x| <|> );
321 }",
322 &["x"],
323 );
324 }
325
326 #[test]
327 fn test_metod_call_scope() {
328 do_check(
329 r"
330 fn quux() {
331 z.f(|x| <|> );
332 }",
333 &["x"],
334 );
335 }
336
337 #[test]
338 fn test_loop_scope() {
339 do_check(
340 r"
341 fn quux() {
342 loop {
343 let x = ();
344 <|>
345 };
346 }",
347 &["x"],
348 );
349 }
350
351 #[test]
352 fn test_match() {
353 do_check(
354 r"
355 fn quux() {
356 match () {
357 Some(x) => {
358 <|>
359 }
360 };
361 }",
362 &["x"],
363 );
364 }
365
366 #[test]
367 fn test_shadow_variable() {
368 do_check(
369 r"
370 fn foo(x: String) {
371 let x : &str = &x<|>;
372 }",
373 &["x"],
374 );
375 }
376
377 fn do_check_local_name(code: &str, expected_offset: u32) {
378 let (off, code) = extract_offset(code);
379 let file = SourceFileNode::parse(&code);
380 let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
381 let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
382
383 let scopes = FnScopes::new(fn_def);
384
385 let local_name_entry = resolve_local_name(name_ref, &scopes).unwrap();
386 let local_name = local_name_entry.ptr().resolve(&file);
387 let expected_name =
388 find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into()).unwrap();
389 assert_eq!(local_name.range(), expected_name.syntax().range());
390 }
391
392 #[test]
393 fn test_resolve_local_name() {
394 do_check_local_name(
395 r#"
396 fn foo(x: i32, y: u32) {
397 {
398 let z = x * 2;
399 }
400 {
401 let t = x<|> * 3;
402 }
403 }"#,
404 21,
405 );
406 }
407
408 #[test]
409 fn test_resolve_local_name_declaration() {
410 do_check_local_name(
411 r#"
412 fn foo(x: String) {
413 let x : &str = &x<|>;
414 }"#,
415 21,
416 );
417 }
418
419 #[test]
420 fn test_resolve_local_name_shadow() {
421 do_check_local_name(
422 r"
423 fn foo(x: String) {
424 let x : &str = &x;
425 x<|>
426 }",
427 46,
428 );
429 }
430}
diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
deleted file mode 100644
index 56bde3849..000000000
--- a/crates/ra_analysis/src/descriptors/mod.rs
+++ /dev/null
@@ -1,92 +0,0 @@
1pub(crate) mod function;
2pub(crate) mod module;
3
4use std::sync::Arc;
5
6use ra_syntax::{
7 ast::{self, AstNode, FnDefNode},
8 TextRange,
9};
10
11use crate::{
12 db::SyntaxDatabase,
13 descriptors::function::{resolve_local_name, FnId, FnScopes},
14 descriptors::module::{ModuleId, ModuleScope, ModuleTree, ModuleSource},
15 input::SourceRootId,
16 syntax_ptr::LocalSyntaxPtr,
17 Cancelable,
18};
19
20salsa::query_group! {
21 pub(crate) trait DescriptorDatabase: SyntaxDatabase {
22 fn module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
23 type ModuleTreeQuery;
24 use fn module::imp::module_tree;
25 }
26 fn submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
27 type SubmodulesQuery;
28 use fn module::imp::submodules;
29 }
30 fn module_scope(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<ModuleScope>> {
31 type ModuleScopeQuery;
32 use fn module::imp::module_scope;
33 }
34 fn fn_syntax(fn_id: FnId) -> FnDefNode {
35 type FnSyntaxQuery;
36 // Don't retain syntax trees in memory
37 storage volatile;
38 use fn function::imp::fn_syntax;
39 }
40 fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
41 type FnScopesQuery;
42 use fn function::imp::fn_scopes;
43 }
44 }
45}
46
47#[derive(Debug)]
48pub struct ReferenceDescriptor {
49 pub range: TextRange,
50 pub name: String,
51}
52
53#[derive(Debug)]
54pub struct DeclarationDescriptor<'a> {
55 pat: ast::BindPat<'a>,
56 pub range: TextRange,
57}
58
59impl<'a> DeclarationDescriptor<'a> {
60 pub fn new(pat: ast::BindPat) -> DeclarationDescriptor {
61 let range = pat.syntax().range();
62
63 DeclarationDescriptor { pat, range }
64 }
65
66 pub fn find_all_refs(&self) -> Vec<ReferenceDescriptor> {
67 let name_ptr = LocalSyntaxPtr::new(self.pat.syntax());
68
69 let fn_def = match self.pat.syntax().ancestors().find_map(ast::FnDef::cast) {
70 Some(def) => def,
71 None => return Default::default(),
72 };
73
74 let fn_scopes = FnScopes::new(fn_def);
75
76 let refs: Vec<_> = fn_def
77 .syntax()
78 .descendants()
79 .filter_map(ast::NameRef::cast)
80 .filter(|name_ref| match resolve_local_name(*name_ref, &fn_scopes) {
81 None => false,
82 Some(entry) => entry.ptr() == name_ptr,
83 })
84 .map(|name_ref| ReferenceDescriptor {
85 name: name_ref.syntax().text().to_string(),
86 range: name_ref.syntax().range(),
87 })
88 .collect();
89
90 refs
91 }
92}
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs
deleted file mode 100644
index ade96ddc0..000000000
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ /dev/null
@@ -1,249 +0,0 @@
1use std::sync::Arc;
2
3use ra_syntax::{
4 ast::{self, ModuleItemOwner, NameOwner},
5 SmolStr,
6};
7use relative_path::RelativePathBuf;
8use rustc_hash::{FxHashMap, FxHashSet};
9
10use crate::{
11 db,
12 descriptors::DescriptorDatabase,
13 input::{SourceRoot, SourceRootId},
14 Cancelable, FileId, FileResolverImp,
15};
16
17use super::{
18 LinkData, LinkId, ModuleData, ModuleId, ModuleScope, ModuleSource, ModuleSourceNode,
19 ModuleTree, Problem,
20};
21
22#[derive(Clone, Hash, PartialEq, Eq, Debug)]
23pub(crate) enum Submodule {
24 Declaration(SmolStr),
25 Definition(SmolStr, ModuleSource),
26}
27
28impl Submodule {
29 fn name(&self) -> &SmolStr {
30 match self {
31 Submodule::Declaration(name) => name,
32 Submodule::Definition(name, _) => name,
33 }
34 }
35}
36
37pub(crate) fn submodules(
38 db: &impl DescriptorDatabase,
39 source: ModuleSource,
40) -> Cancelable<Arc<Vec<Submodule>>> {
41 db::check_canceled(db)?;
42 let file_id = source.file_id();
43 let submodules = match source.resolve(db) {
44 ModuleSourceNode::SourceFile(it) => collect_submodules(file_id, it.borrowed()),
45 ModuleSourceNode::Module(it) => it
46 .borrowed()
47 .item_list()
48 .map(|it| collect_submodules(file_id, it))
49 .unwrap_or_else(Vec::new),
50 };
51 return Ok(Arc::new(submodules));
52
53 fn collect_submodules<'a>(
54 file_id: FileId,
55 root: impl ast::ModuleItemOwner<'a>,
56 ) -> Vec<Submodule> {
57 modules(root)
58 .map(|(name, m)| {
59 if m.has_semi() {
60 Submodule::Declaration(name)
61 } else {
62 let src = ModuleSource::new_inline(file_id, m);
63 Submodule::Definition(name, src)
64 }
65 })
66 .collect()
67 }
68}
69
70pub(crate) fn modules<'a>(
71 root: impl ast::ModuleItemOwner<'a>,
72) -> impl Iterator<Item = (SmolStr, ast::Module<'a>)> {
73 root.items()
74 .filter_map(|item| match item {
75 ast::ModuleItem::Module(m) => Some(m),
76 _ => None,
77 })
78 .filter_map(|module| {
79 let name = module.name()?.text();
80 Some((name, module))
81 })
82}
83
84pub(crate) fn module_scope(
85 db: &impl DescriptorDatabase,
86 source_root_id: SourceRootId,
87 module_id: ModuleId,
88) -> Cancelable<Arc<ModuleScope>> {
89 let tree = db.module_tree(source_root_id)?;
90 let source = module_id.source(&tree).resolve(db);
91 let res = match source {
92 ModuleSourceNode::SourceFile(it) => ModuleScope::new(it.borrowed().items()),
93 ModuleSourceNode::Module(it) => match it.borrowed().item_list() {
94 Some(items) => ModuleScope::new(items.items()),
95 None => ModuleScope::new(std::iter::empty()),
96 },
97 };
98 Ok(Arc::new(res))
99}
100
101pub(crate) fn module_tree(
102 db: &impl DescriptorDatabase,
103 source_root: SourceRootId,
104) -> Cancelable<Arc<ModuleTree>> {
105 db::check_canceled(db)?;
106 let res = create_module_tree(db, source_root)?;
107 Ok(Arc::new(res))
108}
109
110fn create_module_tree<'a>(
111 db: &impl DescriptorDatabase,
112 source_root: SourceRootId,
113) -> Cancelable<ModuleTree> {
114 let mut tree = ModuleTree {
115 mods: Vec::new(),
116 links: Vec::new(),
117 };
118
119 let mut roots = FxHashMap::default();
120 let mut visited = FxHashSet::default();
121
122 let source_root = db.source_root(source_root);
123 for &file_id in source_root.files.iter() {
124 let source = ModuleSource::SourceFile(file_id);
125 if visited.contains(&source) {
126 continue; // TODO: use explicit crate_roots here
127 }
128 assert!(!roots.contains_key(&file_id));
129 let module_id = build_subtree(
130 db,
131 &source_root,
132 &mut tree,
133 &mut visited,
134 &mut roots,
135 None,
136 source,
137 )?;
138 roots.insert(file_id, module_id);
139 }
140 Ok(tree)
141}
142
143fn build_subtree(
144 db: &impl DescriptorDatabase,
145 source_root: &SourceRoot,
146 tree: &mut ModuleTree,
147 visited: &mut FxHashSet<ModuleSource>,
148 roots: &mut FxHashMap<FileId, ModuleId>,
149 parent: Option<LinkId>,
150 source: ModuleSource,
151) -> Cancelable<ModuleId> {
152 visited.insert(source);
153 let id = tree.push_mod(ModuleData {
154 source,
155 parent,
156 children: Vec::new(),
157 });
158 for sub in db.submodules(source)?.iter() {
159 let link = tree.push_link(LinkData {
160 name: sub.name().clone(),
161 owner: id,
162 points_to: Vec::new(),
163 problem: None,
164 });
165
166 let (points_to, problem) = match sub {
167 Submodule::Declaration(name) => {
168 let (points_to, problem) =
169 resolve_submodule(source, &name, &source_root.file_resolver);
170 let points_to = points_to
171 .into_iter()
172 .map(|file_id| match roots.remove(&file_id) {
173 Some(module_id) => {
174 tree.module_mut(module_id).parent = Some(link);
175 Ok(module_id)
176 }
177 None => build_subtree(
178 db,
179 source_root,
180 tree,
181 visited,
182 roots,
183 Some(link),
184 ModuleSource::SourceFile(file_id),
185 ),
186 })
187 .collect::<Cancelable<Vec<_>>>()?;
188 (points_to, problem)
189 }
190 Submodule::Definition(_name, submodule_source) => {
191 let points_to = build_subtree(
192 db,
193 source_root,
194 tree,
195 visited,
196 roots,
197 Some(link),
198 *submodule_source,
199 )?;
200 (vec![points_to], None)
201 }
202 };
203
204 tree.link_mut(link).points_to = points_to;
205 tree.link_mut(link).problem = problem;
206 }
207 Ok(id)
208}
209
210fn resolve_submodule(
211 source: ModuleSource,
212 name: &SmolStr,
213 file_resolver: &FileResolverImp,
214) -> (Vec<FileId>, Option<Problem>) {
215 let file_id = match source {
216 ModuleSource::SourceFile(it) => it,
217 ModuleSource::Module(..) => {
218 // TODO
219 return (Vec::new(), None);
220 }
221 };
222 let mod_name = file_resolver.file_stem(file_id);
223 let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
224
225 let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
226 let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
227 let points_to: Vec<FileId>;
228 let problem: Option<Problem>;
229 if is_dir_owner {
230 points_to = [&file_mod, &dir_mod]
231 .iter()
232 .filter_map(|path| file_resolver.resolve(file_id, path))
233 .collect();
234 problem = if points_to.is_empty() {
235 Some(Problem::UnresolvedModule {
236 candidate: file_mod,
237 })
238 } else {
239 None
240 }
241 } else {
242 points_to = Vec::new();
243 problem = Some(Problem::NotDirOwner {
244 move_to: RelativePathBuf::from(format!("../{}/mod.rs", mod_name)),
245 candidate: file_mod,
246 });
247 }
248 (points_to, problem)
249}
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
deleted file mode 100644
index bc1148b22..000000000
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ /dev/null
@@ -1,236 +0,0 @@
1pub(super) mod imp;
2pub(crate) mod scope;
3
4use ra_syntax::{
5 ast::{self, AstNode, NameOwner},
6 SmolStr, SyntaxNode, SyntaxNodeRef,
7};
8use relative_path::RelativePathBuf;
9
10use crate::{db::SyntaxDatabase, syntax_ptr::SyntaxPtr, FileId};
11
12pub(crate) use self::scope::ModuleScope;
13
14/// Phisically, rust source is organized as a set of files, but logically it is
15/// organized as a tree of modules. Usually, a single file corresponds to a
16/// single module, but it is not nessary the case.
17///
18/// Module encapsulate the logic of transitioning from the fuzzy world of files
19/// (which can have multiple parents) to the precise world of modules (which
20/// always have one parent).
21#[derive(Debug, PartialEq, Eq, Hash)]
22pub(crate) struct ModuleTree {
23 mods: Vec<ModuleData>,
24 links: Vec<LinkData>,
25}
26
27impl ModuleTree {
28 pub(crate) fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
29 self.mods
30 .iter()
31 .enumerate()
32 .filter(|(_idx, it)| it.source == source)
33 .map(|(idx, _)| ModuleId(idx as u32))
34 .collect()
35 }
36
37 pub(crate) fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
38 self.modules_for_source(source).pop()
39 }
40}
41
42/// `ModuleSource` is the syntax tree element that produced this module:
43/// either a file, or an inlinde module.
44#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
45pub(crate) enum ModuleSource {
46 SourceFile(FileId),
47 #[allow(dead_code)]
48 Module(SyntaxPtr),
49}
50
51/// An owned syntax node for a module. Unlike `ModuleSource`,
52/// this holds onto the AST for the whole file.
53enum ModuleSourceNode {
54 SourceFile(ast::SourceFileNode),
55 Module(ast::ModuleNode),
56}
57
58#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
59pub(crate) struct ModuleId(u32);
60
61#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
62pub(crate) struct LinkId(u32);
63
64#[derive(Clone, Debug, Hash, PartialEq, Eq)]
65pub enum Problem {
66 UnresolvedModule {
67 candidate: RelativePathBuf,
68 },
69 NotDirOwner {
70 move_to: RelativePathBuf,
71 candidate: RelativePathBuf,
72 },
73}
74
75impl ModuleId {
76 pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource {
77 tree.module(self).source
78 }
79 pub(crate) fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
80 tree.module(self).parent
81 }
82 pub(crate) fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
83 let link = self.parent_link(tree)?;
84 Some(tree.link(link).owner)
85 }
86 pub(crate) fn root(self, tree: &ModuleTree) -> ModuleId {
87 let mut curr = self;
88 let mut i = 0;
89 while let Some(next) = curr.parent(tree) {
90 curr = next;
91 i += 1;
92 // simplistic cycle detection
93 if i > 100 {
94 return self;
95 }
96 }
97 curr
98 }
99 pub(crate) fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
100 let link = tree
101 .module(self)
102 .children
103 .iter()
104 .map(|&it| tree.link(it))
105 .find(|it| it.name == name)?;
106 Some(*link.points_to.first()?)
107 }
108 pub(crate) fn problems(
109 self,
110 tree: &ModuleTree,
111 db: &impl SyntaxDatabase,
112 ) -> Vec<(SyntaxNode, Problem)> {
113 tree.module(self)
114 .children
115 .iter()
116 .filter_map(|&it| {
117 let p = tree.link(it).problem.clone()?;
118 let s = it.bind_source(tree, db);
119 let s = s.borrowed().name().unwrap().syntax().owned();
120 Some((s, p))
121 })
122 .collect()
123 }
124}
125
126impl LinkId {
127 pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId {
128 tree.link(self).owner
129 }
130 pub(crate) fn bind_source<'a>(
131 self,
132 tree: &ModuleTree,
133 db: &impl SyntaxDatabase,
134 ) -> ast::ModuleNode {
135 let owner = self.owner(tree);
136 match owner.source(tree).resolve(db) {
137 ModuleSourceNode::SourceFile(root) => {
138 let ast = imp::modules(root.borrowed())
139 .find(|(name, _)| name == &tree.link(self).name)
140 .unwrap()
141 .1;
142 ast.owned()
143 }
144 ModuleSourceNode::Module(it) => it,
145 }
146 }
147}
148
149#[derive(Debug, PartialEq, Eq, Hash)]
150struct ModuleData {
151 source: ModuleSource,
152 parent: Option<LinkId>,
153 children: Vec<LinkId>,
154}
155
156impl ModuleSource {
157 pub(crate) fn for_node(file_id: FileId, node: SyntaxNodeRef) -> ModuleSource {
158 for node in node.ancestors() {
159 if let Some(m) = ast::Module::cast(node) {
160 if !m.has_semi() {
161 return ModuleSource::new_inline(file_id, m);
162 }
163 }
164 }
165 ModuleSource::SourceFile(file_id)
166 }
167 pub(crate) fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
168 assert!(!module.has_semi());
169 let ptr = SyntaxPtr::new(file_id, module.syntax());
170 ModuleSource::Module(ptr)
171 }
172
173 pub(crate) fn as_file(self) -> Option<FileId> {
174 match self {
175 ModuleSource::SourceFile(f) => Some(f),
176 ModuleSource::Module(..) => None,
177 }
178 }
179
180 pub(crate) fn file_id(self) -> FileId {
181 match self {
182 ModuleSource::SourceFile(f) => f,
183 ModuleSource::Module(ptr) => ptr.file_id(),
184 }
185 }
186
187 fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
188 match self {
189 ModuleSource::SourceFile(file_id) => {
190 let syntax = db.file_syntax(file_id);
191 ModuleSourceNode::SourceFile(syntax.ast().owned())
192 }
193 ModuleSource::Module(ptr) => {
194 let syntax = db.resolve_syntax_ptr(ptr);
195 let syntax = syntax.borrowed();
196 let module = ast::Module::cast(syntax).unwrap();
197 ModuleSourceNode::Module(module.owned())
198 }
199 }
200 }
201}
202
203#[derive(Hash, Debug, PartialEq, Eq)]
204struct LinkData {
205 owner: ModuleId,
206 name: SmolStr,
207 points_to: Vec<ModuleId>,
208 problem: Option<Problem>,
209}
210
211impl ModuleTree {
212 fn module(&self, id: ModuleId) -> &ModuleData {
213 &self.mods[id.0 as usize]
214 }
215 fn module_mut(&mut self, id: ModuleId) -> &mut ModuleData {
216 &mut self.mods[id.0 as usize]
217 }
218 fn link(&self, id: LinkId) -> &LinkData {
219 &self.links[id.0 as usize]
220 }
221 fn link_mut(&mut self, id: LinkId) -> &mut LinkData {
222 &mut self.links[id.0 as usize]
223 }
224
225 fn push_mod(&mut self, data: ModuleData) -> ModuleId {
226 let id = ModuleId(self.mods.len() as u32);
227 self.mods.push(data);
228 id
229 }
230 fn push_link(&mut self, data: LinkData) -> LinkId {
231 let id = LinkId(self.links.len() as u32);
232 self.mods[data.owner.0 as usize].children.push(id);
233 self.links.push(data);
234 id
235 }
236}
diff --git a/crates/ra_analysis/src/descriptors/module/scope.rs b/crates/ra_analysis/src/descriptors/module/scope.rs
deleted file mode 100644
index 4490228e4..000000000
--- a/crates/ra_analysis/src/descriptors/module/scope.rs
+++ /dev/null
@@ -1,124 +0,0 @@
1//! Backend for module-level scope resolution & completion
2
3use ra_syntax::{ast, AstNode, SmolStr};
4
5use crate::syntax_ptr::LocalSyntaxPtr;
6
7/// `ModuleScope` contains all named items declared in the scope.
8#[derive(Debug, PartialEq, Eq)]
9pub(crate) struct ModuleScope {
10 entries: Vec<Entry>,
11}
12
13/// `Entry` is a single named declaration iside a module.
14#[derive(Debug, PartialEq, Eq)]
15pub(crate) struct Entry {
16 ptr: LocalSyntaxPtr,
17 kind: EntryKind,
18 name: SmolStr,
19}
20
21#[derive(Debug, PartialEq, Eq)]
22enum EntryKind {
23 Item,
24 Import,
25}
26
27impl ModuleScope {
28 pub(super) fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> ModuleScope {
29 let mut entries = Vec::new();
30 for item in items {
31 let entry = match item {
32 ast::ModuleItem::StructDef(item) => Entry::new(item),
33 ast::ModuleItem::EnumDef(item) => Entry::new(item),
34 ast::ModuleItem::FnDef(item) => Entry::new(item),
35 ast::ModuleItem::ConstDef(item) => Entry::new(item),
36 ast::ModuleItem::StaticDef(item) => Entry::new(item),
37 ast::ModuleItem::TraitDef(item) => Entry::new(item),
38 ast::ModuleItem::TypeDef(item) => Entry::new(item),
39 ast::ModuleItem::Module(item) => Entry::new(item),
40 ast::ModuleItem::UseItem(item) => {
41 if let Some(tree) = item.use_tree() {
42 collect_imports(tree, &mut entries);
43 }
44 continue;
45 }
46 ast::ModuleItem::ExternCrateItem(_) | ast::ModuleItem::ImplItem(_) => continue,
47 };
48 entries.extend(entry)
49 }
50
51 ModuleScope { entries }
52 }
53
54 pub fn entries(&self) -> &[Entry] {
55 self.entries.as_slice()
56 }
57}
58
59impl Entry {
60 fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<Entry> {
61 let name = item.name()?;
62 Some(Entry {
63 name: name.text(),
64 ptr: LocalSyntaxPtr::new(name.syntax()),
65 kind: EntryKind::Item,
66 })
67 }
68 fn new_import(path: ast::Path) -> Option<Entry> {
69 let name_ref = path.segment()?.name_ref()?;
70 Some(Entry {
71 name: name_ref.text(),
72 ptr: LocalSyntaxPtr::new(name_ref.syntax()),
73 kind: EntryKind::Import,
74 })
75 }
76 pub fn name(&self) -> &SmolStr {
77 &self.name
78 }
79 pub fn ptr(&self) -> LocalSyntaxPtr {
80 self.ptr
81 }
82}
83
84fn collect_imports(tree: ast::UseTree, acc: &mut Vec<Entry>) {
85 if let Some(use_tree_list) = tree.use_tree_list() {
86 return use_tree_list
87 .use_trees()
88 .for_each(|it| collect_imports(it, acc));
89 }
90 if let Some(path) = tree.path() {
91 acc.extend(Entry::new_import(path));
92 }
93}
94
95#[cfg(test)]
96mod tests {
97 use super::*;
98 use ra_syntax::{ast::ModuleItemOwner, SourceFileNode};
99
100 fn do_check(code: &str, expected: &[&str]) {
101 let file = SourceFileNode::parse(&code);
102 let scope = ModuleScope::new(file.ast().items());
103 let actual = scope.entries.iter().map(|it| it.name()).collect::<Vec<_>>();
104 assert_eq!(expected, actual.as_slice());
105 }
106
107 #[test]
108 fn test_module_scope() {
109 do_check(
110 "
111 struct Foo;
112 enum Bar {}
113 mod baz {}
114 fn quux() {}
115 use x::{
116 y::z,
117 t,
118 };
119 type T = ();
120 ",
121 &["Foo", "Bar", "baz", "quux", "z", "t", "T"],
122 )
123 }
124}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 74c248a96..f5cb3550e 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,91 +1,33 @@
1use std::{ 1use std::{
2 fmt, 2 fmt,
3 hash::{Hash, Hasher},
4 sync::Arc, 3 sync::Arc,
5}; 4};
6 5
7use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit}; 6use ra_editor::{self, find_node_at_offset, FileSymbol, LineIndex, LocalEdit};
8use ra_syntax::{ 7use ra_syntax::{
9 ast::{self, ArgListOwner, Expr, NameOwner}, 8 ast::{self, ArgListOwner, Expr, NameOwner},
10 AstNode, SourceFileNode, SmolStr, 9 AstNode, SourceFileNode,
11 SyntaxKind::*, 10 SyntaxKind::*,
12 SyntaxNodeRef, TextRange, TextUnit, 11 SyntaxNodeRef, TextRange, TextUnit,
13}; 12};
13use ra_db::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE, SyntaxDatabase, SourceFileQuery};
14use rayon::prelude::*; 14use rayon::prelude::*;
15use relative_path::RelativePath;
16use rustc_hash::FxHashSet; 15use rustc_hash::FxHashSet;
17use salsa::{Database, ParallelDatabase}; 16use salsa::{Database, ParallelDatabase};
17use hir::{
18 self,
19 FnSignatureInfo,
20 Problem,
21};
18 22
19use crate::{ 23use crate::{
20 completion::{completions, CompletionItem}, 24 completion::{completions, CompletionItem},
21 db::{self, FileSyntaxQuery, SyntaxDatabase}, 25 db,
22 descriptors::{ 26 symbol_index::{SymbolIndex, SymbolsDatabase},
23 function::{FnDescriptor, FnId}, 27 AnalysisChange, Cancelable, CrateId, Diagnostic, FileId,
24 module::{ModuleSource, ModuleTree, Problem},
25 DeclarationDescriptor, DescriptorDatabase,
26 },
27 input::{FilesDatabase, SourceRoot, SourceRootId, WORKSPACE},
28 symbol_index::SymbolIndex,
29 AnalysisChange, Cancelable, CrateGraph, CrateId, Diagnostic, FileId, FileResolver,
30 FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit, 28 FileSystemEdit, FilePosition, Query, SourceChange, SourceFileNodeEdit,
31}; 29};
32 30
33#[derive(Clone, Debug)]
34pub(crate) struct FileResolverImp {
35 inner: Arc<FileResolver>,
36}
37
38impl PartialEq for FileResolverImp {
39 fn eq(&self, other: &FileResolverImp) -> bool {
40 self.inner() == other.inner()
41 }
42}
43
44impl Eq for FileResolverImp {}
45
46impl Hash for FileResolverImp {
47 fn hash<H: Hasher>(&self, hasher: &mut H) {
48 self.inner().hash(hasher);
49 }
50}
51
52impl FileResolverImp {
53 pub(crate) fn new(inner: Arc<FileResolver>) -> FileResolverImp {
54 FileResolverImp { inner }
55 }
56 pub(crate) fn file_stem(&self, file_id: FileId) -> String {
57 self.inner.file_stem(file_id)
58 }
59 pub(crate) fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId> {
60 self.inner.resolve(file_id, path)
61 }
62 fn inner(&self) -> *const FileResolver {
63 &*self.inner
64 }
65}
66
67impl Default for FileResolverImp {
68 fn default() -> FileResolverImp {
69 #[derive(Debug)]
70 struct DummyResolver;
71 impl FileResolver for DummyResolver {
72 fn file_stem(&self, _file_: FileId) -> String {
73 panic!("file resolver not set")
74 }
75 fn resolve(
76 &self,
77 _file_id: FileId,
78 _path: &::relative_path::RelativePath,
79 ) -> Option<FileId> {
80 panic!("file resolver not set")
81 }
82 }
83 FileResolverImp {
84 inner: Arc::new(DummyResolver),
85 }
86 }
87}
88
89#[derive(Debug, Default)] 31#[derive(Debug, Default)]
90pub(crate) struct AnalysisHostImpl { 32pub(crate) struct AnalysisHostImpl {
91 db: db::RootDatabase, 33 db: db::RootDatabase,
@@ -102,7 +44,7 @@ impl AnalysisHostImpl {
102 44
103 for (file_id, text) in change.files_changed { 45 for (file_id, text) in change.files_changed {
104 self.db 46 self.db
105 .query_mut(crate::input::FileTextQuery) 47 .query_mut(ra_db::FileTextQuery)
106 .set(file_id, Arc::new(text)) 48 .set(file_id, Arc::new(text))
107 } 49 }
108 if !(change.files_added.is_empty() && change.files_removed.is_empty()) { 50 if !(change.files_added.is_empty() && change.files_removed.is_empty()) {
@@ -112,22 +54,22 @@ impl AnalysisHostImpl {
112 let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE)); 54 let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE));
113 for (file_id, text) in change.files_added { 55 for (file_id, text) in change.files_added {
114 self.db 56 self.db
115 .query_mut(crate::input::FileTextQuery) 57 .query_mut(ra_db::FileTextQuery)
116 .set(file_id, Arc::new(text)); 58 .set(file_id, Arc::new(text));
117 self.db 59 self.db
118 .query_mut(crate::input::FileSourceRootQuery) 60 .query_mut(ra_db::FileSourceRootQuery)
119 .set(file_id, crate::input::WORKSPACE); 61 .set(file_id, ra_db::WORKSPACE);
120 source_root.files.insert(file_id); 62 source_root.files.insert(file_id);
121 } 63 }
122 for file_id in change.files_removed { 64 for file_id in change.files_removed {
123 self.db 65 self.db
124 .query_mut(crate::input::FileTextQuery) 66 .query_mut(ra_db::FileTextQuery)
125 .set(file_id, Arc::new(String::new())); 67 .set(file_id, Arc::new(String::new()));
126 source_root.files.remove(&file_id); 68 source_root.files.remove(&file_id);
127 } 69 }
128 source_root.file_resolver = file_resolver; 70 source_root.file_resolver = file_resolver;
129 self.db 71 self.db
130 .query_mut(crate::input::SourceRootQuery) 72 .query_mut(ra_db::SourceRootQuery)
131 .set(WORKSPACE, Arc::new(source_root)) 73 .set(WORKSPACE, Arc::new(source_root))
132 } 74 }
133 if !change.libraries_added.is_empty() { 75 if !change.libraries_added.is_empty() {
@@ -138,11 +80,16 @@ impl AnalysisHostImpl {
138 let mut files = FxHashSet::default(); 80 let mut files = FxHashSet::default();
139 for (file_id, text) in library.files { 81 for (file_id, text) in library.files {
140 files.insert(file_id); 82 files.insert(file_id);
83 log::debug!(
84 "library file: {:?} {:?}",
85 file_id,
86 library.file_resolver.debug_path(file_id)
87 );
141 self.db 88 self.db
142 .query_mut(crate::input::FileSourceRootQuery) 89 .query_mut(ra_db::FileSourceRootQuery)
143 .set_constant(file_id, source_root_id); 90 .set_constant(file_id, source_root_id);
144 self.db 91 self.db
145 .query_mut(crate::input::FileTextQuery) 92 .query_mut(ra_db::FileTextQuery)
146 .set_constant(file_id, Arc::new(text)); 93 .set_constant(file_id, Arc::new(text));
147 } 94 }
148 let source_root = SourceRoot { 95 let source_root = SourceRoot {
@@ -150,19 +97,19 @@ impl AnalysisHostImpl {
150 file_resolver: library.file_resolver, 97 file_resolver: library.file_resolver,
151 }; 98 };
152 self.db 99 self.db
153 .query_mut(crate::input::SourceRootQuery) 100 .query_mut(ra_db::SourceRootQuery)
154 .set(source_root_id, Arc::new(source_root)); 101 .set(source_root_id, Arc::new(source_root));
155 self.db 102 self.db
156 .query_mut(crate::input::LibrarySymbolsQuery) 103 .query_mut(crate::symbol_index::LibrarySymbolsQuery)
157 .set(source_root_id, Arc::new(library.symbol_index)); 104 .set(source_root_id, Arc::new(library.symbol_index));
158 } 105 }
159 self.db 106 self.db
160 .query_mut(crate::input::LibrariesQuery) 107 .query_mut(ra_db::LibrariesQuery)
161 .set((), Arc::new(libraries)); 108 .set((), Arc::new(libraries));
162 } 109 }
163 if let Some(crate_graph) = change.crate_graph { 110 if let Some(crate_graph) = change.crate_graph {
164 self.db 111 self.db
165 .query_mut(crate::input::CrateGraphQuery) 112 .query_mut(ra_db::CrateGraphQuery)
166 .set((), Arc::new(crate_graph)) 113 .set((), Arc::new(crate_graph))
167 } 114 }
168 } 115 }
@@ -181,7 +128,7 @@ impl fmt::Debug for AnalysisImpl {
181 128
182impl AnalysisImpl { 129impl AnalysisImpl {
183 pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode { 130 pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
184 self.db.file_syntax(file_id) 131 self.db.source_file(file_id)
185 } 132 }
186 pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> { 133 pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
187 self.db.file_lines(file_id) 134 self.db.file_lines(file_id)
@@ -212,59 +159,48 @@ impl AnalysisImpl {
212 .collect() 159 .collect()
213 }; 160 };
214 self.db 161 self.db
215 .query(FileSyntaxQuery) 162 .query(SourceFileQuery)
216 .sweep(salsa::SweepStrategy::default().discard_values()); 163 .sweep(salsa::SweepStrategy::default().discard_values());
217 Ok(query.search(&buf)) 164 Ok(query.search(&buf))
218 } 165 }
219 fn module_tree(&self, file_id: FileId) -> Cancelable<Arc<ModuleTree>> { 166 /// This return `Vec`: a module may be included from several places. We
220 let source_root = self.db.file_source_root(file_id); 167 /// don't handle this case yet though, so the Vec has length at most one.
221 self.db.module_tree(source_root)
222 }
223 pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> { 168 pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
224 let module_tree = self.module_tree(position.file_id)?; 169 let descr = match hir::Module::guess_from_position(&*self.db, position)? {
225 let file = self.db.file_syntax(position.file_id); 170 None => return Ok(Vec::new()),
226 let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset) 171 Some(it) => it,
227 {
228 Some(m) if !m.has_semi() => ModuleSource::new_inline(position.file_id, m),
229 _ => ModuleSource::SourceFile(position.file_id),
230 }; 172 };
231 173 let (file_id, decl) = match descr.parent_link_source(&*self.db) {
232 let res = module_tree 174 None => return Ok(Vec::new()),
233 .modules_for_source(module_source) 175 Some(it) => it,
234 .into_iter() 176 };
235 .filter_map(|module_id| { 177 let decl = decl.borrowed();
236 let link = module_id.parent_link(&module_tree)?; 178 let decl_name = decl.name().unwrap();
237 let file_id = link.owner(&module_tree).source(&module_tree).file_id(); 179 let sym = FileSymbol {
238 let decl = link.bind_source(&module_tree, &*self.db); 180 name: decl_name.text(),
239 let decl = decl.borrowed(); 181 node_range: decl_name.syntax().range(),
240 182 kind: MODULE,
241 let decl_name = decl.name().unwrap(); 183 };
242 184 Ok(vec![(file_id, sym)])
243 let sym = FileSymbol {
244 name: decl_name.text(),
245 node_range: decl_name.syntax().range(),
246 kind: MODULE,
247 };
248 Some((file_id, sym))
249 })
250 .collect();
251 Ok(res)
252 } 185 }
186 /// Returns `Vec` for the same reason as `parent_module`
253 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> { 187 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
254 let module_tree = self.module_tree(file_id)?; 188 let descr = match hir::Module::guess_from_file_id(&*self.db, file_id)? {
255 let crate_graph = self.db.crate_graph(); 189 None => return Ok(Vec::new()),
256 let res = module_tree 190 Some(it) => it,
257 .modules_for_source(ModuleSource::SourceFile(file_id)) 191 };
258 .into_iter() 192 let root = descr.crate_root();
259 .map(|it| it.root(&module_tree)) 193 let file_id = root
260 .filter_map(|it| it.source(&module_tree).as_file()) 194 .source()
261 .filter_map(|it| crate_graph.crate_id_for_crate_root(it)) 195 .as_file()
262 .collect(); 196 .expect("root module always has a file as a source");
263 197
264 Ok(res) 198 let crate_graph = self.db.crate_graph();
199 let crate_id = crate_graph.crate_id_for_crate_root(file_id);
200 Ok(crate_id.into_iter().collect())
265 } 201 }
266 pub fn crate_root(&self, crate_id: CrateId) -> FileId { 202 pub fn crate_root(&self, crate_id: CrateId) -> FileId {
267 self.db.crate_graph().crate_roots[&crate_id] 203 self.db.crate_graph().crate_root(crate_id)
268 } 204 }
269 pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> { 205 pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
270 completions(&self.db, position) 206 completions(&self.db, position)
@@ -273,51 +209,51 @@ impl AnalysisImpl {
273 &self, 209 &self,
274 position: FilePosition, 210 position: FilePosition,
275 ) -> Cancelable<Vec<(FileId, FileSymbol)>> { 211 ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
276 let module_tree = self.module_tree(position.file_id)?; 212 let file = self.db.source_file(position.file_id);
277 let file = self.db.file_syntax(position.file_id);
278 let syntax = file.syntax(); 213 let syntax = file.syntax();
279 if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) { 214 if let Some(name_ref) = find_node_at_offset::<ast::NameRef>(syntax, position.offset) {
280 // First try to resolve the symbol locally 215 if let Some(fn_descr) =
281 return if let Some((name, range)) = 216 hir::Function::guess_for_name_ref(&*self.db, position.file_id, name_ref)
282 resolve_local_name(&self.db, position.file_id, name_ref)
283 { 217 {
284 let mut vec = vec![]; 218 let scope = fn_descr.scope(&*self.db);
285 vec.push(( 219 // First try to resolve the symbol locally
286 position.file_id, 220 return if let Some(entry) = scope.resolve_local_name(name_ref) {
287 FileSymbol { 221 let mut vec = vec![];
288 name, 222 vec.push((
289 node_range: range, 223 position.file_id,
290 kind: NAME, 224 FileSymbol {
291 }, 225 name: entry.name().clone(),
292 )); 226 node_range: entry.ptr().range(),
293 Ok(vec) 227 kind: NAME,
294 } else { 228 },
295 // If that fails try the index based approach. 229 ));
296 self.index_resolve(name_ref) 230 Ok(vec)
297 }; 231 } else {
232 // If that fails try the index based approach.
233 self.index_resolve(name_ref)
234 };
235 }
298 } 236 }
299 if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) { 237 if let Some(name) = find_node_at_offset::<ast::Name>(syntax, position.offset) {
300 if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) { 238 if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
301 if module.has_semi() { 239 if module.has_semi() {
302 let file_ids = self.resolve_module(&*module_tree, position.file_id, module); 240 let parent_module =
303 241 hir::Module::guess_from_file_id(&*self.db, position.file_id)?;
304 let res = file_ids 242 let child_name = module.name();
305 .into_iter() 243 match (parent_module, child_name) {
306 .map(|id| { 244 (Some(parent_module), Some(child_name)) => {
307 let name = module 245 if let Some(child) = parent_module.child(&child_name.text()) {
308 .name() 246 let file_id = child.source().file_id();
309 .map(|n| n.text()) 247 let symbol = FileSymbol {
310 .unwrap_or_else(|| SmolStr::new("")); 248 name: child_name.text(),
311 let symbol = FileSymbol { 249 node_range: TextRange::offset_len(0.into(), 0.into()),
312 name, 250 kind: MODULE,
313 node_range: TextRange::offset_len(0.into(), 0.into()), 251 };
314 kind: MODULE, 252 return Ok(vec![(file_id, symbol)]);
315 }; 253 }
316 (id, symbol) 254 }
317 }) 255 _ => (),
318 .collect(); 256 }
319
320 return Ok(res);
321 } 257 }
322 } 258 }
323 } 259 }
@@ -325,32 +261,42 @@ impl AnalysisImpl {
325 } 261 }
326 262
327 pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> { 263 pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
328 let file = self.db.file_syntax(position.file_id); 264 let file = self.db.source_file(position.file_id);
329 let syntax = file.syntax();
330
331 // Find the binding associated with the offset 265 // Find the binding associated with the offset
332 let maybe_binding = 266 let (binding, descr) = match find_binding(&self.db, &file, position) {
333 find_node_at_offset::<ast::BindPat>(syntax, position.offset).or_else(|| {
334 let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
335 let resolved = resolve_local_name(&self.db, position.file_id, name_ref)?;
336 find_node_at_offset::<ast::BindPat>(syntax, resolved.1.end())
337 });
338
339 let binding = match maybe_binding {
340 None => return Vec::new(), 267 None => return Vec::new(),
341 Some(it) => it, 268 Some(it) => it,
342 }; 269 };
343 270
344 let decl = DeclarationDescriptor::new(binding); 271 let mut ret = vec![(position.file_id, binding.syntax().range())];
345
346 let mut ret = vec![(position.file_id, decl.range)];
347 ret.extend( 272 ret.extend(
348 decl.find_all_refs() 273 descr
274 .scope(&*self.db)
275 .find_all_refs(binding)
349 .into_iter() 276 .into_iter()
350 .map(|ref_desc| (position.file_id, ref_desc.range)), 277 .map(|ref_desc| (position.file_id, ref_desc.range)),
351 ); 278 );
352 279
353 ret 280 return ret;
281
282 fn find_binding<'a>(
283 db: &db::RootDatabase,
284 source_file: &'a SourceFileNode,
285 position: FilePosition,
286 ) -> Option<(ast::BindPat<'a>, hir::Function)> {
287 let syntax = source_file.syntax();
288 if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
289 let descr = hir::Function::guess_for_bind_pat(db, position.file_id, binding)?;
290 return Some((binding, descr));
291 };
292 let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
293 let descr = hir::Function::guess_for_name_ref(db, position.file_id, name_ref)?;
294 let scope = descr.scope(db);
295 let resolved = scope.resolve_local_name(name_ref)?;
296 let resolved = resolved.ptr().resolve(source_file);
297 let binding = find_node_at_offset::<ast::BindPat>(syntax, resolved.range().end())?;
298 Some((binding, descr))
299 }
354 } 300 }
355 301
356 pub fn doc_comment_for( 302 pub fn doc_comment_for(
@@ -358,14 +304,13 @@ impl AnalysisImpl {
358 file_id: FileId, 304 file_id: FileId,
359 symbol: FileSymbol, 305 symbol: FileSymbol,
360 ) -> Cancelable<Option<String>> { 306 ) -> Cancelable<Option<String>> {
361 let file = self.db.file_syntax(file_id); 307 let file = self.db.source_file(file_id);
362 308
363 Ok(symbol.docs(&file)) 309 Ok(symbol.docs(&file))
364 } 310 }
365 311
366 pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> { 312 pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
367 let module_tree = self.module_tree(file_id)?; 313 let syntax = self.db.source_file(file_id);
368 let syntax = self.db.file_syntax(file_id);
369 314
370 let mut res = ra_editor::diagnostics(&syntax) 315 let mut res = ra_editor::diagnostics(&syntax)
371 .into_iter() 316 .into_iter()
@@ -375,8 +320,8 @@ impl AnalysisImpl {
375 fix: None, 320 fix: None,
376 }) 321 })
377 .collect::<Vec<_>>(); 322 .collect::<Vec<_>>();
378 if let Some(m) = module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) { 323 if let Some(m) = hir::Module::guess_from_file_id(&*self.db, file_id)? {
379 for (name_node, problem) in m.problems(&module_tree, &*self.db) { 324 for (name_node, problem) in m.problems(&*self.db) {
380 let diag = match problem { 325 let diag = match problem {
381 Problem::UnresolvedModule { candidate } => { 326 Problem::UnresolvedModule { candidate } => {
382 let create_file = FileSystemEdit::CreateFile { 327 let create_file = FileSystemEdit::CreateFile {
@@ -452,27 +397,22 @@ impl AnalysisImpl {
452 pub fn resolve_callable( 397 pub fn resolve_callable(
453 &self, 398 &self,
454 position: FilePosition, 399 position: FilePosition,
455 ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> { 400 ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
456 let file = self.db.file_syntax(position.file_id); 401 let file = self.db.source_file(position.file_id);
457 let syntax = file.syntax(); 402 let syntax = file.syntax();
458 403
459 // Find the calling expression and it's NameRef 404 // Find the calling expression and it's NameRef
460 let calling_node = match FnCallNode::with_node(syntax, position.offset) { 405 let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
461 Some(node) => node, 406 let name_ref = ctry!(calling_node.name_ref());
462 None => return Ok(None),
463 };
464 let name_ref = match calling_node.name_ref() {
465 Some(name) => name,
466 None => return Ok(None),
467 };
468 407
469 // Resolve the function's NameRef (NOTE: this isn't entirely accurate). 408 // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
470 let file_symbols = self.index_resolve(name_ref)?; 409 let file_symbols = self.index_resolve(name_ref)?;
471 for (fn_fiel_id, fs) in file_symbols { 410 for (fn_file_id, fs) in file_symbols {
472 if fs.kind == FN_DEF { 411 if fs.kind == FN_DEF {
473 let fn_file = self.db.file_syntax(fn_fiel_id); 412 let fn_file = self.db.source_file(fn_file_id);
474 if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) { 413 if let Some(fn_def) = find_node_at_offset(fn_file.syntax(), fs.node_range.start()) {
475 if let Some(descriptor) = FnDescriptor::new(fn_def) { 414 let descr = hir::Function::guess_from_source(&*self.db, fn_file_id, fn_def);
415 if let Some(descriptor) = descr.signature_info(&*self.db) {
476 // If we have a calling expression let's find which argument we are on 416 // If we have a calling expression let's find which argument we are on
477 let mut current_parameter = None; 417 let mut current_parameter = None;
478 418
@@ -526,27 +466,6 @@ impl AnalysisImpl {
526 query.limit(4); 466 query.limit(4);
527 self.world_symbols(query) 467 self.world_symbols(query)
528 } 468 }
529
530 fn resolve_module(
531 &self,
532 module_tree: &ModuleTree,
533 file_id: FileId,
534 module: ast::Module,
535 ) -> Vec<FileId> {
536 let name = match module.name() {
537 Some(name) => name.text(),
538 None => return Vec::new(),
539 };
540 let module_id = match module_tree.any_module_for_source(ModuleSource::SourceFile(file_id)) {
541 Some(id) => id,
542 None => return Vec::new(),
543 };
544 module_id
545 .child(module_tree, name.as_str())
546 .and_then(|it| it.source(&module_tree).as_file())
547 .into_iter()
548 .collect()
549 }
550} 469}
551 470
552impl SourceChange { 471impl SourceChange {
@@ -566,16 +485,6 @@ impl SourceChange {
566 } 485 }
567} 486}
568 487
569impl CrateGraph {
570 fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
571 let (&crate_id, _) = self
572 .crate_roots
573 .iter()
574 .find(|(_crate_id, &root_id)| root_id == file_id)?;
575 Some(crate_id)
576 }
577}
578
579enum FnCallNode<'a> { 488enum FnCallNode<'a> {
580 CallExpr(ast::CallExpr<'a>), 489 CallExpr(ast::CallExpr<'a>),
581 MethodCallExpr(ast::MethodCallExpr<'a>), 490 MethodCallExpr(ast::MethodCallExpr<'a>),
@@ -614,16 +523,3 @@ impl<'a> FnCallNode<'a> {
614 } 523 }
615 } 524 }
616} 525}
617
618fn resolve_local_name(
619 db: &db::RootDatabase,
620 file_id: FileId,
621 name_ref: ast::NameRef,
622) -> Option<(SmolStr, TextRange)> {
623 let fn_def = name_ref.syntax().ancestors().find_map(ast::FnDef::cast)?;
624 let fn_id = FnId::new(file_id, fn_def);
625 let scopes = db.fn_scopes(fn_id);
626 let scope_entry = crate::descriptors::function::resolve_local_name(name_ref, &scopes)?;
627 let syntax = db.resolve_syntax_ptr(scope_entry.ptr().into_global(file_id));
628 Some((scope_entry.name().clone(), syntax.range()))
629}
diff --git a/crates/ra_analysis/src/input.rs b/crates/ra_analysis/src/input.rs
deleted file mode 100644
index ba8a17fd5..000000000
--- a/crates/ra_analysis/src/input.rs
+++ /dev/null
@@ -1,76 +0,0 @@
1use std::{fmt, sync::Arc};
2
3use relative_path::RelativePath;
4use rustc_hash::FxHashMap;
5use rustc_hash::FxHashSet;
6use salsa;
7
8use crate::{symbol_index::SymbolIndex, FileResolverImp};
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
11pub struct FileId(pub u32);
12
13#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
14pub struct CrateId(pub u32);
15
16#[derive(Debug, Clone, Default, PartialEq, Eq)]
17pub struct CrateGraph {
18 pub(crate) crate_roots: FxHashMap<CrateId, FileId>,
19}
20
21impl CrateGraph {
22 pub fn new() -> CrateGraph {
23 CrateGraph::default()
24 }
25 pub fn add_crate_root(&mut self, file_id: FileId) -> CrateId {
26 let crate_id = CrateId(self.crate_roots.len() as u32);
27 let prev = self.crate_roots.insert(crate_id, file_id);
28 assert!(prev.is_none());
29 crate_id
30 }
31}
32
33pub trait FileResolver: fmt::Debug + Send + Sync + 'static {
34 fn file_stem(&self, file_id: FileId) -> String;
35 fn resolve(&self, file_id: FileId, path: &RelativePath) -> Option<FileId>;
36}
37
38salsa::query_group! {
39 pub(crate) trait FilesDatabase: salsa::Database {
40 fn file_text(file_id: FileId) -> Arc<String> {
41 type FileTextQuery;
42 storage input;
43 }
44 fn file_source_root(file_id: FileId) -> SourceRootId {
45 type FileSourceRootQuery;
46 storage input;
47 }
48 fn source_root(id: SourceRootId) -> Arc<SourceRoot> {
49 type SourceRootQuery;
50 storage input;
51 }
52 fn libraries() -> Arc<Vec<SourceRootId>> {
53 type LibrariesQuery;
54 storage input;
55 }
56 fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
57 type LibrarySymbolsQuery;
58 storage input;
59 }
60 fn crate_graph() -> Arc<CrateGraph> {
61 type CrateGraphQuery;
62 storage input;
63 }
64 }
65}
66
67#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
68pub(crate) struct SourceRootId(pub(crate) u32);
69
70#[derive(Default, Clone, Debug, PartialEq, Eq)]
71pub(crate) struct SourceRoot {
72 pub(crate) file_resolver: FileResolverImp,
73 pub(crate) files: FxHashSet<FileId>,
74}
75
76pub(crate) const WORKSPACE: SourceRootId = SourceRootId(0);
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index ad0273edc..12df580ba 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -1,5 +1,5 @@
1//! ra_analyzer crate is the brain of Rust analyzer. It relies on the `salsa` 1//! ra_analyzer crate is the brain of Rust analyzer. It relies on the `salsa`
2//! crate, which provides and incremental on-deman database of facts. 2//! crate, which provides and incremental on-demand database of facts.
3 3
4extern crate fst; 4extern crate fst;
5extern crate ra_editor; 5extern crate ra_editor;
@@ -9,47 +9,45 @@ extern crate relative_path;
9extern crate rustc_hash; 9extern crate rustc_hash;
10extern crate salsa; 10extern crate salsa;
11 11
12macro_rules! ctry {
13 ($expr:expr) => {
14 match $expr {
15 None => return Ok(None),
16 Some(it) => it,
17 }
18 };
19}
20
12mod db; 21mod db;
13mod input;
14mod imp; 22mod imp;
15mod completion; 23mod completion;
16mod descriptors;
17mod symbol_index; 24mod symbol_index;
18mod syntax_ptr;
19pub mod mock_analysis; 25pub mod mock_analysis;
20 26
21use std::{fmt, sync::Arc}; 27use std::{fmt, sync::Arc};
22 28
23use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit}; 29use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit};
30use ra_db::FileResolverImp;
24use rayon::prelude::*; 31use rayon::prelude::*;
25use relative_path::RelativePathBuf; 32use relative_path::RelativePathBuf;
26 33
27use crate::{ 34use crate::{
28 imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp}, 35 imp::{AnalysisHostImpl, AnalysisImpl},
29 symbol_index::SymbolIndex, 36 symbol_index::SymbolIndex,
30}; 37};
31 38
32pub use crate::{ 39pub use crate::{
33 completion::CompletionItem, 40 completion::CompletionItem,
34 descriptors::function::FnDescriptor,
35 input::{CrateGraph, CrateId, FileId, FileResolver},
36}; 41};
37pub use ra_editor::{ 42pub use ra_editor::{
38 FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode, 43 FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
39}; 44};
45pub use hir::FnSignatureInfo;
40 46
41#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] 47pub use ra_db::{
42pub struct Canceled; 48 Canceled, Cancelable, FilePosition,
43 49 CrateGraph, CrateId, FileId, FileResolver
44pub type Cancelable<T> = Result<T, Canceled>; 50};
45
46impl std::fmt::Display for Canceled {
47 fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
48 fmt.write_str("Canceled")
49 }
50}
51
52impl std::error::Error for Canceled {}
53 51
54#[derive(Default)] 52#[derive(Default)]
55pub struct AnalysisChange { 53pub struct AnalysisChange {
@@ -119,12 +117,6 @@ impl AnalysisHost {
119 } 117 }
120} 118}
121 119
122#[derive(Clone, Copy, Debug)]
123pub struct FilePosition {
124 pub file_id: FileId,
125 pub offset: TextUnit,
126}
127
128#[derive(Debug)] 120#[derive(Debug)]
129pub struct SourceChange { 121pub struct SourceChange {
130 pub label: String, 122 pub label: String,
@@ -294,7 +286,7 @@ impl Analysis {
294 pub fn resolve_callable( 286 pub fn resolve_callable(
295 &self, 287 &self,
296 position: FilePosition, 288 position: FilePosition,
297 ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> { 289 ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
298 self.imp.resolve_callable(position) 290 self.imp.resolve_callable(position)
299 } 291 }
300} 292}
diff --git a/crates/ra_analysis/src/mock_analysis.rs b/crates/ra_analysis/src/mock_analysis.rs
index 8e8f969f4..0d9a7a147 100644
--- a/crates/ra_analysis/src/mock_analysis.rs
+++ b/crates/ra_analysis/src/mock_analysis.rs
@@ -1,9 +1,10 @@
1use std::sync::Arc; 1use std::sync::Arc;
2 2
3use relative_path::{RelativePath, RelativePathBuf}; 3use relative_path::{RelativePathBuf};
4use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER}; 4use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER};
5use ra_db::mock::FileMap;
5 6
6use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FileResolver, FilePosition}; 7use crate::{Analysis, AnalysisChange, AnalysisHost, FileId, FilePosition};
7 8
8/// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis 9/// Mock analysis is used in test to bootstrap an AnalysisHost/Analysis
9/// from a set of in-memory files. 10/// from a set of in-memory files.
@@ -76,16 +77,15 @@ impl MockAnalysis {
76 } 77 }
77 pub fn analysis_host(self) -> AnalysisHost { 78 pub fn analysis_host(self) -> AnalysisHost {
78 let mut host = AnalysisHost::default(); 79 let mut host = AnalysisHost::default();
79 let mut file_map = Vec::new(); 80 let mut file_map = FileMap::default();
80 let mut change = AnalysisChange::new(); 81 let mut change = AnalysisChange::new();
81 for (id, (path, contents)) in self.files.into_iter().enumerate() { 82 for (path, contents) in self.files.into_iter() {
82 let file_id = FileId((id + 1) as u32);
83 assert!(path.starts_with('/')); 83 assert!(path.starts_with('/'));
84 let path = RelativePathBuf::from_path(&path[1..]).unwrap(); 84 let path = RelativePathBuf::from_path(&path[1..]).unwrap();
85 let file_id = file_map.add(path);
85 change.add_file(file_id, contents); 86 change.add_file(file_id, contents);
86 file_map.push((file_id, path));
87 } 87 }
88 change.set_file_resolver(Arc::new(FileMap(file_map))); 88 change.set_file_resolver(Arc::new(file_map));
89 host.apply_change(change); 89 host.apply_change(change);
90 host 90 host
91 } 91 }
@@ -113,29 +113,3 @@ pub fn single_file_with_position(code: &str) -> (Analysis, FilePosition) {
113 let pos = mock.add_file_with_position("/main.rs", code); 113 let pos = mock.add_file_with_position("/main.rs", code);
114 (mock.analysis(), pos) 114 (mock.analysis(), pos)
115} 115}
116
117#[derive(Debug)]
118struct FileMap(Vec<(FileId, RelativePathBuf)>);
119
120impl FileMap {
121 fn iter<'a>(&'a self) -> impl Iterator<Item = (FileId, &'a RelativePath)> + 'a {
122 self.0
123 .iter()
124 .map(|(id, path)| (*id, path.as_relative_path()))
125 }
126
127 fn path(&self, id: FileId) -> &RelativePath {
128 self.iter().find(|&(it, _)| it == id).unwrap().1
129 }
130}
131
132impl FileResolver for FileMap {
133 fn file_stem(&self, id: FileId) -> String {
134 self.path(id).file_stem().unwrap().to_string()
135 }
136 fn resolve(&self, id: FileId, rel: &RelativePath) -> Option<FileId> {
137 let path = self.path(id).join(rel).normalize();
138 let id = self.iter().find(|&(_, p)| path == p)?.0;
139 Some(id)
140 }
141}
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index 3a0667ecd..b48a37229 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -4,14 +4,36 @@ use std::{
4}; 4};
5 5
6use fst::{self, Streamer}; 6use fst::{self, Streamer};
7use ra_editor::{file_symbols, FileSymbol}; 7use ra_editor::{self, FileSymbol};
8use ra_syntax::{ 8use ra_syntax::{
9 SourceFileNode, 9 SourceFileNode,
10 SyntaxKind::{self, *}, 10 SyntaxKind::{self, *},
11}; 11};
12use ra_db::{SyntaxDatabase, SourceRootId};
12use rayon::prelude::*; 13use rayon::prelude::*;
13 14
14use crate::{FileId, Query}; 15use crate::{
16 Cancelable,
17 FileId, Query,
18};
19
20salsa::query_group! {
21 pub(crate) trait SymbolsDatabase: SyntaxDatabase {
22 fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
23 type FileSymbolsQuery;
24 }
25 fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
26 type LibrarySymbolsQuery;
27 storage input;
28 }
29 }
30}
31
32fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
33 db.check_canceled()?;
34 let syntax = db.source_file(file_id);
35 Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
36}
15 37
16#[derive(Default, Debug)] 38#[derive(Default, Debug)]
17pub(crate) struct SymbolIndex { 39pub(crate) struct SymbolIndex {
@@ -39,7 +61,7 @@ impl SymbolIndex {
39 ) -> SymbolIndex { 61 ) -> SymbolIndex {
40 let mut symbols = files 62 let mut symbols = files
41 .flat_map(|(file_id, file)| { 63 .flat_map(|(file_id, file)| {
42 file_symbols(&file) 64 ra_editor::file_symbols(&file)
43 .into_iter() 65 .into_iter()
44 .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol))) 66 .map(move |symbol| (symbol.name.as_str().to_lowercase(), (file_id, symbol)))
45 .collect::<Vec<_>>() 67 .collect::<Vec<_>>()
diff --git a/crates/ra_analysis/src/syntax_ptr.rs b/crates/ra_analysis/src/syntax_ptr.rs
deleted file mode 100644
index 194b94584..000000000
--- a/crates/ra_analysis/src/syntax_ptr.rs
+++ /dev/null
@@ -1,84 +0,0 @@
1use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
2
3use crate::db::SyntaxDatabase;
4use crate::FileId;
5
6pub(crate) fn resolve_syntax_ptr(db: &impl SyntaxDatabase, ptr: SyntaxPtr) -> SyntaxNode {
7 let syntax = db.file_syntax(ptr.file_id);
8 ptr.local.resolve(&syntax)
9}
10
11/// SyntaxPtr is a cheap `Copy` id which identifies a particular syntax node,
12/// without retaining syntax tree in memory. You need to explicitly `resolve`
13/// `SyntaxPtr` to get a `SyntaxNode`
14#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
15pub(crate) struct SyntaxPtr {
16 file_id: FileId,
17 local: LocalSyntaxPtr,
18}
19
20impl SyntaxPtr {
21 pub(crate) fn new(file_id: FileId, node: SyntaxNodeRef) -> SyntaxPtr {
22 let local = LocalSyntaxPtr::new(node);
23 SyntaxPtr { file_id, local }
24 }
25
26 pub(crate) fn file_id(self) -> FileId {
27 self.file_id
28 }
29}
30
31/// A pionter to a syntax node inside a file.
32#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
33pub(crate) struct LocalSyntaxPtr {
34 range: TextRange,
35 kind: SyntaxKind,
36}
37
38impl LocalSyntaxPtr {
39 pub(crate) fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
40 LocalSyntaxPtr {
41 range: node.range(),
42 kind: node.kind(),
43 }
44 }
45
46 pub(crate) fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
47 let mut curr = file.syntax();
48 loop {
49 if curr.range() == self.range && curr.kind() == self.kind {
50 return curr.owned();
51 }
52 curr = curr
53 .children()
54 .find(|it| self.range.is_subrange(&it.range()))
55 .unwrap_or_else(|| panic!("can't resolve local ptr to SyntaxNode: {:?}", self))
56 }
57 }
58
59 pub(crate) fn into_global(self, file_id: FileId) -> SyntaxPtr {
60 SyntaxPtr {
61 file_id,
62 local: self,
63 }
64 }
65
66 // Seems unfortunate to expose
67 pub(crate) fn range(self) -> TextRange {
68 self.range
69 }
70}
71
72#[test]
73fn test_local_syntax_ptr() {
74 use ra_syntax::{ast, AstNode};
75 let file = SourceFileNode::parse("struct Foo { f: u32, }");
76 let field = file
77 .syntax()
78 .descendants()
79 .find_map(ast::NamedFieldDef::cast)
80 .unwrap();
81 let ptr = LocalSyntaxPtr::new(field.syntax());
82 let field_syntax = ptr.resolve(&file);
83 assert_eq!(field.syntax(), field_syntax);
84}
diff --git a/crates/ra_analysis/tests/tests.rs b/crates/ra_analysis/tests/tests.rs
index 719c166b5..fbe89f444 100644
--- a/crates/ra_analysis/tests/tests.rs
+++ b/crates/ra_analysis/tests/tests.rs
@@ -10,10 +10,10 @@ use test_utils::assert_eq_dbg;
10 10
11use ra_analysis::{ 11use ra_analysis::{
12 mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis}, 12 mock_analysis::{analysis_and_position, single_file, single_file_with_position, MockAnalysis},
13 AnalysisChange, CrateGraph, FileId, FnDescriptor, 13 AnalysisChange, CrateGraph, FileId, FnSignatureInfo,
14}; 14};
15 15
16fn get_signature(text: &str) -> (FnDescriptor, Option<usize>) { 16fn get_signature(text: &str) -> (FnSignatureInfo, Option<usize>) {
17 let (analysis, position) = single_file_with_position(text); 17 let (analysis, position) = single_file_with_position(text);
18 analysis.resolve_callable(position).unwrap().unwrap() 18 analysis.resolve_callable(position).unwrap().unwrap()
19} 19}
@@ -126,7 +126,7 @@ fn test_resolve_crate_root() {
126 let mut host = mock.analysis_host(); 126 let mut host = mock.analysis_host();
127 assert!(host.analysis().crate_for(mod_file).unwrap().is_empty()); 127 assert!(host.analysis().crate_for(mod_file).unwrap().is_empty());
128 128
129 let mut crate_graph = CrateGraph::new(); 129 let mut crate_graph = CrateGraph::default();
130 let crate_id = crate_graph.add_crate_root(root_file); 130 let crate_id = crate_graph.add_crate_root(root_file);
131 let mut change = AnalysisChange::new(); 131 let mut change = AnalysisChange::new();
132 change.set_crate_graph(crate_graph); 132 change.set_crate_graph(crate_graph);
@@ -447,8 +447,8 @@ fn test_complete_crate_path() {
447 ); 447 );
448 let completions = analysis.completions(position).unwrap().unwrap(); 448 let completions = analysis.completions(position).unwrap().unwrap();
449 assert_eq_dbg( 449 assert_eq_dbg(
450 r#"[CompletionItem { label: "foo", lookup: None, snippet: None }, 450 r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
451 CompletionItem { label: "Spam", lookup: None, snippet: None }]"#, 451 CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
452 &completions, 452 &completions,
453 ); 453 );
454} 454}
@@ -466,8 +466,8 @@ fn test_complete_crate_path_with_braces() {
466 ); 466 );
467 let completions = analysis.completions(position).unwrap().unwrap(); 467 let completions = analysis.completions(position).unwrap().unwrap();
468 assert_eq_dbg( 468 assert_eq_dbg(
469 r#"[CompletionItem { label: "foo", lookup: None, snippet: None }, 469 r#"[CompletionItem { label: "Spam", lookup: None, snippet: None },
470 CompletionItem { label: "Spam", lookup: None, snippet: None }]"#, 470 CompletionItem { label: "foo", lookup: None, snippet: None }]"#,
471 &completions, 471 &completions,
472 ); 472 );
473} 473}
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-03 02:20:22 +0100