aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_analysis
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_analysis')
-rw-r--r--crates/ra_analysis/Cargo.toml2
-rw-r--r--crates/ra_analysis/src/arena.rs96
-rw-r--r--crates/ra_analysis/src/completion/mod.rs13
-rw-r--r--crates/ra_analysis/src/completion/reference_completion.rs44
-rw-r--r--crates/ra_analysis/src/db.rs164
-rw-r--r--crates/ra_analysis/src/descriptors/function/imp.rs21
-rw-r--r--crates/ra_analysis/src/descriptors/function/mod.rs137
-rw-r--r--crates/ra_analysis/src/descriptors/function/scope.rs424
-rw-r--r--crates/ra_analysis/src/descriptors/mod.rs101
-rw-r--r--crates/ra_analysis/src/descriptors/module/imp.rs229
-rw-r--r--crates/ra_analysis/src/descriptors/module/mod.rs344
-rw-r--r--crates/ra_analysis/src/descriptors/module/nameres.rs461
-rw-r--r--crates/ra_analysis/src/descriptors/path.rs153
-rw-r--r--crates/ra_analysis/src/imp.rs248
-rw-r--r--crates/ra_analysis/src/input.rs79
-rw-r--r--crates/ra_analysis/src/lib.rs44
-rw-r--r--crates/ra_analysis/src/loc2id.rs138
-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.rs6
21 files changed, 212 insertions, 2644 deletions
diff --git a/crates/ra_analysis/Cargo.toml b/crates/ra_analysis/Cargo.toml
index b4a1a09b5..fe9765a66 100644
--- a/crates/ra_analysis/Cargo.toml
+++ b/crates/ra_analysis/Cargo.toml
@@ -14,4 +14,6 @@ rustc-hash = "1.0"
14parking_lot = "0.6.4" 14parking_lot = "0.6.4"
15ra_syntax = { path = "../ra_syntax" } 15ra_syntax = { path = "../ra_syntax" }
16ra_editor = { path = "../ra_editor" } 16ra_editor = { path = "../ra_editor" }
17ra_db = { path = "../ra_db" }
18hir = { path = "../ra_hir", package = "ra_hir" }
17test_utils = { path = "../test_utils" } 19test_utils = { path = "../test_utils" }
diff --git a/crates/ra_analysis/src/arena.rs b/crates/ra_analysis/src/arena.rs
deleted file mode 100644
index 98ed89274..000000000
--- a/crates/ra_analysis/src/arena.rs
+++ /dev/null
@@ -1,96 +0,0 @@
1//! A simple id-based arena, similar to https://github.com/fitzgen/id-arena.
2//! We use our own version for more compact id's and to allow inherent impls
3//! on Ids.
4
5use std::{
6 fmt,
7 ops::{Index, IndexMut},
8 hash::{Hash, Hasher},
9 marker::PhantomData,
10};
11
12pub(crate) struct Id<T> {
13 idx: u32,
14 _ty: PhantomData<fn() -> T>,
15}
16
17impl<T> fmt::Debug for Id<T> {
18 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
19 f.debug_tuple("Id").field(&self.idx).finish()
20 }
21}
22impl<T> Copy for Id<T> {}
23impl<T> Clone for Id<T> {
24 fn clone(&self) -> Id<T> {
25 *self
26 }
27}
28
29impl<T> PartialEq for Id<T> {
30 fn eq(&self, other: &Id<T>) -> bool {
31 self.idx == other.idx
32 }
33}
34
35impl<T> Eq for Id<T> {}
36
37impl<T> Hash for Id<T> {
38 fn hash<H: Hasher>(&self, h: &mut H) {
39 self.idx.hash(h);
40 }
41}
42
43#[derive(Debug, PartialEq, Eq)]
44pub(crate) struct Arena<T> {
45 data: Vec<T>,
46}
47
48impl<T> Default for Arena<T> {
49 fn default() -> Arena<T> {
50 Arena { data: Vec::new() }
51 }
52}
53
54impl<T> Arena<T> {
55 pub(crate) fn push(&mut self, value: T) -> Id<T> {
56 let id = self.data.len() as u32;
57 self.data.push(value);
58 Id {
59 idx: id as u32,
60 _ty: PhantomData,
61 }
62 }
63
64 pub(crate) fn keys<'a>(&'a self) -> impl Iterator<Item = Id<T>> + 'a {
65 (0..(self.data.len() as u32)).into_iter().map(|idx| Id {
66 idx,
67 _ty: PhantomData,
68 })
69 }
70
71 pub(crate) fn items<'a>(&'a self) -> impl Iterator<Item = (Id<T>, &T)> + 'a {
72 self.data.iter().enumerate().map(|(idx, item)| {
73 let idx = idx as u32;
74 (
75 Id {
76 idx,
77 _ty: PhantomData,
78 },
79 item,
80 )
81 })
82 }
83}
84
85impl<T> Index<Id<T>> for Arena<T> {
86 type Output = T;
87 fn index(&self, id: Id<T>) -> &T {
88 &self.data[id.idx as usize]
89 }
90}
91
92impl<T> IndexMut<Id<T>> for Arena<T> {
93 fn index_mut(&mut self, id: Id<T>) -> &mut T {
94 &mut self.data[id.idx as usize]
95 }
96}
diff --git a/crates/ra_analysis/src/completion/mod.rs b/crates/ra_analysis/src/completion/mod.rs
index d7acca044..124da486a 100644
--- a/crates/ra_analysis/src/completion/mod.rs
+++ b/crates/ra_analysis/src/completion/mod.rs
@@ -7,13 +7,11 @@ use ra_syntax::{
7 AstNode, AtomEdit, 7 AstNode, AtomEdit,
8 SyntaxNodeRef, 8 SyntaxNodeRef,
9}; 9};
10use ra_db::SyntaxDatabase;
10use rustc_hash::{FxHashMap}; 11use rustc_hash::{FxHashMap};
11 12
12use crate::{ 13use crate::{
13 db::{self, SyntaxDatabase}, 14 db,
14 descriptors::{
15 module::{ModuleDescriptor}
16 },
17 Cancelable, FilePosition 15 Cancelable, FilePosition
18}; 16};
19 17
@@ -31,17 +29,14 @@ 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 module = match ModuleDescriptor::guess_from_position(db, position)? { 39 let module = ctry!(hir::Module::guess_from_position(db, position)?);
42 None => return Ok(None),
43 Some(it) => it,
44 };
45 40
46 let mut res = Vec::new(); 41 let mut res = Vec::new();
47 let mut has_completions = false; 42 let mut has_completions = false;
diff --git a/crates/ra_analysis/src/completion/reference_completion.rs b/crates/ra_analysis/src/completion/reference_completion.rs
index e52062107..8ea7478a8 100644
--- a/crates/ra_analysis/src/completion/reference_completion.rs
+++ b/crates/ra_analysis/src/completion/reference_completion.rs
@@ -6,22 +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 completion::CompletionItem, 18 completion::CompletionItem,
13 descriptors::{
14 module::{ModuleDescriptor},
15 function::FnScopes,
16 Path,
17 },
18 Cancelable 19 Cancelable
19}; 20};
20 21
21pub(super) fn completions( 22pub(super) fn completions(
22 acc: &mut Vec<CompletionItem>, 23 acc: &mut Vec<CompletionItem>,
23 db: &RootDatabase, 24 db: &RootDatabase,
24 module: &ModuleDescriptor, 25 module: &hir::Module,
25 file: &SourceFileNode, 26 file: &SourceFileNode,
26 name_ref: ast::NameRef, 27 name_ref: ast::NameRef,
27) -> Cancelable<()> { 28) -> Cancelable<()> {
@@ -42,13 +43,15 @@ pub(super) fn completions(
42 let module_scope = module.scope(db)?; 43 let module_scope = module.scope(db)?;
43 acc.extend( 44 acc.extend(
44 module_scope 45 module_scope
45 .items 46 .entries()
46 .iter()
47 .filter(|(_name, res)| { 47 .filter(|(_name, res)| {
48 // Don't expose this item 48 // Don't expose this item
49 match res.import_name { 49 match res.import {
50 None => true, 50 None => true,
51 Some(ptr) => !ptr.range().is_subrange(&name_ref.syntax().range()), 51 Some(import) => {
52 let range = import.range(db, module.source().file_id());
53 !range.is_subrange(&name_ref.syntax().range())
54 }
52 } 55 }
53 }) 56 })
54 .map(|(name, _res)| CompletionItem { 57 .map(|(name, _res)| CompletionItem {
@@ -147,26 +150,27 @@ fn complete_fn(name_ref: ast::NameRef, scopes: &FnScopes, acc: &mut Vec<Completi
147fn complete_path( 150fn complete_path(
148 acc: &mut Vec<CompletionItem>, 151 acc: &mut Vec<CompletionItem>,
149 db: &RootDatabase, 152 db: &RootDatabase,
150 module: &ModuleDescriptor, 153 module: &hir::Module,
151 mut path: Path, 154 mut path: Path,
152) -> Cancelable<()> { 155) -> Cancelable<()> {
153 if path.segments.is_empty() { 156 if path.segments.is_empty() {
154 return Ok(()); 157 return Ok(());
155 } 158 }
156 path.segments.pop(); 159 path.segments.pop();
157 let target_module = match module.resolve_path(path) { 160 let def_id = match module.resolve_path(db, path)? {
158 None => return Ok(()), 161 None => return Ok(()),
159 Some(it) => it, 162 Some(it) => it,
160 }; 163 };
164 let target_module = match def_id.resolve(db)? {
165 Def::Module(it) => it,
166 Def::Item => return Ok(()),
167 };
161 let module_scope = target_module.scope(db)?; 168 let module_scope = target_module.scope(db)?;
162 let completions = module_scope 169 let completions = module_scope.entries().map(|(name, _res)| CompletionItem {
163 .items 170 label: name.to_string(),
164 .iter() 171 lookup: None,
165 .map(|(name, _res)| CompletionItem { 172 snippet: None,
166 label: name.to_string(), 173 });
167 lookup: None,
168 snippet: None,
169 });
170 acc.extend(completions); 174 acc.extend(completions);
171 Ok(()) 175 Ok(())
172} 176}
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 6b56f99ac..df2ef293d 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -1,171 +1,95 @@
1use std::sync::Arc; 1use std::sync::Arc;
2#[cfg(test)]
3use parking_lot::Mutex;
4use ra_editor::LineIndex;
5use ra_syntax::{SourceFileNode, SyntaxNode};
6use salsa::{self, Database}; 2use salsa::{self, Database};
3use ra_db::{LocationIntener, BaseDatabase};
4use hir::{self, DefId, DefLoc, FnId, SourceItemId};
7 5
8use crate::{ 6use crate::{
9 db, 7 symbol_index,
10 descriptors::{
11 DescriptorDatabase, FnScopesQuery, FnSyntaxQuery, ModuleTreeQuery,
12 SubmodulesQuery, ItemMapQuery, InputModuleItemsQuery,
13 },
14 symbol_index::SymbolIndex,
15 syntax_ptr::SyntaxPtr,
16 loc2id::{IdMaps, IdDatabase},
17 Cancelable, Canceled, FileId,
18}; 8};
19 9
20#[derive(Debug)] 10#[derive(Debug)]
21pub(crate) struct RootDatabase { 11pub(crate) struct RootDatabase {
22 #[cfg(test)]
23 events: Mutex<Option<Vec<salsa::Event<RootDatabase>>>>,
24 #[cfg(not(test))]
25 events: (),
26
27 runtime: salsa::Runtime<RootDatabase>, 12 runtime: salsa::Runtime<RootDatabase>,
28 id_maps: IdMaps, 13 id_maps: Arc<IdMaps>,
14}
15
16#[derive(Debug, Default)]
17struct IdMaps {
18 fns: LocationIntener<SourceItemId, FnId>,
19 defs: LocationIntener<DefLoc, DefId>,
29} 20}
30 21
31impl salsa::Database for RootDatabase { 22impl salsa::Database for RootDatabase {
32 fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> { 23 fn salsa_runtime(&self) -> &salsa::Runtime<RootDatabase> {
33 &self.runtime 24 &self.runtime
34 } 25 }
35
36 #[allow(unused)]
37 fn salsa_event(&self, event: impl Fn() -> salsa::Event<RootDatabase>) {
38 #[cfg(test)]
39 {
40 let mut events = self.events.lock();
41 if let Some(events) = &mut *events {
42 events.push(event());
43 }
44 }
45 }
46} 26}
47 27
48impl Default for RootDatabase { 28impl Default for RootDatabase {
49 fn default() -> RootDatabase { 29 fn default() -> RootDatabase {
50 let mut db = RootDatabase { 30 let mut db = RootDatabase {
51 events: Default::default(),
52 runtime: salsa::Runtime::default(), 31 runtime: salsa::Runtime::default(),
53 id_maps: IdMaps::default(), 32 id_maps: Default::default(),
54 }; 33 };
55 db.query_mut(crate::input::SourceRootQuery) 34 db.query_mut(ra_db::SourceRootQuery)
56 .set(crate::input::WORKSPACE, Default::default()); 35 .set(ra_db::WORKSPACE, Default::default());
57 db.query_mut(crate::input::CrateGraphQuery) 36 db.query_mut(ra_db::CrateGraphQuery)
58 .set((), Default::default()); 37 .set((), Default::default());
59 db.query_mut(crate::input::LibrariesQuery) 38 db.query_mut(ra_db::LibrariesQuery)
60 .set((), Default::default()); 39 .set((), Default::default());
61 db 40 db
62 } 41 }
63} 42}
64 43
65pub(crate) fn check_canceled(db: &impl salsa::Database) -> Cancelable<()> {
66 if db.salsa_runtime().is_current_revision_canceled() {
67 Err(Canceled)
68 } else {
69 Ok(())
70 }
71}
72
73impl salsa::ParallelDatabase for RootDatabase { 44impl salsa::ParallelDatabase for RootDatabase {
74 fn snapshot(&self) -> salsa::Snapshot<RootDatabase> { 45 fn snapshot(&self) -> salsa::Snapshot<RootDatabase> {
75 salsa::Snapshot::new(RootDatabase { 46 salsa::Snapshot::new(RootDatabase {
76 events: Default::default(),
77 runtime: self.runtime.snapshot(self), 47 runtime: self.runtime.snapshot(self),
78 id_maps: self.id_maps.clone(), 48 id_maps: self.id_maps.clone(),
79 }) 49 })
80 } 50 }
81} 51}
82 52
83impl IdDatabase for RootDatabase { 53impl BaseDatabase for RootDatabase {}
84 fn id_maps(&self) -> &IdMaps {
85 &self.id_maps
86 }
87}
88 54
89#[cfg(test)] 55impl AsRef<LocationIntener<DefLoc, DefId>> for RootDatabase {
90impl RootDatabase { 56 fn as_ref(&self) -> &LocationIntener<DefLoc, DefId> {
91 pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event<RootDatabase>> { 57 &self.id_maps.defs
92 *self.events.lock() = Some(Vec::new());
93 f();
94 let events = self.events.lock().take().unwrap();
95 events
96 } 58 }
59}
97 60
98 pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> { 61impl AsRef<LocationIntener<hir::SourceItemId, FnId>> for RootDatabase {
99 let events = self.log(f); 62 fn as_ref(&self) -> &LocationIntener<hir::SourceItemId, FnId> {
100 events 63 &self.id_maps.fns
101 .into_iter()
102 .filter_map(|e| match e.kind {
103 // This pretty horrible, but `Debug` is the only way to inspect
104 // QueryDescriptor at the moment.
105 salsa::EventKind::WillExecute { descriptor } => Some(format!("{:?}", descriptor)),
106 _ => None,
107 })
108 .collect()
109 } 64 }
110} 65}
111 66
112salsa::database_storage! { 67salsa::database_storage! {
113 pub(crate) struct RootDatabaseStorage for RootDatabase { 68 pub(crate) struct RootDatabaseStorage for RootDatabase {
114 impl crate::input::FilesDatabase { 69 impl ra_db::FilesDatabase {
115 fn file_text() for crate::input::FileTextQuery; 70 fn file_text() for ra_db::FileTextQuery;
116 fn file_source_root() for crate::input::FileSourceRootQuery; 71 fn file_source_root() for ra_db::FileSourceRootQuery;
117 fn source_root() for crate::input::SourceRootQuery; 72 fn source_root() for ra_db::SourceRootQuery;
118 fn libraries() for crate::input::LibrariesQuery; 73 fn libraries() for ra_db::LibrariesQuery;
119 fn library_symbols() for crate::input::LibrarySymbolsQuery; 74 fn crate_graph() for ra_db::CrateGraphQuery;
120 fn crate_graph() for crate::input::CrateGraphQuery;
121 }
122 impl SyntaxDatabase {
123 fn file_syntax() for FileSyntaxQuery;
124 fn file_lines() for FileLinesQuery;
125 fn file_symbols() for FileSymbolsQuery;
126 fn resolve_syntax_ptr() for ResolveSyntaxPtrQuery;
127 }
128 impl DescriptorDatabase {
129 fn module_tree() for ModuleTreeQuery;
130 fn fn_scopes() for FnScopesQuery;
131 fn _input_module_items() for InputModuleItemsQuery;
132 fn _item_map() for ItemMapQuery;
133 fn _fn_syntax() for FnSyntaxQuery;
134 fn _submodules() for SubmodulesQuery;
135 } 75 }
136 } 76 impl ra_db::SyntaxDatabase {
137} 77 fn source_file() for ra_db::SourceFileQuery;
138 78 fn file_lines() for ra_db::FileLinesQuery;
139salsa::query_group! {
140 pub(crate) trait SyntaxDatabase: crate::input::FilesDatabase {
141 fn file_syntax(file_id: FileId) -> SourceFileNode {
142 type FileSyntaxQuery;
143 } 79 }
144 fn file_lines(file_id: FileId) -> Arc<LineIndex> { 80 impl symbol_index::SymbolsDatabase {
145 type FileLinesQuery; 81 fn file_symbols() for symbol_index::FileSymbolsQuery;
82 fn library_symbols() for symbol_index::LibrarySymbolsQuery;
146 } 83 }
147 fn file_symbols(file_id: FileId) -> Cancelable<Arc<SymbolIndex>> { 84 impl hir::db::HirDatabase {
148 type FileSymbolsQuery; 85 fn module_tree() for hir::db::ModuleTreeQuery;
149 } 86 fn fn_scopes() for hir::db::FnScopesQuery;
150 fn resolve_syntax_ptr(ptr: SyntaxPtr) -> SyntaxNode { 87 fn file_items() for hir::db::SourceFileItemsQuery;
151 type ResolveSyntaxPtrQuery; 88 fn file_item() for hir::db::FileItemQuery;
152 // Don't retain syntax trees in memory 89 fn input_module_items() for hir::db::InputModuleItemsQuery;
153 storage volatile; 90 fn item_map() for hir::db::ItemMapQuery;
154 use fn crate::syntax_ptr::resolve_syntax_ptr; 91 fn fn_syntax() for hir::db::FnSyntaxQuery;
92 fn submodules() for hir::db::SubmodulesQuery;
155 } 93 }
156 } 94 }
157} 95}
158
159fn file_syntax(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
160 let text = db.file_text(file_id);
161 SourceFileNode::parse(&*text)
162}
163fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
164 let text = db.file_text(file_id);
165 Arc::new(LineIndex::new(&*text))
166}
167fn file_symbols(db: &impl SyntaxDatabase, file_id: FileId) -> Cancelable<Arc<SymbolIndex>> {
168 db::check_canceled(db)?;
169 let syntax = db.file_syntax(file_id);
170 Ok(Arc::new(SymbolIndex::for_file(file_id, syntax)))
171}
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 e09deba0f..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`
11pub(crate) fn fn_syntax(db: &impl DescriptorDatabase, fn_id: FnId) -> FnDefNode {
12 let ptr = db.id_maps().fn_ptr(fn_id);
13 let syntax = db.resolve_syntax_ptr(ptr);
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 86eee5e93..000000000
--- a/crates/ra_analysis/src/descriptors/function/mod.rs
+++ /dev/null
@@ -1,137 +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::{
12 syntax_ptr::SyntaxPtr, FileId,
13 loc2id::IdDatabase,
14};
15
16pub(crate) use self::scope::{resolve_local_name, FnScopes};
17pub(crate) use crate::loc2id::FnId;
18
19impl FnId {
20 pub(crate) fn get(db: &impl IdDatabase, file_id: FileId, fn_def: ast::FnDef) -> FnId {
21 let ptr = SyntaxPtr::new(file_id, fn_def.syntax());
22 db.id_maps().fn_id(ptr)
23 }
24}
25
26#[derive(Debug, Clone)]
27pub struct FnDescriptor {
28 pub name: String,
29 pub label: String,
30 pub ret_type: Option<String>,
31 pub params: Vec<String>,
32 pub doc: Option<String>,
33}
34
35impl FnDescriptor {
36 pub fn new(node: ast::FnDef) -> Option<Self> {
37 let name = node.name()?.text().to_string();
38
39 let mut doc = None;
40
41 // Strip the body out for the label.
42 let mut label: String = if let Some(body) = node.body() {
43 let body_range = body.syntax().range();
44 let label: String = node
45 .syntax()
46 .children()
47 .filter(|child| !child.range().is_subrange(&body_range))
48 .map(|node| node.text().to_string())
49 .collect();
50 label
51 } else {
52 node.syntax().text().to_string()
53 };
54
55 if let Some((comment_range, docs)) = FnDescriptor::extract_doc_comments(node) {
56 let comment_range = comment_range
57 .checked_sub(node.syntax().range().start())
58 .unwrap();
59 let start = comment_range.start().to_usize();
60 let end = comment_range.end().to_usize();
61
62 // Remove the comment from the label
63 label.replace_range(start..end, "");
64
65 // Massage markdown
66 let mut processed_lines = Vec::new();
67 let mut in_code_block = false;
68 for line in docs.lines() {
69 if line.starts_with("```") {
70 in_code_block = !in_code_block;
71 }
72
73 let line = if in_code_block && line.starts_with("```") && !line.contains("rust") {
74 "```rust".into()
75 } else {
76 line.to_string()
77 };
78
79 processed_lines.push(line);
80 }
81
82 if !processed_lines.is_empty() {
83 doc = Some(processed_lines.join("\n"));
84 }
85 }
86
87 let params = FnDescriptor::param_list(node);
88 let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
89
90 Some(FnDescriptor {
91 name,
92 ret_type,
93 params,
94 label: label.trim().to_owned(),
95 doc,
96 })
97 }
98
99 fn extract_doc_comments(node: ast::FnDef) -> Option<(TextRange, String)> {
100 if node.doc_comments().count() == 0 {
101 return None;
102 }
103
104 let comment_text = node.doc_comment_text();
105
106 let (begin, end) = node
107 .doc_comments()
108 .map(|comment| comment.syntax().range())
109 .map(|range| (range.start().to_usize(), range.end().to_usize()))
110 .fold((std::usize::MAX, std::usize::MIN), |acc, range| {
111 (min(acc.0, range.0), max(acc.1, range.1))
112 });
113
114 let range = TextRange::from_to(TextUnit::from_usize(begin), TextUnit::from_usize(end));
115
116 Some((range, comment_text))
117 }
118
119 fn param_list(node: ast::FnDef) -> Vec<String> {
120 let mut res = vec![];
121 if let Some(param_list) = node.param_list() {
122 if let Some(self_param) = param_list.self_param() {
123 res.push(self_param.syntax().text().to_string())
124 }
125
126 // Maybe use param.pat here? See if we can just extract the name?
127 //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
128 res.extend(
129 param_list
130 .params()
131 .filter_map(|p| p.pat())
132 .map(|pat| pat.syntax().text().to_string()),
133 );
134 }
135 res
136 }
137}
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 54d7fa456..000000000
--- a/crates/ra_analysis/src/descriptors/function/scope.rs
+++ /dev/null
@@ -1,424 +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::{
10 syntax_ptr::LocalSyntaxPtr,
11 arena::{Arena, Id},
12};
13
14pub(crate) type ScopeId = Id<ScopeData>;
15
16#[derive(Debug, PartialEq, Eq)]
17pub struct FnScopes {
18 pub(crate) self_param: Option<LocalSyntaxPtr>,
19 scopes: Arena<ScopeData>,
20 scope_for: FxHashMap<LocalSyntaxPtr, ScopeId>,
21}
22
23#[derive(Debug, PartialEq, Eq)]
24pub struct ScopeEntry {
25 name: SmolStr,
26 ptr: LocalSyntaxPtr,
27}
28
29#[derive(Debug, PartialEq, Eq)]
30pub(crate) struct ScopeData {
31 parent: Option<ScopeId>,
32 entries: Vec<ScopeEntry>,
33}
34
35impl FnScopes {
36 pub(crate) fn new(fn_def: ast::FnDef) -> FnScopes {
37 let mut scopes = FnScopes {
38 self_param: fn_def
39 .param_list()
40 .and_then(|it| it.self_param())
41 .map(|it| LocalSyntaxPtr::new(it.syntax())),
42 scopes: Arena::default(),
43 scope_for: FxHashMap::default(),
44 };
45 let root = scopes.root_scope();
46 scopes.add_params_bindings(root, fn_def.param_list());
47 if let Some(body) = fn_def.body() {
48 compute_block_scopes(body, &mut scopes, root)
49 }
50 scopes
51 }
52 pub(crate) fn entries(&self, scope: ScopeId) -> &[ScopeEntry] {
53 &self.scopes[scope].entries
54 }
55 pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
56 generate(self.scope_for(node), move |&scope| {
57 self.scopes[scope].parent
58 })
59 }
60 fn root_scope(&mut self) -> ScopeId {
61 self.scopes.push(ScopeData {
62 parent: None,
63 entries: vec![],
64 })
65 }
66 fn new_scope(&mut self, parent: ScopeId) -> ScopeId {
67 self.scopes.push(ScopeData {
68 parent: Some(parent),
69 entries: vec![],
70 })
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.scopes[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}
97
98impl ScopeEntry {
99 fn new(pat: ast::BindPat) -> Option<ScopeEntry> {
100 let name = pat.name()?;
101 let res = ScopeEntry {
102 name: name.text(),
103 ptr: LocalSyntaxPtr::new(pat.syntax()),
104 };
105 Some(res)
106 }
107 pub(crate) fn name(&self) -> &SmolStr {
108 &self.name
109 }
110 pub(crate) fn ptr(&self) -> LocalSyntaxPtr {
111 self.ptr
112 }
113}
114
115fn compute_block_scopes(block: ast::Block, scopes: &mut FnScopes, mut scope: ScopeId) {
116 for stmt in block.statements() {
117 match stmt {
118 ast::Stmt::LetStmt(stmt) => {
119 if let Some(expr) = stmt.initializer() {
120 scopes.set_scope(expr.syntax(), scope);
121 compute_expr_scopes(expr, scopes, scope);
122 }
123 scope = scopes.new_scope(scope);
124 if let Some(pat) = stmt.pat() {
125 scopes.add_bindings(scope, pat);
126 }
127 }
128 ast::Stmt::ExprStmt(expr_stmt) => {
129 if let Some(expr) = expr_stmt.expr() {
130 scopes.set_scope(expr.syntax(), scope);
131 compute_expr_scopes(expr, scopes, scope);
132 }
133 }
134 }
135 }
136 if let Some(expr) = block.expr() {
137 scopes.set_scope(expr.syntax(), scope);
138 compute_expr_scopes(expr, scopes, scope);
139 }
140}
141
142fn compute_expr_scopes(expr: ast::Expr, scopes: &mut FnScopes, scope: ScopeId) {
143 match expr {
144 ast::Expr::IfExpr(e) => {
145 let cond_scope = e
146 .condition()
147 .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
148 if let Some(block) = e.then_branch() {
149 compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
150 }
151 if let Some(block) = e.else_branch() {
152 compute_block_scopes(block, scopes, scope);
153 }
154 }
155 ast::Expr::BlockExpr(e) => {
156 if let Some(block) = e.block() {
157 compute_block_scopes(block, scopes, scope);
158 }
159 }
160 ast::Expr::LoopExpr(e) => {
161 if let Some(block) = e.loop_body() {
162 compute_block_scopes(block, scopes, scope);
163 }
164 }
165 ast::Expr::WhileExpr(e) => {
166 let cond_scope = e
167 .condition()
168 .and_then(|cond| compute_cond_scopes(cond, scopes, scope));
169 if let Some(block) = e.loop_body() {
170 compute_block_scopes(block, scopes, cond_scope.unwrap_or(scope));
171 }
172 }
173 ast::Expr::ForExpr(e) => {
174 if let Some(expr) = e.iterable() {
175 compute_expr_scopes(expr, scopes, scope);
176 }
177 let mut scope = scope;
178 if let Some(pat) = e.pat() {
179 scope = scopes.new_scope(scope);
180 scopes.add_bindings(scope, pat);
181 }
182 if let Some(block) = e.loop_body() {
183 compute_block_scopes(block, scopes, scope);
184 }
185 }
186 ast::Expr::LambdaExpr(e) => {
187 let scope = scopes.new_scope(scope);
188 scopes.add_params_bindings(scope, e.param_list());
189 if let Some(body) = e.body() {
190 scopes.set_scope(body.syntax(), scope);
191 compute_expr_scopes(body, scopes, scope);
192 }
193 }
194 ast::Expr::CallExpr(e) => {
195 compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
196 }
197 ast::Expr::MethodCallExpr(e) => {
198 compute_call_scopes(e.expr(), e.arg_list(), scopes, scope);
199 }
200 ast::Expr::MatchExpr(e) => {
201 if let Some(expr) = e.expr() {
202 compute_expr_scopes(expr, scopes, scope);
203 }
204 for arm in e.match_arm_list().into_iter().flat_map(|it| it.arms()) {
205 let scope = scopes.new_scope(scope);
206 for pat in arm.pats() {
207 scopes.add_bindings(scope, pat);
208 }
209 if let Some(expr) = arm.expr() {
210 compute_expr_scopes(expr, scopes, scope);
211 }
212 }
213 }
214 _ => expr
215 .syntax()
216 .children()
217 .filter_map(ast::Expr::cast)
218 .for_each(|expr| compute_expr_scopes(expr, scopes, scope)),
219 };
220
221 fn compute_call_scopes(
222 receiver: Option<ast::Expr>,
223 arg_list: Option<ast::ArgList>,
224 scopes: &mut FnScopes,
225 scope: ScopeId,
226 ) {
227 arg_list
228 .into_iter()
229 .flat_map(|it| it.args())
230 .chain(receiver)
231 .for_each(|expr| compute_expr_scopes(expr, scopes, scope));
232 }
233
234 fn compute_cond_scopes(
235 cond: ast::Condition,
236 scopes: &mut FnScopes,
237 scope: ScopeId,
238 ) -> Option<ScopeId> {
239 if let Some(expr) = cond.expr() {
240 compute_expr_scopes(expr, scopes, scope);
241 }
242 if let Some(pat) = cond.pat() {
243 let s = scopes.new_scope(scope);
244 scopes.add_bindings(s, pat);
245 Some(s)
246 } else {
247 None
248 }
249 }
250}
251
252pub fn resolve_local_name<'a>(
253 name_ref: ast::NameRef,
254 scopes: &'a FnScopes,
255) -> Option<&'a ScopeEntry> {
256 let mut shadowed = FxHashSet::default();
257 let ret = scopes
258 .scope_chain(name_ref.syntax())
259 .flat_map(|scope| scopes.entries(scope).iter())
260 .filter(|entry| shadowed.insert(entry.name()))
261 .filter(|entry| entry.name() == &name_ref.text())
262 .nth(0);
263 ret
264}
265
266#[cfg(test)]
267mod tests {
268 use ra_editor::find_node_at_offset;
269 use ra_syntax::SourceFileNode;
270 use test_utils::extract_offset;
271
272 use super::*;
273
274 fn do_check(code: &str, expected: &[&str]) {
275 let (off, code) = extract_offset(code);
276 let code = {
277 let mut buf = String::new();
278 let off = u32::from(off) as usize;
279 buf.push_str(&code[..off]);
280 buf.push_str("marker");
281 buf.push_str(&code[off..]);
282 buf
283 };
284 let file = SourceFileNode::parse(&code);
285 let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
286 let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
287 let scopes = FnScopes::new(fn_def);
288 let actual = scopes
289 .scope_chain(marker.syntax())
290 .flat_map(|scope| scopes.entries(scope))
291 .map(|it| it.name())
292 .collect::<Vec<_>>();
293 assert_eq!(actual.as_slice(), expected);
294 }
295
296 #[test]
297 fn test_lambda_scope() {
298 do_check(
299 r"
300 fn quux(foo: i32) {
301 let f = |bar, baz: i32| {
302 <|>
303 };
304 }",
305 &["bar", "baz", "foo"],
306 );
307 }
308
309 #[test]
310 fn test_call_scope() {
311 do_check(
312 r"
313 fn quux() {
314 f(|x| <|> );
315 }",
316 &["x"],
317 );
318 }
319
320 #[test]
321 fn test_metod_call_scope() {
322 do_check(
323 r"
324 fn quux() {
325 z.f(|x| <|> );
326 }",
327 &["x"],
328 );
329 }
330
331 #[test]
332 fn test_loop_scope() {
333 do_check(
334 r"
335 fn quux() {
336 loop {
337 let x = ();
338 <|>
339 };
340 }",
341 &["x"],
342 );
343 }
344
345 #[test]
346 fn test_match() {
347 do_check(
348 r"
349 fn quux() {
350 match () {
351 Some(x) => {
352 <|>
353 }
354 };
355 }",
356 &["x"],
357 );
358 }
359
360 #[test]
361 fn test_shadow_variable() {
362 do_check(
363 r"
364 fn foo(x: String) {
365 let x : &str = &x<|>;
366 }",
367 &["x"],
368 );
369 }
370
371 fn do_check_local_name(code: &str, expected_offset: u32) {
372 let (off, code) = extract_offset(code);
373 let file = SourceFileNode::parse(&code);
374 let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
375 let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
376
377 let scopes = FnScopes::new(fn_def);
378
379 let local_name_entry = resolve_local_name(name_ref, &scopes).unwrap();
380 let local_name = local_name_entry.ptr().resolve(&file);
381 let expected_name =
382 find_node_at_offset::<ast::Name>(file.syntax(), expected_offset.into()).unwrap();
383 assert_eq!(local_name.range(), expected_name.syntax().range());
384 }
385
386 #[test]
387 fn test_resolve_local_name() {
388 do_check_local_name(
389 r#"
390 fn foo(x: i32, y: u32) {
391 {
392 let z = x * 2;
393 }
394 {
395 let t = x<|> * 3;
396 }
397 }"#,
398 21,
399 );
400 }
401
402 #[test]
403 fn test_resolve_local_name_declaration() {
404 do_check_local_name(
405 r#"
406 fn foo(x: String) {
407 let x : &str = &x<|>;
408 }"#,
409 21,
410 );
411 }
412
413 #[test]
414 fn test_resolve_local_name_shadow() {
415 do_check_local_name(
416 r"
417 fn foo(x: String) {
418 let x : &str = &x;
419 x<|>
420 }",
421 46,
422 );
423 }
424}
diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
deleted file mode 100644
index 97750ea64..000000000
--- a/crates/ra_analysis/src/descriptors/mod.rs
+++ /dev/null
@@ -1,101 +0,0 @@
1pub(crate) mod function;
2pub(crate) mod module;
3mod path;
4
5use std::sync::Arc;
6
7use ra_syntax::{
8 ast::{self, FnDefNode, AstNode},
9 TextRange,
10};
11
12use crate::{
13 db::SyntaxDatabase,
14 descriptors::function::{resolve_local_name, FnId, FnScopes},
15 descriptors::module::{ModuleId, ModuleTree, ModuleSource, nameres::{ItemMap, InputModuleItems}},
16 input::SourceRootId,
17 loc2id::IdDatabase,
18 syntax_ptr::LocalSyntaxPtr,
19 Cancelable,
20};
21
22pub(crate) use self::path::{Path, PathKind};
23
24salsa::query_group! {
25 pub(crate) trait DescriptorDatabase: SyntaxDatabase + IdDatabase {
26 fn fn_scopes(fn_id: FnId) -> Arc<FnScopes> {
27 type FnScopesQuery;
28 use fn function::imp::fn_scopes;
29 }
30
31 fn _input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable<Arc<InputModuleItems>> {
32 type InputModuleItemsQuery;
33 use fn module::nameres::input_module_items;
34 }
35 fn _item_map(source_root_id: SourceRootId) -> Cancelable<Arc<ItemMap>> {
36 type ItemMapQuery;
37 use fn module::nameres::item_map;
38 }
39 fn _module_tree(source_root_id: SourceRootId) -> Cancelable<Arc<ModuleTree>> {
40 type ModuleTreeQuery;
41 use fn module::imp::module_tree;
42 }
43 fn _fn_syntax(fn_id: FnId) -> FnDefNode {
44 type FnSyntaxQuery;
45 // Don't retain syntax trees in memory
46 storage volatile;
47 use fn function::imp::fn_syntax;
48 }
49 fn _submodules(source: ModuleSource) -> Cancelable<Arc<Vec<module::imp::Submodule>>> {
50 type SubmodulesQuery;
51 use fn module::imp::submodules;
52 }
53 }
54}
55
56#[derive(Debug)]
57pub struct ReferenceDescriptor {
58 pub range: TextRange,
59 pub name: String,
60}
61
62#[derive(Debug)]
63pub struct DeclarationDescriptor<'a> {
64 pat: ast::BindPat<'a>,
65 pub range: TextRange,
66}
67
68impl<'a> DeclarationDescriptor<'a> {
69 pub fn new(pat: ast::BindPat) -> DeclarationDescriptor {
70 let range = pat.syntax().range();
71
72 DeclarationDescriptor { pat, range }
73 }
74
75 pub fn find_all_refs(&self) -> Vec<ReferenceDescriptor> {
76 let name_ptr = LocalSyntaxPtr::new(self.pat.syntax());
77
78 let fn_def = match self.pat.syntax().ancestors().find_map(ast::FnDef::cast) {
79 Some(def) => def,
80 None => return Default::default(),
81 };
82
83 let fn_scopes = FnScopes::new(fn_def);
84
85 let refs: Vec<_> = fn_def
86 .syntax()
87 .descendants()
88 .filter_map(ast::NameRef::cast)
89 .filter(|name_ref| match resolve_local_name(*name_ref, &fn_scopes) {
90 None => false,
91 Some(entry) => entry.ptr() == name_ptr,
92 })
93 .map(|name_ref| ReferenceDescriptor {
94 name: name_ref.syntax().text().to_string(),
95 range: name_ref.syntax().range(),
96 })
97 .collect();
98
99 refs
100 }
101}
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 80892acb7..000000000
--- a/crates/ra_analysis/src/descriptors/module/imp.rs
+++ /dev/null
@@ -1,229 +0,0 @@
1use std::sync::Arc;
2
3use ra_syntax::{
4 ast::{self, 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, 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_tree(
85 db: &impl DescriptorDatabase,
86 source_root: SourceRootId,
87) -> Cancelable<Arc<ModuleTree>> {
88 db::check_canceled(db)?;
89 let res = create_module_tree(db, source_root)?;
90 Ok(Arc::new(res))
91}
92
93fn create_module_tree<'a>(
94 db: &impl DescriptorDatabase,
95 source_root: SourceRootId,
96) -> Cancelable<ModuleTree> {
97 let mut tree = ModuleTree::default();
98
99 let mut roots = FxHashMap::default();
100 let mut visited = FxHashSet::default();
101
102 let source_root = db.source_root(source_root);
103 for &file_id in source_root.files.iter() {
104 let source = ModuleSource::SourceFile(file_id);
105 if visited.contains(&source) {
106 continue; // TODO: use explicit crate_roots here
107 }
108 assert!(!roots.contains_key(&file_id));
109 let module_id = build_subtree(
110 db,
111 &source_root,
112 &mut tree,
113 &mut visited,
114 &mut roots,
115 None,
116 source,
117 )?;
118 roots.insert(file_id, module_id);
119 }
120 Ok(tree)
121}
122
123fn build_subtree(
124 db: &impl DescriptorDatabase,
125 source_root: &SourceRoot,
126 tree: &mut ModuleTree,
127 visited: &mut FxHashSet<ModuleSource>,
128 roots: &mut FxHashMap<FileId, ModuleId>,
129 parent: Option<LinkId>,
130 source: ModuleSource,
131) -> Cancelable<ModuleId> {
132 visited.insert(source);
133 let id = tree.push_mod(ModuleData {
134 source,
135 parent,
136 children: Vec::new(),
137 });
138 for sub in db._submodules(source)?.iter() {
139 let link = tree.push_link(LinkData {
140 name: sub.name().clone(),
141 owner: id,
142 points_to: Vec::new(),
143 problem: None,
144 });
145
146 let (points_to, problem) = match sub {
147 Submodule::Declaration(name) => {
148 let (points_to, problem) =
149 resolve_submodule(source, &name, &source_root.file_resolver);
150 let points_to = points_to
151 .into_iter()
152 .map(|file_id| match roots.remove(&file_id) {
153 Some(module_id) => {
154 tree.mods[module_id].parent = Some(link);
155 Ok(module_id)
156 }
157 None => build_subtree(
158 db,
159 source_root,
160 tree,
161 visited,
162 roots,
163 Some(link),
164 ModuleSource::SourceFile(file_id),
165 ),
166 })
167 .collect::<Cancelable<Vec<_>>>()?;
168 (points_to, problem)
169 }
170 Submodule::Definition(_name, submodule_source) => {
171 let points_to = build_subtree(
172 db,
173 source_root,
174 tree,
175 visited,
176 roots,
177 Some(link),
178 *submodule_source,
179 )?;
180 (vec![points_to], None)
181 }
182 };
183
184 tree.links[link].points_to = points_to;
185 tree.links[link].problem = problem;
186 }
187 Ok(id)
188}
189
190fn resolve_submodule(
191 source: ModuleSource,
192 name: &SmolStr,
193 file_resolver: &FileResolverImp,
194) -> (Vec<FileId>, Option<Problem>) {
195 let file_id = match source {
196 ModuleSource::SourceFile(it) => it,
197 ModuleSource::Module(..) => {
198 // TODO
199 return (Vec::new(), None);
200 }
201 };
202 let mod_name = file_resolver.file_stem(file_id);
203 let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
204
205 let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
206 let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
207 let points_to: Vec<FileId>;
208 let problem: Option<Problem>;
209 if is_dir_owner {
210 points_to = [&file_mod, &dir_mod]
211 .iter()
212 .filter_map(|path| file_resolver.resolve(file_id, path))
213 .collect();
214 problem = if points_to.is_empty() {
215 Some(Problem::UnresolvedModule {
216 candidate: file_mod,
217 })
218 } else {
219 None
220 }
221 } else {
222 points_to = Vec::new();
223 problem = Some(Problem::NotDirOwner {
224 move_to: RelativePathBuf::from(format!("../{}/mod.rs", mod_name)),
225 candidate: file_mod,
226 });
227 }
228 (points_to, problem)
229}
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 54ff95b66..000000000
--- a/crates/ra_analysis/src/descriptors/module/mod.rs
+++ /dev/null
@@ -1,344 +0,0 @@
1pub(super) mod imp;
2pub(super) mod nameres;
3
4use std::sync::Arc;
5
6use ra_editor::find_node_at_offset;
7
8use ra_syntax::{
9 algo::generate,
10 ast::{self, AstNode, NameOwner},
11 SmolStr, SyntaxNode,
12};
13use relative_path::RelativePathBuf;
14
15use crate::{
16 db::SyntaxDatabase, syntax_ptr::SyntaxPtr, FileId, FilePosition, Cancelable,
17 descriptors::{Path, PathKind, DescriptorDatabase},
18 input::SourceRootId,
19 arena::{Arena, Id},
20};
21
22pub(crate) use self::nameres::ModuleScope;
23
24/// `ModuleDescriptor` is API entry point to get all the information
25/// about a particular module.
26#[derive(Debug, Clone)]
27pub(crate) struct ModuleDescriptor {
28 tree: Arc<ModuleTree>,
29 source_root_id: SourceRootId,
30 module_id: ModuleId,
31}
32
33impl ModuleDescriptor {
34 /// Lookup `ModuleDescriptor` by `FileId`. Note that this is inherently
35 /// lossy transformation: in general, a single source might correspond to
36 /// several modules.
37 pub fn guess_from_file_id(
38 db: &impl DescriptorDatabase,
39 file_id: FileId,
40 ) -> Cancelable<Option<ModuleDescriptor>> {
41 ModuleDescriptor::guess_from_source(db, file_id, ModuleSource::SourceFile(file_id))
42 }
43
44 /// Lookup `ModuleDescriptor` by position in the source code. Note that this
45 /// is inherently lossy transformation: in general, a single source might
46 /// correspond to several modules.
47 pub fn guess_from_position(
48 db: &impl DescriptorDatabase,
49 position: FilePosition,
50 ) -> Cancelable<Option<ModuleDescriptor>> {
51 let file = db.file_syntax(position.file_id);
52 let module_source = match find_node_at_offset::<ast::Module>(file.syntax(), position.offset)
53 {
54 Some(m) if !m.has_semi() => ModuleSource::new_inline(position.file_id, m),
55 _ => ModuleSource::SourceFile(position.file_id),
56 };
57 ModuleDescriptor::guess_from_source(db, position.file_id, module_source)
58 }
59
60 fn guess_from_source(
61 db: &impl DescriptorDatabase,
62 file_id: FileId,
63 module_source: ModuleSource,
64 ) -> Cancelable<Option<ModuleDescriptor>> {
65 let source_root_id = db.file_source_root(file_id);
66 let module_tree = db._module_tree(source_root_id)?;
67
68 let res = match module_tree.any_module_for_source(module_source) {
69 None => None,
70 Some(module_id) => Some(ModuleDescriptor {
71 tree: module_tree,
72 source_root_id,
73 module_id,
74 }),
75 };
76 Ok(res)
77 }
78
79 /// Returns `mod foo;` or `mod foo {}` node whihc declared this module.
80 /// Returns `None` for the root module
81 pub fn parent_link_source(
82 &self,
83 db: &impl DescriptorDatabase,
84 ) -> Option<(FileId, ast::ModuleNode)> {
85 let link = self.module_id.parent_link(&self.tree)?;
86 let file_id = link.owner(&self.tree).source(&self.tree).file_id();
87 let src = link.bind_source(&self.tree, db);
88 Some((file_id, src))
89 }
90
91 pub fn source(&self) -> ModuleSource {
92 self.module_id.source(&self.tree)
93 }
94
95 /// Parent module. Returns `None` if this is a root module.
96 pub fn parent(&self) -> Option<ModuleDescriptor> {
97 let parent_id = self.module_id.parent(&self.tree)?;
98 Some(ModuleDescriptor {
99 module_id: parent_id,
100 ..self.clone()
101 })
102 }
103
104 /// The root of the tree this module is part of
105 pub fn crate_root(&self) -> ModuleDescriptor {
106 let root_id = self.module_id.crate_root(&self.tree);
107 ModuleDescriptor {
108 module_id: root_id,
109 ..self.clone()
110 }
111 }
112
113 /// `name` is `None` for the crate's root module
114 #[allow(unused)]
115 pub fn name(&self) -> Option<SmolStr> {
116 let link = self.module_id.parent_link(&self.tree)?;
117 Some(link.name(&self.tree))
118 }
119
120 /// Finds a child module with the specified name.
121 pub fn child(&self, name: &str) -> Option<ModuleDescriptor> {
122 let child_id = self.module_id.child(&self.tree, name)?;
123 Some(ModuleDescriptor {
124 module_id: child_id,
125 ..self.clone()
126 })
127 }
128
129 /// Returns a `ModuleScope`: a set of items, visible in this module.
130 pub(crate) fn scope(&self, db: &impl DescriptorDatabase) -> Cancelable<ModuleScope> {
131 let item_map = db._item_map(self.source_root_id)?;
132 let res = item_map.per_module[&self.module_id].clone();
133 Ok(res)
134 }
135
136 pub(crate) fn resolve_path(&self, path: Path) -> Option<ModuleDescriptor> {
137 let mut curr = match path.kind {
138 PathKind::Crate => self.crate_root(),
139 PathKind::Self_ | PathKind::Plain => self.clone(),
140 PathKind::Super => self.parent()?,
141 };
142 let segments = path.segments;
143 for name in segments {
144 curr = curr.child(&name)?;
145 }
146 Some(curr)
147 }
148
149 pub fn problems(&self, db: &impl DescriptorDatabase) -> Vec<(SyntaxNode, Problem)> {
150 self.module_id.problems(&self.tree, db)
151 }
152}
153
154/// Phisically, rust source is organized as a set of files, but logically it is
155/// organized as a tree of modules. Usually, a single file corresponds to a
156/// single module, but it is not nessary the case.
157///
158/// Module encapsulate the logic of transitioning from the fuzzy world of files
159/// (which can have multiple parents) to the precise world of modules (which
160/// always have one parent).
161#[derive(Default, Debug, PartialEq, Eq)]
162pub(crate) struct ModuleTree {
163 mods: Arena<ModuleData>,
164 links: Arena<LinkData>,
165}
166
167impl ModuleTree {
168 fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
169 self.mods.keys()
170 }
171
172 fn modules_for_source(&self, source: ModuleSource) -> Vec<ModuleId> {
173 self.mods
174 .items()
175 .filter(|(_idx, it)| it.source == source)
176 .map(|(idx, _)| idx)
177 .collect()
178 }
179
180 fn any_module_for_source(&self, source: ModuleSource) -> Option<ModuleId> {
181 self.modules_for_source(source).pop()
182 }
183}
184
185/// `ModuleSource` is the syntax tree element that produced this module:
186/// either a file, or an inlinde module.
187#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
188pub(crate) enum ModuleSource {
189 SourceFile(FileId),
190 #[allow(dead_code)]
191 Module(SyntaxPtr),
192}
193
194/// An owned syntax node for a module. Unlike `ModuleSource`,
195/// this holds onto the AST for the whole file.
196enum ModuleSourceNode {
197 SourceFile(ast::SourceFileNode),
198 Module(ast::ModuleNode),
199}
200
201pub(crate) type ModuleId = Id<ModuleData>;
202type LinkId = Id<LinkData>;
203
204#[derive(Clone, Debug, Hash, PartialEq, Eq)]
205pub enum Problem {
206 UnresolvedModule {
207 candidate: RelativePathBuf,
208 },
209 NotDirOwner {
210 move_to: RelativePathBuf,
211 candidate: RelativePathBuf,
212 },
213}
214
215impl ModuleId {
216 fn source(self, tree: &ModuleTree) -> ModuleSource {
217 tree.mods[self].source
218 }
219 fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
220 tree.mods[self].parent
221 }
222 fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
223 let link = self.parent_link(tree)?;
224 Some(tree.links[link].owner)
225 }
226 fn crate_root(self, tree: &ModuleTree) -> ModuleId {
227 generate(Some(self), move |it| it.parent(tree))
228 .last()
229 .unwrap()
230 }
231 fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
232 let link = tree.mods[self]
233 .children
234 .iter()
235 .map(|&it| &tree.links[it])
236 .find(|it| it.name == name)?;
237 Some(*link.points_to.first()?)
238 }
239 fn children<'a>(self, tree: &'a ModuleTree) -> impl Iterator<Item = (SmolStr, ModuleId)> + 'a {
240 tree.mods[self].children.iter().filter_map(move |&it| {
241 let link = &tree.links[it];
242 let module = *link.points_to.first()?;
243 Some((link.name.clone(), module))
244 })
245 }
246 fn problems(self, tree: &ModuleTree, db: &impl SyntaxDatabase) -> Vec<(SyntaxNode, Problem)> {
247 tree.mods[self]
248 .children
249 .iter()
250 .filter_map(|&it| {
251 let p = tree.links[it].problem.clone()?;
252 let s = it.bind_source(tree, db);
253 let s = s.borrowed().name().unwrap().syntax().owned();
254 Some((s, p))
255 })
256 .collect()
257 }
258}
259
260impl LinkId {
261 fn owner(self, tree: &ModuleTree) -> ModuleId {
262 tree.links[self].owner
263 }
264 fn name(self, tree: &ModuleTree) -> SmolStr {
265 tree.links[self].name.clone()
266 }
267 fn bind_source<'a>(self, tree: &ModuleTree, db: &impl SyntaxDatabase) -> ast::ModuleNode {
268 let owner = self.owner(tree);
269 match owner.source(tree).resolve(db) {
270 ModuleSourceNode::SourceFile(root) => {
271 let ast = imp::modules(root.borrowed())
272 .find(|(name, _)| name == &tree.links[self].name)
273 .unwrap()
274 .1;
275 ast.owned()
276 }
277 ModuleSourceNode::Module(it) => it,
278 }
279 }
280}
281
282#[derive(Debug, PartialEq, Eq, Hash)]
283pub(crate) struct ModuleData {
284 source: ModuleSource,
285 parent: Option<LinkId>,
286 children: Vec<LinkId>,
287}
288
289impl ModuleSource {
290 fn new_inline(file_id: FileId, module: ast::Module) -> ModuleSource {
291 assert!(!module.has_semi());
292 let ptr = SyntaxPtr::new(file_id, module.syntax());
293 ModuleSource::Module(ptr)
294 }
295
296 pub(crate) fn as_file(self) -> Option<FileId> {
297 match self {
298 ModuleSource::SourceFile(f) => Some(f),
299 ModuleSource::Module(..) => None,
300 }
301 }
302
303 pub(crate) fn file_id(self) -> FileId {
304 match self {
305 ModuleSource::SourceFile(f) => f,
306 ModuleSource::Module(ptr) => ptr.file_id(),
307 }
308 }
309
310 fn resolve(self, db: &impl SyntaxDatabase) -> ModuleSourceNode {
311 match self {
312 ModuleSource::SourceFile(file_id) => {
313 let syntax = db.file_syntax(file_id);
314 ModuleSourceNode::SourceFile(syntax.ast().owned())
315 }
316 ModuleSource::Module(ptr) => {
317 let syntax = db.resolve_syntax_ptr(ptr);
318 let syntax = syntax.borrowed();
319 let module = ast::Module::cast(syntax).unwrap();
320 ModuleSourceNode::Module(module.owned())
321 }
322 }
323 }
324}
325
326#[derive(Hash, Debug, PartialEq, Eq)]
327struct LinkData {
328 owner: ModuleId,
329 name: SmolStr,
330 points_to: Vec<ModuleId>,
331 problem: Option<Problem>,
332}
333
334impl ModuleTree {
335 fn push_mod(&mut self, data: ModuleData) -> ModuleId {
336 self.mods.push(data)
337 }
338 fn push_link(&mut self, data: LinkData) -> LinkId {
339 let owner = data.owner;
340 let id = self.links.push(data);
341 self.mods[owner].children.push(id);
342 id
343 }
344}
diff --git a/crates/ra_analysis/src/descriptors/module/nameres.rs b/crates/ra_analysis/src/descriptors/module/nameres.rs
deleted file mode 100644
index 648ec5e43..000000000
--- a/crates/ra_analysis/src/descriptors/module/nameres.rs
+++ /dev/null
@@ -1,461 +0,0 @@
1//! Name resolution algorithm. The end result of the algorithm is `ItemMap`: a
2//! map with maps each module to it's scope: the set of items, visible in the
3//! module. That is, we only resolve imports here, name resolution of item
4//! bodies will be done in a separate step.
5//!
6//! Like Rustc, we use an interative per-crate algorithm: we start with scopes
7//! containing only directly defined items, and then iteratively resolve
8//! imports.
9//!
10//! To make this work nicely in the IDE scenarios, we place `InputModuleItems`
11//! in between raw syntax and name resolution. `InputModuleItems` are computed
12//! using only the module's syntax, and it is all directly defined items plus
13//! imports. The plain is to make `InputModuleItems` independent of local
14//! modifications (that is, typing inside a function shold not change IMIs),
15//! such that the results of name resolution can be preserved unless the module
16//! structure itself is modified.
17use std::{
18 sync::Arc,
19 time::Instant,
20};
21
22use rustc_hash::FxHashMap;
23
24use ra_syntax::{
25 SmolStr, SyntaxKind::{self, *},
26 ast::{self, ModuleItemOwner}
27};
28
29use crate::{
30 Cancelable,
31 loc2id::{DefId, DefLoc},
32 descriptors::{
33 Path, PathKind,
34 DescriptorDatabase,
35 module::{ModuleId, ModuleTree, ModuleSourceNode},
36 },
37 syntax_ptr::{LocalSyntaxPtr},
38 input::SourceRootId,
39};
40
41/// Item map is the result of the name resolution. Item map contains, for each
42/// module, the set of visible items.
43#[derive(Default, Debug, PartialEq, Eq)]
44pub(crate) struct ItemMap {
45 pub(crate) per_module: FxHashMap<ModuleId, ModuleScope>,
46}
47
48#[derive(Debug, Default, PartialEq, Eq, Clone)]
49pub(crate) struct ModuleScope {
50 pub(crate) items: FxHashMap<SmolStr, Resolution>,
51}
52
53/// A set of items and imports declared inside a module, without relation to
54/// other modules.
55///
56/// This stands in-between raw syntax and name resolution and alow us to avoid
57/// recomputing name res: if `InputModuleItems` are the same, we can avoid
58/// running name resolution.
59#[derive(Debug, Default, PartialEq, Eq)]
60pub(crate) struct InputModuleItems {
61 items: Vec<ModuleItem>,
62 imports: Vec<Import>,
63}
64
65#[derive(Debug, Clone, PartialEq, Eq)]
66struct Import {
67 path: Path,
68 kind: ImportKind,
69}
70
71#[derive(Debug, Clone, PartialEq, Eq)]
72enum ImportKind {
73 Glob,
74 // TODO: make offset independent
75 Named(LocalSyntaxPtr),
76}
77
78pub(crate) fn input_module_items(
79 db: &impl DescriptorDatabase,
80 source_root: SourceRootId,
81 module_id: ModuleId,
82) -> Cancelable<Arc<InputModuleItems>> {
83 let module_tree = db._module_tree(source_root)?;
84 let source = module_id.source(&module_tree);
85 let res = match source.resolve(db) {
86 ModuleSourceNode::SourceFile(it) => {
87 let items = it.borrowed().items();
88 InputModuleItems::new(items)
89 }
90 ModuleSourceNode::Module(it) => {
91 let items = it
92 .borrowed()
93 .item_list()
94 .into_iter()
95 .flat_map(|it| it.items());
96 InputModuleItems::new(items)
97 }
98 };
99 Ok(Arc::new(res))
100}
101
102pub(crate) fn item_map(
103 db: &impl DescriptorDatabase,
104 source_root: SourceRootId,
105) -> Cancelable<Arc<ItemMap>> {
106 let start = Instant::now();
107 let module_tree = db._module_tree(source_root)?;
108 let input = module_tree
109 .modules()
110 .map(|id| {
111 let items = db._input_module_items(source_root, id)?;
112 Ok((id, items))
113 })
114 .collect::<Cancelable<FxHashMap<_, _>>>()?;
115
116 let mut resolver = Resolver {
117 db: db,
118 input: &input,
119 source_root,
120 module_tree,
121 result: ItemMap::default(),
122 };
123 resolver.resolve()?;
124 let res = resolver.result;
125 let elapsed = start.elapsed();
126 log::info!("item_map: {:?}", elapsed);
127 Ok(Arc::new(res))
128}
129
130/// Resolution is basically `DefId` atm, but it should account for stuff like
131/// multiple namespaces, ambiguity and errors.
132#[derive(Debug, Clone, PartialEq, Eq)]
133pub(crate) struct Resolution {
134 /// None for unresolved
135 pub(crate) def_id: Option<DefId>,
136 /// ident by whitch this is imported into local scope.
137 /// TODO: make this offset-independent.
138 pub(crate) import_name: Option<LocalSyntaxPtr>,
139}
140
141// #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
142// enum Namespace {
143// Types,
144// Values,
145// }
146
147// #[derive(Debug)]
148// struct PerNs<T> {
149// types: Option<T>,
150// values: Option<T>,
151// }
152
153#[derive(Debug, PartialEq, Eq)]
154struct ModuleItem {
155 ptr: LocalSyntaxPtr,
156 name: SmolStr,
157 kind: SyntaxKind,
158 vis: Vis,
159}
160
161#[derive(Debug, PartialEq, Eq)]
162enum Vis {
163 // Priv,
164 Other,
165}
166
167impl InputModuleItems {
168 fn new<'a>(items: impl Iterator<Item = ast::ModuleItem<'a>>) -> InputModuleItems {
169 let mut res = InputModuleItems::default();
170 for item in items {
171 res.add_item(item);
172 }
173 res
174 }
175
176 fn add_item(&mut self, item: ast::ModuleItem) -> Option<()> {
177 match item {
178 ast::ModuleItem::StructDef(it) => self.items.push(ModuleItem::new(it)?),
179 ast::ModuleItem::EnumDef(it) => self.items.push(ModuleItem::new(it)?),
180 ast::ModuleItem::FnDef(it) => self.items.push(ModuleItem::new(it)?),
181 ast::ModuleItem::TraitDef(it) => self.items.push(ModuleItem::new(it)?),
182 ast::ModuleItem::TypeDef(it) => self.items.push(ModuleItem::new(it)?),
183 ast::ModuleItem::ImplItem(_) => {
184 // impls don't define items
185 }
186 ast::ModuleItem::UseItem(it) => self.add_use_item(it),
187 ast::ModuleItem::ExternCrateItem(_) => {
188 // TODO
189 }
190 ast::ModuleItem::ConstDef(it) => self.items.push(ModuleItem::new(it)?),
191 ast::ModuleItem::StaticDef(it) => self.items.push(ModuleItem::new(it)?),
192 ast::ModuleItem::Module(it) => self.items.push(ModuleItem::new(it)?),
193 }
194 Some(())
195 }
196
197 fn add_use_item(&mut self, item: ast::UseItem) {
198 Path::expand_use_item(item, |path, ptr| {
199 let kind = match ptr {
200 None => ImportKind::Glob,
201 Some(ptr) => ImportKind::Named(ptr),
202 };
203 self.imports.push(Import { kind, path })
204 })
205 }
206}
207
208impl ModuleItem {
209 fn new<'a>(item: impl ast::NameOwner<'a>) -> Option<ModuleItem> {
210 let name = item.name()?.text();
211 let ptr = LocalSyntaxPtr::new(item.syntax());
212 let kind = item.syntax().kind();
213 let vis = Vis::Other;
214 let res = ModuleItem {
215 ptr,
216 name,
217 kind,
218 vis,
219 };
220 Some(res)
221 }
222}
223
224struct Resolver<'a, DB> {
225 db: &'a DB,
226 input: &'a FxHashMap<ModuleId, Arc<InputModuleItems>>,
227 source_root: SourceRootId,
228 module_tree: Arc<ModuleTree>,
229 result: ItemMap,
230}
231
232impl<'a, DB> Resolver<'a, DB>
233where
234 DB: DescriptorDatabase,
235{
236 fn resolve(&mut self) -> Cancelable<()> {
237 for (&module_id, items) in self.input.iter() {
238 self.populate_module(module_id, items)
239 }
240
241 for &module_id in self.input.keys() {
242 crate::db::check_canceled(self.db)?;
243 self.resolve_imports(module_id);
244 }
245 Ok(())
246 }
247
248 fn populate_module(&mut self, module_id: ModuleId, input: &InputModuleItems) {
249 let file_id = module_id.source(&self.module_tree).file_id();
250
251 let mut module_items = ModuleScope::default();
252
253 for import in input.imports.iter() {
254 if let Some(name) = import.path.segments.iter().last() {
255 if let ImportKind::Named(ptr) = import.kind {
256 module_items.items.insert(
257 name.clone(),
258 Resolution {
259 def_id: None,
260 import_name: Some(ptr),
261 },
262 );
263 }
264 }
265 }
266
267 for item in input.items.iter() {
268 if item.kind == MODULE {
269 // handle submodules separatelly
270 continue;
271 }
272 let ptr = item.ptr.into_global(file_id);
273 let def_loc = DefLoc::Item { ptr };
274 let def_id = self.db.id_maps().def_id(def_loc);
275 let resolution = Resolution {
276 def_id: Some(def_id),
277 import_name: None,
278 };
279 module_items.items.insert(item.name.clone(), resolution);
280 }
281
282 for (name, mod_id) in module_id.children(&self.module_tree) {
283 let def_loc = DefLoc::Module {
284 id: mod_id,
285 source_root: self.source_root,
286 };
287 let def_id = self.db.id_maps().def_id(def_loc);
288 let resolution = Resolution {
289 def_id: Some(def_id),
290 import_name: None,
291 };
292 module_items.items.insert(name, resolution);
293 }
294
295 self.result.per_module.insert(module_id, module_items);
296 }
297
298 fn resolve_imports(&mut self, module_id: ModuleId) {
299 for import in self.input[&module_id].imports.iter() {
300 self.resolve_import(module_id, import);
301 }
302 }
303
304 fn resolve_import(&mut self, module_id: ModuleId, import: &Import) {
305 let ptr = match import.kind {
306 ImportKind::Glob => return,
307 ImportKind::Named(ptr) => ptr,
308 };
309
310 let mut curr = match import.path.kind {
311 // TODO: handle extern crates
312 PathKind::Plain => return,
313 PathKind::Self_ => module_id,
314 PathKind::Super => {
315 match module_id.parent(&self.module_tree) {
316 Some(it) => it,
317 // TODO: error
318 None => return,
319 }
320 }
321 PathKind::Crate => module_id.crate_root(&self.module_tree),
322 };
323
324 for (i, name) in import.path.segments.iter().enumerate() {
325 let is_last = i == import.path.segments.len() - 1;
326
327 let def_id = match self.result.per_module[&curr].items.get(name) {
328 None => return,
329 Some(res) => match res.def_id {
330 Some(it) => it,
331 None => return,
332 },
333 };
334
335 if !is_last {
336 curr = match self.db.id_maps().def_loc(def_id) {
337 DefLoc::Module { id, .. } => id,
338 _ => return,
339 }
340 } else {
341 self.update(module_id, |items| {
342 let res = Resolution {
343 def_id: Some(def_id),
344 import_name: Some(ptr),
345 };
346 items.items.insert(name.clone(), res);
347 })
348 }
349 }
350 }
351
352 fn update(&mut self, module_id: ModuleId, f: impl FnOnce(&mut ModuleScope)) {
353 let module_items = self.result.per_module.get_mut(&module_id).unwrap();
354 f(module_items)
355 }
356}
357
358#[cfg(test)]
359mod tests {
360 use crate::{
361 AnalysisChange,
362 mock_analysis::{MockAnalysis, analysis_and_position},
363 descriptors::{DescriptorDatabase, module::ModuleDescriptor},
364 input::FilesDatabase,
365};
366 use super::*;
367
368 fn item_map(fixture: &str) -> (Arc<ItemMap>, ModuleId) {
369 let (analysis, pos) = analysis_and_position(fixture);
370 let db = analysis.imp.db;
371 let source_root = db.file_source_root(pos.file_id);
372 let descr = ModuleDescriptor::guess_from_position(&*db, pos)
373 .unwrap()
374 .unwrap();
375 let module_id = descr.module_id;
376 (db._item_map(source_root).unwrap(), module_id)
377 }
378
379 #[test]
380 fn test_item_map() {
381 let (item_map, module_id) = item_map(
382 "
383 //- /lib.rs
384 mod foo;
385
386 use crate::foo::bar::Baz;
387 <|>
388
389 //- /foo/mod.rs
390 pub mod bar;
391
392 //- /foo/bar.rs
393 pub struct Baz;
394 ",
395 );
396 let name = SmolStr::from("Baz");
397 let resolution = &item_map.per_module[&module_id].items[&name];
398 assert!(resolution.def_id.is_some());
399 }
400
401 #[test]
402 fn typing_inside_a_function_should_not_invalidate_item_map() {
403 let mock_analysis = MockAnalysis::with_files(
404 "
405 //- /lib.rs
406 mod foo;
407
408 use crate::foo::bar::Baz;
409
410 fn foo() -> i32 {
411 1 + 1
412 }
413 //- /foo/mod.rs
414 pub mod bar;
415
416 //- /foo/bar.rs
417 pub struct Baz;
418 ",
419 );
420
421 let file_id = mock_analysis.id_of("/lib.rs");
422 let mut host = mock_analysis.analysis_host();
423
424 let source_root = host.analysis().imp.db.file_source_root(file_id);
425
426 {
427 let db = host.analysis().imp.db;
428 let events = db.log_executed(|| {
429 db._item_map(source_root).unwrap();
430 });
431 assert!(format!("{:?}", events).contains("_item_map"))
432 }
433
434 let mut change = AnalysisChange::new();
435
436 change.change_file(
437 file_id,
438 "
439 mod foo;
440
441 use crate::foo::bar::Baz;
442
443 fn foo() -> i32 { 92 }
444 "
445 .to_string(),
446 );
447
448 host.apply_change(change);
449
450 {
451 let db = host.analysis().imp.db;
452 let events = db.log_executed(|| {
453 db._item_map(source_root).unwrap();
454 });
455 // assert!(
456 // !format!("{:?}", events).contains("_item_map"),
457 // "{:#?}", events
458 // )
459 }
460 }
461}
diff --git a/crates/ra_analysis/src/descriptors/path.rs b/crates/ra_analysis/src/descriptors/path.rs
deleted file mode 100644
index 99fca18b1..000000000
--- a/crates/ra_analysis/src/descriptors/path.rs
+++ /dev/null
@@ -1,153 +0,0 @@
1use ra_syntax::{SmolStr, ast, AstNode};
2
3use crate::syntax_ptr::LocalSyntaxPtr;
4
5#[derive(Debug, Clone, PartialEq, Eq)]
6pub(crate) struct Path {
7 pub(crate) kind: PathKind,
8 pub(crate) segments: Vec<SmolStr>,
9}
10
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub(crate) enum PathKind {
13 Plain,
14 Self_,
15 Super,
16 Crate,
17}
18
19impl Path {
20 /// Calls `cb` with all paths, represented by this use item.
21 pub(crate) fn expand_use_item(
22 item: ast::UseItem,
23 mut cb: impl FnMut(Path, Option<LocalSyntaxPtr>),
24 ) {
25 if let Some(tree) = item.use_tree() {
26 expand_use_tree(None, tree, &mut cb);
27 }
28 }
29
30 /// Converts an `ast::Path` to `Path`. Works with use trees.
31 pub(crate) fn from_ast(mut path: ast::Path) -> Option<Path> {
32 let mut kind = PathKind::Plain;
33 let mut segments = Vec::new();
34 loop {
35 let segment = path.segment()?;
36 match segment.kind()? {
37 ast::PathSegmentKind::Name(name) => segments.push(name.text()),
38 ast::PathSegmentKind::CrateKw => {
39 kind = PathKind::Crate;
40 break;
41 }
42 ast::PathSegmentKind::SelfKw => {
43 kind = PathKind::Self_;
44 break;
45 }
46 ast::PathSegmentKind::SuperKw => {
47 kind = PathKind::Super;
48 break;
49 }
50 }
51 path = match qualifier(path) {
52 Some(it) => it,
53 None => break,
54 };
55 }
56 segments.reverse();
57 return Some(Path { kind, segments });
58
59 fn qualifier(path: ast::Path) -> Option<ast::Path> {
60 if let Some(q) = path.qualifier() {
61 return Some(q);
62 }
63 // TODO: this bottom up traversal is not too precise.
64 // Should we handle do a top-down analysiss, recording results?
65 let use_tree_list = path.syntax().ancestors().find_map(ast::UseTreeList::cast)?;
66 let use_tree = use_tree_list.parent_use_tree();
67 use_tree.path()
68 }
69 }
70
71 /// `true` is this path is a single identifier, like `foo`
72 pub(crate) fn is_ident(&self) -> bool {
73 self.kind == PathKind::Plain && self.segments.len() == 1
74 }
75}
76
77fn expand_use_tree(
78 prefix: Option<Path>,
79 tree: ast::UseTree,
80 cb: &mut impl FnMut(Path, Option<LocalSyntaxPtr>),
81) {
82 if let Some(use_tree_list) = tree.use_tree_list() {
83 let prefix = match tree.path() {
84 None => prefix,
85 Some(path) => match convert_path(prefix, path) {
86 Some(it) => Some(it),
87 None => return, // TODO: report errors somewhere
88 },
89 };
90 for tree in use_tree_list.use_trees() {
91 expand_use_tree(prefix.clone(), tree, cb);
92 }
93 } else {
94 if let Some(ast_path) = tree.path() {
95 if let Some(path) = convert_path(prefix, ast_path) {
96 let ptr = if tree.has_star() {
97 None
98 } else {
99 let ptr = LocalSyntaxPtr::new(ast_path.segment().unwrap().syntax());
100 Some(ptr)
101 };
102 cb(path, ptr)
103 }
104 }
105 }
106}
107
108fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
109 let prefix = if let Some(qual) = path.qualifier() {
110 Some(convert_path(prefix, qual)?)
111 } else {
112 None
113 };
114 let segment = path.segment()?;
115 let res = match segment.kind()? {
116 ast::PathSegmentKind::Name(name) => {
117 let mut res = prefix.unwrap_or_else(|| Path {
118 kind: PathKind::Plain,
119 segments: Vec::with_capacity(1),
120 });
121 res.segments.push(name.text());
122 res
123 }
124 ast::PathSegmentKind::CrateKw => {
125 if prefix.is_some() {
126 return None;
127 }
128 Path {
129 kind: PathKind::Crate,
130 segments: Vec::new(),
131 }
132 }
133 ast::PathSegmentKind::SelfKw => {
134 if prefix.is_some() {
135 return None;
136 }
137 Path {
138 kind: PathKind::Self_,
139 segments: Vec::new(),
140 }
141 }
142 ast::PathSegmentKind::SuperKw => {
143 if prefix.is_some() {
144 return None;
145 }
146 Path {
147 kind: PathKind::Super,
148 segments: Vec::new(),
149 }
150 }
151 };
152 Some(res)
153}
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index ad6b52371..f5cb3550e 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,94 +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::{ModuleDescriptor, 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 pub(crate) fn debug_path(&self, file_id: FileId) -> Option<std::path::PathBuf> {
63 self.inner.debug_path(file_id)
64 }
65 fn inner(&self) -> *const FileResolver {
66 &*self.inner
67 }
68}
69
70impl Default for FileResolverImp {
71 fn default() -> FileResolverImp {
72 #[derive(Debug)]
73 struct DummyResolver;
74 impl FileResolver for DummyResolver {
75 fn file_stem(&self, _file_: FileId) -> String {
76 panic!("file resolver not set")
77 }
78 fn resolve(
79 &self,
80 _file_id: FileId,
81 _path: &::relative_path::RelativePath,
82 ) -> Option<FileId> {
83 panic!("file resolver not set")
84 }
85 }
86 FileResolverImp {
87 inner: Arc::new(DummyResolver),
88 }
89 }
90}
91
92#[derive(Debug, Default)] 31#[derive(Debug, Default)]
93pub(crate) struct AnalysisHostImpl { 32pub(crate) struct AnalysisHostImpl {
94 db: db::RootDatabase, 33 db: db::RootDatabase,
@@ -105,7 +44,7 @@ impl AnalysisHostImpl {
105 44
106 for (file_id, text) in change.files_changed { 45 for (file_id, text) in change.files_changed {
107 self.db 46 self.db
108 .query_mut(crate::input::FileTextQuery) 47 .query_mut(ra_db::FileTextQuery)
109 .set(file_id, Arc::new(text)) 48 .set(file_id, Arc::new(text))
110 } 49 }
111 if !(change.files_added.is_empty() && change.files_removed.is_empty()) { 50 if !(change.files_added.is_empty() && change.files_removed.is_empty()) {
@@ -115,22 +54,22 @@ impl AnalysisHostImpl {
115 let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE)); 54 let mut source_root = SourceRoot::clone(&self.db.source_root(WORKSPACE));
116 for (file_id, text) in change.files_added { 55 for (file_id, text) in change.files_added {
117 self.db 56 self.db
118 .query_mut(crate::input::FileTextQuery) 57 .query_mut(ra_db::FileTextQuery)
119 .set(file_id, Arc::new(text)); 58 .set(file_id, Arc::new(text));
120 self.db 59 self.db
121 .query_mut(crate::input::FileSourceRootQuery) 60 .query_mut(ra_db::FileSourceRootQuery)
122 .set(file_id, crate::input::WORKSPACE); 61 .set(file_id, ra_db::WORKSPACE);
123 source_root.files.insert(file_id); 62 source_root.files.insert(file_id);
124 } 63 }
125 for file_id in change.files_removed { 64 for file_id in change.files_removed {
126 self.db 65 self.db
127 .query_mut(crate::input::FileTextQuery) 66 .query_mut(ra_db::FileTextQuery)
128 .set(file_id, Arc::new(String::new())); 67 .set(file_id, Arc::new(String::new()));
129 source_root.files.remove(&file_id); 68 source_root.files.remove(&file_id);
130 } 69 }
131 source_root.file_resolver = file_resolver; 70 source_root.file_resolver = file_resolver;
132 self.db 71 self.db
133 .query_mut(crate::input::SourceRootQuery) 72 .query_mut(ra_db::SourceRootQuery)
134 .set(WORKSPACE, Arc::new(source_root)) 73 .set(WORKSPACE, Arc::new(source_root))
135 } 74 }
136 if !change.libraries_added.is_empty() { 75 if !change.libraries_added.is_empty() {
@@ -147,10 +86,10 @@ impl AnalysisHostImpl {
147 library.file_resolver.debug_path(file_id) 86 library.file_resolver.debug_path(file_id)
148 ); 87 );
149 self.db 88 self.db
150 .query_mut(crate::input::FileSourceRootQuery) 89 .query_mut(ra_db::FileSourceRootQuery)
151 .set_constant(file_id, source_root_id); 90 .set_constant(file_id, source_root_id);
152 self.db 91 self.db
153 .query_mut(crate::input::FileTextQuery) 92 .query_mut(ra_db::FileTextQuery)
154 .set_constant(file_id, Arc::new(text)); 93 .set_constant(file_id, Arc::new(text));
155 } 94 }
156 let source_root = SourceRoot { 95 let source_root = SourceRoot {
@@ -158,19 +97,19 @@ impl AnalysisHostImpl {
158 file_resolver: library.file_resolver, 97 file_resolver: library.file_resolver,
159 }; 98 };
160 self.db 99 self.db
161 .query_mut(crate::input::SourceRootQuery) 100 .query_mut(ra_db::SourceRootQuery)
162 .set(source_root_id, Arc::new(source_root)); 101 .set(source_root_id, Arc::new(source_root));
163 self.db 102 self.db
164 .query_mut(crate::input::LibrarySymbolsQuery) 103 .query_mut(crate::symbol_index::LibrarySymbolsQuery)
165 .set(source_root_id, Arc::new(library.symbol_index)); 104 .set(source_root_id, Arc::new(library.symbol_index));
166 } 105 }
167 self.db 106 self.db
168 .query_mut(crate::input::LibrariesQuery) 107 .query_mut(ra_db::LibrariesQuery)
169 .set((), Arc::new(libraries)); 108 .set((), Arc::new(libraries));
170 } 109 }
171 if let Some(crate_graph) = change.crate_graph { 110 if let Some(crate_graph) = change.crate_graph {
172 self.db 111 self.db
173 .query_mut(crate::input::CrateGraphQuery) 112 .query_mut(ra_db::CrateGraphQuery)
174 .set((), Arc::new(crate_graph)) 113 .set((), Arc::new(crate_graph))
175 } 114 }
176 } 115 }
@@ -189,7 +128,7 @@ impl fmt::Debug for AnalysisImpl {
189 128
190impl AnalysisImpl { 129impl AnalysisImpl {
191 pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode { 130 pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
192 self.db.file_syntax(file_id) 131 self.db.source_file(file_id)
193 } 132 }
194 pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> { 133 pub fn file_line_index(&self, file_id: FileId) -> Arc<LineIndex> {
195 self.db.file_lines(file_id) 134 self.db.file_lines(file_id)
@@ -220,14 +159,14 @@ impl AnalysisImpl {
220 .collect() 159 .collect()
221 }; 160 };
222 self.db 161 self.db
223 .query(FileSyntaxQuery) 162 .query(SourceFileQuery)
224 .sweep(salsa::SweepStrategy::default().discard_values()); 163 .sweep(salsa::SweepStrategy::default().discard_values());
225 Ok(query.search(&buf)) 164 Ok(query.search(&buf))
226 } 165 }
227 /// This return `Vec`: a module may be included from several places. We 166 /// This return `Vec`: a module may be included from several places. We
228 /// don't handle this case yet though, so the Vec has length at most one. 167 /// don't handle this case yet though, so the Vec has length at most one.
229 pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> { 168 pub fn parent_module(&self, position: FilePosition) -> Cancelable<Vec<(FileId, FileSymbol)>> {
230 let descr = match ModuleDescriptor::guess_from_position(&*self.db, position)? { 169 let descr = match hir::Module::guess_from_position(&*self.db, position)? {
231 None => return Ok(Vec::new()), 170 None => return Ok(Vec::new()),
232 Some(it) => it, 171 Some(it) => it,
233 }; 172 };
@@ -246,7 +185,7 @@ impl AnalysisImpl {
246 } 185 }
247 /// Returns `Vec` for the same reason as `parent_module` 186 /// Returns `Vec` for the same reason as `parent_module`
248 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> { 187 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
249 let descr = match ModuleDescriptor::guess_from_file_id(&*self.db, file_id)? { 188 let descr = match hir::Module::guess_from_file_id(&*self.db, file_id)? {
250 None => return Ok(Vec::new()), 189 None => return Ok(Vec::new()),
251 Some(it) => it, 190 Some(it) => it,
252 }; 191 };
@@ -261,7 +200,7 @@ impl AnalysisImpl {
261 Ok(crate_id.into_iter().collect()) 200 Ok(crate_id.into_iter().collect())
262 } 201 }
263 pub fn crate_root(&self, crate_id: CrateId) -> FileId { 202 pub fn crate_root(&self, crate_id: CrateId) -> FileId {
264 self.db.crate_graph().crate_roots[&crate_id] 203 self.db.crate_graph().crate_root(crate_id)
265 } 204 }
266 pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> { 205 pub fn completions(&self, position: FilePosition) -> Cancelable<Option<Vec<CompletionItem>>> {
267 completions(&self.db, position) 206 completions(&self.db, position)
@@ -270,33 +209,36 @@ impl AnalysisImpl {
270 &self, 209 &self,
271 position: FilePosition, 210 position: FilePosition,
272 ) -> Cancelable<Vec<(FileId, FileSymbol)>> { 211 ) -> Cancelable<Vec<(FileId, FileSymbol)>> {
273 let file = self.db.file_syntax(position.file_id); 212 let file = self.db.source_file(position.file_id);
274 let syntax = file.syntax(); 213 let syntax = file.syntax();
275 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) {
276 // First try to resolve the symbol locally 215 if let Some(fn_descr) =
277 return if let Some((name, range)) = 216 hir::Function::guess_for_name_ref(&*self.db, position.file_id, name_ref)
278 resolve_local_name(&self.db, position.file_id, name_ref)
279 { 217 {
280 let mut vec = vec![]; 218 let scope = fn_descr.scope(&*self.db);
281 vec.push(( 219 // First try to resolve the symbol locally
282 position.file_id, 220 return if let Some(entry) = scope.resolve_local_name(name_ref) {
283 FileSymbol { 221 let mut vec = vec![];
284 name, 222 vec.push((
285 node_range: range, 223 position.file_id,
286 kind: NAME, 224 FileSymbol {
287 }, 225 name: entry.name().clone(),
288 )); 226 node_range: entry.ptr().range(),
289 Ok(vec) 227 kind: NAME,
290 } else { 228 },
291 // If that fails try the index based approach. 229 ));
292 self.index_resolve(name_ref) 230 Ok(vec)
293 }; 231 } else {
232 // If that fails try the index based approach.
233 self.index_resolve(name_ref)
234 };
235 }
294 } 236 }
295 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) {
296 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) {
297 if module.has_semi() { 239 if module.has_semi() {
298 let parent_module = 240 let parent_module =
299 ModuleDescriptor::guess_from_file_id(&*self.db, position.file_id)?; 241 hir::Module::guess_from_file_id(&*self.db, position.file_id)?;
300 let child_name = module.name(); 242 let child_name = module.name();
301 match (parent_module, child_name) { 243 match (parent_module, child_name) {
302 (Some(parent_module), Some(child_name)) => { 244 (Some(parent_module), Some(child_name)) => {
@@ -319,32 +261,42 @@ impl AnalysisImpl {
319 } 261 }
320 262
321 pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> { 263 pub fn find_all_refs(&self, position: FilePosition) -> Vec<(FileId, TextRange)> {
322 let file = self.db.file_syntax(position.file_id); 264 let file = self.db.source_file(position.file_id);
323 let syntax = file.syntax();
324
325 // Find the binding associated with the offset 265 // Find the binding associated with the offset
326 let maybe_binding = 266 let (binding, descr) = match find_binding(&self.db, &file, position) {
327 find_node_at_offset::<ast::BindPat>(syntax, position.offset).or_else(|| {
328 let name_ref = find_node_at_offset::<ast::NameRef>(syntax, position.offset)?;
329 let resolved = resolve_local_name(&self.db, position.file_id, name_ref)?;
330 find_node_at_offset::<ast::BindPat>(syntax, resolved.1.end())
331 });
332
333 let binding = match maybe_binding {
334 None => return Vec::new(), 267 None => return Vec::new(),
335 Some(it) => it, 268 Some(it) => it,
336 }; 269 };
337 270
338 let decl = DeclarationDescriptor::new(binding); 271 let mut ret = vec![(position.file_id, binding.syntax().range())];
339
340 let mut ret = vec![(position.file_id, decl.range)];
341 ret.extend( 272 ret.extend(
342 decl.find_all_refs() 273 descr
274 .scope(&*self.db)
275 .find_all_refs(binding)
343 .into_iter() 276 .into_iter()
344 .map(|ref_desc| (position.file_id, ref_desc.range)), 277 .map(|ref_desc| (position.file_id, ref_desc.range)),
345 ); 278 );
346 279
347 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 }
348 } 300 }
349 301
350 pub fn doc_comment_for( 302 pub fn doc_comment_for(
@@ -352,13 +304,13 @@ impl AnalysisImpl {
352 file_id: FileId, 304 file_id: FileId,
353 symbol: FileSymbol, 305 symbol: FileSymbol,
354 ) -> Cancelable<Option<String>> { 306 ) -> Cancelable<Option<String>> {
355 let file = self.db.file_syntax(file_id); 307 let file = self.db.source_file(file_id);
356 308
357 Ok(symbol.docs(&file)) 309 Ok(symbol.docs(&file))
358 } 310 }
359 311
360 pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> { 312 pub fn diagnostics(&self, file_id: FileId) -> Cancelable<Vec<Diagnostic>> {
361 let syntax = self.db.file_syntax(file_id); 313 let syntax = self.db.source_file(file_id);
362 314
363 let mut res = ra_editor::diagnostics(&syntax) 315 let mut res = ra_editor::diagnostics(&syntax)
364 .into_iter() 316 .into_iter()
@@ -368,7 +320,7 @@ impl AnalysisImpl {
368 fix: None, 320 fix: None,
369 }) 321 })
370 .collect::<Vec<_>>(); 322 .collect::<Vec<_>>();
371 if let Some(m) = ModuleDescriptor::guess_from_file_id(&*self.db, file_id)? { 323 if let Some(m) = hir::Module::guess_from_file_id(&*self.db, file_id)? {
372 for (name_node, problem) in m.problems(&*self.db) { 324 for (name_node, problem) in m.problems(&*self.db) {
373 let diag = match problem { 325 let diag = match problem {
374 Problem::UnresolvedModule { candidate } => { 326 Problem::UnresolvedModule { candidate } => {
@@ -445,27 +397,22 @@ impl AnalysisImpl {
445 pub fn resolve_callable( 397 pub fn resolve_callable(
446 &self, 398 &self,
447 position: FilePosition, 399 position: FilePosition,
448 ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> { 400 ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
449 let file = self.db.file_syntax(position.file_id); 401 let file = self.db.source_file(position.file_id);
450 let syntax = file.syntax(); 402 let syntax = file.syntax();
451 403
452 // Find the calling expression and it's NameRef 404 // Find the calling expression and it's NameRef
453 let calling_node = match FnCallNode::with_node(syntax, position.offset) { 405 let calling_node = ctry!(FnCallNode::with_node(syntax, position.offset));
454 Some(node) => node, 406 let name_ref = ctry!(calling_node.name_ref());
455 None => return Ok(None),
456 };
457 let name_ref = match calling_node.name_ref() {
458 Some(name) => name,
459 None => return Ok(None),
460 };
461 407
462 // Resolve the function's NameRef (NOTE: this isn't entirely accurate). 408 // Resolve the function's NameRef (NOTE: this isn't entirely accurate).
463 let file_symbols = self.index_resolve(name_ref)?; 409 let file_symbols = self.index_resolve(name_ref)?;
464 for (fn_fiel_id, fs) in file_symbols { 410 for (fn_file_id, fs) in file_symbols {
465 if fs.kind == FN_DEF { 411 if fs.kind == FN_DEF {
466 let fn_file = self.db.file_syntax(fn_fiel_id); 412 let fn_file = self.db.source_file(fn_file_id);
467 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()) {
468 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) {
469 // 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
470 let mut current_parameter = None; 417 let mut current_parameter = None;
471 418
@@ -538,16 +485,6 @@ impl SourceChange {
538 } 485 }
539} 486}
540 487
541impl CrateGraph {
542 fn crate_id_for_crate_root(&self, file_id: FileId) -> Option<CrateId> {
543 let (&crate_id, _) = self
544 .crate_roots
545 .iter()
546 .find(|(_crate_id, &root_id)| root_id == file_id)?;
547 Some(crate_id)
548 }
549}
550
551enum FnCallNode<'a> { 488enum FnCallNode<'a> {
552 CallExpr(ast::CallExpr<'a>), 489 CallExpr(ast::CallExpr<'a>),
553 MethodCallExpr(ast::MethodCallExpr<'a>), 490 MethodCallExpr(ast::MethodCallExpr<'a>),
@@ -586,16 +523,3 @@ impl<'a> FnCallNode<'a> {
586 } 523 }
587 } 524 }
588} 525}
589
590fn resolve_local_name(
591 db: &db::RootDatabase,
592 file_id: FileId,
593 name_ref: ast::NameRef,
594) -> Option<(SmolStr, TextRange)> {
595 let fn_def = name_ref.syntax().ancestors().find_map(ast::FnDef::cast)?;
596 let fn_id = FnId::get(db, file_id, fn_def);
597 let scopes = db.fn_scopes(fn_id);
598 let scope_entry = crate::descriptors::function::resolve_local_name(name_ref, &scopes)?;
599 let syntax = db.resolve_syntax_ptr(scope_entry.ptr().into_global(file_id));
600 Some((scope_entry.name().clone(), syntax.range()))
601}
diff --git a/crates/ra_analysis/src/input.rs b/crates/ra_analysis/src/input.rs
deleted file mode 100644
index a78b6e397..000000000
--- a/crates/ra_analysis/src/input.rs
+++ /dev/null
@@ -1,79 +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 fn debug_path(&self, _file_id: FileId) -> Option<std::path::PathBuf> {
37 None
38 }
39}
40
41salsa::query_group! {
42 pub(crate) trait FilesDatabase: salsa::Database {
43 fn file_text(file_id: FileId) -> Arc<String> {
44 type FileTextQuery;
45 storage input;
46 }
47 fn file_source_root(file_id: FileId) -> SourceRootId {
48 type FileSourceRootQuery;
49 storage input;
50 }
51 fn source_root(id: SourceRootId) -> Arc<SourceRoot> {
52 type SourceRootQuery;
53 storage input;
54 }
55 fn libraries() -> Arc<Vec<SourceRootId>> {
56 type LibrariesQuery;
57 storage input;
58 }
59 fn library_symbols(id: SourceRootId) -> Arc<SymbolIndex> {
60 type LibrarySymbolsQuery;
61 storage input;
62 }
63 fn crate_graph() -> Arc<CrateGraph> {
64 type CrateGraphQuery;
65 storage input;
66 }
67 }
68}
69
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
71pub(crate) struct SourceRootId(pub(crate) u32);
72
73#[derive(Default, Clone, Debug, PartialEq, Eq)]
74pub(crate) struct SourceRoot {
75 pub(crate) file_resolver: FileResolverImp,
76 pub(crate) files: FxHashSet<FileId>,
77}
78
79pub(crate) const WORKSPACE: SourceRootId = SourceRootId(0);
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index cedbd1fc8..12df580ba 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -9,49 +9,45 @@ extern crate relative_path;
9extern crate rustc_hash; 9extern crate rustc_hash;
10extern crate salsa; 10extern crate salsa;
11 11
12mod arena; 12macro_rules! ctry {
13 ($expr:expr) => {
14 match $expr {
15 None => return Ok(None),
16 Some(it) => it,
17 }
18 };
19}
20
13mod db; 21mod db;
14mod loc2id;
15mod input;
16mod imp; 22mod imp;
17mod completion; 23mod completion;
18mod descriptors;
19mod symbol_index; 24mod symbol_index;
20mod syntax_ptr;
21pub mod mock_analysis; 25pub mod mock_analysis;
22 26
23use std::{fmt, sync::Arc}; 27use std::{fmt, sync::Arc};
24 28
25use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit}; 29use ra_syntax::{AtomEdit, SourceFileNode, TextRange, TextUnit};
30use ra_db::FileResolverImp;
26use rayon::prelude::*; 31use rayon::prelude::*;
27use relative_path::RelativePathBuf; 32use relative_path::RelativePathBuf;
28 33
29use crate::{ 34use crate::{
30 imp::{AnalysisHostImpl, AnalysisImpl, FileResolverImp}, 35 imp::{AnalysisHostImpl, AnalysisImpl},
31 symbol_index::SymbolIndex, 36 symbol_index::SymbolIndex,
32}; 37};
33 38
34pub use crate::{ 39pub use crate::{
35 completion::CompletionItem, 40 completion::CompletionItem,
36 descriptors::function::FnDescriptor,
37 input::{CrateGraph, CrateId, FileId, FileResolver},
38}; 41};
39pub use ra_editor::{ 42pub use ra_editor::{
40 FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode, 43 FileSymbol, Fold, FoldKind, HighlightedRange, LineIndex, Runnable, RunnableKind, StructureNode,
41}; 44};
45pub use hir::FnSignatureInfo;
42 46
43#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] 47pub use ra_db::{
44pub struct Canceled; 48 Canceled, Cancelable, FilePosition,
45 49 CrateGraph, CrateId, FileId, FileResolver
46pub type Cancelable<T> = Result<T, Canceled>; 50};
47
48impl std::fmt::Display for Canceled {
49 fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
50 fmt.write_str("Canceled")
51 }
52}
53
54impl std::error::Error for Canceled {}
55 51
56#[derive(Default)] 52#[derive(Default)]
57pub struct AnalysisChange { 53pub struct AnalysisChange {
@@ -121,12 +117,6 @@ impl AnalysisHost {
121 } 117 }
122} 118}
123 119
124#[derive(Clone, Copy, Debug)]
125pub struct FilePosition {
126 pub file_id: FileId,
127 pub offset: TextUnit,
128}
129
130#[derive(Debug)] 120#[derive(Debug)]
131pub struct SourceChange { 121pub struct SourceChange {
132 pub label: String, 122 pub label: String,
@@ -296,7 +286,7 @@ impl Analysis {
296 pub fn resolve_callable( 286 pub fn resolve_callable(
297 &self, 287 &self,
298 position: FilePosition, 288 position: FilePosition,
299 ) -> Cancelable<Option<(FnDescriptor, Option<usize>)>> { 289 ) -> Cancelable<Option<(FnSignatureInfo, Option<usize>)>> {
300 self.imp.resolve_callable(position) 290 self.imp.resolve_callable(position)
301 } 291 }
302} 292}
diff --git a/crates/ra_analysis/src/loc2id.rs b/crates/ra_analysis/src/loc2id.rs
deleted file mode 100644
index e4b55f9b0..000000000
--- a/crates/ra_analysis/src/loc2id.rs
+++ /dev/null
@@ -1,138 +0,0 @@
1use parking_lot::Mutex;
2
3use std::{
4 hash::Hash,
5 sync::Arc,
6};
7
8use rustc_hash::FxHashMap;
9
10use crate::{
11 descriptors::module::ModuleId,
12 syntax_ptr::SyntaxPtr,
13 input::SourceRootId,
14};
15
16/// There are two principle ways to refer to things:
17/// - by their locatinon (module in foo/bar/baz.rs at line 42)
18/// - by their numeric id (module `ModuleId(42)`)
19///
20/// The first one is more powerful (you can actually find the thing in question
21/// by id), but the second one is so much more compact.
22///
23/// `Loc2IdMap` allows us to have a cake an eat it as well: by maintaining a
24/// bidirectional mapping between positional and numeric ids, we can use compact
25/// representation wich still allows us to get the actual item
26#[derive(Debug)]
27pub(crate) struct Loc2IdMap<L, ID>
28where
29 ID: NumericId,
30 L: Clone + Eq + Hash,
31{
32 loc2id: FxHashMap<L, ID>,
33 id2loc: FxHashMap<ID, L>,
34}
35
36impl<L, ID> Default for Loc2IdMap<L, ID>
37where
38 ID: NumericId,
39 L: Clone + Eq + Hash,
40{
41 fn default() -> Self {
42 Loc2IdMap {
43 loc2id: FxHashMap::default(),
44 id2loc: FxHashMap::default(),
45 }
46 }
47}
48
49impl<L, ID> Loc2IdMap<L, ID>
50where
51 ID: NumericId,
52 L: Clone + Eq + Hash,
53{
54 pub fn loc2id(&mut self, loc: &L) -> ID {
55 match self.loc2id.get(loc) {
56 Some(id) => return id.clone(),
57 None => (),
58 }
59 let id = self.loc2id.len();
60 assert!(id < u32::max_value() as usize);
61 let id = ID::from_u32(id as u32);
62 self.loc2id.insert(loc.clone(), id.clone());
63 self.id2loc.insert(id.clone(), loc.clone());
64 id
65 }
66
67 pub fn id2loc(&self, id: ID) -> L {
68 self.id2loc[&id].clone()
69 }
70}
71
72pub(crate) trait NumericId: Clone + Eq + Hash {
73 fn from_u32(id: u32) -> Self;
74 fn to_u32(self) -> u32;
75}
76
77macro_rules! impl_numeric_id {
78 ($id:ident) => {
79 impl NumericId for $id {
80 fn from_u32(id: u32) -> Self {
81 $id(id)
82 }
83 fn to_u32(self) -> u32 {
84 self.0
85 }
86 }
87 };
88}
89
90#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
91pub(crate) struct FnId(u32);
92impl_numeric_id!(FnId);
93
94#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
95pub(crate) struct DefId(u32);
96impl_numeric_id!(DefId);
97
98#[derive(Clone, Debug, PartialEq, Eq, Hash)]
99pub(crate) enum DefLoc {
100 Module {
101 id: ModuleId,
102 source_root: SourceRootId,
103 },
104 Item {
105 ptr: SyntaxPtr,
106 },
107}
108
109pub(crate) trait IdDatabase: salsa::Database {
110 fn id_maps(&self) -> &IdMaps;
111}
112
113#[derive(Debug, Default, Clone)]
114pub(crate) struct IdMaps {
115 inner: Arc<IdMapsInner>,
116}
117
118impl IdMaps {
119 pub(crate) fn fn_id(&self, ptr: SyntaxPtr) -> FnId {
120 self.inner.fns.lock().loc2id(&ptr)
121 }
122 pub(crate) fn fn_ptr(&self, fn_id: FnId) -> SyntaxPtr {
123 self.inner.fns.lock().id2loc(fn_id)
124 }
125
126 pub(crate) fn def_id(&self, loc: DefLoc) -> DefId {
127 self.inner.defs.lock().loc2id(&loc)
128 }
129 pub(crate) fn def_loc(&self, def_id: DefId) -> DefLoc {
130 self.inner.defs.lock().id2loc(def_id)
131 }
132}
133
134#[derive(Debug, Default)]
135struct IdMapsInner {
136 fns: Mutex<Loc2IdMap<SyntaxPtr, FnId>>,
137 defs: Mutex<Loc2IdMap<DefLoc, DefId>>,
138}
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 72b2ebf97..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);
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-22 21:58:33 +0000