aboutsummaryrefslogtreecommitdiff
path: root/crates/ra_analysis/src
diff options
context:
space:
mode:
Diffstat (limited to 'crates/ra_analysis/src')
-rw-r--r--crates/ra_analysis/src/db.rs4
-rw-r--r--crates/ra_analysis/src/descriptors.rs282
-rw-r--r--crates/ra_analysis/src/descriptors/mod.rs63
-rw-r--r--crates/ra_analysis/src/descriptors/module/imp.rs146
-rw-r--r--crates/ra_analysis/src/descriptors/module/mod.rs176
-rw-r--r--crates/ra_analysis/src/imp.rs145
-rw-r--r--crates/ra_analysis/src/lib.rs1
-rw-r--r--crates/ra_analysis/src/roots.rs103
-rw-r--r--crates/ra_analysis/src/symbol_index.rs4
9 files changed, 487 insertions, 437 deletions
diff --git a/crates/ra_analysis/src/db.rs b/crates/ra_analysis/src/db.rs
index 956cbe162..b527cde61 100644
--- a/crates/ra_analysis/src/db.rs
+++ b/crates/ra_analysis/src/db.rs
@@ -12,7 +12,7 @@ use salsa;
12use crate::{ 12use crate::{
13 db, 13 db,
14 Cancelable, Canceled, 14 Cancelable, Canceled,
15 module_map::{ModuleDescriptorQuery, ModuleTreeQuery, ModulesDatabase}, 15 descriptors::module::{SubmodulesQuery, ModuleTreeQuery, ModulesDatabase},
16 symbol_index::SymbolIndex, 16 symbol_index::SymbolIndex,
17 FileId, FileResolverImp, 17 FileId, FileResolverImp,
18}; 18};
@@ -69,7 +69,7 @@ salsa::database_storage! {
69 } 69 }
70 impl ModulesDatabase { 70 impl ModulesDatabase {
71 fn module_tree() for ModuleTreeQuery; 71 fn module_tree() for ModuleTreeQuery;
72 fn module_descriptor() for ModuleDescriptorQuery; 72 fn module_descriptor() for SubmodulesQuery;
73 } 73 }
74 } 74 }
75} 75}
diff --git a/crates/ra_analysis/src/descriptors.rs b/crates/ra_analysis/src/descriptors.rs
deleted file mode 100644
index 92da26493..000000000
--- a/crates/ra_analysis/src/descriptors.rs
+++ /dev/null
@@ -1,282 +0,0 @@
1use std::collections::BTreeMap;
2
3use ra_syntax::{
4 ast::{self, AstNode, NameOwner},
5 text_utils::is_subrange,
6 SmolStr,
7};
8use relative_path::RelativePathBuf;
9
10use crate::{imp::FileResolverImp, FileId};
11
12#[derive(Debug, PartialEq, Eq, Hash)]
13pub struct ModuleDescriptor {
14 pub submodules: Vec<Submodule>,
15}
16
17impl ModuleDescriptor {
18 pub fn new(root: ast::Root) -> ModuleDescriptor {
19 let submodules = modules(root).map(|(name, _)| Submodule { name }).collect();
20
21 ModuleDescriptor { submodules }
22 }
23}
24
25fn modules(root: ast::Root<'_>) -> impl Iterator<Item = (SmolStr, ast::Module<'_>)> {
26 root.modules().filter_map(|module| {
27 let name = module.name()?.text();
28 if !module.has_semi() {
29 return None;
30 }
31 Some((name, module))
32 })
33}
34
35#[derive(Clone, Hash, PartialEq, Eq, Debug)]
36pub struct Submodule {
37 pub name: SmolStr,
38}
39
40#[derive(Debug, PartialEq, Eq, Hash)]
41pub(crate) struct ModuleTreeDescriptor {
42 nodes: Vec<NodeData>,
43 links: Vec<LinkData>,
44 file_id2node: BTreeMap<FileId, Node>,
45}
46
47#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
48struct Node(usize);
49#[derive(Hash, Debug, PartialEq, Eq)]
50struct NodeData {
51 file_id: FileId,
52 links: Vec<Link>,
53 parents: Vec<Link>,
54}
55
56#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
57pub(crate) struct Link(usize);
58#[derive(Hash, Debug, PartialEq, Eq)]
59struct LinkData {
60 owner: Node,
61 name: SmolStr,
62 points_to: Vec<Node>,
63 problem: Option<Problem>,
64}
65
66#[derive(Clone, Debug, Hash, PartialEq, Eq)]
67pub enum Problem {
68 UnresolvedModule {
69 candidate: RelativePathBuf,
70 },
71 NotDirOwner {
72 move_to: RelativePathBuf,
73 candidate: RelativePathBuf,
74 },
75}
76
77impl ModuleTreeDescriptor {
78 pub(crate) fn new<'a>(
79 files: impl Iterator<Item = (FileId, &'a ModuleDescriptor)> + Clone,
80 file_resolver: &FileResolverImp,
81 ) -> ModuleTreeDescriptor {
82 let mut file_id2node = BTreeMap::new();
83 let mut nodes: Vec<NodeData> = files
84 .clone()
85 .enumerate()
86 .map(|(idx, (file_id, _))| {
87 file_id2node.insert(file_id, Node(idx));
88 NodeData {
89 file_id,
90 links: Vec::new(),
91 parents: Vec::new(),
92 }
93 })
94 .collect();
95 let mut links = Vec::new();
96
97 for (idx, (file_id, descr)) in files.enumerate() {
98 let owner = Node(idx);
99 for sub in descr.submodules.iter() {
100 let link = Link(links.len());
101 nodes[owner.0].links.push(link);
102 let (points_to, problem) = resolve_submodule(file_id, &sub.name, file_resolver);
103 let points_to = points_to
104 .into_iter()
105 .map(|file_id| {
106 let node = file_id2node[&file_id];
107 nodes[node.0].parents.push(link);
108 node
109 })
110 .collect();
111
112 links.push(LinkData {
113 owner,
114 name: sub.name.clone(),
115 points_to,
116 problem,
117 })
118 }
119 }
120
121 ModuleTreeDescriptor {
122 nodes,
123 links,
124 file_id2node,
125 }
126 }
127
128 pub(crate) fn parent_modules(&self, file_id: FileId) -> Vec<Link> {
129 let node = self.file_id2node[&file_id];
130 self.node(node).parents.clone()
131 }
132 pub(crate) fn child_module_by_name(&self, file_id: FileId, name: &str) -> Vec<FileId> {
133 let node = self.file_id2node[&file_id];
134 self.node(node)
135 .links
136 .iter()
137 .filter(|it| it.name(self) == name)
138 .flat_map(|link| {
139 link.points_to(self)
140 .iter()
141 .map(|&node| self.node(node).file_id)
142 })
143 .collect()
144 }
145 pub(crate) fn problems<'a, 'b>(
146 &'b self,
147 file_id: FileId,
148 root: ast::Root<'a>,
149 ) -> Vec<(ast::Name<'a>, &'b Problem)> {
150 let node = self.file_id2node[&file_id];
151 self.node(node)
152 .links
153 .iter()
154 .filter_map(|&link| {
155 let problem = self.link(link).problem.as_ref()?;
156 let name = link.bind_source(self, root).name()?;
157 Some((name, problem))
158 })
159 .collect()
160 }
161
162 fn node(&self, node: Node) -> &NodeData {
163 &self.nodes[node.0]
164 }
165 fn link(&self, link: Link) -> &LinkData {
166 &self.links[link.0]
167 }
168}
169
170impl Link {
171 pub(crate) fn name(self, tree: &ModuleTreeDescriptor) -> SmolStr {
172 tree.link(self).name.clone()
173 }
174 pub(crate) fn owner(self, tree: &ModuleTreeDescriptor) -> FileId {
175 let owner = tree.link(self).owner;
176 tree.node(owner).file_id
177 }
178 fn points_to(self, tree: &ModuleTreeDescriptor) -> &[Node] {
179 &tree.link(self).points_to
180 }
181 pub(crate) fn bind_source<'a>(
182 self,
183 tree: &ModuleTreeDescriptor,
184 root: ast::Root<'a>,
185 ) -> ast::Module<'a> {
186 modules(root)
187 .find(|(name, _)| name == &tree.link(self).name)
188 .unwrap()
189 .1
190 }
191}
192
193fn resolve_submodule(
194 file_id: FileId,
195 name: &SmolStr,
196 file_resolver: &FileResolverImp,
197) -> (Vec<FileId>, Option<Problem>) {
198 let mod_name = file_resolver.file_stem(file_id);
199 let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
200
201 let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
202 let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
203 let points_to: Vec<FileId>;
204 let problem: Option<Problem>;
205 if is_dir_owner {
206 points_to = [&file_mod, &dir_mod]
207 .iter()
208 .filter_map(|path| file_resolver.resolve(file_id, path))
209 .collect();
210 problem = if points_to.is_empty() {
211 Some(Problem::UnresolvedModule {
212 candidate: file_mod,
213 })
214 } else {
215 None
216 }
217 } else {
218 points_to = Vec::new();
219 problem = Some(Problem::NotDirOwner {
220 move_to: RelativePathBuf::from(format!("../{}/mod.rs", mod_name)),
221 candidate: file_mod,
222 });
223 }
224 (points_to, problem)
225}
226
227#[derive(Debug, Clone)]
228pub struct FnDescriptor {
229 pub name: String,
230 pub label: String,
231 pub ret_type: Option<String>,
232 pub params: Vec<String>,
233}
234
235impl FnDescriptor {
236 pub fn new(node: ast::FnDef) -> Option<Self> {
237 let name = node.name()?.text().to_string();
238
239 // Strip the body out for the label.
240 let label: String = if let Some(body) = node.body() {
241 let body_range = body.syntax().range();
242 let label: String = node
243 .syntax()
244 .children()
245 .filter(|child| !is_subrange(body_range, child.range()))
246 .map(|node| node.text().to_string())
247 .collect();
248 label
249 } else {
250 node.syntax().text().to_string()
251 };
252
253 let params = FnDescriptor::param_list(node);
254 let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
255
256 Some(FnDescriptor {
257 name,
258 ret_type,
259 params,
260 label,
261 })
262 }
263
264 fn param_list(node: ast::FnDef) -> Vec<String> {
265 let mut res = vec![];
266 if let Some(param_list) = node.param_list() {
267 if let Some(self_param) = param_list.self_param() {
268 res.push(self_param.syntax().text().to_string())
269 }
270
271 // Maybe use param.pat here? See if we can just extract the name?
272 //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
273 res.extend(
274 param_list
275 .params()
276 .filter_map(|p| p.pat())
277 .map(|pat| pat.syntax().text().to_string()),
278 );
279 }
280 res
281 }
282}
diff --git a/crates/ra_analysis/src/descriptors/mod.rs b/crates/ra_analysis/src/descriptors/mod.rs
new file mode 100644
index 000000000..873eb47e4
--- /dev/null
+++ b/crates/ra_analysis/src/descriptors/mod.rs
@@ -0,0 +1,63 @@
1pub(crate) mod module;
2
3use ra_syntax::{
4 ast::{self, AstNode, NameOwner},
5 text_utils::is_subrange,
6};
7
8#[derive(Debug, Clone)]
9pub struct FnDescriptor {
10 pub name: String,
11 pub label: String,
12 pub ret_type: Option<String>,
13 pub params: Vec<String>,
14}
15
16impl FnDescriptor {
17 pub fn new(node: ast::FnDef) -> Option<Self> {
18 let name = node.name()?.text().to_string();
19
20 // Strip the body out for the label.
21 let label: String = if let Some(body) = node.body() {
22 let body_range = body.syntax().range();
23 let label: String = node
24 .syntax()
25 .children()
26 .filter(|child| !is_subrange(body_range, child.range()))
27 .map(|node| node.text().to_string())
28 .collect();
29 label
30 } else {
31 node.syntax().text().to_string()
32 };
33
34 let params = FnDescriptor::param_list(node);
35 let ret_type = node.ret_type().map(|r| r.syntax().text().to_string());
36
37 Some(FnDescriptor {
38 name,
39 ret_type,
40 params,
41 label,
42 })
43 }
44
45 fn param_list(node: ast::FnDef) -> Vec<String> {
46 let mut res = vec![];
47 if let Some(param_list) = node.param_list() {
48 if let Some(self_param) = param_list.self_param() {
49 res.push(self_param.syntax().text().to_string())
50 }
51
52 // Maybe use param.pat here? See if we can just extract the name?
53 //res.extend(param_list.params().map(|p| p.syntax().text().to_string()));
54 res.extend(
55 param_list
56 .params()
57 .filter_map(|p| p.pat())
58 .map(|pat| pat.syntax().text().to_string()),
59 );
60 }
61 res
62 }
63}
diff --git a/crates/ra_analysis/src/descriptors/module/imp.rs b/crates/ra_analysis/src/descriptors/module/imp.rs
new file mode 100644
index 000000000..22e4bd785
--- /dev/null
+++ b/crates/ra_analysis/src/descriptors/module/imp.rs
@@ -0,0 +1,146 @@
1use std::sync::Arc;
2
3use relative_path::RelativePathBuf;
4use rustc_hash::{FxHashMap, FxHashSet};
5use ra_syntax::{
6 SmolStr,
7 ast::{self, NameOwner},
8};
9
10use crate::{
11 FileId, Cancelable, FileResolverImp,
12 db,
13};
14
15use super::{
16 ModuleData, ModuleTree, ModuleId, LinkId, LinkData, Problem, ModulesDatabase
17};
18
19
20pub(super) fn submodules(db: &impl ModulesDatabase, file_id: FileId) -> Cancelable<Arc<Vec<SmolStr>>> {
21 db::check_canceled(db)?;
22 let file = db.file_syntax(file_id);
23 let root = file.ast();
24 let submodules = modules(root).map(|(name, _)| name).collect();
25 Ok(Arc::new(submodules))
26}
27
28pub(super) fn modules(root: ast::Root<'_>) -> impl Iterator<Item = (SmolStr, ast::Module<'_>)> {
29 root.modules().filter_map(|module| {
30 let name = module.name()?.text();
31 if !module.has_semi() {
32 return None;
33 }
34 Some((name, module))
35 })
36}
37
38pub(super) fn module_tree(db: &impl ModulesDatabase) -> Cancelable<Arc<ModuleTree>> {
39 db::check_canceled(db)?;
40 let res = create_module_tree(db)?;
41 Ok(Arc::new(res))
42}
43
44
45#[derive(Clone, Hash, PartialEq, Eq, Debug)]
46pub struct Submodule {
47 pub name: SmolStr,
48}
49
50
51fn create_module_tree<'a>(
52 db: &impl ModulesDatabase,
53) -> Cancelable<ModuleTree> {
54 let mut tree = ModuleTree {
55 mods: Vec::new(),
56 links: Vec::new(),
57 };
58
59 let mut roots = FxHashMap::default();
60 let mut visited = FxHashSet::default();
61
62 for &file_id in db.file_set().files.iter() {
63 if visited.contains(&file_id) {
64 continue; // TODO: use explicit crate_roots here
65 }
66 assert!(!roots.contains_key(&file_id));
67 let module_id = build_subtree(db, &mut tree, &mut visited, &mut roots, None, file_id)?;
68 roots.insert(file_id, module_id);
69 }
70 Ok(tree)
71}
72
73fn build_subtree(
74 db: &impl ModulesDatabase,
75 tree: &mut ModuleTree,
76 visited: &mut FxHashSet<FileId>,
77 roots: &mut FxHashMap<FileId, ModuleId>,
78 parent: Option<LinkId>,
79 file_id: FileId,
80) -> Cancelable<ModuleId> {
81 visited.insert(file_id);
82 let id = tree.push_mod(ModuleData {
83 file_id,
84 parent,
85 children: Vec::new(),
86 });
87 let file_set = db.file_set();
88 let file_resolver = &file_set.resolver;
89 for name in db.submodules(file_id)?.iter() {
90 let (points_to, problem) = resolve_submodule(file_id, name, file_resolver);
91 let link = tree.push_link(LinkData {
92 name: name.clone(),
93 owner: id,
94 points_to: Vec::new(),
95 problem: None,
96 });
97
98 let points_to = points_to
99 .into_iter()
100 .map(|file_id| match roots.remove(&file_id) {
101 Some(module_id) => {
102 tree.module_mut(module_id).parent = Some(link);
103 Ok(module_id)
104 }
105 None => build_subtree(db, tree, visited, roots, Some(link), file_id),
106 })
107 .collect::<Cancelable<Vec<_>>>()?;
108 tree.link_mut(link).points_to = points_to;
109 tree.link_mut(link).problem = problem;
110 }
111 Ok(id)
112}
113
114fn resolve_submodule(
115 file_id: FileId,
116 name: &SmolStr,
117 file_resolver: &FileResolverImp,
118) -> (Vec<FileId>, Option<Problem>) {
119 let mod_name = file_resolver.file_stem(file_id);
120 let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main";
121
122 let file_mod = RelativePathBuf::from(format!("../{}.rs", name));
123 let dir_mod = RelativePathBuf::from(format!("../{}/mod.rs", name));
124 let points_to: Vec<FileId>;
125 let problem: Option<Problem>;
126 if is_dir_owner {
127 points_to = [&file_mod, &dir_mod]
128 .iter()
129 .filter_map(|path| file_resolver.resolve(file_id, path))
130 .collect();
131 problem = if points_to.is_empty() {
132 Some(Problem::UnresolvedModule {
133 candidate: file_mod,
134 })
135 } else {
136 None
137 }
138 } else {
139 points_to = Vec::new();
140 problem = Some(Problem::NotDirOwner {
141 move_to: RelativePathBuf::from(format!("../{}/mod.rs", mod_name)),
142 candidate: file_mod,
143 });
144 }
145 (points_to, problem)
146}
diff --git a/crates/ra_analysis/src/descriptors/module/mod.rs b/crates/ra_analysis/src/descriptors/module/mod.rs
new file mode 100644
index 000000000..52da650b3
--- /dev/null
+++ b/crates/ra_analysis/src/descriptors/module/mod.rs
@@ -0,0 +1,176 @@
1mod imp;
2
3use std::sync::Arc;
4
5use relative_path::RelativePathBuf;
6use ra_syntax::{ast::{self, NameOwner, AstNode}, SmolStr, SyntaxNode};
7
8use crate::{
9 FileId, Cancelable,
10 db::SyntaxDatabase,
11};
12
13salsa::query_group! {
14 pub(crate) trait ModulesDatabase: SyntaxDatabase {
15 fn module_tree() -> Cancelable<Arc<ModuleTree>> {
16 type ModuleTreeQuery;
17 use fn imp::module_tree;
18 }
19 fn submodules(file_id: FileId) -> Cancelable<Arc<Vec<SmolStr>>> {
20 type SubmodulesQuery;
21 use fn imp::submodules;
22 }
23 }
24}
25
26
27#[derive(Debug, PartialEq, Eq, Hash)]
28pub(crate) struct ModuleTree {
29 mods: Vec<ModuleData>,
30 links: Vec<LinkData>,
31}
32
33impl ModuleTree {
34 pub(crate) fn modules_for_file(&self, file_id: FileId) -> Vec<ModuleId> {
35 self.mods.iter()
36 .enumerate()
37 .filter(|(_idx, it)| it.file_id == file_id).map(|(idx, _)| ModuleId(idx as u32))
38 .collect()
39 }
40
41 pub(crate) fn any_module_for_file(&self, file_id: FileId) -> Option<ModuleId> {
42 self.modules_for_file(file_id).pop()
43 }
44}
45
46#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
47pub(crate) struct ModuleId(u32);
48
49#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
50pub(crate) struct LinkId(u32);
51
52#[derive(Clone, Debug, Hash, PartialEq, Eq)]
53pub enum Problem {
54 UnresolvedModule {
55 candidate: RelativePathBuf,
56 },
57 NotDirOwner {
58 move_to: RelativePathBuf,
59 candidate: RelativePathBuf,
60 },
61}
62
63impl ModuleId {
64 pub(crate) fn file_id(self, tree: &ModuleTree) -> FileId {
65 tree.module(self).file_id
66 }
67 pub(crate) fn parent_link(self, tree: &ModuleTree) -> Option<LinkId> {
68 tree.module(self).parent
69 }
70 pub(crate) fn parent(self, tree: &ModuleTree) -> Option<ModuleId> {
71 let link = self.parent_link(tree)?;
72 Some(tree.link(link).owner)
73 }
74 pub(crate) fn root(self, tree: &ModuleTree) -> ModuleId {
75 let mut curr = self;
76 let mut i = 0;
77 while let Some(next) = curr.parent(tree) {
78 curr = next;
79 i += 1;
80 if i > 100 {
81 return self;
82 }
83 }
84 curr
85 }
86 pub(crate) fn child(self, tree: &ModuleTree, name: &str) -> Option<ModuleId> {
87 let link = tree.module(self)
88 .children
89 .iter()
90 .map(|&it| tree.link(it))
91 .find(|it| it.name == name)?;
92 Some(*link.points_to.first()?)
93 }
94 pub(crate) fn problems(
95 self,
96 tree: &ModuleTree,
97 root: ast::Root,
98 ) -> Vec<(SyntaxNode, Problem)> {
99 tree.module(self)
100 .children
101 .iter()
102 .filter_map(|&it| {
103 let p = tree.link(it).problem.clone()?;
104 let s = it.bind_source(tree, root);
105 let s = s.name().unwrap().syntax().owned();
106 Some((s, p))
107 })
108 .collect()
109 }
110}
111
112impl LinkId {
113 pub(crate) fn name(self, tree: &ModuleTree) -> SmolStr {
114 tree.link(self).name.clone()
115 }
116 pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId {
117 tree.link(self).owner
118 }
119 fn points_to(self, tree: &ModuleTree) -> &[ModuleId] {
120 &tree.link(self).points_to
121 }
122 pub(crate) fn bind_source<'a>(
123 self,
124 tree: &ModuleTree,
125 root: ast::Root<'a>,
126 ) -> ast::Module<'a> {
127 imp::modules(root)
128 .find(|(name, _)| name == &tree.link(self).name)
129 .unwrap()
130 .1
131 }
132}
133
134#[derive(Debug, PartialEq, Eq, Hash)]
135struct ModuleData {
136 file_id: FileId,
137 parent: Option<LinkId>,
138 children: Vec<LinkId>,
139}
140
141#[derive(Hash, Debug, PartialEq, Eq)]
142struct LinkData {
143 owner: ModuleId,
144 name: SmolStr,
145 points_to: Vec<ModuleId>,
146 problem: Option<Problem>,
147}
148
149
150impl ModuleTree {
151 fn module(&self, id: ModuleId) -> &ModuleData {
152 &self.mods[id.0 as usize]
153 }
154 fn module_mut(&mut self, id: ModuleId) -> &mut ModuleData {
155 &mut self.mods[id.0 as usize]
156 }
157 fn link(&self, id: LinkId) -> &LinkData {
158 &self.links[id.0 as usize]
159 }
160 fn link_mut(&mut self, id: LinkId) -> &mut LinkData {
161 &mut self.links[id.0 as usize]
162 }
163
164 fn push_mod(&mut self, data: ModuleData) -> ModuleId {
165 let id = ModuleId(self.mods.len() as u32);
166 self.mods.push(data);
167 id
168 }
169 fn push_link(&mut self, data: LinkData) -> LinkId {
170 let id = LinkId(self.links.len() as u32);
171 self.mods[data.owner.0 as usize].children.push(id);
172 self.links.push(data);
173 id
174 }
175}
176
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 196627539..c15873328 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -1,5 +1,4 @@
1use std::{ 1use std::{
2 collections::VecDeque,
3 fmt, 2 fmt,
4 hash::{Hash, Hasher}, 3 hash::{Hash, Hasher},
5 iter, 4 iter,
@@ -17,7 +16,8 @@ use relative_path::RelativePath;
17use rustc_hash::FxHashSet; 16use rustc_hash::FxHashSet;
18 17
19use crate::{ 18use crate::{
20 descriptors::{FnDescriptor, ModuleTreeDescriptor, Problem}, 19 descriptors::module::{ModuleTree, Problem},
20 descriptors::{FnDescriptor},
21 roots::{ReadonlySourceRoot, SourceRoot, WritableSourceRoot}, 21 roots::{ReadonlySourceRoot, SourceRoot, WritableSourceRoot},
22 CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, Position, 22 CrateGraph, CrateId, Diagnostic, FileId, FileResolver, FileSystemEdit, Position,
23 Query, SourceChange, SourceFileEdit, Cancelable, 23 Query, SourceChange, SourceFileEdit, Cancelable,
@@ -113,7 +113,7 @@ impl AnalysisHostImpl {
113 self.data_mut().crate_graph = graph; 113 self.data_mut().crate_graph = graph;
114 } 114 }
115 pub fn add_library(&mut self, root: ReadonlySourceRoot) { 115 pub fn add_library(&mut self, root: ReadonlySourceRoot) {
116 self.data_mut().libs.push(Arc::new(root)); 116 self.data_mut().libs.push(root);
117 } 117 }
118 fn data_mut(&mut self) -> &mut WorldData { 118 fn data_mut(&mut self) -> &mut WorldData {
119 &mut self.data 119 &mut self.data
@@ -135,7 +135,7 @@ impl AnalysisImpl {
135 if self.data.root.contains(file_id) { 135 if self.data.root.contains(file_id) {
136 return &self.data.root; 136 return &self.data.root;
137 } 137 }
138 &**self 138 self
139 .data 139 .data
140 .libs 140 .libs
141 .iter() 141 .iter()
@@ -162,19 +162,21 @@ impl AnalysisImpl {
162 pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> { 162 pub fn parent_module(&self, file_id: FileId) -> Cancelable<Vec<(FileId, FileSymbol)>> {
163 let root = self.root(file_id); 163 let root = self.root(file_id);
164 let module_tree = root.module_tree()?; 164 let module_tree = root.module_tree()?;
165 let res = module_tree 165
166 .parent_modules(file_id) 166 let res = module_tree.modules_for_file(file_id)
167 .iter() 167 .into_iter()
168 .map(|link| { 168 .filter_map(|module_id| {
169 let file_id = link.owner(&module_tree); 169 let link = module_id.parent_link(&module_tree)?;
170 let file_id = link.owner(&module_tree).file_id(&module_tree);
170 let syntax = root.syntax(file_id); 171 let syntax = root.syntax(file_id);
171 let decl = link.bind_source(&module_tree, syntax.ast()); 172 let decl = link.bind_source(&module_tree, syntax.ast());
173
172 let sym = FileSymbol { 174 let sym = FileSymbol {
173 name: link.name(&module_tree), 175 name: decl.name().unwrap().text(),
174 node_range: decl.syntax().range(), 176 node_range: decl.syntax().range(),
175 kind: MODULE, 177 kind: MODULE,
176 }; 178 };
177 (file_id, sym) 179 Some((file_id, sym))
178 }) 180 })
179 .collect(); 181 .collect();
180 Ok(res) 182 Ok(res)
@@ -182,22 +184,13 @@ impl AnalysisImpl {
182 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> { 184 pub fn crate_for(&self, file_id: FileId) -> Cancelable<Vec<CrateId>> {
183 let module_tree = self.root(file_id).module_tree()?; 185 let module_tree = self.root(file_id).module_tree()?;
184 let crate_graph = &self.data.crate_graph; 186 let crate_graph = &self.data.crate_graph;
185 let mut res = Vec::new(); 187 let res = module_tree.modules_for_file(file_id)
186 let mut work = VecDeque::new(); 188 .into_iter()
187 work.push_back(file_id); 189 .map(|it| it.root(&module_tree))
188 let mut visited = FxHashSet::default(); 190 .map(|it| it.file_id(&module_tree))
189 while let Some(id) = work.pop_front() { 191 .filter_map(|it| crate_graph.crate_id_for_crate_root(it))
190 if let Some(crate_id) = crate_graph.crate_id_for_crate_root(id) { 192 .collect();
191 res.push(crate_id); 193
192 continue;
193 }
194 let parents = module_tree
195 .parent_modules(id)
196 .into_iter()
197 .map(|link| link.owner(&module_tree))
198 .filter(|&id| visited.insert(id));
199 work.extend(parents);
200 }
201 Ok(res) 194 Ok(res)
202 } 195 }
203 pub fn crate_root(&self, crate_id: CrateId) -> FileId { 196 pub fn crate_root(&self, crate_id: CrateId) -> FileId {
@@ -303,50 +296,51 @@ impl AnalysisImpl {
303 fix: None, 296 fix: None,
304 }) 297 })
305 .collect::<Vec<_>>(); 298 .collect::<Vec<_>>();
306 299 if let Some(m) = module_tree.any_module_for_file(file_id) {
307 for (name_node, problem) in module_tree.problems(file_id, syntax.ast()) { 300 for (name_node, problem) in m.problems(&module_tree, syntax.ast()) {
308 let diag = match problem { 301 let diag = match problem {
309 Problem::UnresolvedModule { candidate } => { 302 Problem::UnresolvedModule { candidate } => {
310 let create_file = FileSystemEdit::CreateFile { 303 let create_file = FileSystemEdit::CreateFile {
311 anchor: file_id, 304 anchor: file_id,
312 path: candidate.clone(), 305 path: candidate.clone(),
313 }; 306 };
314 let fix = SourceChange { 307 let fix = SourceChange {
315 label: "create module".to_string(), 308 label: "create module".to_string(),
316 source_file_edits: Vec::new(), 309 source_file_edits: Vec::new(),
317 file_system_edits: vec![create_file], 310 file_system_edits: vec![create_file],
318 cursor_position: None, 311 cursor_position: None,
319 }; 312 };
320 Diagnostic { 313 Diagnostic {
321 range: name_node.syntax().range(), 314 range: name_node.range(),
322 message: "unresolved module".to_string(), 315 message: "unresolved module".to_string(),
323 fix: Some(fix), 316 fix: Some(fix),
317 }
324 } 318 }
325 } 319 Problem::NotDirOwner { move_to, candidate } => {
326 Problem::NotDirOwner { move_to, candidate } => { 320 let move_file = FileSystemEdit::MoveFile {
327 let move_file = FileSystemEdit::MoveFile { 321 file: file_id,
328 file: file_id, 322 path: move_to.clone(),
329 path: move_to.clone(), 323 };
330 }; 324 let create_file = FileSystemEdit::CreateFile {
331 let create_file = FileSystemEdit::CreateFile { 325 anchor: file_id,
332 anchor: file_id, 326 path: move_to.join(candidate),
333 path: move_to.join(candidate), 327 };
334 }; 328 let fix = SourceChange {
335 let fix = SourceChange { 329 label: "move file and create module".to_string(),
336 label: "move file and create module".to_string(), 330 source_file_edits: Vec::new(),
337 source_file_edits: Vec::new(), 331 file_system_edits: vec![move_file, create_file],
338 file_system_edits: vec![move_file, create_file], 332 cursor_position: None,
339 cursor_position: None, 333 };
340 }; 334 Diagnostic {
341 Diagnostic { 335 range: name_node.range(),
342 range: name_node.syntax().range(), 336 message: "can't declare module at this location".to_string(),
343 message: "can't declare module at this location".to_string(), 337 fix: Some(fix),
344 fix: Some(fix), 338 }
345 } 339 }
346 } 340 };
347 }; 341 res.push(diag)
348 res.push(diag) 342 }
349 } 343 };
350 Ok(res) 344 Ok(res)
351 } 345 }
352 346
@@ -457,7 +451,7 @@ impl AnalysisImpl {
457 451
458 fn resolve_module( 452 fn resolve_module(
459 &self, 453 &self,
460 module_tree: &ModuleTreeDescriptor, 454 module_tree: &ModuleTree,
461 file_id: FileId, 455 file_id: FileId,
462 module: ast::Module, 456 module: ast::Module,
463 ) -> Vec<FileId> { 457 ) -> Vec<FileId> {
@@ -465,7 +459,14 @@ impl AnalysisImpl {
465 Some(name) => name.text(), 459 Some(name) => name.text(),
466 None => return Vec::new(), 460 None => return Vec::new(),
467 }; 461 };
468 module_tree.child_module_by_name(file_id, name.as_str()) 462 let module_id = match module_tree.any_module_for_file(file_id) {
463 Some(id) => id,
464 None => return Vec::new(),
465 };
466 module_id.child(module_tree, name.as_str())
467 .map(|it| it.file_id(module_tree))
468 .into_iter()
469 .collect()
469 } 470 }
470} 471}
471 472
@@ -473,7 +474,7 @@ impl AnalysisImpl {
473struct WorldData { 474struct WorldData {
474 crate_graph: CrateGraph, 475 crate_graph: CrateGraph,
475 root: WritableSourceRoot, 476 root: WritableSourceRoot,
476 libs: Vec<Arc<ReadonlySourceRoot>>, 477 libs: Vec<ReadonlySourceRoot>,
477} 478}
478 479
479impl SourceChange { 480impl SourceChange {
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index 38585f6e9..a03f44205 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -13,7 +13,6 @@ extern crate salsa;
13mod db; 13mod db;
14mod descriptors; 14mod descriptors;
15mod imp; 15mod imp;
16mod module_map;
17mod roots; 16mod roots;
18mod symbol_index; 17mod symbol_index;
19 18
diff --git a/crates/ra_analysis/src/roots.rs b/crates/ra_analysis/src/roots.rs
index 123c4acfa..7100f7c71 100644
--- a/crates/ra_analysis/src/roots.rs
+++ b/crates/ra_analysis/src/roots.rs
@@ -1,25 +1,22 @@
1use std::{panic, sync::Arc}; 1use std::{sync::Arc};
2 2
3use once_cell::sync::OnceCell;
4use ra_editor::LineIndex; 3use ra_editor::LineIndex;
5use ra_syntax::File; 4use ra_syntax::File;
6use rayon::prelude::*; 5use rustc_hash::FxHashSet;
7use rustc_hash::{FxHashMap, FxHashSet};
8use salsa::Database; 6use salsa::Database;
9 7
10use crate::{ 8use crate::{
11 Cancelable, 9 Cancelable,
12 db::{self, FilesDatabase, SyntaxDatabase}, 10 db::{self, FilesDatabase, SyntaxDatabase},
13 descriptors::{ModuleDescriptor, ModuleTreeDescriptor},
14 imp::FileResolverImp, 11 imp::FileResolverImp,
15 module_map::ModulesDatabase, 12 descriptors::module::{ModulesDatabase, ModuleTree},
16 symbol_index::SymbolIndex, 13 symbol_index::SymbolIndex,
17 FileId, 14 FileId,
18}; 15};
19 16
20pub(crate) trait SourceRoot { 17pub(crate) trait SourceRoot {
21 fn contains(&self, file_id: FileId) -> bool; 18 fn contains(&self, file_id: FileId) -> bool;
22 fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>>; 19 fn module_tree(&self) -> Cancelable<Arc<ModuleTree>>;
23 fn lines(&self, file_id: FileId) -> Arc<LineIndex>; 20 fn lines(&self, file_id: FileId) -> Arc<LineIndex>;
24 fn syntax(&self, file_id: FileId) -> File; 21 fn syntax(&self, file_id: FileId) -> File;
25 fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()>; 22 fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()>;
@@ -65,7 +62,7 @@ impl WritableSourceRoot {
65} 62}
66 63
67impl SourceRoot for WritableSourceRoot { 64impl SourceRoot for WritableSourceRoot {
68 fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>> { 65 fn module_tree(&self) -> Cancelable<Arc<ModuleTree>> {
69 self.db.module_tree() 66 self.db.module_tree()
70 } 67 }
71 fn contains(&self, file_id: FileId) -> bool { 68 fn contains(&self, file_id: FileId) -> bool {
@@ -86,97 +83,47 @@ impl SourceRoot for WritableSourceRoot {
86 } 83 }
87} 84}
88 85
89#[derive(Debug)] 86#[derive(Debug, Clone)]
90struct FileData {
91 text: String,
92 lines: OnceCell<Arc<LineIndex>>,
93 syntax: OnceCell<File>,
94}
95
96impl FileData {
97 fn new(text: String) -> FileData {
98 FileData {
99 text,
100 syntax: OnceCell::new(),
101 lines: OnceCell::new(),
102 }
103 }
104 fn lines(&self) -> &Arc<LineIndex> {
105 self.lines
106 .get_or_init(|| Arc::new(LineIndex::new(&self.text)))
107 }
108 fn syntax(&self) -> &File {
109 let text = &self.text;
110 let syntax = &self.syntax;
111 match panic::catch_unwind(panic::AssertUnwindSafe(|| {
112 syntax.get_or_init(|| File::parse(text))
113 })) {
114 Ok(file) => file,
115 Err(err) => {
116 error!("Parser paniced on:\n------\n{}\n------\n", text);
117 panic::resume_unwind(err)
118 }
119 }
120 }
121}
122
123#[derive(Debug)]
124pub(crate) struct ReadonlySourceRoot { 87pub(crate) struct ReadonlySourceRoot {
88 db: db::RootDatabase,
125 symbol_index: Arc<SymbolIndex>, 89 symbol_index: Arc<SymbolIndex>,
126 file_map: FxHashMap<FileId, FileData>,
127 module_tree: Arc<ModuleTreeDescriptor>,
128} 90}
129 91
130impl ReadonlySourceRoot { 92impl ReadonlySourceRoot {
131 pub(crate) fn new( 93 pub(crate) fn new(
132 files: Vec<(FileId, String)>, 94 files: Vec<(FileId, String)>,
133 file_resolver: FileResolverImp, 95 resolver: FileResolverImp,
134 ) -> ReadonlySourceRoot { 96 ) -> ReadonlySourceRoot {
135 let modules = files 97 let db = db::RootDatabase::default();
136 .par_iter() 98 let mut file_ids = FxHashSet::default();
137 .map(|(file_id, text)| { 99 for (file_id, text) in files {
138 let syntax = File::parse(text); 100 file_ids.insert(file_id);
139 let mod_descr = ModuleDescriptor::new(syntax.ast()); 101 db.query(db::FileTextQuery).set(file_id, Arc::new(text));
140 (*file_id, syntax, mod_descr) 102 }
141 })
142 .collect::<Vec<_>>();
143 let module_tree =
144 ModuleTreeDescriptor::new(modules.iter().map(|it| (it.0, &it.2)), &file_resolver);
145 103
104 db.query(db::FileSetQuery)
105 .set((), Arc::new(db::FileSet { files: file_ids, resolver }));
106 let file_set = db.file_set();
146 let symbol_index = 107 let symbol_index =
147 SymbolIndex::for_files(modules.par_iter().map(|it| (it.0, it.1.clone()))); 108 SymbolIndex::for_files(file_set.files.iter() // TODO: par iter
148 let file_map: FxHashMap<FileId, FileData> = files 109 .map(|&file_id| (file_id, db.file_syntax(file_id))));
149 .into_iter()
150 .map(|(id, text)| (id, FileData::new(text)))
151 .collect();
152
153 ReadonlySourceRoot {
154 symbol_index: Arc::new(symbol_index),
155 file_map,
156 module_tree: Arc::new(module_tree),
157 }
158 }
159 110
160 fn data(&self, file_id: FileId) -> &FileData { 111 ReadonlySourceRoot { db, symbol_index: Arc::new(symbol_index) }
161 match self.file_map.get(&file_id) {
162 Some(data) => data,
163 None => panic!("unknown file: {:?}", file_id),
164 }
165 } 112 }
166} 113}
167 114
168impl SourceRoot for ReadonlySourceRoot { 115impl SourceRoot for ReadonlySourceRoot {
169 fn module_tree(&self) -> Cancelable<Arc<ModuleTreeDescriptor>> { 116 fn module_tree(&self) -> Cancelable<Arc<ModuleTree>> {
170 Ok(Arc::clone(&self.module_tree)) 117 self.db.module_tree()
171 } 118 }
172 fn contains(&self, file_id: FileId) -> bool { 119 fn contains(&self, file_id: FileId) -> bool {
173 self.file_map.contains_key(&file_id) 120 self.db.file_set().files.contains(&file_id)
174 } 121 }
175 fn lines(&self, file_id: FileId) -> Arc<LineIndex> { 122 fn lines(&self, file_id: FileId) -> Arc<LineIndex> {
176 Arc::clone(self.data(file_id).lines()) 123 self.db.file_lines(file_id)
177 } 124 }
178 fn syntax(&self, file_id: FileId) -> File { 125 fn syntax(&self, file_id: FileId) -> File {
179 self.data(file_id).syntax().clone() 126 self.db.file_syntax(file_id)
180 } 127 }
181 fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()> { 128 fn symbols(&self, acc: &mut Vec<Arc<SymbolIndex>>) -> Cancelable<()> {
182 acc.push(Arc::clone(&self.symbol_index)); 129 acc.push(Arc::clone(&self.symbol_index));
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index a0f3c0437..1b7d9f779 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -34,7 +34,7 @@ impl Hash for SymbolIndex {
34} 34}
35 35
36impl SymbolIndex { 36impl SymbolIndex {
37 pub(crate) fn for_files(files: impl ParallelIterator<Item = (FileId, File)>) -> SymbolIndex { 37 pub(crate) fn for_files(files: impl Iterator<Item = (FileId, File)>) -> SymbolIndex {
38 let mut symbols = files 38 let mut symbols = files
39 .flat_map(|(file_id, file)| { 39 .flat_map(|(file_id, file)| {
40 file_symbols(&file) 40 file_symbols(&file)
@@ -52,7 +52,7 @@ impl SymbolIndex {
52 } 52 }
53 53
54 pub(crate) fn for_file(file_id: FileId, file: File) -> SymbolIndex { 54 pub(crate) fn for_file(file_id: FileId, file: File) -> SymbolIndex {
55 SymbolIndex::for_files(::rayon::iter::once((file_id, file))) 55 SymbolIndex::for_files(::std::iter::once((file_id, file)))
56 } 56 }
57} 57}
58 58
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-24 09:59:13 +0000