aboutsummaryrefslogtreecommitdiff
path: root/crates
diff options
context:
space:
mode:
Diffstat (limited to 'crates')
-rw-r--r--crates/ra_hir/src/code_model.rs37
-rw-r--r--crates/ra_hir/src/code_model/src.rs4
-rw-r--r--crates/ra_hir/src/db.rs9
-rw-r--r--crates/ra_hir/src/diagnostics.rs21
-rw-r--r--crates/ra_hir/src/from_id.rs58
-rw-r--r--crates/ra_hir/src/from_source.rs22
-rw-r--r--crates/ra_hir/src/lib.rs1
-rw-r--r--crates/ra_hir/src/nameres.rs508
-rw-r--r--crates/ra_hir/src/nameres/tests.rs21
-rw-r--r--crates/ra_hir/src/nameres/tests/globs.rs4
-rw-r--r--crates/ra_hir/src/nameres/tests/incremental.rs7
-rw-r--r--crates/ra_hir/src/nameres/tests/macros.rs10
-rw-r--r--crates/ra_hir/src/resolve.rs108
-rw-r--r--crates/ra_hir/src/source_binder.rs7
-rw-r--r--crates/ra_hir/src/ty/tests.rs2
-rw-r--r--crates/ra_hir_def/src/adt.rs14
-rw-r--r--crates/ra_hir_def/src/db.rs15
-rw-r--r--crates/ra_hir_def/src/diagnostics.rs26
-rw-r--r--crates/ra_hir_def/src/lib.rs5
-rw-r--r--crates/ra_hir_def/src/nameres.rs488
-rw-r--r--crates/ra_hir_def/src/nameres/collector.rs (renamed from crates/ra_hir/src/nameres/collector.rs)160
-rw-r--r--crates/ra_hir_def/src/nameres/per_ns.rs (renamed from crates/ra_hir/src/nameres/per_ns.rs)24
-rw-r--r--crates/ra_ide_api/src/completion/complete_path.rs8
23 files changed, 826 insertions, 733 deletions
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs
index 5b78bdfef..f03b59217 100644
--- a/crates/ra_hir/src/code_model.rs
+++ b/crates/ra_hir/src/code_model.rs
@@ -9,7 +9,7 @@ use hir_def::{
9 adt::VariantData, 9 adt::VariantData,
10 builtin_type::BuiltinType, 10 builtin_type::BuiltinType,
11 type_ref::{Mutability, TypeRef}, 11 type_ref::{Mutability, TypeRef},
12 CrateModuleId, LocalEnumVariantId, LocalStructFieldId, ModuleId, 12 CrateModuleId, LocalEnumVariantId, LocalStructFieldId, ModuleId, UnionId,
13}; 13};
14use hir_expand::{ 14use hir_expand::{
15 diagnostics::DiagnosticSink, 15 diagnostics::DiagnosticSink,
@@ -28,11 +28,11 @@ use crate::{
28 TypeAliasId, 28 TypeAliasId,
29 }, 29 },
30 impl_block::ImplBlock, 30 impl_block::ImplBlock,
31 nameres::{ImportId, ModuleScope, Namespace}, 31 nameres::{ImportId, Namespace},
32 resolve::{Resolver, Scope, TypeNs}, 32 resolve::{Resolver, Scope, TypeNs},
33 traits::TraitData, 33 traits::TraitData,
34 ty::{InferenceResult, TraitRef}, 34 ty::{InferenceResult, TraitRef},
35 Either, HasSource, Name, Ty, 35 Either, HasSource, Name, ScopeDef, Ty,
36}; 36};
37 37
38/// hir::Crate describes a single crate. It's the main interface with which 38/// hir::Crate describes a single crate. It's the main interface with which
@@ -66,7 +66,7 @@ impl Crate {
66 } 66 }
67 67
68 pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> { 68 pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> {
69 let module_id = db.crate_def_map(self).root(); 69 let module_id = db.crate_def_map(self.crate_id).root();
70 Some(Module::new(self, module_id)) 70 Some(Module::new(self, module_id))
71 } 71 }
72 72
@@ -120,7 +120,7 @@ impl Module {
120 120
121 /// Name of this module. 121 /// Name of this module.
122 pub fn name(self, db: &impl DefDatabase) -> Option<Name> { 122 pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
123 let def_map = db.crate_def_map(self.krate()); 123 let def_map = db.crate_def_map(self.id.krate);
124 let parent = def_map[self.id.module_id].parent?; 124 let parent = def_map[self.id.module_id].parent?;
125 def_map[parent].children.iter().find_map(|(name, module_id)| { 125 def_map[parent].children.iter().find_map(|(name, module_id)| {
126 if *module_id == self.id.module_id { 126 if *module_id == self.id.module_id {
@@ -151,20 +151,20 @@ impl Module {
151 /// might be missing `krate`. This can happen if a module's file is not included 151 /// might be missing `krate`. This can happen if a module's file is not included
152 /// in the module tree of any target in `Cargo.toml`. 152 /// in the module tree of any target in `Cargo.toml`.
153 pub fn crate_root(self, db: &impl DefDatabase) -> Module { 153 pub fn crate_root(self, db: &impl DefDatabase) -> Module {
154 let def_map = db.crate_def_map(self.krate()); 154 let def_map = db.crate_def_map(self.id.krate);
155 self.with_module_id(def_map.root()) 155 self.with_module_id(def_map.root())
156 } 156 }
157 157
158 /// Finds a child module with the specified name. 158 /// Finds a child module with the specified name.
159 pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> { 159 pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> {
160 let def_map = db.crate_def_map(self.krate()); 160 let def_map = db.crate_def_map(self.id.krate);
161 let child_id = def_map[self.id.module_id].children.get(name)?; 161 let child_id = def_map[self.id.module_id].children.get(name)?;
162 Some(self.with_module_id(*child_id)) 162 Some(self.with_module_id(*child_id))
163 } 163 }
164 164
165 /// Iterates over all child modules. 165 /// Iterates over all child modules.
166 pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> { 166 pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> {
167 let def_map = db.crate_def_map(self.krate()); 167 let def_map = db.crate_def_map(self.id.krate);
168 let children = def_map[self.id.module_id] 168 let children = def_map[self.id.module_id]
169 .children 169 .children
170 .iter() 170 .iter()
@@ -175,7 +175,7 @@ impl Module {
175 175
176 /// Finds a parent module. 176 /// Finds a parent module.
177 pub fn parent(self, db: &impl DefDatabase) -> Option<Module> { 177 pub fn parent(self, db: &impl DefDatabase) -> Option<Module> {
178 let def_map = db.crate_def_map(self.krate()); 178 let def_map = db.crate_def_map(self.id.krate);
179 let parent_id = def_map[self.id.module_id].parent?; 179 let parent_id = def_map[self.id.module_id].parent?;
180 Some(self.with_module_id(parent_id)) 180 Some(self.with_module_id(parent_id))
181 } 181 }
@@ -191,12 +191,16 @@ impl Module {
191 } 191 }
192 192
193 /// Returns a `ModuleScope`: a set of items, visible in this module. 193 /// Returns a `ModuleScope`: a set of items, visible in this module.
194 pub fn scope(self, db: &impl HirDatabase) -> ModuleScope { 194 pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<ImportId>)> {
195 db.crate_def_map(self.krate())[self.id.module_id].scope.clone() 195 db.crate_def_map(self.id.krate)[self.id.module_id]
196 .scope
197 .entries()
198 .map(|(name, res)| (name.clone(), res.def.into(), res.import))
199 .collect()
196 } 200 }
197 201
198 pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) { 202 pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) {
199 db.crate_def_map(self.krate()).add_diagnostics(db, self.id.module_id, sink); 203 db.crate_def_map(self.id.krate).add_diagnostics(db, self.id.module_id, sink);
200 for decl in self.declarations(db) { 204 for decl in self.declarations(db) {
201 match decl { 205 match decl {
202 crate::ModuleDef::Function(f) => f.diagnostics(db, sink), 206 crate::ModuleDef::Function(f) => f.diagnostics(db, sink),
@@ -220,12 +224,12 @@ impl Module {
220 } 224 }
221 225
222 pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver { 226 pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver {
223 let def_map = db.crate_def_map(self.krate()); 227 let def_map = db.crate_def_map(self.id.krate);
224 Resolver::default().push_module_scope(def_map, self.id.module_id) 228 Resolver::default().push_module_scope(def_map, self.id.module_id)
225 } 229 }
226 230
227 pub fn declarations(self, db: &impl DefDatabase) -> Vec<ModuleDef> { 231 pub fn declarations(self, db: &impl DefDatabase) -> Vec<ModuleDef> {
228 let def_map = db.crate_def_map(self.krate()); 232 let def_map = db.crate_def_map(self.id.krate);
229 def_map[self.id.module_id] 233 def_map[self.id.module_id]
230 .scope 234 .scope
231 .entries() 235 .entries()
@@ -233,6 +237,7 @@ impl Module {
233 .flat_map(|per_ns| { 237 .flat_map(|per_ns| {
234 per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter()) 238 per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter())
235 }) 239 })
240 .map(ModuleDef::from)
236 .collect() 241 .collect()
237 } 242 }
238 243
@@ -336,12 +341,12 @@ impl Struct {
336 341
337#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] 342#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
338pub struct Union { 343pub struct Union {
339 pub(crate) id: StructId, 344 pub(crate) id: UnionId,
340} 345}
341 346
342impl Union { 347impl Union {
343 pub fn name(self, db: &impl DefDatabase) -> Option<Name> { 348 pub fn name(self, db: &impl DefDatabase) -> Option<Name> {
344 db.struct_data(self.id).name.clone() 349 db.union_data(self.id).name.clone()
345 } 350 }
346 351
347 pub fn module(self, db: &impl HirDatabase) -> Module { 352 pub fn module(self, db: &impl HirDatabase) -> Module {
diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs
index bd0c3c226..6d116ee75 100644
--- a/crates/ra_hir/src/code_model/src.rs
+++ b/crates/ra_hir/src/code_model/src.rs
@@ -22,7 +22,7 @@ pub trait HasSource {
22impl Module { 22impl Module {
23 /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items. 23 /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items.
24 pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ModuleSource> { 24 pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source<ModuleSource> {
25 let def_map = db.crate_def_map(self.krate()); 25 let def_map = db.crate_def_map(self.id.krate);
26 let decl_id = def_map[self.id.module_id].declaration; 26 let decl_id = def_map[self.id.module_id].declaration;
27 let file_id = def_map[self.id.module_id].definition; 27 let file_id = def_map[self.id.module_id].definition;
28 let ast = ModuleSource::new(db, file_id, decl_id); 28 let ast = ModuleSource::new(db, file_id, decl_id);
@@ -36,7 +36,7 @@ impl Module {
36 self, 36 self,
37 db: &(impl DefDatabase + AstDatabase), 37 db: &(impl DefDatabase + AstDatabase),
38 ) -> Option<Source<ast::Module>> { 38 ) -> Option<Source<ast::Module>> {
39 let def_map = db.crate_def_map(self.krate()); 39 let def_map = db.crate_def_map(self.id.krate);
40 let decl = def_map[self.id.module_id].declaration?; 40 let decl = def_map[self.id.module_id].declaration?;
41 let ast = decl.to_node(db); 41 let ast = decl.to_node(db);
42 Some(Source { file_id: decl.file_id(), ast }) 42 Some(Source { file_id: decl.file_id(), ast })
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 89ca4e39f..f45804c7c 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -11,7 +11,7 @@ use crate::{
11 ids, 11 ids,
12 impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks}, 12 impl_block::{ImplBlock, ImplSourceMap, ModuleImplBlocks},
13 lang_item::{LangItemTarget, LangItems}, 13 lang_item::{LangItemTarget, LangItems},
14 nameres::{CrateDefMap, Namespace}, 14 nameres::Namespace,
15 traits::TraitData, 15 traits::TraitData,
16 ty::{ 16 ty::{
17 method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate, 17 method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate,
@@ -23,8 +23,8 @@ use crate::{
23}; 23};
24 24
25pub use hir_def::db::{ 25pub use hir_def::db::{
26 DefDatabase2, DefDatabase2Storage, EnumDataQuery, InternDatabase, InternDatabaseStorage, 26 CrateDefMapQuery, DefDatabase2, DefDatabase2Storage, EnumDataQuery, InternDatabase,
27 RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery, 27 InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery,
28}; 28};
29pub use hir_expand::db::{ 29pub use hir_expand::db::{
30 AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, 30 AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery,
@@ -41,9 +41,6 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 {
41 #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)] 41 #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)]
42 fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex; 42 fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex;
43 43
44 #[salsa::invoke(CrateDefMap::crate_def_map_query)]
45 fn crate_def_map(&self, krate: Crate) -> Arc<CrateDefMap>;
46
47 #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)] 44 #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)]
48 fn impls_in_module_with_source_map( 45 fn impls_in_module_with_source_map(
49 &self, 46 &self,
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs
index a33af8f46..1751e7be3 100644
--- a/crates/ra_hir/src/diagnostics.rs
+++ b/crates/ra_hir/src/diagnostics.rs
@@ -3,10 +3,10 @@
3use std::any::Any; 3use std::any::Any;
4 4
5use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr}; 5use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr};
6use relative_path::RelativePathBuf;
7 6
8use crate::{db::AstDatabase, HirFileId, Name, Source}; 7use crate::{db::AstDatabase, HirFileId, Name, Source};
9 8
9pub use hir_def::diagnostics::UnresolvedModule;
10pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink}; 10pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink};
11 11
12#[derive(Debug)] 12#[derive(Debug)]
@@ -30,25 +30,6 @@ impl Diagnostic for NoSuchField {
30} 30}
31 31
32#[derive(Debug)] 32#[derive(Debug)]
33pub struct UnresolvedModule {
34 pub file: HirFileId,
35 pub decl: AstPtr<ast::Module>,
36 pub candidate: RelativePathBuf,
37}
38
39impl Diagnostic for UnresolvedModule {
40 fn message(&self) -> String {
41 "unresolved module".to_string()
42 }
43 fn source(&self) -> Source<SyntaxNodePtr> {
44 Source { file_id: self.file, ast: self.decl.into() }
45 }
46 fn as_any(&self) -> &(dyn Any + Send + 'static) {
47 self
48 }
49}
50
51#[derive(Debug)]
52pub struct MissingFields { 33pub struct MissingFields {
53 pub file: HirFileId, 34 pub file: HirFileId,
54 pub field_list: AstPtr<ast::RecordFieldList>, 35 pub field_list: AstPtr<ast::RecordFieldList>,
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs
new file mode 100644
index 000000000..c08203bca
--- /dev/null
+++ b/crates/ra_hir/src/from_id.rs
@@ -0,0 +1,58 @@
1use hir_def::{AdtId, EnumVariantId, ModuleDefId};
2
3use crate::{Adt, EnumVariant, ModuleDef};
4
5macro_rules! from_id {
6 ($(($id:path, $ty:path)),*) => {$(
7 impl From<$id> for $ty {
8 fn from(id: $id) -> $ty {
9 $ty { id }
10 }
11 }
12 )*}
13}
14
15from_id![
16 (hir_def::ModuleId, crate::Module),
17 (hir_def::StructId, crate::Struct),
18 (hir_def::UnionId, crate::Union),
19 (hir_def::EnumId, crate::Enum),
20 (hir_def::TypeAliasId, crate::TypeAlias),
21 (hir_def::TraitId, crate::Trait),
22 (hir_def::StaticId, crate::Static),
23 (hir_def::ConstId, crate::Const),
24 (hir_def::FunctionId, crate::Function),
25 (hir_expand::MacroDefId, crate::MacroDef)
26];
27
28impl From<AdtId> for Adt {
29 fn from(id: AdtId) -> Self {
30 match id {
31 AdtId::StructId(it) => Adt::Struct(it.into()),
32 AdtId::UnionId(it) => Adt::Union(it.into()),
33 AdtId::EnumId(it) => Adt::Enum(it.into()),
34 }
35 }
36}
37
38impl From<EnumVariantId> for EnumVariant {
39 fn from(id: EnumVariantId) -> Self {
40 EnumVariant { parent: id.parent.into(), id: id.local_id }
41 }
42}
43
44impl From<ModuleDefId> for ModuleDef {
45 fn from(id: ModuleDefId) -> Self {
46 match id {
47 ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()),
48 ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()),
49 ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()),
50 ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()),
51 ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()),
52 ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()),
53 ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()),
54 ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()),
55 ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it),
56 }
57 }
58}
diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs
index a9de01455..9899bdbbc 100644
--- a/crates/ra_hir/src/from_source.rs
+++ b/crates/ra_hir/src/from_source.rs
@@ -149,14 +149,20 @@ impl Module {
149 ModuleSource::SourceFile(_) => None, 149 ModuleSource::SourceFile(_) => None,
150 }; 150 };
151 151
152 db.relevant_crates(src.file_id.original_file(db)) 152 db.relevant_crates(src.file_id.original_file(db)).iter().find_map(|&crate_id| {
153 .iter() 153 let def_map = db.crate_def_map(crate_id);
154 .map(|&crate_id| Crate { crate_id }) 154
155 .find_map(|krate| { 155 let (module_id, _module_data) =
156 let def_map = db.crate_def_map(krate); 156 def_map.modules.iter().find(|(_module_id, module_data)| {
157 let module_id = def_map.find_module_by_source(src.file_id, decl_id)?; 157 if decl_id.is_some() {
158 Some(Module::new(krate, module_id)) 158 module_data.declaration == decl_id
159 }) 159 } else {
160 module_data.definition.map(|it| it.into()) == Some(src.file_id)
161 }
162 })?;
163
164 Some(Module::new(Crate { crate_id }, module_id))
165 })
160 } 166 }
161} 167}
162 168
diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs
index 0ba17e571..52bad2228 100644
--- a/crates/ra_hir/src/lib.rs
+++ b/crates/ra_hir/src/lib.rs
@@ -47,6 +47,7 @@ mod resolve;
47pub mod diagnostics; 47pub mod diagnostics;
48mod util; 48mod util;
49 49
50mod from_id;
50mod code_model; 51mod code_model;
51 52
52pub mod from_source; 53pub mod from_source;
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 32a6ab474..bb775cfc9 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -47,512 +47,10 @@
47//! path and, upon success, we run macro expansion and "collect module" phase 47//! path and, upon success, we run macro expansion and "collect module" phase
48//! on the result 48//! on the result
49 49
50mod per_ns;
51mod collector;
52#[cfg(test)] 50#[cfg(test)]
53mod tests; 51mod tests;
54 52
55use std::sync::Arc; 53pub use hir_def::nameres::{
56 54 per_ns::{Namespace, PerNs},
57use hir_def::{builtin_type::BuiltinType, CrateModuleId}; 55 raw::ImportId,
58use hir_expand::diagnostics::DiagnosticSink;
59use once_cell::sync::Lazy;
60use ra_arena::Arena;
61use ra_db::{Edition, FileId};
62use ra_prof::profile;
63use ra_syntax::ast;
64use rustc_hash::{FxHashMap, FxHashSet};
65use test_utils::tested_by;
66
67use crate::{
68 db::{AstDatabase, DefDatabase},
69 ids::MacroDefId,
70 nameres::diagnostics::DefDiagnostic,
71 Adt, AstId, Crate, HirFileId, MacroDef, Module, ModuleDef, Name, Path, PathKind, Trait,
72}; 56};
73
74pub use self::per_ns::{Namespace, PerNs};
75
76pub use hir_def::nameres::raw::ImportId;
77
78/// Contains all top-level defs from a macro-expanded crate
79#[derive(Debug, PartialEq, Eq)]
80pub struct CrateDefMap {
81 krate: Crate,
82 edition: Edition,
83 /// The prelude module for this crate. This either comes from an import
84 /// marked with the `prelude_import` attribute, or (in the normal case) from
85 /// a dependency (`std` or `core`).
86 prelude: Option<Module>,
87 extern_prelude: FxHashMap<Name, ModuleDef>,
88 root: CrateModuleId,
89 modules: Arena<CrateModuleId, ModuleData>,
90
91 /// Some macros are not well-behavior, which leads to infinite loop
92 /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
93 /// We mark it down and skip it in collector
94 ///
95 /// FIXME:
96 /// Right now it only handle a poison macro in a single crate,
97 /// such that if other crate try to call that macro,
98 /// the whole process will do again until it became poisoned in that crate.
99 /// We should handle this macro set globally
100 /// However, do we want to put it as a global variable?
101 poison_macros: FxHashSet<MacroDefId>,
102
103 diagnostics: Vec<DefDiagnostic>,
104}
105
106impl std::ops::Index<CrateModuleId> for CrateDefMap {
107 type Output = ModuleData;
108 fn index(&self, id: CrateModuleId) -> &ModuleData {
109 &self.modules[id]
110 }
111}
112
113#[derive(Default, Debug, PartialEq, Eq)]
114pub struct ModuleData {
115 pub(crate) parent: Option<CrateModuleId>,
116 pub(crate) children: FxHashMap<Name, CrateModuleId>,
117 pub(crate) scope: ModuleScope,
118 /// None for root
119 pub(crate) declaration: Option<AstId<ast::Module>>,
120 /// None for inline modules.
121 ///
122 /// Note that non-inline modules, by definition, live inside non-macro file.
123 pub(crate) definition: Option<FileId>,
124}
125
126#[derive(Debug, Default, PartialEq, Eq, Clone)]
127pub struct ModuleScope {
128 items: FxHashMap<Name, Resolution>,
129 /// Macros visable in current module in legacy textual scope
130 ///
131 /// For macros invoked by an unquatified identifier like `bar!()`, `legacy_macros` will be searched in first.
132 /// If it yields no result, then it turns to module scoped `macros`.
133 /// It macros with name quatified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped,
134 /// and only normal scoped `macros` will be searched in.
135 ///
136 /// Note that this automatically inherit macros defined textually before the definition of module itself.
137 ///
138 /// Module scoped macros will be inserted into `items` instead of here.
139 // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will
140 // be all resolved to the last one defined if shadowing happens.
141 legacy_macros: FxHashMap<Name, MacroDef>,
142}
143
144static BUILTIN_SCOPE: Lazy<FxHashMap<Name, Resolution>> = Lazy::new(|| {
145 BuiltinType::ALL
146 .iter()
147 .map(|(name, ty)| {
148 (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), import: None })
149 })
150 .collect()
151});
152
153/// Legacy macros can only be accessed through special methods like `get_legacy_macros`.
154/// Other methods will only resolve values, types and module scoped macros only.
155impl ModuleScope {
156 pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, &'a Resolution)> + 'a {
157 //FIXME: shadowing
158 self.items.iter().chain(BUILTIN_SCOPE.iter())
159 }
160
161 /// Iterate over all module scoped macros
162 pub fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDef)> + 'a {
163 self.items
164 .iter()
165 .filter_map(|(name, res)| res.def.get_macros().map(|macro_| (name, macro_)))
166 }
167
168 /// Iterate over all legacy textual scoped macros visable at the end of the module
169 pub fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDef)> + 'a {
170 self.legacy_macros.iter().map(|(name, def)| (name, *def))
171 }
172
173 /// Get a name from current module scope, legacy macros are not included
174 pub fn get(&self, name: &Name) -> Option<&Resolution> {
175 self.items.get(name).or_else(|| BUILTIN_SCOPE.get(name))
176 }
177
178 pub fn traits<'a>(&'a self) -> impl Iterator<Item = Trait> + 'a {
179 self.items.values().filter_map(|r| match r.def.take_types() {
180 Some(ModuleDef::Trait(t)) => Some(t),
181 _ => None,
182 })
183 }
184
185 fn get_legacy_macro(&self, name: &Name) -> Option<MacroDef> {
186 self.legacy_macros.get(name).copied()
187 }
188}
189
190#[derive(Debug, Clone, PartialEq, Eq, Default)]
191pub struct Resolution {
192 /// None for unresolved
193 pub def: PerNs,
194 /// ident by which this is imported into local scope.
195 pub import: Option<ImportId>,
196}
197
198impl Resolution {
199 pub(crate) fn from_macro(macro_: MacroDef) -> Self {
200 Resolution { def: PerNs::macros(macro_), import: None }
201 }
202}
203
204#[derive(Debug, Clone)]
205struct ResolvePathResult {
206 resolved_def: PerNs,
207 segment_index: Option<usize>,
208 reached_fixedpoint: ReachedFixedPoint,
209}
210
211impl ResolvePathResult {
212 fn empty(reached_fixedpoint: ReachedFixedPoint) -> ResolvePathResult {
213 ResolvePathResult::with(PerNs::none(), reached_fixedpoint, None)
214 }
215
216 fn with(
217 resolved_def: PerNs,
218 reached_fixedpoint: ReachedFixedPoint,
219 segment_index: Option<usize>,
220 ) -> ResolvePathResult {
221 ResolvePathResult { resolved_def, reached_fixedpoint, segment_index }
222 }
223}
224
225#[derive(Debug, Clone, Copy, PartialEq, Eq)]
226enum ResolveMode {
227 Import,
228 Other,
229}
230
231#[derive(Debug, Clone, Copy, PartialEq, Eq)]
232enum ReachedFixedPoint {
233 Yes,
234 No,
235}
236
237impl CrateDefMap {
238 pub(crate) fn crate_def_map_query(
239 // Note that this doesn't have `+ AstDatabase`!
240 // This gurantess that `CrateDefMap` is stable across reparses.
241 db: &impl DefDatabase,
242 krate: Crate,
243 ) -> Arc<CrateDefMap> {
244 let _p = profile("crate_def_map_query");
245 let def_map = {
246 let edition = krate.edition(db);
247 let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
248 let root = modules.alloc(ModuleData::default());
249 CrateDefMap {
250 krate,
251 edition,
252 extern_prelude: FxHashMap::default(),
253 prelude: None,
254 root,
255 modules,
256 poison_macros: FxHashSet::default(),
257 diagnostics: Vec::new(),
258 }
259 };
260 let def_map = collector::collect_defs(db, def_map);
261 Arc::new(def_map)
262 }
263
264 pub(crate) fn krate(&self) -> Crate {
265 self.krate
266 }
267
268 pub(crate) fn root(&self) -> CrateModuleId {
269 self.root
270 }
271
272 pub(crate) fn prelude(&self) -> Option<Module> {
273 self.prelude
274 }
275
276 pub(crate) fn extern_prelude(&self) -> &FxHashMap<Name, ModuleDef> {
277 &self.extern_prelude
278 }
279
280 pub(crate) fn add_diagnostics(
281 &self,
282 db: &(impl DefDatabase + AstDatabase),
283 module: CrateModuleId,
284 sink: &mut DiagnosticSink,
285 ) {
286 self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
287 }
288
289 pub(crate) fn find_module_by_source(
290 &self,
291 file_id: HirFileId,
292 decl_id: Option<AstId<ast::Module>>,
293 ) -> Option<CrateModuleId> {
294 let (module_id, _module_data) = self.modules.iter().find(|(_module_id, module_data)| {
295 if decl_id.is_some() {
296 module_data.declaration == decl_id
297 } else {
298 module_data.definition.map(|it| it.into()) == Some(file_id)
299 }
300 })?;
301 Some(module_id)
302 }
303
304 pub(crate) fn resolve_path(
305 &self,
306 db: &impl DefDatabase,
307 original_module: CrateModuleId,
308 path: &Path,
309 ) -> (PerNs, Option<usize>) {
310 let res = self.resolve_path_fp_with_macro(db, ResolveMode::Other, original_module, path);
311 (res.resolved_def, res.segment_index)
312 }
313
314 // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
315 // the result.
316 fn resolve_path_fp_with_macro(
317 &self,
318 db: &impl DefDatabase,
319 mode: ResolveMode,
320 original_module: CrateModuleId,
321 path: &Path,
322 ) -> ResolvePathResult {
323 let mut segments = path.segments.iter().enumerate();
324 let mut curr_per_ns: PerNs = match path.kind {
325 PathKind::DollarCrate(crate_id) => {
326 let krate = Crate { crate_id };
327 if krate == self.krate {
328 tested_by!(macro_dollar_crate_self);
329 PerNs::types(Module::new(self.krate, self.root).into())
330 } else {
331 match krate.root_module(db) {
332 Some(module) => {
333 tested_by!(macro_dollar_crate_other);
334 PerNs::types(module.into())
335 }
336 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
337 }
338 }
339 }
340 PathKind::Crate => PerNs::types(Module::new(self.krate, self.root).into()),
341 PathKind::Self_ => PerNs::types(Module::new(self.krate, original_module).into()),
342 // plain import or absolute path in 2015: crate-relative with
343 // fallback to extern prelude (with the simplification in
344 // rust-lang/rust#57745)
345 // FIXME there must be a nicer way to write this condition
346 PathKind::Plain | PathKind::Abs
347 if self.edition == Edition::Edition2015
348 && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
349 {
350 let segment = match segments.next() {
351 Some((_, segment)) => segment,
352 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
353 };
354 log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
355 self.resolve_name_in_crate_root_or_extern_prelude(&segment.name)
356 }
357 PathKind::Plain => {
358 let segment = match segments.next() {
359 Some((_, segment)) => segment,
360 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
361 };
362 log::debug!("resolving {:?} in module", segment);
363 self.resolve_name_in_module(db, original_module, &segment.name)
364 }
365 PathKind::Super => {
366 if let Some(p) = self.modules[original_module].parent {
367 PerNs::types(Module::new(self.krate, p).into())
368 } else {
369 log::debug!("super path in root module");
370 return ResolvePathResult::empty(ReachedFixedPoint::Yes);
371 }
372 }
373 PathKind::Abs => {
374 // 2018-style absolute path -- only extern prelude
375 let segment = match segments.next() {
376 Some((_, segment)) => segment,
377 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
378 };
379 if let Some(def) = self.extern_prelude.get(&segment.name) {
380 log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
381 PerNs::types(*def)
382 } else {
383 return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
384 }
385 }
386 PathKind::Type(_) => {
387 // This is handled in `infer::infer_path_expr`
388 // The result returned here does not matter
389 return ResolvePathResult::empty(ReachedFixedPoint::Yes);
390 }
391 };
392
393 for (i, segment) in segments {
394 let curr = match curr_per_ns.take_types() {
395 Some(r) => r,
396 None => {
397 // we still have path segments left, but the path so far
398 // didn't resolve in the types namespace => no resolution
399 // (don't break here because `curr_per_ns` might contain
400 // something in the value namespace, and it would be wrong
401 // to return that)
402 return ResolvePathResult::empty(ReachedFixedPoint::No);
403 }
404 };
405 // resolve segment in curr
406
407 curr_per_ns = match curr {
408 ModuleDef::Module(module) => {
409 if module.krate() != self.krate {
410 let path =
411 Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
412 log::debug!("resolving {:?} in other crate", path);
413 let defp_map = db.crate_def_map(module.krate());
414 let (def, s) = defp_map.resolve_path(db, module.id.module_id, &path);
415 return ResolvePathResult::with(
416 def,
417 ReachedFixedPoint::Yes,
418 s.map(|s| s + i),
419 );
420 }
421
422 // Since it is a qualified path here, it should not contains legacy macros
423 match self[module.id.module_id].scope.get(&segment.name) {
424 Some(res) => res.def,
425 _ => {
426 log::debug!("path segment {:?} not found", segment.name);
427 return ResolvePathResult::empty(ReachedFixedPoint::No);
428 }
429 }
430 }
431 ModuleDef::Adt(Adt::Enum(e)) => {
432 // enum variant
433 tested_by!(can_import_enum_variant);
434 match e.variant(db, &segment.name) {
435 Some(variant) => PerNs::both(variant.into(), variant.into()),
436 None => {
437 return ResolvePathResult::with(
438 PerNs::types(e.into()),
439 ReachedFixedPoint::Yes,
440 Some(i),
441 );
442 }
443 }
444 }
445 s => {
446 // could be an inherent method call in UFCS form
447 // (`Struct::method`), or some other kind of associated item
448 log::debug!(
449 "path segment {:?} resolved to non-module {:?}, but is not last",
450 segment.name,
451 curr,
452 );
453
454 return ResolvePathResult::with(
455 PerNs::types(s),
456 ReachedFixedPoint::Yes,
457 Some(i),
458 );
459 }
460 };
461 }
462 ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
463 }
464
465 fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs {
466 let from_crate_root =
467 self[self.root].scope.get(name).map_or_else(PerNs::none, |res| res.def);
468 let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
469
470 from_crate_root.or(from_extern_prelude)
471 }
472
473 pub(crate) fn resolve_name_in_module(
474 &self,
475 db: &impl DefDatabase,
476 module: CrateModuleId,
477 name: &Name,
478 ) -> PerNs {
479 // Resolve in:
480 // - legacy scope of macro
481 // - current module / scope
482 // - extern prelude
483 // - std prelude
484 let from_legacy_macro =
485 self[module].scope.get_legacy_macro(name).map_or_else(PerNs::none, PerNs::macros);
486 let from_scope = self[module].scope.get(name).map_or_else(PerNs::none, |res| res.def);
487 let from_extern_prelude =
488 self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
489 let from_prelude = self.resolve_in_prelude(db, name);
490
491 from_legacy_macro.or(from_scope).or(from_extern_prelude).or(from_prelude)
492 }
493
494 fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
495 self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
496 }
497
498 fn resolve_in_prelude(&self, db: &impl DefDatabase, name: &Name) -> PerNs {
499 if let Some(prelude) = self.prelude {
500 let keep;
501 let def_map = if prelude.krate() == self.krate {
502 self
503 } else {
504 // Extend lifetime
505 keep = db.crate_def_map(prelude.krate());
506 &keep
507 };
508 def_map[prelude.id.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
509 } else {
510 PerNs::none()
511 }
512 }
513}
514
515mod diagnostics {
516 use hir_expand::diagnostics::DiagnosticSink;
517 use ra_syntax::{ast, AstPtr};
518 use relative_path::RelativePathBuf;
519
520 use crate::{
521 db::{AstDatabase, DefDatabase},
522 diagnostics::UnresolvedModule,
523 nameres::CrateModuleId,
524 AstId,
525 };
526
527 #[derive(Debug, PartialEq, Eq)]
528 pub(super) enum DefDiagnostic {
529 UnresolvedModule {
530 module: CrateModuleId,
531 declaration: AstId<ast::Module>,
532 candidate: RelativePathBuf,
533 },
534 }
535
536 impl DefDiagnostic {
537 pub(super) fn add_to(
538 &self,
539 db: &(impl DefDatabase + AstDatabase),
540 target_module: CrateModuleId,
541 sink: &mut DiagnosticSink,
542 ) {
543 match self {
544 DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
545 if *module != target_module {
546 return;
547 }
548 let decl = declaration.to_node(db);
549 sink.push(UnresolvedModule {
550 file: declaration.file_id(),
551 decl: AstPtr::new(&decl),
552 candidate: candidate.clone(),
553 })
554 }
555 }
556 }
557 }
558}
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs
index 8c6b40aaf..02db91a86 100644
--- a/crates/ra_hir/src/nameres/tests.rs
+++ b/crates/ra_hir/src/nameres/tests.rs
@@ -6,30 +6,25 @@ mod mod_resolution;
6 6
7use std::sync::Arc; 7use std::sync::Arc;
8 8
9use hir_def::{db::DefDatabase2, nameres::*, CrateModuleId};
9use insta::assert_snapshot; 10use insta::assert_snapshot;
10use ra_db::SourceDatabase; 11use ra_db::SourceDatabase;
11use test_utils::covers; 12// use test_utils::covers;
12 13
13use crate::{ 14use crate::mock::{CrateGraphFixture, MockDatabase};
14 mock::{CrateGraphFixture, MockDatabase},
15 Crate,
16};
17
18use super::*;
19 15
20fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> { 16fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> {
21 let mut db = MockDatabase::with_files(fixture); 17 let mut db = MockDatabase::with_files(fixture);
22 if let Some(graph) = graph { 18 if let Some(graph) = graph {
23 db.set_crate_graph_from_fixture(graph); 19 db.set_crate_graph_from_fixture(graph);
24 } 20 }
25 let crate_id = db.crate_graph().iter().next().unwrap(); 21 let krate = db.crate_graph().iter().next().unwrap();
26 let krate = Crate { crate_id };
27 db.crate_def_map(krate) 22 db.crate_def_map(krate)
28} 23}
29 24
30fn render_crate_def_map(map: &CrateDefMap) -> String { 25fn render_crate_def_map(map: &CrateDefMap) -> String {
31 let mut buf = String::new(); 26 let mut buf = String::new();
32 go(&mut buf, map, "\ncrate", map.root); 27 go(&mut buf, map, "\ncrate", map.root());
33 return buf.trim().to_string(); 28 return buf.trim().to_string();
34 29
35 fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) { 30 fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) {
@@ -118,7 +113,7 @@ fn crate_def_map_smoke_test() {
118 113
119#[test] 114#[test]
120fn bogus_paths() { 115fn bogus_paths() {
121 covers!(bogus_paths); 116 // covers!(bogus_paths);
122 let map = def_map( 117 let map = def_map(
123 " 118 "
124 //- /lib.rs 119 //- /lib.rs
@@ -233,7 +228,7 @@ fn re_exports() {
233 228
234#[test] 229#[test]
235fn std_prelude() { 230fn std_prelude() {
236 covers!(std_prelude); 231 // covers!(std_prelude);
237 let map = def_map_with_crate_graph( 232 let map = def_map_with_crate_graph(
238 " 233 "
239 //- /main.rs 234 //- /main.rs
@@ -261,7 +256,7 @@ fn std_prelude() {
261 256
262#[test] 257#[test]
263fn can_import_enum_variant() { 258fn can_import_enum_variant() {
264 covers!(can_import_enum_variant); 259 // covers!(can_import_enum_variant);
265 let map = def_map( 260 let map = def_map(
266 " 261 "
267 //- /lib.rs 262 //- /lib.rs
diff --git a/crates/ra_hir/src/nameres/tests/globs.rs b/crates/ra_hir/src/nameres/tests/globs.rs
index 7ac22b47b..b3e4d8d94 100644
--- a/crates/ra_hir/src/nameres/tests/globs.rs
+++ b/crates/ra_hir/src/nameres/tests/globs.rs
@@ -75,7 +75,7 @@ fn glob_2() {
75 75
76#[test] 76#[test]
77fn glob_across_crates() { 77fn glob_across_crates() {
78 covers!(glob_across_crates); 78 // covers!(glob_across_crates);
79 let map = def_map_with_crate_graph( 79 let map = def_map_with_crate_graph(
80 " 80 "
81 //- /main.rs 81 //- /main.rs
@@ -98,7 +98,7 @@ fn glob_across_crates() {
98 98
99#[test] 99#[test]
100fn glob_enum() { 100fn glob_enum() {
101 covers!(glob_enum); 101 // covers!(glob_enum);
102 let map = def_map( 102 let map = def_map(
103 " 103 "
104 //- /lib.rs 104 //- /lib.rs
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs
index af9c39760..723ece7b0 100644
--- a/crates/ra_hir/src/nameres/tests/incremental.rs
+++ b/crates/ra_hir/src/nameres/tests/incremental.rs
@@ -1,13 +1,12 @@
1use super::*;
2
3use std::sync::Arc; 1use std::sync::Arc;
4 2
5use ra_db::{SourceDatabase, SourceDatabaseExt}; 3use ra_db::{SourceDatabase, SourceDatabaseExt};
6 4
5use super::*;
6
7fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) { 7fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) {
8 let (mut db, pos) = MockDatabase::with_position(initial); 8 let (mut db, pos) = MockDatabase::with_position(initial);
9 let crate_id = db.crate_graph().iter().next().unwrap(); 9 let krate = db.crate_graph().iter().next().unwrap();
10 let krate = Crate { crate_id };
11 { 10 {
12 let events = db.log_executed(|| { 11 let events = db.log_executed(|| {
13 db.crate_def_map(krate); 12 db.crate_def_map(krate);
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs
index 4f52ad2c5..78bb0eb0d 100644
--- a/crates/ra_hir/src/nameres/tests/macros.rs
+++ b/crates/ra_hir/src/nameres/tests/macros.rs
@@ -187,7 +187,7 @@ fn unexpanded_macro_should_expand_by_fixedpoint_loop() {
187 187
188#[test] 188#[test]
189fn macro_rules_from_other_crates_are_visible_with_macro_use() { 189fn macro_rules_from_other_crates_are_visible_with_macro_use() {
190 covers!(macro_rules_from_other_crates_are_visible_with_macro_use); 190 // covers!(macro_rules_from_other_crates_are_visible_with_macro_use);
191 let map = def_map_with_crate_graph( 191 let map = def_map_with_crate_graph(
192 " 192 "
193 //- /main.rs 193 //- /main.rs
@@ -241,7 +241,7 @@ fn macro_rules_from_other_crates_are_visible_with_macro_use() {
241 241
242#[test] 242#[test]
243fn prelude_is_macro_use() { 243fn prelude_is_macro_use() {
244 covers!(prelude_is_macro_use); 244 // covers!(prelude_is_macro_use);
245 let map = def_map_with_crate_graph( 245 let map = def_map_with_crate_graph(
246 " 246 "
247 //- /main.rs 247 //- /main.rs
@@ -531,8 +531,8 @@ fn path_qualified_macros() {
531 531
532#[test] 532#[test]
533fn macro_dollar_crate_is_correct_in_item() { 533fn macro_dollar_crate_is_correct_in_item() {
534 covers!(macro_dollar_crate_self); 534 // covers!(macro_dollar_crate_self);
535 covers!(macro_dollar_crate_other); 535 // covers!(macro_dollar_crate_other);
536 let map = def_map_with_crate_graph( 536 let map = def_map_with_crate_graph(
537 " 537 "
538 //- /main.rs 538 //- /main.rs
@@ -594,7 +594,7 @@ fn macro_dollar_crate_is_correct_in_item() {
594 594
595#[test] 595#[test]
596fn macro_dollar_crate_is_correct_in_indirect_deps() { 596fn macro_dollar_crate_is_correct_in_indirect_deps() {
597 covers!(macro_dollar_crate_other); 597 // covers!(macro_dollar_crate_other);
598 // From std 598 // From std
599 let map = def_map_with_crate_graph( 599 let map = def_map_with_crate_graph(
600 r#" 600 r#"
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs
index 75b24d386..3e3f8c252 100644
--- a/crates/ra_hir/src/resolve.rs
+++ b/crates/ra_hir/src/resolve.rs
@@ -3,8 +3,9 @@ use std::sync::Arc;
3 3
4use hir_def::{ 4use hir_def::{
5 builtin_type::BuiltinType, 5 builtin_type::BuiltinType,
6 nameres::CrateDefMap,
6 path::{Path, PathKind}, 7 path::{Path, PathKind},
7 CrateModuleId, 8 AdtId, CrateModuleId, ModuleDefId,
8}; 9};
9use hir_expand::name::{self, Name}; 10use hir_expand::name::{self, Name};
10use rustc_hash::FxHashSet; 11use rustc_hash::FxHashSet;
@@ -18,7 +19,7 @@ use crate::{
18 }, 19 },
19 generics::GenericParams, 20 generics::GenericParams,
20 impl_block::ImplBlock, 21 impl_block::ImplBlock,
21 nameres::{CrateDefMap, PerNs}, 22 nameres::PerNs,
22 Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias, 23 Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias,
23}; 24};
24 25
@@ -90,7 +91,7 @@ impl Resolver {
90 pub(crate) fn resolve_known_trait(&self, db: &impl HirDatabase, path: &Path) -> Option<Trait> { 91 pub(crate) fn resolve_known_trait(&self, db: &impl HirDatabase, path: &Path) -> Option<Trait> {
91 let res = self.resolve_module_path(db, path).take_types()?; 92 let res = self.resolve_module_path(db, path).take_types()?;
92 match res { 93 match res {
93 ModuleDef::Trait(it) => Some(it), 94 ModuleDefId::TraitId(it) => Some(it.into()),
94 _ => None, 95 _ => None,
95 } 96 }
96 } 97 }
@@ -103,7 +104,7 @@ impl Resolver {
103 ) -> Option<Struct> { 104 ) -> Option<Struct> {
104 let res = self.resolve_module_path(db, path).take_types()?; 105 let res = self.resolve_module_path(db, path).take_types()?;
105 match res { 106 match res {
106 ModuleDef::Adt(Adt::Struct(it)) => Some(it), 107 ModuleDefId::AdtId(AdtId::StructId(it)) => Some(it.into()),
107 _ => None, 108 _ => None,
108 } 109 }
109 } 110 }
@@ -112,7 +113,7 @@ impl Resolver {
112 pub(crate) fn resolve_known_enum(&self, db: &impl HirDatabase, path: &Path) -> Option<Enum> { 113 pub(crate) fn resolve_known_enum(&self, db: &impl HirDatabase, path: &Path) -> Option<Enum> {
113 let res = self.resolve_module_path(db, path).take_types()?; 114 let res = self.resolve_module_path(db, path).take_types()?;
114 match res { 115 match res {
115 ModuleDef::Adt(Adt::Enum(it)) => Some(it), 116 ModuleDefId::AdtId(AdtId::EnumId(it)) => Some(it.into()),
116 _ => None, 117 _ => None,
117 } 118 }
118 } 119 }
@@ -166,18 +167,18 @@ impl Resolver {
166 Scope::ModuleScope(m) => { 167 Scope::ModuleScope(m) => {
167 let (module_def, idx) = m.crate_def_map.resolve_path(db, m.module_id, path); 168 let (module_def, idx) = m.crate_def_map.resolve_path(db, m.module_id, path);
168 let res = match module_def.take_types()? { 169 let res = match module_def.take_types()? {
169 ModuleDef::Adt(it) => TypeNs::Adt(it), 170 ModuleDefId::AdtId(it) => TypeNs::Adt(it.into()),
170 ModuleDef::EnumVariant(it) => TypeNs::EnumVariant(it), 171 ModuleDefId::EnumVariantId(it) => TypeNs::EnumVariant(it.into()),
171 172
172 ModuleDef::TypeAlias(it) => TypeNs::TypeAlias(it), 173 ModuleDefId::TypeAliasId(it) => TypeNs::TypeAlias(it.into()),
173 ModuleDef::BuiltinType(it) => TypeNs::BuiltinType(it), 174 ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
174 175
175 ModuleDef::Trait(it) => TypeNs::Trait(it), 176 ModuleDefId::TraitId(it) => TypeNs::Trait(it.into()),
176 177
177 ModuleDef::Function(_) 178 ModuleDefId::FunctionId(_)
178 | ModuleDef::Const(_) 179 | ModuleDefId::ConstId(_)
179 | ModuleDef::Static(_) 180 | ModuleDefId::StaticId(_)
180 | ModuleDef::Module(_) => return None, 181 | ModuleDefId::ModuleId(_) => return None,
181 }; 182 };
182 return Some((res, idx)); 183 return Some((res, idx));
183 } 184 }
@@ -261,33 +262,35 @@ impl Resolver {
261 return match idx { 262 return match idx {
262 None => { 263 None => {
263 let value = match module_def.take_values()? { 264 let value = match module_def.take_values()? {
264 ModuleDef::Function(it) => ValueNs::Function(it), 265 ModuleDefId::FunctionId(it) => ValueNs::Function(it.into()),
265 ModuleDef::Adt(Adt::Struct(it)) => ValueNs::Struct(it), 266 ModuleDefId::AdtId(AdtId::StructId(it)) => {
266 ModuleDef::EnumVariant(it) => ValueNs::EnumVariant(it), 267 ValueNs::Struct(it.into())
267 ModuleDef::Const(it) => ValueNs::Const(it), 268 }
268 ModuleDef::Static(it) => ValueNs::Static(it), 269 ModuleDefId::EnumVariantId(it) => ValueNs::EnumVariant(it.into()),
269 270 ModuleDefId::ConstId(it) => ValueNs::Const(it.into()),
270 ModuleDef::Adt(Adt::Enum(_)) 271 ModuleDefId::StaticId(it) => ValueNs::Static(it.into()),
271 | ModuleDef::Adt(Adt::Union(_)) 272
272 | ModuleDef::Trait(_) 273 ModuleDefId::AdtId(AdtId::EnumId(_))
273 | ModuleDef::TypeAlias(_) 274 | ModuleDefId::AdtId(AdtId::UnionId(_))
274 | ModuleDef::BuiltinType(_) 275 | ModuleDefId::TraitId(_)
275 | ModuleDef::Module(_) => return None, 276 | ModuleDefId::TypeAliasId(_)
277 | ModuleDefId::BuiltinType(_)
278 | ModuleDefId::ModuleId(_) => return None,
276 }; 279 };
277 Some(ResolveValueResult::ValueNs(value)) 280 Some(ResolveValueResult::ValueNs(value))
278 } 281 }
279 Some(idx) => { 282 Some(idx) => {
280 let ty = match module_def.take_types()? { 283 let ty = match module_def.take_types()? {
281 ModuleDef::Adt(it) => TypeNs::Adt(it), 284 ModuleDefId::AdtId(it) => TypeNs::Adt(it.into()),
282 ModuleDef::Trait(it) => TypeNs::Trait(it), 285 ModuleDefId::TraitId(it) => TypeNs::Trait(it.into()),
283 ModuleDef::TypeAlias(it) => TypeNs::TypeAlias(it), 286 ModuleDefId::TypeAliasId(it) => TypeNs::TypeAlias(it.into()),
284 ModuleDef::BuiltinType(it) => TypeNs::BuiltinType(it), 287 ModuleDefId::BuiltinType(it) => TypeNs::BuiltinType(it),
285 288
286 ModuleDef::Module(_) 289 ModuleDefId::ModuleId(_)
287 | ModuleDef::Function(_) 290 | ModuleDefId::FunctionId(_)
288 | ModuleDef::EnumVariant(_) 291 | ModuleDefId::EnumVariantId(_)
289 | ModuleDef::Const(_) 292 | ModuleDefId::ConstId(_)
290 | ModuleDef::Static(_) => return None, 293 | ModuleDefId::StaticId(_) => return None,
291 }; 294 };
292 Some(ResolveValueResult::Partial(ty, idx)) 295 Some(ResolveValueResult::Partial(ty, idx))
293 } 296 }
@@ -315,7 +318,7 @@ impl Resolver {
315 path: &Path, 318 path: &Path,
316 ) -> Option<MacroDef> { 319 ) -> Option<MacroDef> {
317 let (item_map, module) = self.module()?; 320 let (item_map, module) = self.module()?;
318 item_map.resolve_path(db, module, path).0.get_macros() 321 item_map.resolve_path(db, module, path).0.get_macros().map(MacroDef::from)
319 } 322 }
320 323
321 pub(crate) fn process_all_names( 324 pub(crate) fn process_all_names(
@@ -333,10 +336,11 @@ impl Resolver {
333 for scope in &self.scopes { 336 for scope in &self.scopes {
334 if let Scope::ModuleScope(m) = scope { 337 if let Scope::ModuleScope(m) = scope {
335 if let Some(prelude) = m.crate_def_map.prelude() { 338 if let Some(prelude) = m.crate_def_map.prelude() {
336 let prelude_def_map = db.crate_def_map(prelude.krate()); 339 let prelude_def_map = db.crate_def_map(prelude.krate);
337 traits.extend(prelude_def_map[prelude.id.module_id].scope.traits()); 340 traits
341 .extend(prelude_def_map[prelude.module_id].scope.traits().map(Trait::from));
338 } 342 }
339 traits.extend(m.crate_def_map[m.module_id].scope.traits()); 343 traits.extend(m.crate_def_map[m.module_id].scope.traits().map(Trait::from));
340 } 344 }
341 } 345 }
342 traits 346 traits
@@ -351,7 +355,7 @@ impl Resolver {
351 } 355 }
352 356
353 pub(crate) fn krate(&self) -> Option<Crate> { 357 pub(crate) fn krate(&self) -> Option<Crate> {
354 self.module().map(|t| t.0.krate()) 358 self.module().map(|t| Crate { crate_id: t.0.krate() })
355 } 359 }
356 360
357 pub(crate) fn where_predicates_in_scope<'a>( 361 pub(crate) fn where_predicates_in_scope<'a>(
@@ -420,8 +424,10 @@ impl From<PerNs> for ScopeDef {
420 fn from(def: PerNs) -> Self { 424 fn from(def: PerNs) -> Self {
421 def.take_types() 425 def.take_types()
422 .or_else(|| def.take_values()) 426 .or_else(|| def.take_values())
423 .map(ScopeDef::ModuleDef) 427 .map(|module_def_id| ScopeDef::ModuleDef(module_def_id.into()))
424 .or_else(|| def.get_macros().map(ScopeDef::MacroDef)) 428 .or_else(|| {
429 def.get_macros().map(|macro_def_id| ScopeDef::MacroDef(macro_def_id.into()))
430 })
425 .unwrap_or(ScopeDef::Unknown) 431 .unwrap_or(ScopeDef::Unknown)
426 } 432 }
427} 433}
@@ -441,18 +447,16 @@ impl Scope {
441 f(name.clone(), res.def.into()); 447 f(name.clone(), res.def.into());
442 }); 448 });
443 m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| { 449 m.crate_def_map[m.module_id].scope.legacy_macros().for_each(|(name, macro_)| {
444 f(name.clone(), ScopeDef::MacroDef(macro_)); 450 f(name.clone(), ScopeDef::MacroDef(macro_.into()));
445 }); 451 });
446 m.crate_def_map.extern_prelude().iter().for_each(|(name, def)| { 452 m.crate_def_map.extern_prelude().iter().for_each(|(name, &def)| {
447 f(name.clone(), ScopeDef::ModuleDef(*def)); 453 f(name.clone(), ScopeDef::ModuleDef(def.into()));
448 }); 454 });
449 if let Some(prelude) = m.crate_def_map.prelude() { 455 if let Some(prelude) = m.crate_def_map.prelude() {
450 let prelude_def_map = db.crate_def_map(prelude.krate()); 456 let prelude_def_map = db.crate_def_map(prelude.krate);
451 prelude_def_map[prelude.id.module_id].scope.entries().for_each( 457 prelude_def_map[prelude.module_id].scope.entries().for_each(|(name, res)| {
452 |(name, res)| { 458 f(name.clone(), res.def.into());
453 f(name.clone(), res.def.into()); 459 });
454 },
455 );
456 } 460 }
457 } 461 }
458 Scope::GenericParams(gp) => { 462 Scope::GenericParams(gp) => {
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index a4ca59bba..66cb4b357 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -253,8 +253,11 @@ impl SourceAnalyzer {
253 Some(res) 253 Some(res)
254 }); 254 });
255 255
256 let items = 256 let items = self
257 self.resolver.resolve_module_path(db, &path).take_types().map(PathResolution::Def); 257 .resolver
258 .resolve_module_path(db, &path)
259 .take_types()
260 .map(|it| PathResolution::Def(it.into()));
258 types.or(values).or(items).or_else(|| { 261 types.or(values).or(items).or_else(|| {
259 self.resolver.resolve_path_as_macro(db, &path).map(|def| PathResolution::Macro(def)) 262 self.resolver.resolve_path_as_macro(db, &path).map(|def| PathResolution::Macro(def))
260 }) 263 })
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs
index bfef48b16..f27155737 100644
--- a/crates/ra_hir/src/ty/tests.rs
+++ b/crates/ra_hir/src/ty/tests.rs
@@ -3403,7 +3403,7 @@ fn test() { S.foo()<|>; }
3403 3403
3404#[test] 3404#[test]
3405fn infer_macro_with_dollar_crate_is_correct_in_expr() { 3405fn infer_macro_with_dollar_crate_is_correct_in_expr() {
3406 covers!(macro_dollar_crate_other); 3406 // covers!(macro_dollar_crate_other);
3407 let (mut db, pos) = MockDatabase::with_position( 3407 let (mut db, pos) = MockDatabase::with_position(
3408 r#" 3408 r#"
3409//- /main.rs 3409//- /main.rs
diff --git a/crates/ra_hir_def/src/adt.rs b/crates/ra_hir_def/src/adt.rs
index 22bd469f0..8f41e55d2 100644
--- a/crates/ra_hir_def/src/adt.rs
+++ b/crates/ra_hir_def/src/adt.rs
@@ -8,7 +8,7 @@ use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner};
8 8
9use crate::{ 9use crate::{
10 db::DefDatabase2, type_ref::TypeRef, AstItemDef, EnumId, LocalEnumVariantId, 10 db::DefDatabase2, type_ref::TypeRef, AstItemDef, EnumId, LocalEnumVariantId,
11 LocalStructFieldId, StructId, 11 LocalStructFieldId, StructId, UnionId,
12}; 12};
13 13
14/// Note that we use `StructData` for unions as well! 14/// Note that we use `StructData` for unions as well!
@@ -56,6 +56,13 @@ impl StructData {
56 let variant_data = Arc::new(variant_data); 56 let variant_data = Arc::new(variant_data);
57 Arc::new(StructData { name, variant_data }) 57 Arc::new(StructData { name, variant_data })
58 } 58 }
59 pub(crate) fn union_data_query(db: &impl DefDatabase2, struct_: UnionId) -> Arc<StructData> {
60 let src = struct_.source(db);
61 let name = src.ast.name().map(|n| n.as_name());
62 let variant_data = VariantData::new(src.ast.kind());
63 let variant_data = Arc::new(variant_data);
64 Arc::new(StructData { name, variant_data })
65 }
59} 66}
60 67
61impl EnumData { 68impl EnumData {
@@ -74,6 +81,11 @@ impl EnumData {
74 .collect(); 81 .collect();
75 Arc::new(EnumData { name, variants }) 82 Arc::new(EnumData { name, variants })
76 } 83 }
84
85 pub(crate) fn variant(&self, name: &Name) -> Option<LocalEnumVariantId> {
86 let (id, _) = self.variants.iter().find(|(_id, data)| data.name.as_ref() == Some(name))?;
87 Some(id)
88 }
77} 89}
78 90
79impl VariantData { 91impl VariantData {
diff --git a/crates/ra_hir_def/src/db.rs b/crates/ra_hir_def/src/db.rs
index f6027013f..a42348101 100644
--- a/crates/ra_hir_def/src/db.rs
+++ b/crates/ra_hir_def/src/db.rs
@@ -2,13 +2,16 @@
2use std::sync::Arc; 2use std::sync::Arc;
3 3
4use hir_expand::{db::AstDatabase, HirFileId}; 4use hir_expand::{db::AstDatabase, HirFileId};
5use ra_db::{salsa, SourceDatabase}; 5use ra_db::{salsa, CrateId, SourceDatabase};
6use ra_syntax::ast; 6use ra_syntax::ast;
7 7
8use crate::{ 8use crate::{
9 adt::{EnumData, StructData}, 9 adt::{EnumData, StructData},
10 nameres::raw::{ImportSourceMap, RawItems}, 10 nameres::{
11 EnumId, StructId, 11 raw::{ImportSourceMap, RawItems},
12 CrateDefMap,
13 },
14 EnumId, StructId, UnionId,
12}; 15};
13 16
14#[salsa::query_group(InternDatabaseStorage)] 17#[salsa::query_group(InternDatabaseStorage)]
@@ -42,9 +45,15 @@ pub trait DefDatabase2: InternDatabase + AstDatabase {
42 #[salsa::invoke(RawItems::raw_items_query)] 45 #[salsa::invoke(RawItems::raw_items_query)]
43 fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>; 46 fn raw_items(&self, file_id: HirFileId) -> Arc<RawItems>;
44 47
48 #[salsa::invoke(CrateDefMap::crate_def_map_query)]
49 fn crate_def_map(&self, krate: CrateId) -> Arc<CrateDefMap>;
50
45 #[salsa::invoke(StructData::struct_data_query)] 51 #[salsa::invoke(StructData::struct_data_query)]
46 fn struct_data(&self, s: StructId) -> Arc<StructData>; 52 fn struct_data(&self, s: StructId) -> Arc<StructData>;
47 53
54 #[salsa::invoke(StructData::union_data_query)]
55 fn union_data(&self, s: UnionId) -> Arc<StructData>;
56
48 #[salsa::invoke(EnumData::enum_data_query)] 57 #[salsa::invoke(EnumData::enum_data_query)]
49 fn enum_data(&self, e: EnumId) -> Arc<EnumData>; 58 fn enum_data(&self, e: EnumId) -> Arc<EnumData>;
50} 59}
diff --git a/crates/ra_hir_def/src/diagnostics.rs b/crates/ra_hir_def/src/diagnostics.rs
new file mode 100644
index 000000000..637184c58
--- /dev/null
+++ b/crates/ra_hir_def/src/diagnostics.rs
@@ -0,0 +1,26 @@
1use std::any::Any;
2
3use hir_expand::diagnostics::Diagnostic;
4use ra_syntax::{ast, AstPtr, SyntaxNodePtr};
5use relative_path::RelativePathBuf;
6
7use hir_expand::{HirFileId, Source};
8
9#[derive(Debug)]
10pub struct UnresolvedModule {
11 pub file: HirFileId,
12 pub decl: AstPtr<ast::Module>,
13 pub candidate: RelativePathBuf,
14}
15
16impl Diagnostic for UnresolvedModule {
17 fn message(&self) -> String {
18 "unresolved module".to_string()
19 }
20 fn source(&self) -> Source<SyntaxNodePtr> {
21 Source { file_id: self.file, ast: self.decl.into() }
22 }
23 fn as_any(&self) -> &(dyn Any + Send + 'static) {
24 self
25 }
26}
diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs
index 6d66f481d..42e080a72 100644
--- a/crates/ra_hir_def/src/lib.rs
+++ b/crates/ra_hir_def/src/lib.rs
@@ -13,6 +13,7 @@ pub mod path;
13pub mod type_ref; 13pub mod type_ref;
14pub mod builtin_type; 14pub mod builtin_type;
15pub mod adt; 15pub mod adt;
16pub mod diagnostics;
16 17
17// FIXME: this should be private 18// FIXME: this should be private
18pub mod nameres; 19pub mod nameres;
@@ -237,8 +238,8 @@ impl AstItemDef<ast::EnumDef> for EnumId {
237// FIXME: rename to `VariantId`, only enums can ave variants 238// FIXME: rename to `VariantId`, only enums can ave variants
238#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] 239#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
239pub struct EnumVariantId { 240pub struct EnumVariantId {
240 parent: EnumId, 241 pub parent: EnumId,
241 local_id: LocalEnumVariantId, 242 pub local_id: LocalEnumVariantId,
242} 243}
243 244
244#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] 245#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
diff --git a/crates/ra_hir_def/src/nameres.rs b/crates/ra_hir_def/src/nameres.rs
index 11ba8a777..db59344aa 100644
--- a/crates/ra_hir_def/src/nameres.rs
+++ b/crates/ra_hir_def/src/nameres.rs
@@ -2,4 +2,492 @@
2 2
3// FIXME: review privacy of submodules 3// FIXME: review privacy of submodules
4pub mod raw; 4pub mod raw;
5pub mod per_ns;
6pub mod collector;
5pub mod mod_resolution; 7pub mod mod_resolution;
8
9use std::sync::Arc;
10
11use hir_expand::{diagnostics::DiagnosticSink, name::Name, MacroDefId};
12use once_cell::sync::Lazy;
13use ra_arena::Arena;
14use ra_db::{CrateId, Edition, FileId};
15use ra_prof::profile;
16use ra_syntax::ast;
17use rustc_hash::{FxHashMap, FxHashSet};
18// use test_utils::tested_by;
19
20use crate::{
21 builtin_type::BuiltinType,
22 db::DefDatabase2,
23 nameres::{diagnostics::DefDiagnostic, per_ns::PerNs, raw::ImportId},
24 path::{Path, PathKind},
25 AdtId, AstId, CrateModuleId, EnumVariantId, ModuleDefId, ModuleId, TraitId,
26};
27
28/// Contains all top-level defs from a macro-expanded crate
29#[derive(Debug, PartialEq, Eq)]
30pub struct CrateDefMap {
31 krate: CrateId,
32 edition: Edition,
33 /// The prelude module for this crate. This either comes from an import
34 /// marked with the `prelude_import` attribute, or (in the normal case) from
35 /// a dependency (`std` or `core`).
36 prelude: Option<ModuleId>,
37 extern_prelude: FxHashMap<Name, ModuleDefId>,
38 root: CrateModuleId,
39 pub modules: Arena<CrateModuleId, ModuleData>,
40
41 /// Some macros are not well-behavior, which leads to infinite loop
42 /// e.g. macro_rules! foo { ($ty:ty) => { foo!($ty); } }
43 /// We mark it down and skip it in collector
44 ///
45 /// FIXME:
46 /// Right now it only handle a poison macro in a single crate,
47 /// such that if other crate try to call that macro,
48 /// the whole process will do again until it became poisoned in that crate.
49 /// We should handle this macro set globally
50 /// However, do we want to put it as a global variable?
51 poison_macros: FxHashSet<MacroDefId>,
52
53 diagnostics: Vec<DefDiagnostic>,
54}
55
56impl std::ops::Index<CrateModuleId> for CrateDefMap {
57 type Output = ModuleData;
58 fn index(&self, id: CrateModuleId) -> &ModuleData {
59 &self.modules[id]
60 }
61}
62
63#[derive(Default, Debug, PartialEq, Eq)]
64pub struct ModuleData {
65 pub parent: Option<CrateModuleId>,
66 pub children: FxHashMap<Name, CrateModuleId>,
67 pub scope: ModuleScope,
68 /// None for root
69 pub declaration: Option<AstId<ast::Module>>,
70 /// None for inline modules.
71 ///
72 /// Note that non-inline modules, by definition, live inside non-macro file.
73 pub definition: Option<FileId>,
74}
75
76#[derive(Debug, Default, PartialEq, Eq, Clone)]
77pub struct ModuleScope {
78 pub items: FxHashMap<Name, Resolution>,
79 /// Macros visable in current module in legacy textual scope
80 ///
81 /// For macros invoked by an unquatified identifier like `bar!()`, `legacy_macros` will be searched in first.
82 /// If it yields no result, then it turns to module scoped `macros`.
83 /// It macros with name quatified with a path like `crate::foo::bar!()`, `legacy_macros` will be skipped,
84 /// and only normal scoped `macros` will be searched in.
85 ///
86 /// Note that this automatically inherit macros defined textually before the definition of module itself.
87 ///
88 /// Module scoped macros will be inserted into `items` instead of here.
89 // FIXME: Macro shadowing in one module is not properly handled. Non-item place macros will
90 // be all resolved to the last one defined if shadowing happens.
91 legacy_macros: FxHashMap<Name, MacroDefId>,
92}
93
94static BUILTIN_SCOPE: Lazy<FxHashMap<Name, Resolution>> = Lazy::new(|| {
95 BuiltinType::ALL
96 .iter()
97 .map(|(name, ty)| {
98 (name.clone(), Resolution { def: PerNs::types(ty.clone().into()), import: None })
99 })
100 .collect()
101});
102
103/// Legacy macros can only be accessed through special methods like `get_legacy_macros`.
104/// Other methods will only resolve values, types and module scoped macros only.
105impl ModuleScope {
106 pub fn entries<'a>(&'a self) -> impl Iterator<Item = (&'a Name, &'a Resolution)> + 'a {
107 //FIXME: shadowing
108 self.items.iter().chain(BUILTIN_SCOPE.iter())
109 }
110
111 /// Iterate over all module scoped macros
112 pub fn macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
113 self.items
114 .iter()
115 .filter_map(|(name, res)| res.def.get_macros().map(|macro_| (name, macro_)))
116 }
117
118 /// Iterate over all legacy textual scoped macros visable at the end of the module
119 pub fn legacy_macros<'a>(&'a self) -> impl Iterator<Item = (&'a Name, MacroDefId)> + 'a {
120 self.legacy_macros.iter().map(|(name, def)| (name, *def))
121 }
122
123 /// Get a name from current module scope, legacy macros are not included
124 pub fn get(&self, name: &Name) -> Option<&Resolution> {
125 self.items.get(name).or_else(|| BUILTIN_SCOPE.get(name))
126 }
127
128 pub fn traits<'a>(&'a self) -> impl Iterator<Item = TraitId> + 'a {
129 self.items.values().filter_map(|r| match r.def.take_types() {
130 Some(ModuleDefId::TraitId(t)) => Some(t),
131 _ => None,
132 })
133 }
134
135 fn get_legacy_macro(&self, name: &Name) -> Option<MacroDefId> {
136 self.legacy_macros.get(name).copied()
137 }
138}
139
140#[derive(Debug, Clone, PartialEq, Eq, Default)]
141pub struct Resolution {
142 /// None for unresolved
143 pub def: PerNs,
144 /// ident by which this is imported into local scope.
145 pub import: Option<ImportId>,
146}
147
148impl Resolution {
149 pub(crate) fn from_macro(macro_: MacroDefId) -> Self {
150 Resolution { def: PerNs::macros(macro_), import: None }
151 }
152}
153
154#[derive(Debug, Clone)]
155struct ResolvePathResult {
156 resolved_def: PerNs,
157 segment_index: Option<usize>,
158 reached_fixedpoint: ReachedFixedPoint,
159}
160
161impl ResolvePathResult {
162 fn empty(reached_fixedpoint: ReachedFixedPoint) -> ResolvePathResult {
163 ResolvePathResult::with(PerNs::none(), reached_fixedpoint, None)
164 }
165
166 fn with(
167 resolved_def: PerNs,
168 reached_fixedpoint: ReachedFixedPoint,
169 segment_index: Option<usize>,
170 ) -> ResolvePathResult {
171 ResolvePathResult { resolved_def, reached_fixedpoint, segment_index }
172 }
173}
174
175#[derive(Debug, Clone, Copy, PartialEq, Eq)]
176enum ResolveMode {
177 Import,
178 Other,
179}
180
181#[derive(Debug, Clone, Copy, PartialEq, Eq)]
182enum ReachedFixedPoint {
183 Yes,
184 No,
185}
186
187impl CrateDefMap {
188 pub(crate) fn crate_def_map_query(
189 // Note that this doesn't have `+ AstDatabase`!
190 // This gurantess that `CrateDefMap` is stable across reparses.
191 db: &impl DefDatabase2,
192 krate: CrateId,
193 ) -> Arc<CrateDefMap> {
194 let _p = profile("crate_def_map_query");
195 let def_map = {
196 let crate_graph = db.crate_graph();
197 let edition = crate_graph.edition(krate);
198 let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default();
199 let root = modules.alloc(ModuleData::default());
200 CrateDefMap {
201 krate,
202 edition,
203 extern_prelude: FxHashMap::default(),
204 prelude: None,
205 root,
206 modules,
207 poison_macros: FxHashSet::default(),
208 diagnostics: Vec::new(),
209 }
210 };
211 let def_map = collector::collect_defs(db, def_map);
212 Arc::new(def_map)
213 }
214
215 pub fn krate(&self) -> CrateId {
216 self.krate
217 }
218
219 pub fn root(&self) -> CrateModuleId {
220 self.root
221 }
222
223 pub fn prelude(&self) -> Option<ModuleId> {
224 self.prelude
225 }
226
227 pub fn extern_prelude(&self) -> &FxHashMap<Name, ModuleDefId> {
228 &self.extern_prelude
229 }
230
231 pub fn add_diagnostics(
232 &self,
233 db: &impl DefDatabase2,
234 module: CrateModuleId,
235 sink: &mut DiagnosticSink,
236 ) {
237 self.diagnostics.iter().for_each(|it| it.add_to(db, module, sink))
238 }
239
240 pub fn resolve_path(
241 &self,
242 db: &impl DefDatabase2,
243 original_module: CrateModuleId,
244 path: &Path,
245 ) -> (PerNs, Option<usize>) {
246 let res = self.resolve_path_fp_with_macro(db, ResolveMode::Other, original_module, path);
247 (res.resolved_def, res.segment_index)
248 }
249
250 // Returns Yes if we are sure that additions to `ItemMap` wouldn't change
251 // the result.
252 fn resolve_path_fp_with_macro(
253 &self,
254 db: &impl DefDatabase2,
255 mode: ResolveMode,
256 original_module: CrateModuleId,
257 path: &Path,
258 ) -> ResolvePathResult {
259 let mut segments = path.segments.iter().enumerate();
260 let mut curr_per_ns: PerNs = match path.kind {
261 PathKind::DollarCrate(krate) => {
262 if krate == self.krate {
263 // tested_by!(macro_dollar_crate_self);
264 PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
265 } else {
266 let def_map = db.crate_def_map(krate);
267 let module = ModuleId { krate, module_id: def_map.root };
268 // tested_by!(macro_dollar_crate_other);
269 PerNs::types(module.into())
270 }
271 }
272 PathKind::Crate => {
273 PerNs::types(ModuleId { krate: self.krate, module_id: self.root }.into())
274 }
275 PathKind::Self_ => {
276 PerNs::types(ModuleId { krate: self.krate, module_id: original_module }.into())
277 }
278 // plain import or absolute path in 2015: crate-relative with
279 // fallback to extern prelude (with the simplification in
280 // rust-lang/rust#57745)
281 // FIXME there must be a nicer way to write this condition
282 PathKind::Plain | PathKind::Abs
283 if self.edition == Edition::Edition2015
284 && (path.kind == PathKind::Abs || mode == ResolveMode::Import) =>
285 {
286 let segment = match segments.next() {
287 Some((_, segment)) => segment,
288 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
289 };
290 log::debug!("resolving {:?} in crate root (+ extern prelude)", segment);
291 self.resolve_name_in_crate_root_or_extern_prelude(&segment.name)
292 }
293 PathKind::Plain => {
294 let segment = match segments.next() {
295 Some((_, segment)) => segment,
296 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
297 };
298 log::debug!("resolving {:?} in module", segment);
299 self.resolve_name_in_module(db, original_module, &segment.name)
300 }
301 PathKind::Super => {
302 if let Some(p) = self.modules[original_module].parent {
303 PerNs::types(ModuleId { krate: self.krate, module_id: p }.into())
304 } else {
305 log::debug!("super path in root module");
306 return ResolvePathResult::empty(ReachedFixedPoint::Yes);
307 }
308 }
309 PathKind::Abs => {
310 // 2018-style absolute path -- only extern prelude
311 let segment = match segments.next() {
312 Some((_, segment)) => segment,
313 None => return ResolvePathResult::empty(ReachedFixedPoint::Yes),
314 };
315 if let Some(def) = self.extern_prelude.get(&segment.name) {
316 log::debug!("absolute path {:?} resolved to crate {:?}", path, def);
317 PerNs::types(*def)
318 } else {
319 return ResolvePathResult::empty(ReachedFixedPoint::No); // extern crate declarations can add to the extern prelude
320 }
321 }
322 PathKind::Type(_) => {
323 // This is handled in `infer::infer_path_expr`
324 // The result returned here does not matter
325 return ResolvePathResult::empty(ReachedFixedPoint::Yes);
326 }
327 };
328
329 for (i, segment) in segments {
330 let curr = match curr_per_ns.take_types() {
331 Some(r) => r,
332 None => {
333 // we still have path segments left, but the path so far
334 // didn't resolve in the types namespace => no resolution
335 // (don't break here because `curr_per_ns` might contain
336 // something in the value namespace, and it would be wrong
337 // to return that)
338 return ResolvePathResult::empty(ReachedFixedPoint::No);
339 }
340 };
341 // resolve segment in curr
342
343 curr_per_ns = match curr {
344 ModuleDefId::ModuleId(module) => {
345 if module.krate != self.krate {
346 let path =
347 Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ };
348 log::debug!("resolving {:?} in other crate", path);
349 let defp_map = db.crate_def_map(module.krate);
350 let (def, s) = defp_map.resolve_path(db, module.module_id, &path);
351 return ResolvePathResult::with(
352 def,
353 ReachedFixedPoint::Yes,
354 s.map(|s| s + i),
355 );
356 }
357
358 // Since it is a qualified path here, it should not contains legacy macros
359 match self[module.module_id].scope.get(&segment.name) {
360 Some(res) => res.def,
361 _ => {
362 log::debug!("path segment {:?} not found", segment.name);
363 return ResolvePathResult::empty(ReachedFixedPoint::No);
364 }
365 }
366 }
367 ModuleDefId::AdtId(AdtId::EnumId(e)) => {
368 // enum variant
369 // tested_by!(can_import_enum_variant);
370 let enum_data = db.enum_data(e);
371 match enum_data.variant(&segment.name) {
372 Some(local_id) => {
373 let variant = EnumVariantId { parent: e, local_id };
374 PerNs::both(variant.into(), variant.into())
375 }
376 None => {
377 return ResolvePathResult::with(
378 PerNs::types(e.into()),
379 ReachedFixedPoint::Yes,
380 Some(i),
381 );
382 }
383 }
384 }
385 s => {
386 // could be an inherent method call in UFCS form
387 // (`Struct::method`), or some other kind of associated item
388 log::debug!(
389 "path segment {:?} resolved to non-module {:?}, but is not last",
390 segment.name,
391 curr,
392 );
393
394 return ResolvePathResult::with(
395 PerNs::types(s),
396 ReachedFixedPoint::Yes,
397 Some(i),
398 );
399 }
400 };
401 }
402 ResolvePathResult::with(curr_per_ns, ReachedFixedPoint::Yes, None)
403 }
404
405 fn resolve_name_in_crate_root_or_extern_prelude(&self, name: &Name) -> PerNs {
406 let from_crate_root =
407 self[self.root].scope.get(name).map_or_else(PerNs::none, |res| res.def);
408 let from_extern_prelude = self.resolve_name_in_extern_prelude(name);
409
410 from_crate_root.or(from_extern_prelude)
411 }
412
413 pub(crate) fn resolve_name_in_module(
414 &self,
415 db: &impl DefDatabase2,
416 module: CrateModuleId,
417 name: &Name,
418 ) -> PerNs {
419 // Resolve in:
420 // - legacy scope of macro
421 // - current module / scope
422 // - extern prelude
423 // - std prelude
424 let from_legacy_macro =
425 self[module].scope.get_legacy_macro(name).map_or_else(PerNs::none, PerNs::macros);
426 let from_scope = self[module].scope.get(name).map_or_else(PerNs::none, |res| res.def);
427 let from_extern_prelude =
428 self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it));
429 let from_prelude = self.resolve_in_prelude(db, name);
430
431 from_legacy_macro.or(from_scope).or(from_extern_prelude).or(from_prelude)
432 }
433
434 fn resolve_name_in_extern_prelude(&self, name: &Name) -> PerNs {
435 self.extern_prelude.get(name).map_or(PerNs::none(), |&it| PerNs::types(it))
436 }
437
438 fn resolve_in_prelude(&self, db: &impl DefDatabase2, name: &Name) -> PerNs {
439 if let Some(prelude) = self.prelude {
440 let keep;
441 let def_map = if prelude.krate == self.krate {
442 self
443 } else {
444 // Extend lifetime
445 keep = db.crate_def_map(prelude.krate);
446 &keep
447 };
448 def_map[prelude.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def)
449 } else {
450 PerNs::none()
451 }
452 }
453}
454
455mod diagnostics {
456 use hir_expand::diagnostics::DiagnosticSink;
457 use ra_syntax::{ast, AstPtr};
458 use relative_path::RelativePathBuf;
459
460 use crate::{db::DefDatabase2, diagnostics::UnresolvedModule, nameres::CrateModuleId, AstId};
461
462 #[derive(Debug, PartialEq, Eq)]
463 pub(super) enum DefDiagnostic {
464 UnresolvedModule {
465 module: CrateModuleId,
466 declaration: AstId<ast::Module>,
467 candidate: RelativePathBuf,
468 },
469 }
470
471 impl DefDiagnostic {
472 pub(super) fn add_to(
473 &self,
474 db: &impl DefDatabase2,
475 target_module: CrateModuleId,
476 sink: &mut DiagnosticSink,
477 ) {
478 match self {
479 DefDiagnostic::UnresolvedModule { module, declaration, candidate } => {
480 if *module != target_module {
481 return;
482 }
483 let decl = declaration.to_node(db);
484 sink.push(UnresolvedModule {
485 file: declaration.file_id(),
486 decl: AstPtr::new(&decl),
487 candidate: candidate.clone(),
488 })
489 }
490 }
491 }
492 }
493}
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir_def/src/nameres/collector.rs
index ee0a4c99f..8a96d3d31 100644
--- a/crates/ra_hir/src/nameres/collector.rs
+++ b/crates/ra_hir_def/src/nameres/collector.rs
@@ -1,45 +1,49 @@
1//! FIXME: write short doc here 1//! FIXME: write short doc here
2 2
3use hir_def::{ 3use hir_expand::{
4 attr::Attr, 4 name::{self, AsName, Name},
5 nameres::{mod_resolution::ModDir, raw}, 5 HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind,
6}; 6};
7use hir_expand::name;
8use ra_cfg::CfgOptions; 7use ra_cfg::CfgOptions;
9use ra_db::FileId; 8use ra_db::{CrateId, FileId};
10use ra_syntax::{ast, SmolStr}; 9use ra_syntax::{ast, SmolStr};
11use rustc_hash::FxHashMap; 10use rustc_hash::FxHashMap;
12use test_utils::tested_by; 11// use test_utils::tested_by;
13 12
14use crate::{ 13use crate::{
15 db::DefDatabase, 14 attr::Attr,
16 ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind}, 15 db::DefDatabase2,
17 nameres::{ 16 nameres::{
18 diagnostics::DefDiagnostic, Crate, CrateDefMap, CrateModuleId, ModuleData, ModuleDef, 17 diagnostics::DefDiagnostic, mod_resolution::ModDir, per_ns::PerNs, raw, CrateDefMap,
19 PerNs, ReachedFixedPoint, Resolution, ResolveMode, 18 ModuleData, ReachedFixedPoint, Resolution, ResolveMode,
20 }, 19 },
21 Adt, AstId, Const, Enum, Function, HirFileId, MacroDef, Module, Name, Path, PathKind, Static, 20 path::{Path, PathKind},
22 Struct, Trait, TypeAlias, Union, 21 AdtId, AstId, AstItemDef, ConstId, CrateModuleId, EnumId, EnumVariantId, FunctionId,
22 LocationCtx, ModuleDefId, ModuleId, StaticId, StructId, TraitId, TypeAliasId, UnionId,
23}; 23};
24 24
25pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap { 25pub(super) fn collect_defs(db: &impl DefDatabase2, mut def_map: CrateDefMap) -> CrateDefMap {
26 let crate_graph = db.crate_graph();
27
26 // populate external prelude 28 // populate external prelude
27 for dep in def_map.krate.dependencies(db) { 29 for dep in crate_graph.dependencies(def_map.krate) {
28 log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate); 30 let dep_def_map = db.crate_def_map(dep.crate_id);
29 if let Some(module) = dep.krate.root_module(db) { 31 log::debug!("crate dep {:?} -> {:?}", dep.name, dep.crate_id);
30 def_map.extern_prelude.insert(dep.name.clone(), module.into()); 32 def_map.extern_prelude.insert(
31 } 33 dep.as_name(),
34 ModuleId { krate: dep.crate_id, module_id: dep_def_map.root }.into(),
35 );
36
32 // look for the prelude 37 // look for the prelude
33 if def_map.prelude.is_none() { 38 if def_map.prelude.is_none() {
34 let map = db.crate_def_map(dep.krate); 39 let map = db.crate_def_map(dep.crate_id);
35 if map.prelude.is_some() { 40 if map.prelude.is_some() {
36 def_map.prelude = map.prelude; 41 def_map.prelude = map.prelude;
37 } 42 }
38 } 43 }
39 } 44 }
40 45
41 let crate_graph = db.crate_graph(); 46 let cfg_options = crate_graph.cfg_options(def_map.krate);
42 let cfg_options = crate_graph.cfg_options(def_map.krate().crate_id());
43 47
44 let mut collector = DefCollector { 48 let mut collector = DefCollector {
45 db, 49 db,
@@ -101,11 +105,11 @@ struct DefCollector<'a, DB> {
101 105
102impl<DB> DefCollector<'_, DB> 106impl<DB> DefCollector<'_, DB>
103where 107where
104 DB: DefDatabase, 108 DB: DefDatabase2,
105{ 109{
106 fn collect(&mut self) { 110 fn collect(&mut self) {
107 let crate_graph = self.db.crate_graph(); 111 let crate_graph = self.db.crate_graph();
108 let file_id = crate_graph.crate_root(self.def_map.krate.crate_id()); 112 let file_id = crate_graph.crate_root(self.def_map.krate);
109 let raw_items = self.db.raw_items(file_id.into()); 113 let raw_items = self.db.raw_items(file_id.into());
110 let module_id = self.def_map.root; 114 let module_id = self.def_map.root;
111 self.def_map.modules[module_id].definition = Some(file_id); 115 self.def_map.modules[module_id].definition = Some(file_id);
@@ -168,7 +172,7 @@ where
168 &mut self, 172 &mut self,
169 module_id: CrateModuleId, 173 module_id: CrateModuleId,
170 name: Name, 174 name: Name,
171 macro_: MacroDef, 175 macro_: MacroDefId,
172 export: bool, 176 export: bool,
173 ) { 177 ) {
174 // Textual scoping 178 // Textual scoping
@@ -189,7 +193,7 @@ where
189 /// the definition of current module. 193 /// the definition of current module.
190 /// And also, `macro_use` on a module will import all legacy macros visable inside to 194 /// And also, `macro_use` on a module will import all legacy macros visable inside to
191 /// current legacy scope, with possible shadowing. 195 /// current legacy scope, with possible shadowing.
192 fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDef) { 196 fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDefId) {
193 // Always shadowing 197 // Always shadowing
194 self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_); 198 self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_);
195 } 199 }
@@ -213,9 +217,9 @@ where
213 .expect("extern crate should have been desugared to one-element path"), 217 .expect("extern crate should have been desugared to one-element path"),
214 ); 218 );
215 219
216 if let Some(ModuleDef::Module(m)) = res.take_types() { 220 if let Some(ModuleDefId::ModuleId(m)) = res.take_types() {
217 tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use); 221 // tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use);
218 self.import_all_macros_exported(current_module_id, m.krate()); 222 self.import_all_macros_exported(current_module_id, m.krate);
219 } 223 }
220 } 224 }
221 225
@@ -224,7 +228,7 @@ where
224 /// Exported macros are just all macros in the root module scope. 228 /// Exported macros are just all macros in the root module scope.
225 /// Note that it contains not only all `#[macro_export]` macros, but also all aliases 229 /// Note that it contains not only all `#[macro_export]` macros, but also all aliases
226 /// created by `use` in the root module, ignoring the visibility of `use`. 230 /// created by `use` in the root module, ignoring the visibility of `use`.
227 fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: Crate) { 231 fn import_all_macros_exported(&mut self, current_module_id: CrateModuleId, krate: CrateId) {
228 let def_map = self.db.crate_def_map(krate); 232 let def_map = self.db.crate_def_map(krate);
229 for (name, def) in def_map[def_map.root].scope.macros() { 233 for (name, def) in def_map[def_map.root].scope.macros() {
230 // `macro_use` only bring things into legacy scope. 234 // `macro_use` only bring things into legacy scope.
@@ -288,15 +292,15 @@ where
288 if import.is_glob { 292 if import.is_glob {
289 log::debug!("glob import: {:?}", import); 293 log::debug!("glob import: {:?}", import);
290 match def.take_types() { 294 match def.take_types() {
291 Some(ModuleDef::Module(m)) => { 295 Some(ModuleDefId::ModuleId(m)) => {
292 if import.is_prelude { 296 if import.is_prelude {
293 tested_by!(std_prelude); 297 // tested_by!(std_prelude);
294 self.def_map.prelude = Some(m); 298 self.def_map.prelude = Some(m);
295 } else if m.krate() != self.def_map.krate { 299 } else if m.krate != self.def_map.krate {
296 tested_by!(glob_across_crates); 300 // tested_by!(glob_across_crates);
297 // glob import from other crate => we can just import everything once 301 // glob import from other crate => we can just import everything once
298 let item_map = self.db.crate_def_map(m.krate()); 302 let item_map = self.db.crate_def_map(m.krate);
299 let scope = &item_map[m.id.module_id].scope; 303 let scope = &item_map[m.module_id].scope;
300 304
301 // Module scoped macros is included 305 // Module scoped macros is included
302 let items = scope 306 let items = scope
@@ -310,7 +314,7 @@ where
310 // glob import from same crate => we do an initial 314 // glob import from same crate => we do an initial
311 // import, and then need to propagate any further 315 // import, and then need to propagate any further
312 // additions 316 // additions
313 let scope = &self.def_map[m.id.module_id].scope; 317 let scope = &self.def_map[m.module_id].scope;
314 318
315 // Module scoped macros is included 319 // Module scoped macros is included
316 let items = scope 320 let items = scope
@@ -322,23 +326,25 @@ where
322 self.update(module_id, Some(import_id), &items); 326 self.update(module_id, Some(import_id), &items);
323 // record the glob import in case we add further items 327 // record the glob import in case we add further items
324 self.glob_imports 328 self.glob_imports
325 .entry(m.id.module_id) 329 .entry(m.module_id)
326 .or_default() 330 .or_default()
327 .push((module_id, import_id)); 331 .push((module_id, import_id));
328 } 332 }
329 } 333 }
330 Some(ModuleDef::Adt(Adt::Enum(e))) => { 334 Some(ModuleDefId::AdtId(AdtId::EnumId(e))) => {
331 tested_by!(glob_enum); 335 // tested_by!(glob_enum);
332 // glob import from enum => just import all the variants 336 // glob import from enum => just import all the variants
333 let variants = e.variants(self.db); 337 let enum_data = self.db.enum_data(e);
334 let resolutions = variants 338 let resolutions = enum_data
335 .into_iter() 339 .variants
336 .filter_map(|variant| { 340 .iter()
341 .filter_map(|(local_id, variant_data)| {
342 let name = variant_data.name.clone()?;
343 let variant = EnumVariantId { parent: e, local_id };
337 let res = Resolution { 344 let res = Resolution {
338 def: PerNs::both(variant.into(), variant.into()), 345 def: PerNs::both(variant.into(), variant.into()),
339 import: Some(import_id), 346 import: Some(import_id),
340 }; 347 };
341 let name = variant.name(self.db)?;
342 Some((name, res)) 348 Some((name, res))
343 }) 349 })
344 .collect::<Vec<_>>(); 350 .collect::<Vec<_>>();
@@ -367,7 +373,8 @@ where
367 let resolution = Resolution { def, import: Some(import_id) }; 373 let resolution = Resolution { def, import: Some(import_id) };
368 self.update(module_id, Some(import_id), &[(name, resolution)]); 374 self.update(module_id, Some(import_id), &[(name, resolution)]);
369 } 375 }
370 None => tested_by!(bogus_paths), 376 // tested_by!(bogus_paths),
377 None => (),
371 } 378 }
372 } 379 }
373 } 380 }
@@ -451,8 +458,8 @@ where
451 ); 458 );
452 459
453 if let Some(def) = resolved_res.resolved_def.get_macros() { 460 if let Some(def) = resolved_res.resolved_def.get_macros() {
454 let call_id = self.db.intern_macro(MacroCallLoc { def: def.id, ast_id: *ast_id }); 461 let call_id = self.db.intern_macro(MacroCallLoc { def, ast_id: *ast_id });
455 resolved.push((*module_id, call_id, def.id)); 462 resolved.push((*module_id, call_id, def));
456 res = ReachedFixedPoint::No; 463 res = ReachedFixedPoint::No;
457 return false; 464 return false;
458 } 465 }
@@ -517,7 +524,7 @@ struct ModCollector<'a, D> {
517 524
518impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>> 525impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>>
519where 526where
520 DB: DefDatabase, 527 DB: DefDatabase2,
521{ 528{
522 fn collect(&mut self, items: &[raw::RawItem]) { 529 fn collect(&mut self, items: &[raw::RawItem]) {
523 // Note: don't assert that inserted value is fresh: it's simply not true 530 // Note: don't assert that inserted value is fresh: it's simply not true
@@ -526,10 +533,9 @@ where
526 533
527 // Prelude module is always considered to be `#[macro_use]`. 534 // Prelude module is always considered to be `#[macro_use]`.
528 if let Some(prelude_module) = self.def_collector.def_map.prelude { 535 if let Some(prelude_module) = self.def_collector.def_map.prelude {
529 if prelude_module.krate() != self.def_collector.def_map.krate { 536 if prelude_module.krate != self.def_collector.def_map.krate {
530 tested_by!(prelude_is_macro_use); 537 // tested_by!(prelude_is_macro_use);
531 self.def_collector 538 self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate);
532 .import_all_macros_exported(self.module_id, prelude_module.krate());
533 } 539 }
534 } 540 }
535 541
@@ -635,7 +641,9 @@ where
635 modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone(); 641 modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone();
636 modules[self.module_id].children.insert(name.clone(), res); 642 modules[self.module_id].children.insert(name.clone(), res);
637 let resolution = Resolution { 643 let resolution = Resolution {
638 def: PerNs::types(Module::new(self.def_collector.def_map.krate, res).into()), 644 def: PerNs::types(
645 ModuleId { krate: self.def_collector.def_map.krate, module_id: res }.into(),
646 ),
639 import: None, 647 import: None,
640 }; 648 };
641 self.def_collector.update(self.module_id, None, &[(name, resolution)]); 649 self.def_collector.update(self.module_id, None, &[(name, resolution)]);
@@ -643,30 +651,32 @@ where
643 } 651 }
644 652
645 fn define_def(&mut self, def: &raw::DefData) { 653 fn define_def(&mut self, def: &raw::DefData) {
646 let module = Module::new(self.def_collector.def_map.krate, self.module_id); 654 let module =
647 let ctx = LocationCtx::new(self.def_collector.db, module.id, self.file_id); 655 ModuleId { krate: self.def_collector.def_map.krate, module_id: self.module_id };
656 let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id);
648 657
649 macro_rules! def {
650 ($kind:ident, $ast_id:ident) => {
651 $kind { id: AstItemDef::from_ast_id(ctx, $ast_id) }.into()
652 };
653 }
654 let name = def.name.clone(); 658 let name = def.name.clone();
655 let def: PerNs = match def.kind { 659 let def: PerNs = match def.kind {
656 raw::DefKind::Function(ast_id) => PerNs::values(def!(Function, ast_id)), 660 raw::DefKind::Function(ast_id) => {
661 PerNs::values(FunctionId::from_ast_id(ctx, ast_id).into())
662 }
657 raw::DefKind::Struct(ast_id) => { 663 raw::DefKind::Struct(ast_id) => {
658 let s = def!(Struct, ast_id); 664 let s = StructId::from_ast_id(ctx, ast_id).into();
659 PerNs::both(s, s) 665 PerNs::both(s, s)
660 } 666 }
661 raw::DefKind::Union(ast_id) => { 667 raw::DefKind::Union(ast_id) => {
662 let s = def!(Union, ast_id); 668 let s = UnionId::from_ast_id(ctx, ast_id).into();
663 PerNs::both(s, s) 669 PerNs::both(s, s)
664 } 670 }
665 raw::DefKind::Enum(ast_id) => PerNs::types(def!(Enum, ast_id)), 671 raw::DefKind::Enum(ast_id) => PerNs::types(EnumId::from_ast_id(ctx, ast_id).into()),
666 raw::DefKind::Const(ast_id) => PerNs::values(def!(Const, ast_id)), 672 raw::DefKind::Const(ast_id) => PerNs::values(ConstId::from_ast_id(ctx, ast_id).into()),
667 raw::DefKind::Static(ast_id) => PerNs::values(def!(Static, ast_id)), 673 raw::DefKind::Static(ast_id) => {
668 raw::DefKind::Trait(ast_id) => PerNs::types(def!(Trait, ast_id)), 674 PerNs::values(StaticId::from_ast_id(ctx, ast_id).into())
669 raw::DefKind::TypeAlias(ast_id) => PerNs::types(def!(TypeAlias, ast_id)), 675 }
676 raw::DefKind::Trait(ast_id) => PerNs::types(TraitId::from_ast_id(ctx, ast_id).into()),
677 raw::DefKind::TypeAlias(ast_id) => {
678 PerNs::types(TypeAliasId::from_ast_id(ctx, ast_id).into())
679 }
670 }; 680 };
671 let resolution = Resolution { def, import: None }; 681 let resolution = Resolution { def, import: None };
672 self.def_collector.update(self.module_id, None, &[(name, resolution)]) 682 self.def_collector.update(self.module_id, None, &[(name, resolution)])
@@ -678,10 +688,8 @@ where
678 // Case 1: macro rules, define a macro in crate-global mutable scope 688 // Case 1: macro rules, define a macro in crate-global mutable scope
679 if is_macro_rules(&mac.path) { 689 if is_macro_rules(&mac.path) {
680 if let Some(name) = &mac.name { 690 if let Some(name) = &mac.name {
681 let macro_id = 691 let macro_id = MacroDefId { ast_id, krate: self.def_collector.def_map.krate };
682 MacroDefId { ast_id, krate: self.def_collector.def_map.krate.crate_id }; 692 self.def_collector.define_macro(self.module_id, name.clone(), macro_id, mac.export);
683 let macro_ = MacroDef { id: macro_id };
684 self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export);
685 } 693 }
686 return; 694 return;
687 } 695 }
@@ -691,10 +699,10 @@ where
691 if let Some(macro_def) = mac.path.as_ident().and_then(|name| { 699 if let Some(macro_def) = mac.path.as_ident().and_then(|name| {
692 self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name) 700 self.def_collector.def_map[self.module_id].scope.get_legacy_macro(&name)
693 }) { 701 }) {
694 let def = macro_def.id; 702 let macro_call_id =
695 let macro_call_id = self.def_collector.db.intern_macro(MacroCallLoc { def, ast_id }); 703 self.def_collector.db.intern_macro(MacroCallLoc { def: macro_def, ast_id });
696 704
697 self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, def); 705 self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, macro_def);
698 return; 706 return;
699 } 707 }
700 708
@@ -731,7 +739,7 @@ fn is_macro_rules(path: &Path) -> bool {
731 path.as_ident() == Some(&name::MACRO_RULES) 739 path.as_ident() == Some(&name::MACRO_RULES)
732} 740}
733 741
734#[cfg(test)] 742#[cfg(never)]
735mod tests { 743mod tests {
736 use ra_db::SourceDatabase; 744 use ra_db::SourceDatabase;
737 745
diff --git a/crates/ra_hir/src/nameres/per_ns.rs b/crates/ra_hir_def/src/nameres/per_ns.rs
index 0da6789de..298b0b0c7 100644
--- a/crates/ra_hir/src/nameres/per_ns.rs
+++ b/crates/ra_hir_def/src/nameres/per_ns.rs
@@ -1,6 +1,8 @@
1//! FIXME: write short doc here 1//! FIXME: write short doc here
2 2
3use crate::{MacroDef, ModuleDef}; 3use hir_expand::MacroDefId;
4
5use crate::ModuleDefId;
4 6
5#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] 7#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
6pub enum Namespace { 8pub enum Namespace {
@@ -12,11 +14,11 @@ pub enum Namespace {
12 14
13#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] 15#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
14pub struct PerNs { 16pub struct PerNs {
15 pub types: Option<ModuleDef>, 17 pub types: Option<ModuleDefId>,
16 pub values: Option<ModuleDef>, 18 pub values: Option<ModuleDefId>,
17 /// Since macros has different type, many methods simply ignore it. 19 /// Since macros has different type, many methods simply ignore it.
18 /// We can only use special method like `get_macros` to access it. 20 /// We can only use special method like `get_macros` to access it.
19 pub macros: Option<MacroDef>, 21 pub macros: Option<MacroDefId>,
20} 22}
21 23
22impl Default for PerNs { 24impl Default for PerNs {
@@ -30,19 +32,19 @@ impl PerNs {
30 PerNs { types: None, values: None, macros: None } 32 PerNs { types: None, values: None, macros: None }
31 } 33 }
32 34
33 pub fn values(t: ModuleDef) -> PerNs { 35 pub fn values(t: ModuleDefId) -> PerNs {
34 PerNs { types: None, values: Some(t), macros: None } 36 PerNs { types: None, values: Some(t), macros: None }
35 } 37 }
36 38
37 pub fn types(t: ModuleDef) -> PerNs { 39 pub fn types(t: ModuleDefId) -> PerNs {
38 PerNs { types: Some(t), values: None, macros: None } 40 PerNs { types: Some(t), values: None, macros: None }
39 } 41 }
40 42
41 pub fn both(types: ModuleDef, values: ModuleDef) -> PerNs { 43 pub fn both(types: ModuleDefId, values: ModuleDefId) -> PerNs {
42 PerNs { types: Some(types), values: Some(values), macros: None } 44 PerNs { types: Some(types), values: Some(values), macros: None }
43 } 45 }
44 46
45 pub fn macros(macro_: MacroDef) -> PerNs { 47 pub fn macros(macro_: MacroDefId) -> PerNs {
46 PerNs { types: None, values: None, macros: Some(macro_) } 48 PerNs { types: None, values: None, macros: Some(macro_) }
47 } 49 }
48 50
@@ -54,15 +56,15 @@ impl PerNs {
54 self.types.is_some() && self.values.is_some() && self.macros.is_some() 56 self.types.is_some() && self.values.is_some() && self.macros.is_some()
55 } 57 }
56 58
57 pub fn take_types(self) -> Option<ModuleDef> { 59 pub fn take_types(self) -> Option<ModuleDefId> {
58 self.types 60 self.types
59 } 61 }
60 62
61 pub fn take_values(self) -> Option<ModuleDef> { 63 pub fn take_values(self) -> Option<ModuleDefId> {
62 self.values 64 self.values
63 } 65 }
64 66
65 pub fn get_macros(&self) -> Option<MacroDef> { 67 pub fn get_macros(&self) -> Option<MacroDefId> {
66 self.macros 68 self.macros
67 } 69 }
68 70
diff --git a/crates/ra_ide_api/src/completion/complete_path.rs b/crates/ra_ide_api/src/completion/complete_path.rs
index 9ac9768af..09ca40179 100644
--- a/crates/ra_ide_api/src/completion/complete_path.rs
+++ b/crates/ra_ide_api/src/completion/complete_path.rs
@@ -18,15 +18,15 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
18 match def { 18 match def {
19 hir::ModuleDef::Module(module) => { 19 hir::ModuleDef::Module(module) => {
20 let module_scope = module.scope(ctx.db); 20 let module_scope = module.scope(ctx.db);
21 for (name, res) in module_scope.entries() { 21 for (name, def, import) in module_scope {
22 if let Some(hir::ModuleDef::BuiltinType(..)) = res.def.take_types() { 22 if let hir::ScopeDef::ModuleDef(hir::ModuleDef::BuiltinType(..)) = def {
23 if ctx.use_item_syntax.is_some() { 23 if ctx.use_item_syntax.is_some() {
24 tested_by!(dont_complete_primitive_in_use); 24 tested_by!(dont_complete_primitive_in_use);
25 continue; 25 continue;
26 } 26 }
27 } 27 }
28 if Some(module) == ctx.module { 28 if Some(module) == ctx.module {
29 if let Some(import) = res.import { 29 if let Some(import) = import {
30 if let Either::A(use_tree) = module.import_source(ctx.db, import) { 30 if let Either::A(use_tree) = module.import_source(ctx.db, import) {
31 if use_tree.syntax().text_range().contains_inclusive(ctx.offset) { 31 if use_tree.syntax().text_range().contains_inclusive(ctx.offset) {
32 // for `use self::foo<|>`, don't suggest `foo` as a completion 32 // for `use self::foo<|>`, don't suggest `foo` as a completion
@@ -36,7 +36,7 @@ pub(super) fn complete_path(acc: &mut Completions, ctx: &CompletionContext) {
36 } 36 }
37 } 37 }
38 } 38 }
39 acc.add_resolution(ctx, name.to_string(), &res.def.into()); 39 acc.add_resolution(ctx, name.to_string(), &def);
40 } 40 }
41 } 41 }
42 hir::ModuleDef::Adt(_) | hir::ModuleDef::TypeAlias(_) => { 42 hir::ModuleDef::Adt(_) | hir::ModuleDef::TypeAlias(_) => {
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 05:46:55 +0000