diff options
author | Seivan Heidari <[email protected]> | 2019-11-04 12:45:27 +0000 |
---|---|---|
committer | Seivan Heidari <[email protected]> | 2019-11-04 12:45:27 +0000 |
commit | dad9bc6caad71e6aebb92ad9883c08d30431e9b1 (patch) | |
tree | 6495d47108bc56ab0fbb358125fe65ebece8934f /crates/ra_hir | |
parent | 1d8bb4c6c1fef1f8ea513e07d0a7d4c5483129d2 (diff) | |
parent | cc2d75d0f88bdcb1b3e20db36decb6ee6eca517a (diff) |
Merge branch 'master' into feature/themes
Diffstat (limited to 'crates/ra_hir')
26 files changed, 223 insertions, 4078 deletions
diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml index 5df371bc0..324961328 100644 --- a/crates/ra_hir/Cargo.toml +++ b/crates/ra_hir/Cargo.toml | |||
@@ -7,7 +7,6 @@ authors = ["rust-analyzer developers"] | |||
7 | [dependencies] | 7 | [dependencies] |
8 | arrayvec = "0.5.1" | 8 | arrayvec = "0.5.1" |
9 | log = "0.4.5" | 9 | log = "0.4.5" |
10 | relative-path = "1.0.0" | ||
11 | rustc-hash = "1.0" | 10 | rustc-hash = "1.0" |
12 | parking_lot = "0.9.0" | 11 | parking_lot = "0.9.0" |
13 | ena = "0.13" | 12 | ena = "0.13" |
@@ -24,9 +23,9 @@ hir_def = { path = "../ra_hir_def", package = "ra_hir_def" } | |||
24 | test_utils = { path = "../test_utils" } | 23 | test_utils = { path = "../test_utils" } |
25 | ra_prof = { path = "../ra_prof" } | 24 | ra_prof = { path = "../ra_prof" } |
26 | 25 | ||
27 | chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" } | 26 | chalk-solve = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" } |
28 | chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" } | 27 | chalk-rust-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" } |
29 | chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "8314f2fcec8582a58c24b638f1a259d4145a0809" } | 28 | chalk-ir = { git = "https://github.com/rust-lang/chalk.git", rev = "50f9f636123bd88d0cc1b958749981d6702e4d05" } |
30 | lalrpop-intern = "0.15.1" | 29 | lalrpop-intern = "0.15.1" |
31 | 30 | ||
32 | [dev-dependencies] | 31 | [dev-dependencies] |
diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index c97ea18a2..181c5d47a 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs | |||
@@ -9,16 +9,18 @@ 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 | }; | ||
14 | use hir_expand::{ | ||
15 | diagnostics::DiagnosticSink, | ||
16 | name::{self, AsName}, | ||
13 | }; | 17 | }; |
14 | use hir_expand::name::{self, AsName}; | ||
15 | use ra_db::{CrateId, Edition}; | 18 | use ra_db::{CrateId, Edition}; |
16 | use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; | 19 | use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; |
17 | 20 | ||
18 | use crate::{ | 21 | use crate::{ |
19 | adt::VariantDef, | 22 | adt::VariantDef, |
20 | db::{AstDatabase, DefDatabase, HirDatabase}, | 23 | db::{AstDatabase, DefDatabase, HirDatabase}, |
21 | diagnostics::DiagnosticSink, | ||
22 | expr::{validation::ExprValidator, Body, BodySourceMap}, | 24 | expr::{validation::ExprValidator, Body, BodySourceMap}, |
23 | generics::HasGenericParams, | 25 | generics::HasGenericParams, |
24 | ids::{ | 26 | ids::{ |
@@ -26,11 +28,10 @@ use crate::{ | |||
26 | TypeAliasId, | 28 | TypeAliasId, |
27 | }, | 29 | }, |
28 | impl_block::ImplBlock, | 30 | impl_block::ImplBlock, |
29 | nameres::{ImportId, ModuleScope, Namespace}, | ||
30 | resolve::{Resolver, Scope, TypeNs}, | 31 | resolve::{Resolver, Scope, TypeNs}, |
31 | traits::TraitData, | 32 | traits::TraitData, |
32 | ty::{InferenceResult, TraitRef}, | 33 | ty::{InferenceResult, TraitRef}, |
33 | Either, HasSource, Name, Ty, | 34 | Either, HasSource, Name, ScopeDef, Ty, {ImportId, Namespace}, |
34 | }; | 35 | }; |
35 | 36 | ||
36 | /// hir::Crate describes a single crate. It's the main interface with which | 37 | /// hir::Crate describes a single crate. It's the main interface with which |
@@ -64,7 +65,7 @@ impl Crate { | |||
64 | } | 65 | } |
65 | 66 | ||
66 | pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> { | 67 | pub fn root_module(self, db: &impl DefDatabase) -> Option<Module> { |
67 | let module_id = db.crate_def_map(self).root(); | 68 | let module_id = db.crate_def_map(self.crate_id).root(); |
68 | Some(Module::new(self, module_id)) | 69 | Some(Module::new(self, module_id)) |
69 | } | 70 | } |
70 | 71 | ||
@@ -118,7 +119,7 @@ impl Module { | |||
118 | 119 | ||
119 | /// Name of this module. | 120 | /// Name of this module. |
120 | pub fn name(self, db: &impl DefDatabase) -> Option<Name> { | 121 | pub fn name(self, db: &impl DefDatabase) -> Option<Name> { |
121 | let def_map = db.crate_def_map(self.krate()); | 122 | let def_map = db.crate_def_map(self.id.krate); |
122 | let parent = def_map[self.id.module_id].parent?; | 123 | let parent = def_map[self.id.module_id].parent?; |
123 | def_map[parent].children.iter().find_map(|(name, module_id)| { | 124 | def_map[parent].children.iter().find_map(|(name, module_id)| { |
124 | if *module_id == self.id.module_id { | 125 | if *module_id == self.id.module_id { |
@@ -149,20 +150,20 @@ impl Module { | |||
149 | /// might be missing `krate`. This can happen if a module's file is not included | 150 | /// might be missing `krate`. This can happen if a module's file is not included |
150 | /// in the module tree of any target in `Cargo.toml`. | 151 | /// in the module tree of any target in `Cargo.toml`. |
151 | pub fn crate_root(self, db: &impl DefDatabase) -> Module { | 152 | pub fn crate_root(self, db: &impl DefDatabase) -> Module { |
152 | let def_map = db.crate_def_map(self.krate()); | 153 | let def_map = db.crate_def_map(self.id.krate); |
153 | self.with_module_id(def_map.root()) | 154 | self.with_module_id(def_map.root()) |
154 | } | 155 | } |
155 | 156 | ||
156 | /// Finds a child module with the specified name. | 157 | /// Finds a child module with the specified name. |
157 | pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> { | 158 | pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option<Module> { |
158 | let def_map = db.crate_def_map(self.krate()); | 159 | let def_map = db.crate_def_map(self.id.krate); |
159 | let child_id = def_map[self.id.module_id].children.get(name)?; | 160 | let child_id = def_map[self.id.module_id].children.get(name)?; |
160 | Some(self.with_module_id(*child_id)) | 161 | Some(self.with_module_id(*child_id)) |
161 | } | 162 | } |
162 | 163 | ||
163 | /// Iterates over all child modules. | 164 | /// Iterates over all child modules. |
164 | pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> { | 165 | pub fn children(self, db: &impl DefDatabase) -> impl Iterator<Item = Module> { |
165 | let def_map = db.crate_def_map(self.krate()); | 166 | let def_map = db.crate_def_map(self.id.krate); |
166 | let children = def_map[self.id.module_id] | 167 | let children = def_map[self.id.module_id] |
167 | .children | 168 | .children |
168 | .iter() | 169 | .iter() |
@@ -173,7 +174,7 @@ impl Module { | |||
173 | 174 | ||
174 | /// Finds a parent module. | 175 | /// Finds a parent module. |
175 | pub fn parent(self, db: &impl DefDatabase) -> Option<Module> { | 176 | pub fn parent(self, db: &impl DefDatabase) -> Option<Module> { |
176 | let def_map = db.crate_def_map(self.krate()); | 177 | let def_map = db.crate_def_map(self.id.krate); |
177 | let parent_id = def_map[self.id.module_id].parent?; | 178 | let parent_id = def_map[self.id.module_id].parent?; |
178 | Some(self.with_module_id(parent_id)) | 179 | Some(self.with_module_id(parent_id)) |
179 | } | 180 | } |
@@ -189,12 +190,16 @@ impl Module { | |||
189 | } | 190 | } |
190 | 191 | ||
191 | /// Returns a `ModuleScope`: a set of items, visible in this module. | 192 | /// Returns a `ModuleScope`: a set of items, visible in this module. |
192 | pub fn scope(self, db: &impl HirDatabase) -> ModuleScope { | 193 | pub fn scope(self, db: &impl HirDatabase) -> Vec<(Name, ScopeDef, Option<ImportId>)> { |
193 | db.crate_def_map(self.krate())[self.id.module_id].scope.clone() | 194 | db.crate_def_map(self.id.krate)[self.id.module_id] |
195 | .scope | ||
196 | .entries() | ||
197 | .map(|(name, res)| (name.clone(), res.def.into(), res.import)) | ||
198 | .collect() | ||
194 | } | 199 | } |
195 | 200 | ||
196 | pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) { | 201 | pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) { |
197 | db.crate_def_map(self.krate()).add_diagnostics(db, self.id.module_id, sink); | 202 | db.crate_def_map(self.id.krate).add_diagnostics(db, self.id.module_id, sink); |
198 | for decl in self.declarations(db) { | 203 | for decl in self.declarations(db) { |
199 | match decl { | 204 | match decl { |
200 | crate::ModuleDef::Function(f) => f.diagnostics(db, sink), | 205 | crate::ModuleDef::Function(f) => f.diagnostics(db, sink), |
@@ -218,12 +223,12 @@ impl Module { | |||
218 | } | 223 | } |
219 | 224 | ||
220 | pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver { | 225 | pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver { |
221 | let def_map = db.crate_def_map(self.krate()); | 226 | let def_map = db.crate_def_map(self.id.krate); |
222 | Resolver::default().push_module_scope(def_map, self.id.module_id) | 227 | Resolver::default().push_module_scope(def_map, self.id.module_id) |
223 | } | 228 | } |
224 | 229 | ||
225 | pub fn declarations(self, db: &impl DefDatabase) -> Vec<ModuleDef> { | 230 | pub fn declarations(self, db: &impl DefDatabase) -> Vec<ModuleDef> { |
226 | let def_map = db.crate_def_map(self.krate()); | 231 | let def_map = db.crate_def_map(self.id.krate); |
227 | def_map[self.id.module_id] | 232 | def_map[self.id.module_id] |
228 | .scope | 233 | .scope |
229 | .entries() | 234 | .entries() |
@@ -231,6 +236,7 @@ impl Module { | |||
231 | .flat_map(|per_ns| { | 236 | .flat_map(|per_ns| { |
232 | per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter()) | 237 | per_ns.take_types().into_iter().chain(per_ns.take_values().into_iter()) |
233 | }) | 238 | }) |
239 | .map(ModuleDef::from) | ||
234 | .collect() | 240 | .collect() |
235 | } | 241 | } |
236 | 242 | ||
@@ -334,12 +340,12 @@ impl Struct { | |||
334 | 340 | ||
335 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] | 341 | #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] |
336 | pub struct Union { | 342 | pub struct Union { |
337 | pub(crate) id: StructId, | 343 | pub(crate) id: UnionId, |
338 | } | 344 | } |
339 | 345 | ||
340 | impl Union { | 346 | impl Union { |
341 | pub fn name(self, db: &impl DefDatabase) -> Option<Name> { | 347 | pub fn name(self, db: &impl DefDatabase) -> Option<Name> { |
342 | db.struct_data(self.id).name.clone() | 348 | db.union_data(self.id).name.clone() |
343 | } | 349 | } |
344 | 350 | ||
345 | pub fn module(self, db: &impl HirDatabase) -> Module { | 351 | 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 0f4c78df7..6d116ee75 100644 --- a/crates/ra_hir/src/code_model/src.rs +++ b/crates/ra_hir/src/code_model/src.rs | |||
@@ -10,7 +10,7 @@ use crate::{ | |||
10 | ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, | 10 | ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, |
11 | }; | 11 | }; |
12 | 12 | ||
13 | pub use hir_def::Source; | 13 | pub use hir_expand::Source; |
14 | 14 | ||
15 | pub trait HasSource { | 15 | pub trait HasSource { |
16 | type Ast; | 16 | type Ast; |
@@ -22,7 +22,7 @@ pub trait HasSource { | |||
22 | impl Module { | 22 | impl 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..eb66325f7 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs | |||
@@ -11,20 +11,19 @@ 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}, | ||
15 | traits::TraitData, | 14 | traits::TraitData, |
16 | ty::{ | 15 | ty::{ |
17 | method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate, | 16 | method_resolution::CrateImplBlocks, traits::Impl, CallableDef, FnSig, GenericPredicate, |
18 | InferenceResult, Substs, Ty, TypableDef, TypeCtor, | 17 | InferenceResult, Substs, Ty, TypableDef, TypeCtor, |
19 | }, | 18 | }, |
20 | type_alias::TypeAliasData, | 19 | type_alias::TypeAliasData, |
21 | Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Static, | 20 | Const, ConstData, Crate, DefWithBody, ExprScopes, FnData, Function, Module, Namespace, Static, |
22 | StructField, Trait, TypeAlias, | 21 | StructField, Trait, TypeAlias, |
23 | }; | 22 | }; |
24 | 23 | ||
25 | pub use hir_def::db::{ | 24 | pub use hir_def::db::{ |
26 | DefDatabase2, DefDatabase2Storage, EnumDataQuery, InternDatabase, InternDatabaseStorage, | 25 | CrateDefMapQuery, DefDatabase2, DefDatabase2Storage, EnumDataQuery, InternDatabase, |
27 | RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery, | 26 | InternDatabaseStorage, RawItemsQuery, RawItemsWithSourceMapQuery, StructDataQuery, |
28 | }; | 27 | }; |
29 | pub use hir_expand::db::{ | 28 | pub use hir_expand::db::{ |
30 | AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, | 29 | AstDatabase, AstDatabaseStorage, AstIdMapQuery, MacroArgQuery, MacroDefQuery, MacroExpandQuery, |
@@ -41,9 +40,6 @@ pub trait DefDatabase: HirDebugDatabase + DefDatabase2 { | |||
41 | #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)] | 40 | #[salsa::invoke(crate::traits::TraitItemsIndex::trait_items_index)] |
42 | fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex; | 41 | fn trait_items_index(&self, module: Module) -> crate::traits::TraitItemsIndex; |
43 | 42 | ||
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)] | 43 | #[salsa::invoke(ModuleImplBlocks::impls_in_module_with_source_map_query)] |
48 | fn impls_in_module_with_source_map( | 44 | fn impls_in_module_with_source_map( |
49 | &self, | 45 | &self, |
diff --git a/crates/ra_hir/src/diagnostics.rs b/crates/ra_hir/src/diagnostics.rs index 9acdaf8ed..1751e7be3 100644 --- a/crates/ra_hir/src/diagnostics.rs +++ b/crates/ra_hir/src/diagnostics.rs | |||
@@ -1,82 +1,13 @@ | |||
1 | //! FIXME: write short doc here | 1 | //! FIXME: write short doc here |
2 | 2 | ||
3 | use std::{any::Any, fmt}; | 3 | use std::any::Any; |
4 | |||
5 | use ra_syntax::{ast, AstNode, AstPtr, SyntaxNode, SyntaxNodePtr, TextRange}; | ||
6 | use relative_path::RelativePathBuf; | ||
7 | |||
8 | use crate::{db::HirDatabase, HirFileId, Name, Source}; | ||
9 | |||
10 | /// Diagnostic defines hir API for errors and warnings. | ||
11 | /// | ||
12 | /// It is used as a `dyn` object, which you can downcast to a concrete | ||
13 | /// diagnostic. DiagnosticSink are structured, meaning that they include rich | ||
14 | /// information which can be used by IDE to create fixes. DiagnosticSink are | ||
15 | /// expressed in terms of macro-expanded syntax tree nodes (so, it's a bad idea | ||
16 | /// to diagnostic in a salsa value). | ||
17 | /// | ||
18 | /// Internally, various subsystems of hir produce diagnostics specific to a | ||
19 | /// subsystem (typically, an `enum`), which are safe to store in salsa but do not | ||
20 | /// include source locations. Such internal diagnostic are transformed into an | ||
21 | /// instance of `Diagnostic` on demand. | ||
22 | pub trait Diagnostic: Any + Send + Sync + fmt::Debug + 'static { | ||
23 | fn message(&self) -> String; | ||
24 | fn source(&self) -> Source<SyntaxNodePtr>; | ||
25 | fn highlight_range(&self) -> TextRange { | ||
26 | self.source().ast.range() | ||
27 | } | ||
28 | fn as_any(&self) -> &(dyn Any + Send + 'static); | ||
29 | } | ||
30 | |||
31 | pub trait AstDiagnostic { | ||
32 | type AST; | ||
33 | fn ast(&self, db: &impl HirDatabase) -> Self::AST; | ||
34 | } | ||
35 | 4 | ||
36 | impl dyn Diagnostic { | 5 | use ra_syntax::{ast, AstNode, AstPtr, SyntaxNodePtr}; |
37 | pub fn syntax_node(&self, db: &impl HirDatabase) -> SyntaxNode { | ||
38 | let node = db.parse_or_expand(self.source().file_id).unwrap(); | ||
39 | self.source().ast.to_node(&node) | ||
40 | } | ||
41 | 6 | ||
42 | pub fn downcast_ref<D: Diagnostic>(&self) -> Option<&D> { | 7 | use crate::{db::AstDatabase, HirFileId, Name, Source}; |
43 | self.as_any().downcast_ref() | ||
44 | } | ||
45 | } | ||
46 | 8 | ||
47 | pub struct DiagnosticSink<'a> { | 9 | pub use hir_def::diagnostics::UnresolvedModule; |
48 | callbacks: Vec<Box<dyn FnMut(&dyn Diagnostic) -> Result<(), ()> + 'a>>, | 10 | pub use hir_expand::diagnostics::{AstDiagnostic, Diagnostic, DiagnosticSink}; |
49 | default_callback: Box<dyn FnMut(&dyn Diagnostic) + 'a>, | ||
50 | } | ||
51 | |||
52 | impl<'a> DiagnosticSink<'a> { | ||
53 | pub fn new(cb: impl FnMut(&dyn Diagnostic) + 'a) -> DiagnosticSink<'a> { | ||
54 | DiagnosticSink { callbacks: Vec::new(), default_callback: Box::new(cb) } | ||
55 | } | ||
56 | |||
57 | pub fn on<D: Diagnostic, F: FnMut(&D) + 'a>(mut self, mut cb: F) -> DiagnosticSink<'a> { | ||
58 | let cb = move |diag: &dyn Diagnostic| match diag.downcast_ref::<D>() { | ||
59 | Some(d) => { | ||
60 | cb(d); | ||
61 | Ok(()) | ||
62 | } | ||
63 | None => Err(()), | ||
64 | }; | ||
65 | self.callbacks.push(Box::new(cb)); | ||
66 | self | ||
67 | } | ||
68 | |||
69 | pub(crate) fn push(&mut self, d: impl Diagnostic) { | ||
70 | let d: &dyn Diagnostic = &d; | ||
71 | for cb in self.callbacks.iter_mut() { | ||
72 | match cb(d) { | ||
73 | Ok(()) => return, | ||
74 | Err(()) => (), | ||
75 | } | ||
76 | } | ||
77 | (self.default_callback)(d) | ||
78 | } | ||
79 | } | ||
80 | 11 | ||
81 | #[derive(Debug)] | 12 | #[derive(Debug)] |
82 | pub struct NoSuchField { | 13 | pub struct NoSuchField { |
@@ -99,25 +30,6 @@ impl Diagnostic for NoSuchField { | |||
99 | } | 30 | } |
100 | 31 | ||
101 | #[derive(Debug)] | 32 | #[derive(Debug)] |
102 | pub struct UnresolvedModule { | ||
103 | pub file: HirFileId, | ||
104 | pub decl: AstPtr<ast::Module>, | ||
105 | pub candidate: RelativePathBuf, | ||
106 | } | ||
107 | |||
108 | impl Diagnostic for UnresolvedModule { | ||
109 | fn message(&self) -> String { | ||
110 | "unresolved module".to_string() | ||
111 | } | ||
112 | fn source(&self) -> Source<SyntaxNodePtr> { | ||
113 | Source { file_id: self.file, ast: self.decl.into() } | ||
114 | } | ||
115 | fn as_any(&self) -> &(dyn Any + Send + 'static) { | ||
116 | self | ||
117 | } | ||
118 | } | ||
119 | |||
120 | #[derive(Debug)] | ||
121 | pub struct MissingFields { | 33 | pub struct MissingFields { |
122 | pub file: HirFileId, | 34 | pub file: HirFileId, |
123 | pub field_list: AstPtr<ast::RecordFieldList>, | 35 | pub field_list: AstPtr<ast::RecordFieldList>, |
@@ -139,7 +51,7 @@ impl Diagnostic for MissingFields { | |||
139 | impl AstDiagnostic for MissingFields { | 51 | impl AstDiagnostic for MissingFields { |
140 | type AST = ast::RecordFieldList; | 52 | type AST = ast::RecordFieldList; |
141 | 53 | ||
142 | fn ast(&self, db: &impl HirDatabase) -> Self::AST { | 54 | fn ast(&self, db: &impl AstDatabase) -> Self::AST { |
143 | let root = db.parse_or_expand(self.source().file_id).unwrap(); | 55 | let root = db.parse_or_expand(self.source().file_id).unwrap(); |
144 | let node = self.source().ast.to_node(&root); | 56 | let node = self.source().ast.to_node(&root); |
145 | ast::RecordFieldList::cast(node).unwrap() | 57 | ast::RecordFieldList::cast(node).unwrap() |
@@ -167,7 +79,7 @@ impl Diagnostic for MissingOkInTailExpr { | |||
167 | impl AstDiagnostic for MissingOkInTailExpr { | 79 | impl AstDiagnostic for MissingOkInTailExpr { |
168 | type AST = ast::Expr; | 80 | type AST = ast::Expr; |
169 | 81 | ||
170 | fn ast(&self, db: &impl HirDatabase) -> Self::AST { | 82 | fn ast(&self, db: &impl AstDatabase) -> Self::AST { |
171 | let root = db.parse_or_expand(self.file).unwrap(); | 83 | let root = db.parse_or_expand(self.file).unwrap(); |
172 | let node = self.source().ast.to_node(&root); | 84 | let node = self.source().ast.to_node(&root); |
173 | ast::Expr::cast(node).unwrap() | 85 | ast::Expr::cast(node).unwrap() |
diff --git a/crates/ra_hir/src/expr/validation.rs b/crates/ra_hir/src/expr/validation.rs index c685edda1..3054f1dce 100644 --- a/crates/ra_hir/src/expr/validation.rs +++ b/crates/ra_hir/src/expr/validation.rs | |||
@@ -3,12 +3,13 @@ | |||
3 | use std::sync::Arc; | 3 | use std::sync::Arc; |
4 | 4 | ||
5 | use hir_def::path::known; | 5 | use hir_def::path::known; |
6 | use hir_expand::diagnostics::DiagnosticSink; | ||
6 | use ra_syntax::ast; | 7 | use ra_syntax::ast; |
7 | use rustc_hash::FxHashSet; | 8 | use rustc_hash::FxHashSet; |
8 | 9 | ||
9 | use crate::{ | 10 | use crate::{ |
10 | db::HirDatabase, | 11 | db::HirDatabase, |
11 | diagnostics::{DiagnosticSink, MissingFields, MissingOkInTailExpr}, | 12 | diagnostics::{MissingFields, MissingOkInTailExpr}, |
12 | expr::AstPtr, | 13 | expr::AstPtr, |
13 | ty::{ApplicationTy, InferenceResult, Ty, TypeCtor}, | 14 | ty::{ApplicationTy, InferenceResult, Ty, TypeCtor}, |
14 | Adt, Function, Name, Path, | 15 | Adt, Function, Name, Path, |
diff --git a/crates/ra_hir/src/from_id.rs b/crates/ra_hir/src/from_id.rs new file mode 100644 index 000000000..089dbc908 --- /dev/null +++ b/crates/ra_hir/src/from_id.rs | |||
@@ -0,0 +1,63 @@ | |||
1 | //! Utility module for converting between hir_def ids and code_model wrappers. | ||
2 | //! | ||
3 | //! It's unclear if we need this long-term, but it's definitelly useful while we | ||
4 | //! are splitting the hir. | ||
5 | |||
6 | use hir_def::{AdtId, EnumVariantId, ModuleDefId}; | ||
7 | |||
8 | use crate::{Adt, EnumVariant, ModuleDef}; | ||
9 | |||
10 | macro_rules! from_id { | ||
11 | ($(($id:path, $ty:path)),*) => {$( | ||
12 | impl From<$id> for $ty { | ||
13 | fn from(id: $id) -> $ty { | ||
14 | $ty { id } | ||
15 | } | ||
16 | } | ||
17 | )*} | ||
18 | } | ||
19 | |||
20 | from_id![ | ||
21 | (hir_def::ModuleId, crate::Module), | ||
22 | (hir_def::StructId, crate::Struct), | ||
23 | (hir_def::UnionId, crate::Union), | ||
24 | (hir_def::EnumId, crate::Enum), | ||
25 | (hir_def::TypeAliasId, crate::TypeAlias), | ||
26 | (hir_def::TraitId, crate::Trait), | ||
27 | (hir_def::StaticId, crate::Static), | ||
28 | (hir_def::ConstId, crate::Const), | ||
29 | (hir_def::FunctionId, crate::Function), | ||
30 | (hir_expand::MacroDefId, crate::MacroDef) | ||
31 | ]; | ||
32 | |||
33 | impl From<AdtId> for Adt { | ||
34 | fn from(id: AdtId) -> Self { | ||
35 | match id { | ||
36 | AdtId::StructId(it) => Adt::Struct(it.into()), | ||
37 | AdtId::UnionId(it) => Adt::Union(it.into()), | ||
38 | AdtId::EnumId(it) => Adt::Enum(it.into()), | ||
39 | } | ||
40 | } | ||
41 | } | ||
42 | |||
43 | impl From<EnumVariantId> for EnumVariant { | ||
44 | fn from(id: EnumVariantId) -> Self { | ||
45 | EnumVariant { parent: id.parent.into(), id: id.local_id } | ||
46 | } | ||
47 | } | ||
48 | |||
49 | impl From<ModuleDefId> for ModuleDef { | ||
50 | fn from(id: ModuleDefId) -> Self { | ||
51 | match id { | ||
52 | ModuleDefId::ModuleId(it) => ModuleDef::Module(it.into()), | ||
53 | ModuleDefId::FunctionId(it) => ModuleDef::Function(it.into()), | ||
54 | ModuleDefId::AdtId(it) => ModuleDef::Adt(it.into()), | ||
55 | ModuleDefId::EnumVariantId(it) => ModuleDef::EnumVariant(it.into()), | ||
56 | ModuleDefId::ConstId(it) => ModuleDef::Const(it.into()), | ||
57 | ModuleDefId::StaticId(it) => ModuleDef::Static(it.into()), | ||
58 | ModuleDefId::TraitId(it) => ModuleDef::Trait(it.into()), | ||
59 | ModuleDefId::TypeAliasId(it) => ModuleDef::TypeAlias(it.into()), | ||
60 | ModuleDefId::BuiltinType(it) => ModuleDef::BuiltinType(it), | ||
61 | } | ||
62 | } | ||
63 | } | ||
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 40f5562b4..3ba99d92d 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs | |||
@@ -34,7 +34,6 @@ pub mod mock; | |||
34 | pub mod source_binder; | 34 | pub mod source_binder; |
35 | 35 | ||
36 | mod ids; | 36 | mod ids; |
37 | mod nameres; | ||
38 | mod adt; | 37 | mod adt; |
39 | mod traits; | 38 | mod traits; |
40 | mod type_alias; | 39 | mod type_alias; |
@@ -47,6 +46,7 @@ mod resolve; | |||
47 | pub mod diagnostics; | 46 | pub mod diagnostics; |
48 | mod util; | 47 | mod util; |
49 | 48 | ||
49 | mod from_id; | ||
50 | mod code_model; | 50 | mod code_model; |
51 | 51 | ||
52 | pub mod from_source; | 52 | pub mod from_source; |
@@ -62,7 +62,7 @@ pub use crate::{ | |||
62 | adt::VariantDef, | 62 | adt::VariantDef, |
63 | code_model::{ | 63 | code_model::{ |
64 | docs::{DocDef, Docs, Documentation}, | 64 | docs::{DocDef, Docs, Documentation}, |
65 | src::{HasBodySource, HasSource, Source}, | 65 | src::{HasBodySource, HasSource}, |
66 | Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum, | 66 | Adt, AssocItem, Const, ConstData, Container, Crate, CrateDependency, DefWithBody, Enum, |
67 | EnumVariant, FieldSource, FnData, Function, HasBody, MacroDef, Module, ModuleDef, | 67 | EnumVariant, FieldSource, FnData, Function, HasBody, MacroDef, Module, ModuleDef, |
68 | ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, | 68 | ModuleSource, Static, Struct, StructField, Trait, TypeAlias, Union, |
@@ -72,7 +72,6 @@ pub use crate::{ | |||
72 | generics::{GenericDef, GenericParam, GenericParams, HasGenericParams}, | 72 | generics::{GenericDef, GenericParam, GenericParams, HasGenericParams}, |
73 | ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, | 73 | ids::{HirFileId, MacroCallId, MacroCallLoc, MacroDefId, MacroFile}, |
74 | impl_block::ImplBlock, | 74 | impl_block::ImplBlock, |
75 | nameres::{ImportId, Namespace, PerNs}, | ||
76 | resolve::ScopeDef, | 75 | resolve::ScopeDef, |
77 | source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer}, | 76 | source_binder::{PathResolution, ScopeEntryWithSyntax, SourceAnalyzer}, |
78 | ty::{ | 77 | ty::{ |
@@ -82,7 +81,11 @@ pub use crate::{ | |||
82 | 81 | ||
83 | pub use hir_def::{ | 82 | pub use hir_def::{ |
84 | builtin_type::BuiltinType, | 83 | builtin_type::BuiltinType, |
84 | nameres::{ | ||
85 | per_ns::{Namespace, PerNs}, | ||
86 | raw::ImportId, | ||
87 | }, | ||
85 | path::{Path, PathKind}, | 88 | path::{Path, PathKind}, |
86 | type_ref::Mutability, | 89 | type_ref::Mutability, |
87 | }; | 90 | }; |
88 | pub use hir_expand::{either::Either, name::Name}; | 91 | pub use hir_expand::{either::Either, name::Name, Source}; |
diff --git a/crates/ra_hir/src/marks.rs b/crates/ra_hir/src/marks.rs index b423489a1..0d4fa5b67 100644 --- a/crates/ra_hir/src/marks.rs +++ b/crates/ra_hir/src/marks.rs | |||
@@ -1,21 +1,10 @@ | |||
1 | //! See test_utils/src/marks.rs | 1 | //! See test_utils/src/marks.rs |
2 | 2 | ||
3 | test_utils::marks!( | 3 | test_utils::marks!( |
4 | bogus_paths | ||
5 | // FIXME: restore this mark once hir is split | ||
6 | name_res_works_for_broken_modules | ||
7 | can_import_enum_variant | ||
8 | type_var_cycles_resolve_completely | 4 | type_var_cycles_resolve_completely |
9 | type_var_cycles_resolve_as_possible | 5 | type_var_cycles_resolve_as_possible |
10 | type_var_resolves_to_int_var | 6 | type_var_resolves_to_int_var |
11 | glob_enum | ||
12 | glob_across_crates | ||
13 | std_prelude | ||
14 | match_ergonomics_ref | 7 | match_ergonomics_ref |
15 | infer_while_let | 8 | infer_while_let |
16 | macro_rules_from_other_crates_are_visible_with_macro_use | ||
17 | prelude_is_macro_use | ||
18 | coerce_merge_fail_fallback | 9 | coerce_merge_fail_fallback |
19 | macro_dollar_crate_self | ||
20 | macro_dollar_crate_other | ||
21 | ); | 10 | ); |
diff --git a/crates/ra_hir/src/mock.rs b/crates/ra_hir/src/mock.rs index 35dfaf3ba..ab97a09b9 100644 --- a/crates/ra_hir/src/mock.rs +++ b/crates/ra_hir/src/mock.rs | |||
@@ -2,17 +2,17 @@ | |||
2 | 2 | ||
3 | use std::{panic, sync::Arc}; | 3 | use std::{panic, sync::Arc}; |
4 | 4 | ||
5 | use hir_expand::diagnostics::DiagnosticSink; | ||
5 | use parking_lot::Mutex; | 6 | use parking_lot::Mutex; |
6 | use ra_cfg::CfgOptions; | 7 | use ra_cfg::CfgOptions; |
7 | use ra_db::{ | 8 | use ra_db::{ |
8 | salsa, CrateGraph, CrateId, Edition, FileId, FileLoader, FileLoaderDelegate, FilePosition, | 9 | salsa, CrateGraph, CrateId, Edition, FileId, FileLoader, FileLoaderDelegate, FilePosition, |
9 | SourceDatabase, SourceDatabaseExt, SourceRoot, SourceRootId, | 10 | RelativePath, RelativePathBuf, SourceDatabase, SourceDatabaseExt, SourceRoot, SourceRootId, |
10 | }; | 11 | }; |
11 | use relative_path::{RelativePath, RelativePathBuf}; | ||
12 | use rustc_hash::FxHashMap; | 12 | use rustc_hash::FxHashMap; |
13 | use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER}; | 13 | use test_utils::{extract_offset, parse_fixture, CURSOR_MARKER}; |
14 | 14 | ||
15 | use crate::{db, debug::HirDebugHelper, diagnostics::DiagnosticSink}; | 15 | use crate::{db, debug::HirDebugHelper}; |
16 | 16 | ||
17 | pub const WORKSPACE: SourceRootId = SourceRootId(0); | 17 | pub const WORKSPACE: SourceRootId = SourceRootId(0); |
18 | 18 | ||
@@ -77,12 +77,6 @@ impl MockDatabase { | |||
77 | (db, source_root, file_id) | 77 | (db, source_root, file_id) |
78 | } | 78 | } |
79 | 79 | ||
80 | pub fn with_position(fixture: &str) -> (MockDatabase, FilePosition) { | ||
81 | let (db, position) = MockDatabase::from_fixture(fixture); | ||
82 | let position = position.expect("expected a marker ( <|> )"); | ||
83 | (db, position) | ||
84 | } | ||
85 | |||
86 | pub fn file_id_of(&self, path: &str) -> FileId { | 80 | pub fn file_id_of(&self, path: &str) -> FileId { |
87 | match self.files.get(path) { | 81 | match self.files.get(path) { |
88 | Some(it) => *it, | 82 | Some(it) => *it, |
@@ -90,25 +84,6 @@ impl MockDatabase { | |||
90 | } | 84 | } |
91 | } | 85 | } |
92 | 86 | ||
93 | pub fn set_crate_graph_from_fixture(&mut self, graph: CrateGraphFixture) { | ||
94 | let mut ids = FxHashMap::default(); | ||
95 | let mut crate_graph = CrateGraph::default(); | ||
96 | for (crate_name, (crate_root, edition, cfg_options, _)) in graph.0.iter() { | ||
97 | let crate_root = self.file_id_of(&crate_root); | ||
98 | let crate_id = crate_graph.add_crate_root(crate_root, *edition, cfg_options.clone()); | ||
99 | Arc::make_mut(&mut self.crate_names).insert(crate_id, crate_name.clone()); | ||
100 | ids.insert(crate_name, crate_id); | ||
101 | } | ||
102 | for (crate_name, (_, _, _, deps)) in graph.0.iter() { | ||
103 | let from = ids[crate_name]; | ||
104 | for dep in deps { | ||
105 | let to = ids[dep]; | ||
106 | crate_graph.add_dep(from, dep.as_str().into(), to).unwrap(); | ||
107 | } | ||
108 | } | ||
109 | self.set_crate_graph(Arc::new(crate_graph)) | ||
110 | } | ||
111 | |||
112 | pub fn diagnostics(&self) -> String { | 87 | pub fn diagnostics(&self) -> String { |
113 | let mut buf = String::new(); | 88 | let mut buf = String::new(); |
114 | let mut files: Vec<FileId> = self.files.values().copied().collect(); | 89 | let mut files: Vec<FileId> = self.files.values().copied().collect(); |
@@ -285,46 +260,3 @@ impl MockDatabase { | |||
285 | .collect() | 260 | .collect() |
286 | } | 261 | } |
287 | } | 262 | } |
288 | |||
289 | #[derive(Default)] | ||
290 | pub struct CrateGraphFixture(pub Vec<(String, (String, Edition, CfgOptions, Vec<String>))>); | ||
291 | |||
292 | #[macro_export] | ||
293 | macro_rules! crate_graph { | ||
294 | ($( | ||
295 | $crate_name:literal: ( | ||
296 | $crate_path:literal, | ||
297 | $($edition:literal,)? | ||
298 | [$($dep:literal),*] | ||
299 | $(, cfg = { | ||
300 | $($key:literal $(= $value:literal)?),* | ||
301 | $(,)? | ||
302 | })? | ||
303 | ), | ||
304 | )*) => {{ | ||
305 | let mut res = $crate::mock::CrateGraphFixture::default(); | ||
306 | $( | ||
307 | #[allow(unused_mut, unused_assignments)] | ||
308 | let mut edition = ra_db::Edition::Edition2018; | ||
309 | $(edition = ra_db::Edition::from_string($edition);)? | ||
310 | let cfg_options = { | ||
311 | #[allow(unused_mut)] | ||
312 | let mut cfg = ::ra_cfg::CfgOptions::default(); | ||
313 | $( | ||
314 | $( | ||
315 | if 0 == 0 $(+ { drop($value); 1})? { | ||
316 | cfg.insert_atom($key.into()); | ||
317 | } | ||
318 | $(cfg.insert_key_value($key.into(), $value.into());)? | ||
319 | )* | ||
320 | )? | ||
321 | cfg | ||
322 | }; | ||
323 | res.0.push(( | ||
324 | $crate_name.to_string(), | ||
325 | ($crate_path.to_string(), edition, cfg_options, vec![$($dep.to_string()),*]) | ||
326 | )); | ||
327 | )* | ||
328 | res | ||
329 | }} | ||
330 | } | ||
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs deleted file mode 100644 index 7ba031827..000000000 --- a/crates/ra_hir/src/nameres.rs +++ /dev/null | |||
@@ -1,557 +0,0 @@ | |||
1 | //! This module implements import-resolution/macro expansion algorithm. | ||
2 | //! | ||
3 | //! The result of this module is `CrateDefMap`: a data structure which contains: | ||
4 | //! | ||
5 | //! * a tree of modules for the crate | ||
6 | //! * for each module, a set of items visible in the module (directly declared | ||
7 | //! or imported) | ||
8 | //! | ||
9 | //! Note that `CrateDefMap` contains fully macro expanded code. | ||
10 | //! | ||
11 | //! Computing `CrateDefMap` can be partitioned into several logically | ||
12 | //! independent "phases". The phases are mutually recursive though, there's no | ||
13 | //! strict ordering. | ||
14 | //! | ||
15 | //! ## Collecting RawItems | ||
16 | //! | ||
17 | //! This happens in the `raw` module, which parses a single source file into a | ||
18 | //! set of top-level items. Nested imports are desugared to flat imports in | ||
19 | //! this phase. Macro calls are represented as a triple of (Path, Option<Name>, | ||
20 | //! TokenTree). | ||
21 | //! | ||
22 | //! ## Collecting Modules | ||
23 | //! | ||
24 | //! This happens in the `collector` module. In this phase, we recursively walk | ||
25 | //! tree of modules, collect raw items from submodules, populate module scopes | ||
26 | //! with defined items (so, we assign item ids in this phase) and record the set | ||
27 | //! of unresolved imports and macros. | ||
28 | //! | ||
29 | //! While we walk tree of modules, we also record macro_rules definitions and | ||
30 | //! expand calls to macro_rules defined macros. | ||
31 | //! | ||
32 | //! ## Resolving Imports | ||
33 | //! | ||
34 | //! We maintain a list of currently unresolved imports. On every iteration, we | ||
35 | //! try to resolve some imports from this list. If the import is resolved, we | ||
36 | //! record it, by adding an item to current module scope and, if necessary, by | ||
37 | //! recursively populating glob imports. | ||
38 | //! | ||
39 | //! ## Resolving Macros | ||
40 | //! | ||
41 | //! macro_rules from the same crate use a global mutable namespace. We expand | ||
42 | //! them immediately, when we collect modules. | ||
43 | //! | ||
44 | //! Macros from other crates (including proc-macros) can be used with | ||
45 | //! `foo::bar!` syntax. We handle them similarly to imports. There's a list of | ||
46 | //! unexpanded macros. On every iteration, we try to resolve each macro call | ||
47 | //! path and, upon success, we run macro expansion and "collect module" phase | ||
48 | //! on the result | ||
49 | |||
50 | mod per_ns; | ||
51 | mod collector; | ||
52 | #[cfg(test)] | ||
53 | mod tests; | ||
54 | |||
55 | use std::sync::Arc; | ||
56 | |||
57 | use hir_def::{builtin_type::BuiltinType, CrateModuleId}; | ||
58 | use once_cell::sync::Lazy; | ||
59 | use ra_arena::Arena; | ||
60 | use ra_db::{Edition, FileId}; | ||
61 | use ra_prof::profile; | ||
62 | use ra_syntax::ast; | ||
63 | use rustc_hash::{FxHashMap, FxHashSet}; | ||
64 | use test_utils::tested_by; | ||
65 | |||
66 | use crate::{ | ||
67 | db::{AstDatabase, DefDatabase}, | ||
68 | diagnostics::DiagnosticSink, | ||
69 | ids::MacroDefId, | ||
70 | nameres::diagnostics::DefDiagnostic, | ||
71 | Adt, AstId, Crate, HirFileId, MacroDef, Module, ModuleDef, Name, Path, PathKind, Trait, | ||
72 | }; | ||
73 | |||
74 | pub use self::per_ns::{Namespace, PerNs}; | ||
75 | |||
76 | pub use hir_def::nameres::raw::ImportId; | ||
77 | |||
78 | /// Contains all top-level defs from a macro-expanded crate | ||
79 | #[derive(Debug, PartialEq, Eq)] | ||
80 | pub 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 | |||
106 | impl 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)] | ||
114 | pub 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)] | ||
127 | pub 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 | |||
144 | static 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. | ||
155 | impl 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)] | ||
191 | pub 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 | |||
198 | impl 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)] | ||
205 | struct ResolvePathResult { | ||
206 | resolved_def: PerNs, | ||
207 | segment_index: Option<usize>, | ||
208 | reached_fixedpoint: ReachedFixedPoint, | ||
209 | } | ||
210 | |||
211 | impl 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)] | ||
226 | enum ResolveMode { | ||
227 | Import, | ||
228 | Other, | ||
229 | } | ||
230 | |||
231 | #[derive(Debug, Clone, Copy, PartialEq, Eq)] | ||
232 | enum ReachedFixedPoint { | ||
233 | Yes, | ||
234 | No, | ||
235 | } | ||
236 | |||
237 | impl 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 | |||
515 | mod diagnostics { | ||
516 | use ra_syntax::{ast, AstPtr}; | ||
517 | use relative_path::RelativePathBuf; | ||
518 | |||
519 | use crate::{ | ||
520 | db::{AstDatabase, DefDatabase}, | ||
521 | diagnostics::{DiagnosticSink, UnresolvedModule}, | ||
522 | nameres::CrateModuleId, | ||
523 | AstId, | ||
524 | }; | ||
525 | |||
526 | #[derive(Debug, PartialEq, Eq)] | ||
527 | pub(super) enum DefDiagnostic { | ||
528 | UnresolvedModule { | ||
529 | module: CrateModuleId, | ||
530 | declaration: AstId<ast::Module>, | ||
531 | candidate: RelativePathBuf, | ||
532 | }, | ||
533 | } | ||
534 | |||
535 | impl DefDiagnostic { | ||
536 | pub(super) fn add_to( | ||
537 | &self, | ||
538 | db: &(impl DefDatabase + AstDatabase), | ||
539 | target_module: CrateModuleId, | ||
540 | sink: &mut DiagnosticSink, | ||
541 | ) { | ||
542 | match self { | ||
543 | DefDiagnostic::UnresolvedModule { module, declaration, candidate } => { | ||
544 | if *module != target_module { | ||
545 | return; | ||
546 | } | ||
547 | let decl = declaration.to_node(db); | ||
548 | sink.push(UnresolvedModule { | ||
549 | file: declaration.file_id(), | ||
550 | decl: AstPtr::new(&decl), | ||
551 | candidate: candidate.clone(), | ||
552 | }) | ||
553 | } | ||
554 | } | ||
555 | } | ||
556 | } | ||
557 | } | ||
diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs deleted file mode 100644 index ee0a4c99f..000000000 --- a/crates/ra_hir/src/nameres/collector.rs +++ /dev/null | |||
@@ -1,837 +0,0 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | |||
3 | use hir_def::{ | ||
4 | attr::Attr, | ||
5 | nameres::{mod_resolution::ModDir, raw}, | ||
6 | }; | ||
7 | use hir_expand::name; | ||
8 | use ra_cfg::CfgOptions; | ||
9 | use ra_db::FileId; | ||
10 | use ra_syntax::{ast, SmolStr}; | ||
11 | use rustc_hash::FxHashMap; | ||
12 | use test_utils::tested_by; | ||
13 | |||
14 | use crate::{ | ||
15 | db::DefDatabase, | ||
16 | ids::{AstItemDef, LocationCtx, MacroCallId, MacroCallLoc, MacroDefId, MacroFileKind}, | ||
17 | nameres::{ | ||
18 | diagnostics::DefDiagnostic, Crate, CrateDefMap, CrateModuleId, ModuleData, ModuleDef, | ||
19 | PerNs, ReachedFixedPoint, Resolution, ResolveMode, | ||
20 | }, | ||
21 | Adt, AstId, Const, Enum, Function, HirFileId, MacroDef, Module, Name, Path, PathKind, Static, | ||
22 | Struct, Trait, TypeAlias, Union, | ||
23 | }; | ||
24 | |||
25 | pub(super) fn collect_defs(db: &impl DefDatabase, mut def_map: CrateDefMap) -> CrateDefMap { | ||
26 | // populate external prelude | ||
27 | for dep in def_map.krate.dependencies(db) { | ||
28 | log::debug!("crate dep {:?} -> {:?}", dep.name, dep.krate); | ||
29 | if let Some(module) = dep.krate.root_module(db) { | ||
30 | def_map.extern_prelude.insert(dep.name.clone(), module.into()); | ||
31 | } | ||
32 | // look for the prelude | ||
33 | if def_map.prelude.is_none() { | ||
34 | let map = db.crate_def_map(dep.krate); | ||
35 | if map.prelude.is_some() { | ||
36 | def_map.prelude = map.prelude; | ||
37 | } | ||
38 | } | ||
39 | } | ||
40 | |||
41 | let crate_graph = db.crate_graph(); | ||
42 | let cfg_options = crate_graph.cfg_options(def_map.krate().crate_id()); | ||
43 | |||
44 | let mut collector = DefCollector { | ||
45 | db, | ||
46 | def_map, | ||
47 | glob_imports: FxHashMap::default(), | ||
48 | unresolved_imports: Vec::new(), | ||
49 | unexpanded_macros: Vec::new(), | ||
50 | mod_dirs: FxHashMap::default(), | ||
51 | macro_stack_monitor: MacroStackMonitor::default(), | ||
52 | cfg_options, | ||
53 | }; | ||
54 | collector.collect(); | ||
55 | collector.finish() | ||
56 | } | ||
57 | |||
58 | #[derive(Default)] | ||
59 | struct MacroStackMonitor { | ||
60 | counts: FxHashMap<MacroDefId, u32>, | ||
61 | |||
62 | /// Mainly use for test | ||
63 | validator: Option<Box<dyn Fn(u32) -> bool>>, | ||
64 | } | ||
65 | |||
66 | impl MacroStackMonitor { | ||
67 | fn increase(&mut self, macro_def_id: MacroDefId) { | ||
68 | *self.counts.entry(macro_def_id).or_default() += 1; | ||
69 | } | ||
70 | |||
71 | fn decrease(&mut self, macro_def_id: MacroDefId) { | ||
72 | *self.counts.entry(macro_def_id).or_default() -= 1; | ||
73 | } | ||
74 | |||
75 | fn is_poison(&self, macro_def_id: MacroDefId) -> bool { | ||
76 | let cur = *self.counts.get(¯o_def_id).unwrap_or(&0); | ||
77 | |||
78 | if let Some(validator) = &self.validator { | ||
79 | validator(cur) | ||
80 | } else { | ||
81 | cur > 100 | ||
82 | } | ||
83 | } | ||
84 | } | ||
85 | |||
86 | /// Walks the tree of module recursively | ||
87 | struct DefCollector<'a, DB> { | ||
88 | db: &'a DB, | ||
89 | def_map: CrateDefMap, | ||
90 | glob_imports: FxHashMap<CrateModuleId, Vec<(CrateModuleId, raw::ImportId)>>, | ||
91 | unresolved_imports: Vec<(CrateModuleId, raw::ImportId, raw::ImportData)>, | ||
92 | unexpanded_macros: Vec<(CrateModuleId, AstId<ast::MacroCall>, Path)>, | ||
93 | mod_dirs: FxHashMap<CrateModuleId, ModDir>, | ||
94 | |||
95 | /// Some macro use `$tt:tt which mean we have to handle the macro perfectly | ||
96 | /// To prevent stack overflow, we add a deep counter here for prevent that. | ||
97 | macro_stack_monitor: MacroStackMonitor, | ||
98 | |||
99 | cfg_options: &'a CfgOptions, | ||
100 | } | ||
101 | |||
102 | impl<DB> DefCollector<'_, DB> | ||
103 | where | ||
104 | DB: DefDatabase, | ||
105 | { | ||
106 | fn collect(&mut self) { | ||
107 | let crate_graph = self.db.crate_graph(); | ||
108 | let file_id = crate_graph.crate_root(self.def_map.krate.crate_id()); | ||
109 | let raw_items = self.db.raw_items(file_id.into()); | ||
110 | let module_id = self.def_map.root; | ||
111 | self.def_map.modules[module_id].definition = Some(file_id); | ||
112 | ModCollector { | ||
113 | def_collector: &mut *self, | ||
114 | module_id, | ||
115 | file_id: file_id.into(), | ||
116 | raw_items: &raw_items, | ||
117 | mod_dir: ModDir::root(), | ||
118 | } | ||
119 | .collect(raw_items.items()); | ||
120 | |||
121 | // main name resolution fixed-point loop. | ||
122 | let mut i = 0; | ||
123 | loop { | ||
124 | self.db.check_canceled(); | ||
125 | match (self.resolve_imports(), self.resolve_macros()) { | ||
126 | (ReachedFixedPoint::Yes, ReachedFixedPoint::Yes) => break, | ||
127 | _ => i += 1, | ||
128 | } | ||
129 | if i == 1000 { | ||
130 | log::error!("name resolution is stuck"); | ||
131 | break; | ||
132 | } | ||
133 | } | ||
134 | |||
135 | let unresolved_imports = std::mem::replace(&mut self.unresolved_imports, Vec::new()); | ||
136 | // show unresolved imports in completion, etc | ||
137 | for (module_id, import, import_data) in unresolved_imports { | ||
138 | self.record_resolved_import(module_id, PerNs::none(), import, &import_data) | ||
139 | } | ||
140 | } | ||
141 | |||
142 | /// Define a macro with `macro_rules`. | ||
143 | /// | ||
144 | /// It will define the macro in legacy textual scope, and if it has `#[macro_export]`, | ||
145 | /// then it is also defined in the root module scope. | ||
146 | /// You can `use` or invoke it by `crate::macro_name` anywhere, before or after the definition. | ||
147 | /// | ||
148 | /// It is surprising that the macro will never be in the current module scope. | ||
149 | /// These code fails with "unresolved import/macro", | ||
150 | /// ```rust,compile_fail | ||
151 | /// mod m { macro_rules! foo { () => {} } } | ||
152 | /// use m::foo as bar; | ||
153 | /// ``` | ||
154 | /// | ||
155 | /// ```rust,compile_fail | ||
156 | /// macro_rules! foo { () => {} } | ||
157 | /// self::foo!(); | ||
158 | /// crate::foo!(); | ||
159 | /// ``` | ||
160 | /// | ||
161 | /// Well, this code compiles, bacause the plain path `foo` in `use` is searched | ||
162 | /// in the legacy textual scope only. | ||
163 | /// ```rust | ||
164 | /// macro_rules! foo { () => {} } | ||
165 | /// use foo as bar; | ||
166 | /// ``` | ||
167 | fn define_macro( | ||
168 | &mut self, | ||
169 | module_id: CrateModuleId, | ||
170 | name: Name, | ||
171 | macro_: MacroDef, | ||
172 | export: bool, | ||
173 | ) { | ||
174 | // Textual scoping | ||
175 | self.define_legacy_macro(module_id, name.clone(), macro_); | ||
176 | |||
177 | // Module scoping | ||
178 | // In Rust, `#[macro_export]` macros are unconditionally visible at the | ||
179 | // crate root, even if the parent modules is **not** visible. | ||
180 | if export { | ||
181 | self.update(self.def_map.root, None, &[(name, Resolution::from_macro(macro_))]); | ||
182 | } | ||
183 | } | ||
184 | |||
185 | /// Define a legacy textual scoped macro in module | ||
186 | /// | ||
187 | /// We use a map `legacy_macros` to store all legacy textual scoped macros visable per module. | ||
188 | /// It will clone all macros from parent legacy scope, whose definition is prior to | ||
189 | /// the definition of current module. | ||
190 | /// And also, `macro_use` on a module will import all legacy macros visable inside to | ||
191 | /// current legacy scope, with possible shadowing. | ||
192 | fn define_legacy_macro(&mut self, module_id: CrateModuleId, name: Name, macro_: MacroDef) { | ||
193 | // Always shadowing | ||
194 | self.def_map.modules[module_id].scope.legacy_macros.insert(name, macro_); | ||
195 | } | ||
196 | |||
197 | /// Import macros from `#[macro_use] extern crate`. | ||
198 | fn import_macros_from_extern_crate( | ||
199 | &mut self, | ||
200 | current_module_id: CrateModuleId, | ||
201 | import: &raw::ImportData, | ||
202 | ) { | ||
203 | log::debug!( | ||
204 | "importing macros from extern crate: {:?} ({:?})", | ||
205 | import, | ||
206 | self.def_map.edition, | ||
207 | ); | ||
208 | |||
209 | let res = self.def_map.resolve_name_in_extern_prelude( | ||
210 | &import | ||
211 | .path | ||
212 | .as_ident() | ||
213 | .expect("extern crate should have been desugared to one-element path"), | ||
214 | ); | ||
215 | |||
216 | if let Some(ModuleDef::Module(m)) = res.take_types() { | ||
217 | tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use); | ||
218 | self.import_all_macros_exported(current_module_id, m.krate()); | ||
219 | } | ||
220 | } | ||
221 | |||
222 | /// Import all exported macros from another crate | ||
223 | /// | ||
224 | /// 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 | ||
226 | /// 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) { | ||
228 | let def_map = self.db.crate_def_map(krate); | ||
229 | for (name, def) in def_map[def_map.root].scope.macros() { | ||
230 | // `macro_use` only bring things into legacy scope. | ||
231 | self.define_legacy_macro(current_module_id, name.clone(), def); | ||
232 | } | ||
233 | } | ||
234 | |||
235 | fn resolve_imports(&mut self) -> ReachedFixedPoint { | ||
236 | let mut imports = std::mem::replace(&mut self.unresolved_imports, Vec::new()); | ||
237 | let mut resolved = Vec::new(); | ||
238 | imports.retain(|(module_id, import, import_data)| { | ||
239 | let (def, fp) = self.resolve_import(*module_id, import_data); | ||
240 | if fp == ReachedFixedPoint::Yes { | ||
241 | resolved.push((*module_id, def, *import, import_data.clone())) | ||
242 | } | ||
243 | fp == ReachedFixedPoint::No | ||
244 | }); | ||
245 | self.unresolved_imports = imports; | ||
246 | // Resolves imports, filling-in module scopes | ||
247 | let result = | ||
248 | if resolved.is_empty() { ReachedFixedPoint::Yes } else { ReachedFixedPoint::No }; | ||
249 | for (module_id, def, import, import_data) in resolved { | ||
250 | self.record_resolved_import(module_id, def, import, &import_data) | ||
251 | } | ||
252 | result | ||
253 | } | ||
254 | |||
255 | fn resolve_import( | ||
256 | &self, | ||
257 | module_id: CrateModuleId, | ||
258 | import: &raw::ImportData, | ||
259 | ) -> (PerNs, ReachedFixedPoint) { | ||
260 | log::debug!("resolving import: {:?} ({:?})", import, self.def_map.edition); | ||
261 | if import.is_extern_crate { | ||
262 | let res = self.def_map.resolve_name_in_extern_prelude( | ||
263 | &import | ||
264 | .path | ||
265 | .as_ident() | ||
266 | .expect("extern crate should have been desugared to one-element path"), | ||
267 | ); | ||
268 | (res, ReachedFixedPoint::Yes) | ||
269 | } else { | ||
270 | let res = self.def_map.resolve_path_fp_with_macro( | ||
271 | self.db, | ||
272 | ResolveMode::Import, | ||
273 | module_id, | ||
274 | &import.path, | ||
275 | ); | ||
276 | |||
277 | (res.resolved_def, res.reached_fixedpoint) | ||
278 | } | ||
279 | } | ||
280 | |||
281 | fn record_resolved_import( | ||
282 | &mut self, | ||
283 | module_id: CrateModuleId, | ||
284 | def: PerNs, | ||
285 | import_id: raw::ImportId, | ||
286 | import: &raw::ImportData, | ||
287 | ) { | ||
288 | if import.is_glob { | ||
289 | log::debug!("glob import: {:?}", import); | ||
290 | match def.take_types() { | ||
291 | Some(ModuleDef::Module(m)) => { | ||
292 | if import.is_prelude { | ||
293 | tested_by!(std_prelude); | ||
294 | self.def_map.prelude = Some(m); | ||
295 | } else if m.krate() != self.def_map.krate { | ||
296 | tested_by!(glob_across_crates); | ||
297 | // glob import from other crate => we can just import everything once | ||
298 | let item_map = self.db.crate_def_map(m.krate()); | ||
299 | let scope = &item_map[m.id.module_id].scope; | ||
300 | |||
301 | // Module scoped macros is included | ||
302 | let items = scope | ||
303 | .items | ||
304 | .iter() | ||
305 | .map(|(name, res)| (name.clone(), res.clone())) | ||
306 | .collect::<Vec<_>>(); | ||
307 | |||
308 | self.update(module_id, Some(import_id), &items); | ||
309 | } else { | ||
310 | // glob import from same crate => we do an initial | ||
311 | // import, and then need to propagate any further | ||
312 | // additions | ||
313 | let scope = &self.def_map[m.id.module_id].scope; | ||
314 | |||
315 | // Module scoped macros is included | ||
316 | let items = scope | ||
317 | .items | ||
318 | .iter() | ||
319 | .map(|(name, res)| (name.clone(), res.clone())) | ||
320 | .collect::<Vec<_>>(); | ||
321 | |||
322 | self.update(module_id, Some(import_id), &items); | ||
323 | // record the glob import in case we add further items | ||
324 | self.glob_imports | ||
325 | .entry(m.id.module_id) | ||
326 | .or_default() | ||
327 | .push((module_id, import_id)); | ||
328 | } | ||
329 | } | ||
330 | Some(ModuleDef::Adt(Adt::Enum(e))) => { | ||
331 | tested_by!(glob_enum); | ||
332 | // glob import from enum => just import all the variants | ||
333 | let variants = e.variants(self.db); | ||
334 | let resolutions = variants | ||
335 | .into_iter() | ||
336 | .filter_map(|variant| { | ||
337 | let res = Resolution { | ||
338 | def: PerNs::both(variant.into(), variant.into()), | ||
339 | import: Some(import_id), | ||
340 | }; | ||
341 | let name = variant.name(self.db)?; | ||
342 | Some((name, res)) | ||
343 | }) | ||
344 | .collect::<Vec<_>>(); | ||
345 | self.update(module_id, Some(import_id), &resolutions); | ||
346 | } | ||
347 | Some(d) => { | ||
348 | log::debug!("glob import {:?} from non-module/enum {:?}", import, d); | ||
349 | } | ||
350 | None => { | ||
351 | log::debug!("glob import {:?} didn't resolve as type", import); | ||
352 | } | ||
353 | } | ||
354 | } else { | ||
355 | match import.path.segments.last() { | ||
356 | Some(last_segment) => { | ||
357 | let name = import.alias.clone().unwrap_or_else(|| last_segment.name.clone()); | ||
358 | log::debug!("resolved import {:?} ({:?}) to {:?}", name, import, def); | ||
359 | |||
360 | // extern crates in the crate root are special-cased to insert entries into the extern prelude: rust-lang/rust#54658 | ||
361 | if import.is_extern_crate && module_id == self.def_map.root { | ||
362 | if let Some(def) = def.take_types() { | ||
363 | self.def_map.extern_prelude.insert(name.clone(), def); | ||
364 | } | ||
365 | } | ||
366 | |||
367 | let resolution = Resolution { def, import: Some(import_id) }; | ||
368 | self.update(module_id, Some(import_id), &[(name, resolution)]); | ||
369 | } | ||
370 | None => tested_by!(bogus_paths), | ||
371 | } | ||
372 | } | ||
373 | } | ||
374 | |||
375 | fn update( | ||
376 | &mut self, | ||
377 | module_id: CrateModuleId, | ||
378 | import: Option<raw::ImportId>, | ||
379 | resolutions: &[(Name, Resolution)], | ||
380 | ) { | ||
381 | self.update_recursive(module_id, import, resolutions, 0) | ||
382 | } | ||
383 | |||
384 | fn update_recursive( | ||
385 | &mut self, | ||
386 | module_id: CrateModuleId, | ||
387 | import: Option<raw::ImportId>, | ||
388 | resolutions: &[(Name, Resolution)], | ||
389 | depth: usize, | ||
390 | ) { | ||
391 | if depth > 100 { | ||
392 | // prevent stack overflows (but this shouldn't be possible) | ||
393 | panic!("infinite recursion in glob imports!"); | ||
394 | } | ||
395 | let module_items = &mut self.def_map.modules[module_id].scope; | ||
396 | let mut changed = false; | ||
397 | for (name, res) in resolutions { | ||
398 | let existing = module_items.items.entry(name.clone()).or_default(); | ||
399 | |||
400 | if existing.def.types.is_none() && res.def.types.is_some() { | ||
401 | existing.def.types = res.def.types; | ||
402 | existing.import = import.or(res.import); | ||
403 | changed = true; | ||
404 | } | ||
405 | if existing.def.values.is_none() && res.def.values.is_some() { | ||
406 | existing.def.values = res.def.values; | ||
407 | existing.import = import.or(res.import); | ||
408 | changed = true; | ||
409 | } | ||
410 | if existing.def.macros.is_none() && res.def.macros.is_some() { | ||
411 | existing.def.macros = res.def.macros; | ||
412 | existing.import = import.or(res.import); | ||
413 | changed = true; | ||
414 | } | ||
415 | |||
416 | if existing.def.is_none() | ||
417 | && res.def.is_none() | ||
418 | && existing.import.is_none() | ||
419 | && res.import.is_some() | ||
420 | { | ||
421 | existing.import = res.import; | ||
422 | } | ||
423 | } | ||
424 | |||
425 | if !changed { | ||
426 | return; | ||
427 | } | ||
428 | let glob_imports = self | ||
429 | .glob_imports | ||
430 | .get(&module_id) | ||
431 | .into_iter() | ||
432 | .flat_map(|v| v.iter()) | ||
433 | .cloned() | ||
434 | .collect::<Vec<_>>(); | ||
435 | for (glob_importing_module, glob_import) in glob_imports { | ||
436 | // We pass the glob import so that the tracked import in those modules is that glob import | ||
437 | self.update_recursive(glob_importing_module, Some(glob_import), resolutions, depth + 1); | ||
438 | } | ||
439 | } | ||
440 | |||
441 | fn resolve_macros(&mut self) -> ReachedFixedPoint { | ||
442 | let mut macros = std::mem::replace(&mut self.unexpanded_macros, Vec::new()); | ||
443 | let mut resolved = Vec::new(); | ||
444 | let mut res = ReachedFixedPoint::Yes; | ||
445 | macros.retain(|(module_id, ast_id, path)| { | ||
446 | let resolved_res = self.def_map.resolve_path_fp_with_macro( | ||
447 | self.db, | ||
448 | ResolveMode::Other, | ||
449 | *module_id, | ||
450 | path, | ||
451 | ); | ||
452 | |||
453 | 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 }); | ||
455 | resolved.push((*module_id, call_id, def.id)); | ||
456 | res = ReachedFixedPoint::No; | ||
457 | return false; | ||
458 | } | ||
459 | |||
460 | true | ||
461 | }); | ||
462 | |||
463 | self.unexpanded_macros = macros; | ||
464 | |||
465 | for (module_id, macro_call_id, macro_def_id) in resolved { | ||
466 | self.collect_macro_expansion(module_id, macro_call_id, macro_def_id); | ||
467 | } | ||
468 | |||
469 | res | ||
470 | } | ||
471 | |||
472 | fn collect_macro_expansion( | ||
473 | &mut self, | ||
474 | module_id: CrateModuleId, | ||
475 | macro_call_id: MacroCallId, | ||
476 | macro_def_id: MacroDefId, | ||
477 | ) { | ||
478 | if self.def_map.poison_macros.contains(¯o_def_id) { | ||
479 | return; | ||
480 | } | ||
481 | |||
482 | self.macro_stack_monitor.increase(macro_def_id); | ||
483 | |||
484 | if !self.macro_stack_monitor.is_poison(macro_def_id) { | ||
485 | let file_id: HirFileId = macro_call_id.as_file(MacroFileKind::Items); | ||
486 | let raw_items = self.db.raw_items(file_id); | ||
487 | let mod_dir = self.mod_dirs[&module_id].clone(); | ||
488 | ModCollector { | ||
489 | def_collector: &mut *self, | ||
490 | file_id, | ||
491 | module_id, | ||
492 | raw_items: &raw_items, | ||
493 | mod_dir, | ||
494 | } | ||
495 | .collect(raw_items.items()); | ||
496 | } else { | ||
497 | log::error!("Too deep macro expansion: {:?}", macro_call_id); | ||
498 | self.def_map.poison_macros.insert(macro_def_id); | ||
499 | } | ||
500 | |||
501 | self.macro_stack_monitor.decrease(macro_def_id); | ||
502 | } | ||
503 | |||
504 | fn finish(self) -> CrateDefMap { | ||
505 | self.def_map | ||
506 | } | ||
507 | } | ||
508 | |||
509 | /// Walks a single module, populating defs, imports and macros | ||
510 | struct ModCollector<'a, D> { | ||
511 | def_collector: D, | ||
512 | module_id: CrateModuleId, | ||
513 | file_id: HirFileId, | ||
514 | raw_items: &'a raw::RawItems, | ||
515 | mod_dir: ModDir, | ||
516 | } | ||
517 | |||
518 | impl<DB> ModCollector<'_, &'_ mut DefCollector<'_, DB>> | ||
519 | where | ||
520 | DB: DefDatabase, | ||
521 | { | ||
522 | fn collect(&mut self, items: &[raw::RawItem]) { | ||
523 | // Note: don't assert that inserted value is fresh: it's simply not true | ||
524 | // for macros. | ||
525 | self.def_collector.mod_dirs.insert(self.module_id, self.mod_dir.clone()); | ||
526 | |||
527 | // Prelude module is always considered to be `#[macro_use]`. | ||
528 | if let Some(prelude_module) = self.def_collector.def_map.prelude { | ||
529 | if prelude_module.krate() != self.def_collector.def_map.krate { | ||
530 | tested_by!(prelude_is_macro_use); | ||
531 | self.def_collector | ||
532 | .import_all_macros_exported(self.module_id, prelude_module.krate()); | ||
533 | } | ||
534 | } | ||
535 | |||
536 | // This should be processed eagerly instead of deferred to resolving. | ||
537 | // `#[macro_use] extern crate` is hoisted to imports macros before collecting | ||
538 | // any other items. | ||
539 | for item in items { | ||
540 | if self.is_cfg_enabled(item.attrs()) { | ||
541 | if let raw::RawItemKind::Import(import_id) = item.kind { | ||
542 | let import = self.raw_items[import_id].clone(); | ||
543 | if import.is_extern_crate && import.is_macro_use { | ||
544 | self.def_collector.import_macros_from_extern_crate(self.module_id, &import); | ||
545 | } | ||
546 | } | ||
547 | } | ||
548 | } | ||
549 | |||
550 | for item in items { | ||
551 | if self.is_cfg_enabled(item.attrs()) { | ||
552 | match item.kind { | ||
553 | raw::RawItemKind::Module(m) => { | ||
554 | self.collect_module(&self.raw_items[m], item.attrs()) | ||
555 | } | ||
556 | raw::RawItemKind::Import(import_id) => self | ||
557 | .def_collector | ||
558 | .unresolved_imports | ||
559 | .push((self.module_id, import_id, self.raw_items[import_id].clone())), | ||
560 | raw::RawItemKind::Def(def) => self.define_def(&self.raw_items[def]), | ||
561 | raw::RawItemKind::Macro(mac) => self.collect_macro(&self.raw_items[mac]), | ||
562 | } | ||
563 | } | ||
564 | } | ||
565 | } | ||
566 | |||
567 | fn collect_module(&mut self, module: &raw::ModuleData, attrs: &[Attr]) { | ||
568 | let path_attr = self.path_attr(attrs); | ||
569 | let is_macro_use = self.is_macro_use(attrs); | ||
570 | match module { | ||
571 | // inline module, just recurse | ||
572 | raw::ModuleData::Definition { name, items, ast_id } => { | ||
573 | let module_id = | ||
574 | self.push_child_module(name.clone(), AstId::new(self.file_id, *ast_id), None); | ||
575 | |||
576 | ModCollector { | ||
577 | def_collector: &mut *self.def_collector, | ||
578 | module_id, | ||
579 | file_id: self.file_id, | ||
580 | raw_items: self.raw_items, | ||
581 | mod_dir: self.mod_dir.descend_into_definition(name, path_attr), | ||
582 | } | ||
583 | .collect(&*items); | ||
584 | if is_macro_use { | ||
585 | self.import_all_legacy_macros(module_id); | ||
586 | } | ||
587 | } | ||
588 | // out of line module, resolve, parse and recurse | ||
589 | raw::ModuleData::Declaration { name, ast_id } => { | ||
590 | let ast_id = AstId::new(self.file_id, *ast_id); | ||
591 | match self.mod_dir.resolve_declaration( | ||
592 | self.def_collector.db, | ||
593 | self.file_id, | ||
594 | name, | ||
595 | path_attr, | ||
596 | ) { | ||
597 | Ok((file_id, mod_dir)) => { | ||
598 | let module_id = self.push_child_module(name.clone(), ast_id, Some(file_id)); | ||
599 | let raw_items = self.def_collector.db.raw_items(file_id.into()); | ||
600 | ModCollector { | ||
601 | def_collector: &mut *self.def_collector, | ||
602 | module_id, | ||
603 | file_id: file_id.into(), | ||
604 | raw_items: &raw_items, | ||
605 | mod_dir, | ||
606 | } | ||
607 | .collect(raw_items.items()); | ||
608 | if is_macro_use { | ||
609 | self.import_all_legacy_macros(module_id); | ||
610 | } | ||
611 | } | ||
612 | Err(candidate) => self.def_collector.def_map.diagnostics.push( | ||
613 | DefDiagnostic::UnresolvedModule { | ||
614 | module: self.module_id, | ||
615 | declaration: ast_id, | ||
616 | candidate, | ||
617 | }, | ||
618 | ), | ||
619 | }; | ||
620 | } | ||
621 | } | ||
622 | } | ||
623 | |||
624 | fn push_child_module( | ||
625 | &mut self, | ||
626 | name: Name, | ||
627 | declaration: AstId<ast::Module>, | ||
628 | definition: Option<FileId>, | ||
629 | ) -> CrateModuleId { | ||
630 | let modules = &mut self.def_collector.def_map.modules; | ||
631 | let res = modules.alloc(ModuleData::default()); | ||
632 | modules[res].parent = Some(self.module_id); | ||
633 | modules[res].declaration = Some(declaration); | ||
634 | modules[res].definition = definition; | ||
635 | modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone(); | ||
636 | modules[self.module_id].children.insert(name.clone(), res); | ||
637 | let resolution = Resolution { | ||
638 | def: PerNs::types(Module::new(self.def_collector.def_map.krate, res).into()), | ||
639 | import: None, | ||
640 | }; | ||
641 | self.def_collector.update(self.module_id, None, &[(name, resolution)]); | ||
642 | res | ||
643 | } | ||
644 | |||
645 | fn define_def(&mut self, def: &raw::DefData) { | ||
646 | let module = Module::new(self.def_collector.def_map.krate, self.module_id); | ||
647 | let ctx = LocationCtx::new(self.def_collector.db, module.id, self.file_id); | ||
648 | |||
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(); | ||
655 | let def: PerNs = match def.kind { | ||
656 | raw::DefKind::Function(ast_id) => PerNs::values(def!(Function, ast_id)), | ||
657 | raw::DefKind::Struct(ast_id) => { | ||
658 | let s = def!(Struct, ast_id); | ||
659 | PerNs::both(s, s) | ||
660 | } | ||
661 | raw::DefKind::Union(ast_id) => { | ||
662 | let s = def!(Union, ast_id); | ||
663 | PerNs::both(s, s) | ||
664 | } | ||
665 | raw::DefKind::Enum(ast_id) => PerNs::types(def!(Enum, ast_id)), | ||
666 | raw::DefKind::Const(ast_id) => PerNs::values(def!(Const, ast_id)), | ||
667 | raw::DefKind::Static(ast_id) => PerNs::values(def!(Static, ast_id)), | ||
668 | raw::DefKind::Trait(ast_id) => PerNs::types(def!(Trait, ast_id)), | ||
669 | raw::DefKind::TypeAlias(ast_id) => PerNs::types(def!(TypeAlias, ast_id)), | ||
670 | }; | ||
671 | let resolution = Resolution { def, import: None }; | ||
672 | self.def_collector.update(self.module_id, None, &[(name, resolution)]) | ||
673 | } | ||
674 | |||
675 | fn collect_macro(&mut self, mac: &raw::MacroData) { | ||
676 | let ast_id = AstId::new(self.file_id, mac.ast_id); | ||
677 | |||
678 | // Case 1: macro rules, define a macro in crate-global mutable scope | ||
679 | if is_macro_rules(&mac.path) { | ||
680 | if let Some(name) = &mac.name { | ||
681 | let macro_id = | ||
682 | MacroDefId { ast_id, krate: self.def_collector.def_map.krate.crate_id }; | ||
683 | let macro_ = MacroDef { id: macro_id }; | ||
684 | self.def_collector.define_macro(self.module_id, name.clone(), macro_, mac.export); | ||
685 | } | ||
686 | return; | ||
687 | } | ||
688 | |||
689 | // Case 2: try to resolve in legacy scope and expand macro_rules, triggering | ||
690 | // recursive item collection. | ||
691 | 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) | ||
693 | }) { | ||
694 | let def = macro_def.id; | ||
695 | let macro_call_id = self.def_collector.db.intern_macro(MacroCallLoc { def, ast_id }); | ||
696 | |||
697 | self.def_collector.collect_macro_expansion(self.module_id, macro_call_id, def); | ||
698 | return; | ||
699 | } | ||
700 | |||
701 | // Case 3: resolve in module scope, expand during name resolution. | ||
702 | // We rewrite simple path `macro_name` to `self::macro_name` to force resolve in module scope only. | ||
703 | let mut path = mac.path.clone(); | ||
704 | if path.is_ident() { | ||
705 | path.kind = PathKind::Self_; | ||
706 | } | ||
707 | self.def_collector.unexpanded_macros.push((self.module_id, ast_id, path)); | ||
708 | } | ||
709 | |||
710 | fn import_all_legacy_macros(&mut self, module_id: CrateModuleId) { | ||
711 | let macros = self.def_collector.def_map[module_id].scope.legacy_macros.clone(); | ||
712 | for (name, macro_) in macros { | ||
713 | self.def_collector.define_legacy_macro(self.module_id, name.clone(), macro_); | ||
714 | } | ||
715 | } | ||
716 | |||
717 | fn is_cfg_enabled(&self, attrs: &[Attr]) -> bool { | ||
718 | attrs.iter().all(|attr| attr.is_cfg_enabled(&self.def_collector.cfg_options) != Some(false)) | ||
719 | } | ||
720 | |||
721 | fn path_attr<'a>(&self, attrs: &'a [Attr]) -> Option<&'a SmolStr> { | ||
722 | attrs.iter().find_map(|attr| attr.as_path()) | ||
723 | } | ||
724 | |||
725 | fn is_macro_use<'a>(&self, attrs: &'a [Attr]) -> bool { | ||
726 | attrs.iter().any(|attr| attr.is_simple_atom("macro_use")) | ||
727 | } | ||
728 | } | ||
729 | |||
730 | fn is_macro_rules(path: &Path) -> bool { | ||
731 | path.as_ident() == Some(&name::MACRO_RULES) | ||
732 | } | ||
733 | |||
734 | #[cfg(test)] | ||
735 | mod tests { | ||
736 | use ra_db::SourceDatabase; | ||
737 | |||
738 | use super::*; | ||
739 | use crate::{db::DefDatabase, mock::MockDatabase, Crate}; | ||
740 | use ra_arena::Arena; | ||
741 | use rustc_hash::FxHashSet; | ||
742 | |||
743 | fn do_collect_defs( | ||
744 | db: &impl DefDatabase, | ||
745 | def_map: CrateDefMap, | ||
746 | monitor: MacroStackMonitor, | ||
747 | ) -> CrateDefMap { | ||
748 | let mut collector = DefCollector { | ||
749 | db, | ||
750 | def_map, | ||
751 | glob_imports: FxHashMap::default(), | ||
752 | unresolved_imports: Vec::new(), | ||
753 | unexpanded_macros: Vec::new(), | ||
754 | mod_dirs: FxHashMap::default(), | ||
755 | macro_stack_monitor: monitor, | ||
756 | cfg_options: &CfgOptions::default(), | ||
757 | }; | ||
758 | collector.collect(); | ||
759 | collector.finish() | ||
760 | } | ||
761 | |||
762 | fn do_limited_resolve(code: &str, limit: u32, poison_limit: u32) -> CrateDefMap { | ||
763 | let (db, _source_root, _) = MockDatabase::with_single_file(&code); | ||
764 | let crate_id = db.crate_graph().iter().next().unwrap(); | ||
765 | let krate = Crate { crate_id }; | ||
766 | |||
767 | let def_map = { | ||
768 | let edition = krate.edition(&db); | ||
769 | let mut modules: Arena<CrateModuleId, ModuleData> = Arena::default(); | ||
770 | let root = modules.alloc(ModuleData::default()); | ||
771 | CrateDefMap { | ||
772 | krate, | ||
773 | edition, | ||
774 | extern_prelude: FxHashMap::default(), | ||
775 | prelude: None, | ||
776 | root, | ||
777 | modules, | ||
778 | poison_macros: FxHashSet::default(), | ||
779 | diagnostics: Vec::new(), | ||
780 | } | ||
781 | }; | ||
782 | |||
783 | let mut monitor = MacroStackMonitor::default(); | ||
784 | monitor.validator = Some(Box::new(move |count| { | ||
785 | assert!(count < limit); | ||
786 | count >= poison_limit | ||
787 | })); | ||
788 | |||
789 | do_collect_defs(&db, def_map, monitor) | ||
790 | } | ||
791 | |||
792 | #[test] | ||
793 | fn test_macro_expand_limit_width() { | ||
794 | do_limited_resolve( | ||
795 | r#" | ||
796 | macro_rules! foo { | ||
797 | ($($ty:ty)*) => { foo!($($ty)*, $($ty)*); } | ||
798 | } | ||
799 | foo!(KABOOM); | ||
800 | "#, | ||
801 | 16, | ||
802 | 1000, | ||
803 | ); | ||
804 | } | ||
805 | |||
806 | #[test] | ||
807 | fn test_macro_expand_poisoned() { | ||
808 | let def = do_limited_resolve( | ||
809 | r#" | ||
810 | macro_rules! foo { | ||
811 | ($ty:ty) => { foo!($ty); } | ||
812 | } | ||
813 | foo!(KABOOM); | ||
814 | "#, | ||
815 | 100, | ||
816 | 16, | ||
817 | ); | ||
818 | |||
819 | assert_eq!(def.poison_macros.len(), 1); | ||
820 | } | ||
821 | |||
822 | #[test] | ||
823 | fn test_macro_expand_normal() { | ||
824 | let def = do_limited_resolve( | ||
825 | r#" | ||
826 | macro_rules! foo { | ||
827 | ($ident:ident) => { struct $ident {} } | ||
828 | } | ||
829 | foo!(Bar); | ||
830 | "#, | ||
831 | 16, | ||
832 | 16, | ||
833 | ); | ||
834 | |||
835 | assert_eq!(def.poison_macros.len(), 0); | ||
836 | } | ||
837 | } | ||
diff --git a/crates/ra_hir/src/nameres/per_ns.rs b/crates/ra_hir/src/nameres/per_ns.rs deleted file mode 100644 index 0da6789de..000000000 --- a/crates/ra_hir/src/nameres/per_ns.rs +++ /dev/null | |||
@@ -1,80 +0,0 @@ | |||
1 | //! FIXME: write short doc here | ||
2 | |||
3 | use crate::{MacroDef, ModuleDef}; | ||
4 | |||
5 | #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] | ||
6 | pub enum Namespace { | ||
7 | Types, | ||
8 | Values, | ||
9 | // Note that only type inference uses this enum, and it doesn't care about macros. | ||
10 | // Macro, | ||
11 | } | ||
12 | |||
13 | #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)] | ||
14 | pub struct PerNs { | ||
15 | pub types: Option<ModuleDef>, | ||
16 | pub values: Option<ModuleDef>, | ||
17 | /// Since macros has different type, many methods simply ignore it. | ||
18 | /// We can only use special method like `get_macros` to access it. | ||
19 | pub macros: Option<MacroDef>, | ||
20 | } | ||
21 | |||
22 | impl Default for PerNs { | ||
23 | fn default() -> Self { | ||
24 | PerNs { types: None, values: None, macros: None } | ||
25 | } | ||
26 | } | ||
27 | |||
28 | impl PerNs { | ||
29 | pub fn none() -> PerNs { | ||
30 | PerNs { types: None, values: None, macros: None } | ||
31 | } | ||
32 | |||
33 | pub fn values(t: ModuleDef) -> PerNs { | ||
34 | PerNs { types: None, values: Some(t), macros: None } | ||
35 | } | ||
36 | |||
37 | pub fn types(t: ModuleDef) -> PerNs { | ||
38 | PerNs { types: Some(t), values: None, macros: None } | ||
39 | } | ||
40 | |||
41 | pub fn both(types: ModuleDef, values: ModuleDef) -> PerNs { | ||
42 | PerNs { types: Some(types), values: Some(values), macros: None } | ||
43 | } | ||
44 | |||
45 | pub fn macros(macro_: MacroDef) -> PerNs { | ||
46 | PerNs { types: None, values: None, macros: Some(macro_) } | ||
47 | } | ||
48 | |||
49 | pub fn is_none(&self) -> bool { | ||
50 | self.types.is_none() && self.values.is_none() && self.macros.is_none() | ||
51 | } | ||
52 | |||
53 | pub fn is_all(&self) -> bool { | ||
54 | self.types.is_some() && self.values.is_some() && self.macros.is_some() | ||
55 | } | ||
56 | |||
57 | pub fn take_types(self) -> Option<ModuleDef> { | ||
58 | self.types | ||
59 | } | ||
60 | |||
61 | pub fn take_values(self) -> Option<ModuleDef> { | ||
62 | self.values | ||
63 | } | ||
64 | |||
65 | pub fn get_macros(&self) -> Option<MacroDef> { | ||
66 | self.macros | ||
67 | } | ||
68 | |||
69 | pub fn only_macros(&self) -> PerNs { | ||
70 | PerNs { types: None, values: None, macros: self.macros } | ||
71 | } | ||
72 | |||
73 | pub fn or(self, other: PerNs) -> PerNs { | ||
74 | PerNs { | ||
75 | types: self.types.or(other.types), | ||
76 | values: self.values.or(other.values), | ||
77 | macros: self.macros.or(other.macros), | ||
78 | } | ||
79 | } | ||
80 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs deleted file mode 100644 index 8c6b40aaf..000000000 --- a/crates/ra_hir/src/nameres/tests.rs +++ /dev/null | |||
@@ -1,578 +0,0 @@ | |||
1 | mod macros; | ||
2 | mod globs; | ||
3 | mod incremental; | ||
4 | mod primitives; | ||
5 | mod mod_resolution; | ||
6 | |||
7 | use std::sync::Arc; | ||
8 | |||
9 | use insta::assert_snapshot; | ||
10 | use ra_db::SourceDatabase; | ||
11 | use test_utils::covers; | ||
12 | |||
13 | use crate::{ | ||
14 | mock::{CrateGraphFixture, MockDatabase}, | ||
15 | Crate, | ||
16 | }; | ||
17 | |||
18 | use super::*; | ||
19 | |||
20 | fn compute_crate_def_map(fixture: &str, graph: Option<CrateGraphFixture>) -> Arc<CrateDefMap> { | ||
21 | let mut db = MockDatabase::with_files(fixture); | ||
22 | if let Some(graph) = graph { | ||
23 | db.set_crate_graph_from_fixture(graph); | ||
24 | } | ||
25 | let crate_id = db.crate_graph().iter().next().unwrap(); | ||
26 | let krate = Crate { crate_id }; | ||
27 | db.crate_def_map(krate) | ||
28 | } | ||
29 | |||
30 | fn render_crate_def_map(map: &CrateDefMap) -> String { | ||
31 | let mut buf = String::new(); | ||
32 | go(&mut buf, map, "\ncrate", map.root); | ||
33 | return buf.trim().to_string(); | ||
34 | |||
35 | fn go(buf: &mut String, map: &CrateDefMap, path: &str, module: CrateModuleId) { | ||
36 | *buf += path; | ||
37 | *buf += "\n"; | ||
38 | |||
39 | let mut entries = map.modules[module] | ||
40 | .scope | ||
41 | .items | ||
42 | .iter() | ||
43 | .map(|(name, res)| (name, res.def)) | ||
44 | .collect::<Vec<_>>(); | ||
45 | entries.sort_by_key(|(name, _)| *name); | ||
46 | |||
47 | for (name, res) in entries { | ||
48 | *buf += &format!("{}:", name); | ||
49 | |||
50 | if res.types.is_some() { | ||
51 | *buf += " t"; | ||
52 | } | ||
53 | if res.values.is_some() { | ||
54 | *buf += " v"; | ||
55 | } | ||
56 | if res.macros.is_some() { | ||
57 | *buf += " m"; | ||
58 | } | ||
59 | if res.is_none() { | ||
60 | *buf += " _"; | ||
61 | } | ||
62 | |||
63 | *buf += "\n"; | ||
64 | } | ||
65 | |||
66 | for (name, child) in map.modules[module].children.iter() { | ||
67 | let path = path.to_string() + &format!("::{}", name); | ||
68 | go(buf, map, &path, *child); | ||
69 | } | ||
70 | } | ||
71 | } | ||
72 | |||
73 | fn def_map(fixtute: &str) -> String { | ||
74 | let dm = compute_crate_def_map(fixtute, None); | ||
75 | render_crate_def_map(&dm) | ||
76 | } | ||
77 | |||
78 | fn def_map_with_crate_graph(fixture: &str, graph: CrateGraphFixture) -> String { | ||
79 | let dm = compute_crate_def_map(fixture, Some(graph)); | ||
80 | render_crate_def_map(&dm) | ||
81 | } | ||
82 | |||
83 | #[test] | ||
84 | fn crate_def_map_smoke_test() { | ||
85 | let map = def_map( | ||
86 | " | ||
87 | //- /lib.rs | ||
88 | mod foo; | ||
89 | struct S; | ||
90 | use crate::foo::bar::E; | ||
91 | use self::E::V; | ||
92 | |||
93 | //- /foo/mod.rs | ||
94 | pub mod bar; | ||
95 | fn f() {} | ||
96 | |||
97 | //- /foo/bar.rs | ||
98 | pub struct Baz; | ||
99 | enum E { V } | ||
100 | ", | ||
101 | ); | ||
102 | assert_snapshot!(map, @r###" | ||
103 | â‹®crate | ||
104 | â‹®E: t | ||
105 | â‹®S: t v | ||
106 | â‹®V: t v | ||
107 | â‹®foo: t | ||
108 | â‹® | ||
109 | â‹®crate::foo | ||
110 | â‹®bar: t | ||
111 | â‹®f: v | ||
112 | â‹® | ||
113 | â‹®crate::foo::bar | ||
114 | â‹®Baz: t v | ||
115 | â‹®E: t | ||
116 | "###) | ||
117 | } | ||
118 | |||
119 | #[test] | ||
120 | fn bogus_paths() { | ||
121 | covers!(bogus_paths); | ||
122 | let map = def_map( | ||
123 | " | ||
124 | //- /lib.rs | ||
125 | mod foo; | ||
126 | struct S; | ||
127 | use self; | ||
128 | |||
129 | //- /foo/mod.rs | ||
130 | use super; | ||
131 | use crate; | ||
132 | |||
133 | ", | ||
134 | ); | ||
135 | assert_snapshot!(map, @r###" | ||
136 | â‹®crate | ||
137 | â‹®S: t v | ||
138 | â‹®foo: t | ||
139 | â‹® | ||
140 | â‹®crate::foo | ||
141 | "### | ||
142 | ) | ||
143 | } | ||
144 | |||
145 | #[test] | ||
146 | fn use_as() { | ||
147 | let map = def_map( | ||
148 | " | ||
149 | //- /lib.rs | ||
150 | mod foo; | ||
151 | |||
152 | use crate::foo::Baz as Foo; | ||
153 | |||
154 | //- /foo/mod.rs | ||
155 | pub struct Baz; | ||
156 | ", | ||
157 | ); | ||
158 | assert_snapshot!(map, | ||
159 | @r###" | ||
160 | â‹®crate | ||
161 | â‹®Foo: t v | ||
162 | â‹®foo: t | ||
163 | â‹® | ||
164 | â‹®crate::foo | ||
165 | â‹®Baz: t v | ||
166 | "### | ||
167 | ); | ||
168 | } | ||
169 | |||
170 | #[test] | ||
171 | fn use_trees() { | ||
172 | let map = def_map( | ||
173 | " | ||
174 | //- /lib.rs | ||
175 | mod foo; | ||
176 | |||
177 | use crate::foo::bar::{Baz, Quux}; | ||
178 | |||
179 | //- /foo/mod.rs | ||
180 | pub mod bar; | ||
181 | |||
182 | //- /foo/bar.rs | ||
183 | pub struct Baz; | ||
184 | pub enum Quux {}; | ||
185 | ", | ||
186 | ); | ||
187 | assert_snapshot!(map, @r###" | ||
188 | â‹®crate | ||
189 | â‹®Baz: t v | ||
190 | â‹®Quux: t | ||
191 | â‹®foo: t | ||
192 | â‹® | ||
193 | â‹®crate::foo | ||
194 | â‹®bar: t | ||
195 | â‹® | ||
196 | â‹®crate::foo::bar | ||
197 | â‹®Baz: t v | ||
198 | â‹®Quux: t | ||
199 | "###); | ||
200 | } | ||
201 | |||
202 | #[test] | ||
203 | fn re_exports() { | ||
204 | let map = def_map( | ||
205 | " | ||
206 | //- /lib.rs | ||
207 | mod foo; | ||
208 | |||
209 | use self::foo::Baz; | ||
210 | |||
211 | //- /foo/mod.rs | ||
212 | pub mod bar; | ||
213 | |||
214 | pub use self::bar::Baz; | ||
215 | |||
216 | //- /foo/bar.rs | ||
217 | pub struct Baz; | ||
218 | ", | ||
219 | ); | ||
220 | assert_snapshot!(map, @r###" | ||
221 | â‹®crate | ||
222 | â‹®Baz: t v | ||
223 | â‹®foo: t | ||
224 | â‹® | ||
225 | â‹®crate::foo | ||
226 | â‹®Baz: t v | ||
227 | â‹®bar: t | ||
228 | â‹® | ||
229 | â‹®crate::foo::bar | ||
230 | â‹®Baz: t v | ||
231 | "###); | ||
232 | } | ||
233 | |||
234 | #[test] | ||
235 | fn std_prelude() { | ||
236 | covers!(std_prelude); | ||
237 | let map = def_map_with_crate_graph( | ||
238 | " | ||
239 | //- /main.rs | ||
240 | use Foo::*; | ||
241 | |||
242 | //- /lib.rs | ||
243 | mod prelude; | ||
244 | #[prelude_import] | ||
245 | use prelude::*; | ||
246 | |||
247 | //- /prelude.rs | ||
248 | pub enum Foo { Bar, Baz }; | ||
249 | ", | ||
250 | crate_graph! { | ||
251 | "main": ("/main.rs", ["test_crate"]), | ||
252 | "test_crate": ("/lib.rs", []), | ||
253 | }, | ||
254 | ); | ||
255 | assert_snapshot!(map, @r###" | ||
256 | â‹®crate | ||
257 | â‹®Bar: t v | ||
258 | â‹®Baz: t v | ||
259 | "###); | ||
260 | } | ||
261 | |||
262 | #[test] | ||
263 | fn can_import_enum_variant() { | ||
264 | covers!(can_import_enum_variant); | ||
265 | let map = def_map( | ||
266 | " | ||
267 | //- /lib.rs | ||
268 | enum E { V } | ||
269 | use self::E::V; | ||
270 | ", | ||
271 | ); | ||
272 | assert_snapshot!(map, @r###" | ||
273 | â‹®crate | ||
274 | â‹®E: t | ||
275 | â‹®V: t v | ||
276 | "### | ||
277 | ); | ||
278 | } | ||
279 | |||
280 | #[test] | ||
281 | fn edition_2015_imports() { | ||
282 | let map = def_map_with_crate_graph( | ||
283 | " | ||
284 | //- /main.rs | ||
285 | mod foo; | ||
286 | mod bar; | ||
287 | |||
288 | //- /bar.rs | ||
289 | struct Bar; | ||
290 | |||
291 | //- /foo.rs | ||
292 | use bar::Bar; | ||
293 | use other_crate::FromLib; | ||
294 | |||
295 | //- /lib.rs | ||
296 | struct FromLib; | ||
297 | ", | ||
298 | crate_graph! { | ||
299 | "main": ("/main.rs", "2015", ["other_crate"]), | ||
300 | "other_crate": ("/lib.rs", "2018", []), | ||
301 | }, | ||
302 | ); | ||
303 | |||
304 | assert_snapshot!(map, @r###" | ||
305 | â‹®crate | ||
306 | â‹®bar: t | ||
307 | â‹®foo: t | ||
308 | â‹® | ||
309 | â‹®crate::bar | ||
310 | â‹®Bar: t v | ||
311 | â‹® | ||
312 | â‹®crate::foo | ||
313 | â‹®Bar: t v | ||
314 | â‹®FromLib: t v | ||
315 | "###); | ||
316 | } | ||
317 | |||
318 | #[test] | ||
319 | fn item_map_using_self() { | ||
320 | let map = def_map( | ||
321 | " | ||
322 | //- /lib.rs | ||
323 | mod foo; | ||
324 | use crate::foo::bar::Baz::{self}; | ||
325 | //- /foo/mod.rs | ||
326 | pub mod bar; | ||
327 | //- /foo/bar.rs | ||
328 | pub struct Baz; | ||
329 | ", | ||
330 | ); | ||
331 | assert_snapshot!(map, @r###" | ||
332 | â‹®crate | ||
333 | â‹®Baz: t v | ||
334 | â‹®foo: t | ||
335 | â‹® | ||
336 | â‹®crate::foo | ||
337 | â‹®bar: t | ||
338 | â‹® | ||
339 | â‹®crate::foo::bar | ||
340 | â‹®Baz: t v | ||
341 | "###); | ||
342 | } | ||
343 | |||
344 | #[test] | ||
345 | fn item_map_across_crates() { | ||
346 | let map = def_map_with_crate_graph( | ||
347 | " | ||
348 | //- /main.rs | ||
349 | use test_crate::Baz; | ||
350 | |||
351 | //- /lib.rs | ||
352 | pub struct Baz; | ||
353 | ", | ||
354 | crate_graph! { | ||
355 | "main": ("/main.rs", ["test_crate"]), | ||
356 | "test_crate": ("/lib.rs", []), | ||
357 | }, | ||
358 | ); | ||
359 | |||
360 | assert_snapshot!(map, @r###" | ||
361 | â‹®crate | ||
362 | â‹®Baz: t v | ||
363 | "###); | ||
364 | } | ||
365 | |||
366 | #[test] | ||
367 | fn extern_crate_rename() { | ||
368 | let map = def_map_with_crate_graph( | ||
369 | " | ||
370 | //- /main.rs | ||
371 | extern crate alloc as alloc_crate; | ||
372 | |||
373 | mod alloc; | ||
374 | mod sync; | ||
375 | |||
376 | //- /sync.rs | ||
377 | use alloc_crate::Arc; | ||
378 | |||
379 | //- /lib.rs | ||
380 | struct Arc; | ||
381 | ", | ||
382 | crate_graph! { | ||
383 | "main": ("/main.rs", ["alloc"]), | ||
384 | "alloc": ("/lib.rs", []), | ||
385 | }, | ||
386 | ); | ||
387 | |||
388 | assert_snapshot!(map, @r###" | ||
389 | â‹®crate | ||
390 | â‹®alloc_crate: t | ||
391 | â‹®sync: t | ||
392 | â‹® | ||
393 | â‹®crate::sync | ||
394 | â‹®Arc: t v | ||
395 | "###); | ||
396 | } | ||
397 | |||
398 | #[test] | ||
399 | fn extern_crate_rename_2015_edition() { | ||
400 | let map = def_map_with_crate_graph( | ||
401 | " | ||
402 | //- /main.rs | ||
403 | extern crate alloc as alloc_crate; | ||
404 | |||
405 | mod alloc; | ||
406 | mod sync; | ||
407 | |||
408 | //- /sync.rs | ||
409 | use alloc_crate::Arc; | ||
410 | |||
411 | //- /lib.rs | ||
412 | struct Arc; | ||
413 | ", | ||
414 | crate_graph! { | ||
415 | "main": ("/main.rs", "2015", ["alloc"]), | ||
416 | "alloc": ("/lib.rs", []), | ||
417 | }, | ||
418 | ); | ||
419 | |||
420 | assert_snapshot!(map, | ||
421 | @r###" | ||
422 | â‹®crate | ||
423 | â‹®alloc_crate: t | ||
424 | â‹®sync: t | ||
425 | â‹® | ||
426 | â‹®crate::sync | ||
427 | â‹®Arc: t v | ||
428 | "### | ||
429 | ); | ||
430 | } | ||
431 | |||
432 | #[test] | ||
433 | fn import_across_source_roots() { | ||
434 | let map = def_map_with_crate_graph( | ||
435 | " | ||
436 | //- /lib.rs | ||
437 | pub mod a { | ||
438 | pub mod b { | ||
439 | pub struct C; | ||
440 | } | ||
441 | } | ||
442 | |||
443 | //- root /main/ | ||
444 | |||
445 | //- /main/main.rs | ||
446 | use test_crate::a::b::C; | ||
447 | ", | ||
448 | crate_graph! { | ||
449 | "main": ("/main/main.rs", ["test_crate"]), | ||
450 | "test_crate": ("/lib.rs", []), | ||
451 | }, | ||
452 | ); | ||
453 | |||
454 | assert_snapshot!(map, @r###" | ||
455 | â‹®crate | ||
456 | â‹®C: t v | ||
457 | "###); | ||
458 | } | ||
459 | |||
460 | #[test] | ||
461 | fn reexport_across_crates() { | ||
462 | let map = def_map_with_crate_graph( | ||
463 | " | ||
464 | //- /main.rs | ||
465 | use test_crate::Baz; | ||
466 | |||
467 | //- /lib.rs | ||
468 | pub use foo::Baz; | ||
469 | |||
470 | mod foo; | ||
471 | |||
472 | //- /foo.rs | ||
473 | pub struct Baz; | ||
474 | ", | ||
475 | crate_graph! { | ||
476 | "main": ("/main.rs", ["test_crate"]), | ||
477 | "test_crate": ("/lib.rs", []), | ||
478 | }, | ||
479 | ); | ||
480 | |||
481 | assert_snapshot!(map, @r###" | ||
482 | â‹®crate | ||
483 | â‹®Baz: t v | ||
484 | "###); | ||
485 | } | ||
486 | |||
487 | #[test] | ||
488 | fn values_dont_shadow_extern_crates() { | ||
489 | let map = def_map_with_crate_graph( | ||
490 | " | ||
491 | //- /main.rs | ||
492 | fn foo() {} | ||
493 | use foo::Bar; | ||
494 | |||
495 | //- /foo/lib.rs | ||
496 | pub struct Bar; | ||
497 | ", | ||
498 | crate_graph! { | ||
499 | "main": ("/main.rs", ["foo"]), | ||
500 | "foo": ("/foo/lib.rs", []), | ||
501 | }, | ||
502 | ); | ||
503 | |||
504 | assert_snapshot!(map, @r###" | ||
505 | â‹®crate | ||
506 | â‹®Bar: t v | ||
507 | â‹®foo: v | ||
508 | "###); | ||
509 | } | ||
510 | |||
511 | #[test] | ||
512 | fn cfg_not_test() { | ||
513 | let map = def_map_with_crate_graph( | ||
514 | r#" | ||
515 | //- /main.rs | ||
516 | use {Foo, Bar, Baz}; | ||
517 | //- /lib.rs | ||
518 | #[prelude_import] | ||
519 | pub use self::prelude::*; | ||
520 | mod prelude { | ||
521 | #[cfg(test)] | ||
522 | pub struct Foo; | ||
523 | #[cfg(not(test))] | ||
524 | pub struct Bar; | ||
525 | #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))] | ||
526 | pub struct Baz; | ||
527 | } | ||
528 | "#, | ||
529 | crate_graph! { | ||
530 | "main": ("/main.rs", ["std"]), | ||
531 | "std": ("/lib.rs", []), | ||
532 | }, | ||
533 | ); | ||
534 | |||
535 | assert_snapshot!(map, @r###" | ||
536 | â‹®crate | ||
537 | â‹®Bar: t v | ||
538 | â‹®Baz: _ | ||
539 | â‹®Foo: _ | ||
540 | "###); | ||
541 | } | ||
542 | |||
543 | #[test] | ||
544 | fn cfg_test() { | ||
545 | let map = def_map_with_crate_graph( | ||
546 | r#" | ||
547 | //- /main.rs | ||
548 | use {Foo, Bar, Baz}; | ||
549 | //- /lib.rs | ||
550 | #[prelude_import] | ||
551 | pub use self::prelude::*; | ||
552 | mod prelude { | ||
553 | #[cfg(test)] | ||
554 | pub struct Foo; | ||
555 | #[cfg(not(test))] | ||
556 | pub struct Bar; | ||
557 | #[cfg(all(not(any()), feature = "foo", feature = "bar", opt = "42"))] | ||
558 | pub struct Baz; | ||
559 | } | ||
560 | "#, | ||
561 | crate_graph! { | ||
562 | "main": ("/main.rs", ["std"]), | ||
563 | "std": ("/lib.rs", [], cfg = { | ||
564 | "test", | ||
565 | "feature" = "foo", | ||
566 | "feature" = "bar", | ||
567 | "opt" = "42", | ||
568 | }), | ||
569 | }, | ||
570 | ); | ||
571 | |||
572 | assert_snapshot!(map, @r###" | ||
573 | â‹®crate | ||
574 | â‹®Bar: _ | ||
575 | â‹®Baz: t v | ||
576 | â‹®Foo: t v | ||
577 | "###); | ||
578 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests/globs.rs b/crates/ra_hir/src/nameres/tests/globs.rs deleted file mode 100644 index 7ac22b47b..000000000 --- a/crates/ra_hir/src/nameres/tests/globs.rs +++ /dev/null | |||
@@ -1,118 +0,0 @@ | |||
1 | use super::*; | ||
2 | |||
3 | #[test] | ||
4 | fn glob_1() { | ||
5 | let map = def_map( | ||
6 | " | ||
7 | //- /lib.rs | ||
8 | mod foo; | ||
9 | use foo::*; | ||
10 | |||
11 | //- /foo/mod.rs | ||
12 | pub mod bar; | ||
13 | pub use self::bar::Baz; | ||
14 | pub struct Foo; | ||
15 | |||
16 | //- /foo/bar.rs | ||
17 | pub struct Baz; | ||
18 | ", | ||
19 | ); | ||
20 | assert_snapshot!(map, @r###" | ||
21 | â‹®crate | ||
22 | â‹®Baz: t v | ||
23 | â‹®Foo: t v | ||
24 | â‹®bar: t | ||
25 | â‹®foo: t | ||
26 | â‹® | ||
27 | â‹®crate::foo | ||
28 | â‹®Baz: t v | ||
29 | â‹®Foo: t v | ||
30 | â‹®bar: t | ||
31 | â‹® | ||
32 | â‹®crate::foo::bar | ||
33 | â‹®Baz: t v | ||
34 | "### | ||
35 | ); | ||
36 | } | ||
37 | |||
38 | #[test] | ||
39 | fn glob_2() { | ||
40 | let map = def_map( | ||
41 | " | ||
42 | //- /lib.rs | ||
43 | mod foo; | ||
44 | use foo::*; | ||
45 | |||
46 | //- /foo/mod.rs | ||
47 | pub mod bar; | ||
48 | pub use self::bar::*; | ||
49 | pub struct Foo; | ||
50 | |||
51 | //- /foo/bar.rs | ||
52 | pub struct Baz; | ||
53 | pub use super::*; | ||
54 | ", | ||
55 | ); | ||
56 | assert_snapshot!(map, @r###" | ||
57 | â‹®crate | ||
58 | â‹®Baz: t v | ||
59 | â‹®Foo: t v | ||
60 | â‹®bar: t | ||
61 | â‹®foo: t | ||
62 | â‹® | ||
63 | â‹®crate::foo | ||
64 | â‹®Baz: t v | ||
65 | â‹®Foo: t v | ||
66 | â‹®bar: t | ||
67 | â‹® | ||
68 | â‹®crate::foo::bar | ||
69 | â‹®Baz: t v | ||
70 | â‹®Foo: t v | ||
71 | â‹®bar: t | ||
72 | "### | ||
73 | ); | ||
74 | } | ||
75 | |||
76 | #[test] | ||
77 | fn glob_across_crates() { | ||
78 | covers!(glob_across_crates); | ||
79 | let map = def_map_with_crate_graph( | ||
80 | " | ||
81 | //- /main.rs | ||
82 | use test_crate::*; | ||
83 | |||
84 | //- /lib.rs | ||
85 | pub struct Baz; | ||
86 | ", | ||
87 | crate_graph! { | ||
88 | "main": ("/main.rs", ["test_crate"]), | ||
89 | "test_crate": ("/lib.rs", []), | ||
90 | }, | ||
91 | ); | ||
92 | assert_snapshot!(map, @r###" | ||
93 | â‹®crate | ||
94 | â‹®Baz: t v | ||
95 | "### | ||
96 | ); | ||
97 | } | ||
98 | |||
99 | #[test] | ||
100 | fn glob_enum() { | ||
101 | covers!(glob_enum); | ||
102 | let map = def_map( | ||
103 | " | ||
104 | //- /lib.rs | ||
105 | enum Foo { | ||
106 | Bar, Baz | ||
107 | } | ||
108 | use self::Foo::*; | ||
109 | ", | ||
110 | ); | ||
111 | assert_snapshot!(map, @r###" | ||
112 | â‹®crate | ||
113 | â‹®Bar: t v | ||
114 | â‹®Baz: t v | ||
115 | â‹®Foo: t | ||
116 | "### | ||
117 | ); | ||
118 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests/incremental.rs b/crates/ra_hir/src/nameres/tests/incremental.rs deleted file mode 100644 index af9c39760..000000000 --- a/crates/ra_hir/src/nameres/tests/incremental.rs +++ /dev/null | |||
@@ -1,141 +0,0 @@ | |||
1 | use super::*; | ||
2 | |||
3 | use std::sync::Arc; | ||
4 | |||
5 | use ra_db::{SourceDatabase, SourceDatabaseExt}; | ||
6 | |||
7 | fn check_def_map_is_not_recomputed(initial: &str, file_change: &str) { | ||
8 | let (mut db, pos) = MockDatabase::with_position(initial); | ||
9 | let crate_id = db.crate_graph().iter().next().unwrap(); | ||
10 | let krate = Crate { crate_id }; | ||
11 | { | ||
12 | let events = db.log_executed(|| { | ||
13 | db.crate_def_map(krate); | ||
14 | }); | ||
15 | assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events) | ||
16 | } | ||
17 | db.set_file_text(pos.file_id, Arc::new(file_change.to_string())); | ||
18 | |||
19 | { | ||
20 | let events = db.log_executed(|| { | ||
21 | db.crate_def_map(krate); | ||
22 | }); | ||
23 | assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events) | ||
24 | } | ||
25 | } | ||
26 | |||
27 | #[test] | ||
28 | fn typing_inside_a_function_should_not_invalidate_def_map() { | ||
29 | check_def_map_is_not_recomputed( | ||
30 | " | ||
31 | //- /lib.rs | ||
32 | mod foo;<|> | ||
33 | |||
34 | use crate::foo::bar::Baz; | ||
35 | |||
36 | fn foo() -> i32 { | ||
37 | 1 + 1 | ||
38 | } | ||
39 | //- /foo/mod.rs | ||
40 | pub mod bar; | ||
41 | |||
42 | //- /foo/bar.rs | ||
43 | pub struct Baz; | ||
44 | ", | ||
45 | " | ||
46 | mod foo; | ||
47 | |||
48 | use crate::foo::bar::Baz; | ||
49 | |||
50 | fn foo() -> i32 { 92 } | ||
51 | ", | ||
52 | ); | ||
53 | } | ||
54 | |||
55 | #[test] | ||
56 | fn adding_inner_items_should_not_invalidate_def_map() { | ||
57 | check_def_map_is_not_recomputed( | ||
58 | " | ||
59 | //- /lib.rs | ||
60 | struct S { a: i32} | ||
61 | enum E { A } | ||
62 | trait T { | ||
63 | fn a() {} | ||
64 | } | ||
65 | mod foo;<|> | ||
66 | impl S { | ||
67 | fn a() {} | ||
68 | } | ||
69 | use crate::foo::bar::Baz; | ||
70 | //- /foo/mod.rs | ||
71 | pub mod bar; | ||
72 | |||
73 | //- /foo/bar.rs | ||
74 | pub struct Baz; | ||
75 | ", | ||
76 | " | ||
77 | struct S { a: i32, b: () } | ||
78 | enum E { A, B } | ||
79 | trait T { | ||
80 | fn a() {} | ||
81 | fn b() {} | ||
82 | } | ||
83 | mod foo;<|> | ||
84 | impl S { | ||
85 | fn a() {} | ||
86 | fn b() {} | ||
87 | } | ||
88 | use crate::foo::bar::Baz; | ||
89 | ", | ||
90 | ); | ||
91 | } | ||
92 | |||
93 | #[test] | ||
94 | fn typing_inside_a_macro_should_not_invalidate_def_map() { | ||
95 | let (mut db, pos) = MockDatabase::with_position( | ||
96 | " | ||
97 | //- /lib.rs | ||
98 | macro_rules! m { | ||
99 | ($ident:ident) => { | ||
100 | fn f() { | ||
101 | $ident + $ident; | ||
102 | }; | ||
103 | } | ||
104 | } | ||
105 | mod foo; | ||
106 | |||
107 | //- /foo/mod.rs | ||
108 | pub mod bar; | ||
109 | |||
110 | //- /foo/bar.rs | ||
111 | <|> | ||
112 | m!(X); | ||
113 | ", | ||
114 | ); | ||
115 | { | ||
116 | let events = db.log_executed(|| { | ||
117 | let src = crate::Source { | ||
118 | file_id: pos.file_id.into(), | ||
119 | ast: crate::ModuleSource::new(&db, Some(pos.file_id), None), | ||
120 | }; | ||
121 | let module = crate::Module::from_definition(&db, src).unwrap(); | ||
122 | let decls = module.declarations(&db); | ||
123 | assert_eq!(decls.len(), 18); | ||
124 | }); | ||
125 | assert!(format!("{:?}", events).contains("crate_def_map"), "{:#?}", events) | ||
126 | } | ||
127 | db.set_file_text(pos.file_id, Arc::new("m!(Y);".to_string())); | ||
128 | |||
129 | { | ||
130 | let events = db.log_executed(|| { | ||
131 | let src = crate::Source { | ||
132 | file_id: pos.file_id.into(), | ||
133 | ast: crate::ModuleSource::new(&db, Some(pos.file_id), None), | ||
134 | }; | ||
135 | let module = crate::Module::from_definition(&db, src).unwrap(); | ||
136 | let decls = module.declarations(&db); | ||
137 | assert_eq!(decls.len(), 18); | ||
138 | }); | ||
139 | assert!(!format!("{:?}", events).contains("crate_def_map"), "{:#?}", events) | ||
140 | } | ||
141 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests/macros.rs b/crates/ra_hir/src/nameres/tests/macros.rs deleted file mode 100644 index 4f52ad2c5..000000000 --- a/crates/ra_hir/src/nameres/tests/macros.rs +++ /dev/null | |||
@@ -1,635 +0,0 @@ | |||
1 | use super::*; | ||
2 | |||
3 | #[test] | ||
4 | fn macro_rules_are_globally_visible() { | ||
5 | let map = def_map( | ||
6 | " | ||
7 | //- /lib.rs | ||
8 | macro_rules! structs { | ||
9 | ($($i:ident),*) => { | ||
10 | $(struct $i { field: u32 } )* | ||
11 | } | ||
12 | } | ||
13 | structs!(Foo); | ||
14 | mod nested; | ||
15 | |||
16 | //- /nested.rs | ||
17 | structs!(Bar, Baz); | ||
18 | ", | ||
19 | ); | ||
20 | assert_snapshot!(map, @r###" | ||
21 | â‹®crate | ||
22 | â‹®Foo: t v | ||
23 | â‹®nested: t | ||
24 | â‹® | ||
25 | â‹®crate::nested | ||
26 | â‹®Bar: t v | ||
27 | â‹®Baz: t v | ||
28 | "###); | ||
29 | } | ||
30 | |||
31 | #[test] | ||
32 | fn macro_rules_can_define_modules() { | ||
33 | let map = def_map( | ||
34 | " | ||
35 | //- /lib.rs | ||
36 | macro_rules! m { | ||
37 | ($name:ident) => { mod $name; } | ||
38 | } | ||
39 | m!(n1); | ||
40 | |||
41 | mod m { | ||
42 | m!(n3) | ||
43 | } | ||
44 | |||
45 | //- /n1.rs | ||
46 | m!(n2) | ||
47 | //- /n1/n2.rs | ||
48 | struct X; | ||
49 | //- /m/n3.rs | ||
50 | struct Y; | ||
51 | ", | ||
52 | ); | ||
53 | assert_snapshot!(map, @r###" | ||
54 | crate | ||
55 | m: t | ||
56 | n1: t | ||
57 | |||
58 | crate::m | ||
59 | n3: t | ||
60 | |||
61 | crate::m::n3 | ||
62 | Y: t v | ||
63 | |||
64 | crate::n1 | ||
65 | n2: t | ||
66 | |||
67 | crate::n1::n2 | ||
68 | X: t v | ||
69 | "###); | ||
70 | } | ||
71 | |||
72 | #[test] | ||
73 | fn macro_rules_from_other_crates_are_visible() { | ||
74 | let map = def_map_with_crate_graph( | ||
75 | " | ||
76 | //- /main.rs | ||
77 | foo::structs!(Foo, Bar) | ||
78 | mod bar; | ||
79 | |||
80 | //- /bar.rs | ||
81 | use crate::*; | ||
82 | |||
83 | //- /lib.rs | ||
84 | #[macro_export] | ||
85 | macro_rules! structs { | ||
86 | ($($i:ident),*) => { | ||
87 | $(struct $i { field: u32 } )* | ||
88 | } | ||
89 | } | ||
90 | ", | ||
91 | crate_graph! { | ||
92 | "main": ("/main.rs", ["foo"]), | ||
93 | "foo": ("/lib.rs", []), | ||
94 | }, | ||
95 | ); | ||
96 | assert_snapshot!(map, @r###" | ||
97 | â‹®crate | ||
98 | â‹®Bar: t v | ||
99 | â‹®Foo: t v | ||
100 | â‹®bar: t | ||
101 | â‹® | ||
102 | â‹®crate::bar | ||
103 | â‹®Bar: t v | ||
104 | â‹®Foo: t v | ||
105 | â‹®bar: t | ||
106 | "###); | ||
107 | } | ||
108 | |||
109 | #[test] | ||
110 | fn macro_rules_export_with_local_inner_macros_are_visible() { | ||
111 | let map = def_map_with_crate_graph( | ||
112 | " | ||
113 | //- /main.rs | ||
114 | foo::structs!(Foo, Bar) | ||
115 | mod bar; | ||
116 | |||
117 | //- /bar.rs | ||
118 | use crate::*; | ||
119 | |||
120 | //- /lib.rs | ||
121 | #[macro_export(local_inner_macros)] | ||
122 | macro_rules! structs { | ||
123 | ($($i:ident),*) => { | ||
124 | $(struct $i { field: u32 } )* | ||
125 | } | ||
126 | } | ||
127 | ", | ||
128 | crate_graph! { | ||
129 | "main": ("/main.rs", ["foo"]), | ||
130 | "foo": ("/lib.rs", []), | ||
131 | }, | ||
132 | ); | ||
133 | assert_snapshot!(map, @r###" | ||
134 | â‹®crate | ||
135 | â‹®Bar: t v | ||
136 | â‹®Foo: t v | ||
137 | â‹®bar: t | ||
138 | â‹® | ||
139 | â‹®crate::bar | ||
140 | â‹®Bar: t v | ||
141 | â‹®Foo: t v | ||
142 | â‹®bar: t | ||
143 | "###); | ||
144 | } | ||
145 | |||
146 | #[test] | ||
147 | fn unexpanded_macro_should_expand_by_fixedpoint_loop() { | ||
148 | let map = def_map_with_crate_graph( | ||
149 | " | ||
150 | //- /main.rs | ||
151 | macro_rules! baz { | ||
152 | () => { | ||
153 | use foo::bar; | ||
154 | } | ||
155 | } | ||
156 | |||
157 | foo!(); | ||
158 | bar!(); | ||
159 | baz!(); | ||
160 | |||
161 | //- /lib.rs | ||
162 | #[macro_export] | ||
163 | macro_rules! foo { | ||
164 | () => { | ||
165 | struct Foo { field: u32 } | ||
166 | } | ||
167 | } | ||
168 | #[macro_export] | ||
169 | macro_rules! bar { | ||
170 | () => { | ||
171 | use foo::foo; | ||
172 | } | ||
173 | } | ||
174 | ", | ||
175 | crate_graph! { | ||
176 | "main": ("/main.rs", ["foo"]), | ||
177 | "foo": ("/lib.rs", []), | ||
178 | }, | ||
179 | ); | ||
180 | assert_snapshot!(map, @r###" | ||
181 | â‹®crate | ||
182 | â‹®Foo: t v | ||
183 | â‹®bar: m | ||
184 | â‹®foo: m | ||
185 | "###); | ||
186 | } | ||
187 | |||
188 | #[test] | ||
189 | fn 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( | ||
192 | " | ||
193 | //- /main.rs | ||
194 | structs!(Foo); | ||
195 | structs_priv!(Bar); | ||
196 | structs_not_exported!(MacroNotResolved1); | ||
197 | crate::structs!(MacroNotResolved2); | ||
198 | |||
199 | mod bar; | ||
200 | |||
201 | #[macro_use] | ||
202 | extern crate foo; | ||
203 | |||
204 | //- /bar.rs | ||
205 | structs!(Baz); | ||
206 | crate::structs!(MacroNotResolved3); | ||
207 | |||
208 | //- /lib.rs | ||
209 | #[macro_export] | ||
210 | macro_rules! structs { | ||
211 | ($i:ident) => { struct $i; } | ||
212 | } | ||
213 | |||
214 | macro_rules! structs_not_exported { | ||
215 | ($i:ident) => { struct $i; } | ||
216 | } | ||
217 | |||
218 | mod priv_mod { | ||
219 | #[macro_export] | ||
220 | macro_rules! structs_priv { | ||
221 | ($i:ident) => { struct $i; } | ||
222 | } | ||
223 | } | ||
224 | ", | ||
225 | crate_graph! { | ||
226 | "main": ("/main.rs", ["foo"]), | ||
227 | "foo": ("/lib.rs", []), | ||
228 | }, | ||
229 | ); | ||
230 | assert_snapshot!(map, @r###" | ||
231 | â‹®crate | ||
232 | â‹®Bar: t v | ||
233 | â‹®Foo: t v | ||
234 | â‹®bar: t | ||
235 | â‹®foo: t | ||
236 | â‹® | ||
237 | â‹®crate::bar | ||
238 | â‹®Baz: t v | ||
239 | "###); | ||
240 | } | ||
241 | |||
242 | #[test] | ||
243 | fn prelude_is_macro_use() { | ||
244 | covers!(prelude_is_macro_use); | ||
245 | let map = def_map_with_crate_graph( | ||
246 | " | ||
247 | //- /main.rs | ||
248 | structs!(Foo); | ||
249 | structs_priv!(Bar); | ||
250 | structs_outside!(Out); | ||
251 | crate::structs!(MacroNotResolved2); | ||
252 | |||
253 | mod bar; | ||
254 | |||
255 | //- /bar.rs | ||
256 | structs!(Baz); | ||
257 | crate::structs!(MacroNotResolved3); | ||
258 | |||
259 | //- /lib.rs | ||
260 | #[prelude_import] | ||
261 | use self::prelude::*; | ||
262 | |||
263 | mod prelude { | ||
264 | #[macro_export] | ||
265 | macro_rules! structs { | ||
266 | ($i:ident) => { struct $i; } | ||
267 | } | ||
268 | |||
269 | mod priv_mod { | ||
270 | #[macro_export] | ||
271 | macro_rules! structs_priv { | ||
272 | ($i:ident) => { struct $i; } | ||
273 | } | ||
274 | } | ||
275 | } | ||
276 | |||
277 | #[macro_export] | ||
278 | macro_rules! structs_outside { | ||
279 | ($i:ident) => { struct $i; } | ||
280 | } | ||
281 | ", | ||
282 | crate_graph! { | ||
283 | "main": ("/main.rs", ["foo"]), | ||
284 | "foo": ("/lib.rs", []), | ||
285 | }, | ||
286 | ); | ||
287 | assert_snapshot!(map, @r###" | ||
288 | â‹®crate | ||
289 | â‹®Bar: t v | ||
290 | â‹®Foo: t v | ||
291 | â‹®Out: t v | ||
292 | â‹®bar: t | ||
293 | â‹® | ||
294 | â‹®crate::bar | ||
295 | â‹®Baz: t v | ||
296 | "###); | ||
297 | } | ||
298 | |||
299 | #[test] | ||
300 | fn prelude_cycle() { | ||
301 | let map = def_map( | ||
302 | " | ||
303 | //- /lib.rs | ||
304 | #[prelude_import] | ||
305 | use self::prelude::*; | ||
306 | |||
307 | declare_mod!(); | ||
308 | |||
309 | mod prelude { | ||
310 | macro_rules! declare_mod { | ||
311 | () => (mod foo {}) | ||
312 | } | ||
313 | } | ||
314 | ", | ||
315 | ); | ||
316 | assert_snapshot!(map, @r###" | ||
317 | â‹®crate | ||
318 | â‹®prelude: t | ||
319 | â‹® | ||
320 | â‹®crate::prelude | ||
321 | "###); | ||
322 | } | ||
323 | |||
324 | #[test] | ||
325 | fn plain_macros_are_legacy_textual_scoped() { | ||
326 | let map = def_map( | ||
327 | r#" | ||
328 | //- /main.rs | ||
329 | mod m1; | ||
330 | bar!(NotFoundNotMacroUse); | ||
331 | |||
332 | mod m2 { | ||
333 | foo!(NotFoundBeforeInside2); | ||
334 | } | ||
335 | |||
336 | macro_rules! foo { | ||
337 | ($x:ident) => { struct $x; } | ||
338 | } | ||
339 | foo!(Ok); | ||
340 | |||
341 | mod m3; | ||
342 | foo!(OkShadowStop); | ||
343 | bar!(NotFoundMacroUseStop); | ||
344 | |||
345 | #[macro_use] | ||
346 | mod m5 { | ||
347 | #[macro_use] | ||
348 | mod m6 { | ||
349 | macro_rules! foo { | ||
350 | ($x:ident) => { fn $x() {} } | ||
351 | } | ||
352 | } | ||
353 | } | ||
354 | foo!(ok_double_macro_use_shadow); | ||
355 | |||
356 | baz!(NotFoundBefore); | ||
357 | #[macro_use] | ||
358 | mod m7 { | ||
359 | macro_rules! baz { | ||
360 | ($x:ident) => { struct $x; } | ||
361 | } | ||
362 | } | ||
363 | baz!(OkAfter); | ||
364 | |||
365 | //- /m1.rs | ||
366 | foo!(NotFoundBeforeInside1); | ||
367 | macro_rules! bar { | ||
368 | ($x:ident) => { struct $x; } | ||
369 | } | ||
370 | |||
371 | //- /m3/mod.rs | ||
372 | foo!(OkAfterInside); | ||
373 | macro_rules! foo { | ||
374 | ($x:ident) => { fn $x() {} } | ||
375 | } | ||
376 | foo!(ok_shadow); | ||
377 | |||
378 | #[macro_use] | ||
379 | mod m4; | ||
380 | bar!(OkMacroUse); | ||
381 | |||
382 | //- /m3/m4.rs | ||
383 | foo!(ok_shadow_deep); | ||
384 | macro_rules! bar { | ||
385 | ($x:ident) => { struct $x; } | ||
386 | } | ||
387 | "#, | ||
388 | ); | ||
389 | assert_snapshot!(map, @r###" | ||
390 | â‹®crate | ||
391 | â‹®Ok: t v | ||
392 | â‹®OkAfter: t v | ||
393 | â‹®OkShadowStop: t v | ||
394 | â‹®m1: t | ||
395 | â‹®m2: t | ||
396 | â‹®m3: t | ||
397 | â‹®m5: t | ||
398 | â‹®m7: t | ||
399 | â‹®ok_double_macro_use_shadow: v | ||
400 | â‹® | ||
401 | â‹®crate::m7 | ||
402 | â‹® | ||
403 | â‹®crate::m1 | ||
404 | â‹® | ||
405 | â‹®crate::m5 | ||
406 | â‹®m6: t | ||
407 | â‹® | ||
408 | â‹®crate::m5::m6 | ||
409 | â‹® | ||
410 | â‹®crate::m2 | ||
411 | â‹® | ||
412 | â‹®crate::m3 | ||
413 | â‹®OkAfterInside: t v | ||
414 | â‹®OkMacroUse: t v | ||
415 | â‹®m4: t | ||
416 | â‹®ok_shadow: v | ||
417 | â‹® | ||
418 | â‹®crate::m3::m4 | ||
419 | â‹®ok_shadow_deep: v | ||
420 | "###); | ||
421 | } | ||
422 | |||
423 | #[test] | ||
424 | fn type_value_macro_live_in_different_scopes() { | ||
425 | let map = def_map( | ||
426 | " | ||
427 | //- /main.rs | ||
428 | #[macro_export] | ||
429 | macro_rules! foo { | ||
430 | ($x:ident) => { type $x = (); } | ||
431 | } | ||
432 | |||
433 | foo!(foo); | ||
434 | use foo as bar; | ||
435 | |||
436 | use self::foo as baz; | ||
437 | fn baz() {} | ||
438 | ", | ||
439 | ); | ||
440 | assert_snapshot!(map, @r###" | ||
441 | â‹®crate | ||
442 | â‹®bar: t m | ||
443 | â‹®baz: t v m | ||
444 | â‹®foo: t m | ||
445 | "###); | ||
446 | } | ||
447 | |||
448 | #[test] | ||
449 | fn macro_use_can_be_aliased() { | ||
450 | let map = def_map_with_crate_graph( | ||
451 | " | ||
452 | //- /main.rs | ||
453 | #[macro_use] | ||
454 | extern crate foo; | ||
455 | |||
456 | foo!(Direct); | ||
457 | bar!(Alias); | ||
458 | |||
459 | //- /lib.rs | ||
460 | use crate::foo as bar; | ||
461 | |||
462 | mod m { | ||
463 | #[macro_export] | ||
464 | macro_rules! foo { | ||
465 | ($x:ident) => { struct $x; } | ||
466 | } | ||
467 | } | ||
468 | ", | ||
469 | crate_graph! { | ||
470 | "main": ("/main.rs", ["foo"]), | ||
471 | "foo": ("/lib.rs", []), | ||
472 | }, | ||
473 | ); | ||
474 | assert_snapshot!(map, @r###" | ||
475 | â‹®crate | ||
476 | â‹®Alias: t v | ||
477 | â‹®Direct: t v | ||
478 | â‹®foo: t | ||
479 | "###); | ||
480 | } | ||
481 | |||
482 | #[test] | ||
483 | fn path_qualified_macros() { | ||
484 | let map = def_map( | ||
485 | " | ||
486 | //- /main.rs | ||
487 | macro_rules! foo { | ||
488 | ($x:ident) => { struct $x; } | ||
489 | } | ||
490 | |||
491 | crate::foo!(NotResolved); | ||
492 | |||
493 | crate::bar!(OkCrate); | ||
494 | bar!(OkPlain); | ||
495 | alias1!(NotHere); | ||
496 | m::alias1!(OkAliasPlain); | ||
497 | m::alias2!(OkAliasSuper); | ||
498 | m::alias3!(OkAliasCrate); | ||
499 | not_found!(NotFound); | ||
500 | |||
501 | mod m { | ||
502 | #[macro_export] | ||
503 | macro_rules! bar { | ||
504 | ($x:ident) => { struct $x; } | ||
505 | } | ||
506 | |||
507 | pub use bar as alias1; | ||
508 | pub use super::bar as alias2; | ||
509 | pub use crate::bar as alias3; | ||
510 | pub use self::bar as not_found; | ||
511 | } | ||
512 | ", | ||
513 | ); | ||
514 | assert_snapshot!(map, @r###" | ||
515 | â‹®crate | ||
516 | â‹®OkAliasCrate: t v | ||
517 | â‹®OkAliasPlain: t v | ||
518 | â‹®OkAliasSuper: t v | ||
519 | â‹®OkCrate: t v | ||
520 | â‹®OkPlain: t v | ||
521 | â‹®bar: m | ||
522 | â‹®m: t | ||
523 | â‹® | ||
524 | â‹®crate::m | ||
525 | â‹®alias1: m | ||
526 | â‹®alias2: m | ||
527 | â‹®alias3: m | ||
528 | â‹®not_found: _ | ||
529 | "###); | ||
530 | } | ||
531 | |||
532 | #[test] | ||
533 | fn macro_dollar_crate_is_correct_in_item() { | ||
534 | covers!(macro_dollar_crate_self); | ||
535 | covers!(macro_dollar_crate_other); | ||
536 | let map = def_map_with_crate_graph( | ||
537 | " | ||
538 | //- /main.rs | ||
539 | #[macro_use] | ||
540 | extern crate foo; | ||
541 | |||
542 | #[macro_use] | ||
543 | mod m { | ||
544 | macro_rules! current { | ||
545 | () => { | ||
546 | use $crate::Foo as FooSelf; | ||
547 | } | ||
548 | } | ||
549 | } | ||
550 | |||
551 | struct Foo; | ||
552 | |||
553 | current!(); | ||
554 | not_current1!(); | ||
555 | foo::not_current2!(); | ||
556 | |||
557 | //- /lib.rs | ||
558 | mod m { | ||
559 | #[macro_export] | ||
560 | macro_rules! not_current1 { | ||
561 | () => { | ||
562 | use $crate::Bar; | ||
563 | } | ||
564 | } | ||
565 | } | ||
566 | |||
567 | #[macro_export] | ||
568 | macro_rules! not_current2 { | ||
569 | () => { | ||
570 | use $crate::Baz; | ||
571 | } | ||
572 | } | ||
573 | |||
574 | struct Bar; | ||
575 | struct Baz; | ||
576 | ", | ||
577 | crate_graph! { | ||
578 | "main": ("/main.rs", ["foo"]), | ||
579 | "foo": ("/lib.rs", []), | ||
580 | }, | ||
581 | ); | ||
582 | assert_snapshot!(map, @r###" | ||
583 | â‹®crate | ||
584 | â‹®Bar: t v | ||
585 | â‹®Baz: t v | ||
586 | â‹®Foo: t v | ||
587 | â‹®FooSelf: t v | ||
588 | â‹®foo: t | ||
589 | â‹®m: t | ||
590 | â‹® | ||
591 | â‹®crate::m | ||
592 | "###); | ||
593 | } | ||
594 | |||
595 | #[test] | ||
596 | fn macro_dollar_crate_is_correct_in_indirect_deps() { | ||
597 | covers!(macro_dollar_crate_other); | ||
598 | // From std | ||
599 | let map = def_map_with_crate_graph( | ||
600 | r#" | ||
601 | //- /main.rs | ||
602 | foo!(); | ||
603 | |||
604 | //- /std.rs | ||
605 | #[prelude_import] | ||
606 | use self::prelude::*; | ||
607 | |||
608 | pub use core::foo; | ||
609 | |||
610 | mod prelude {} | ||
611 | |||
612 | #[macro_use] | ||
613 | mod std_macros; | ||
614 | |||
615 | //- /core.rs | ||
616 | #[macro_export] | ||
617 | macro_rules! foo { | ||
618 | () => { | ||
619 | use $crate::bar; | ||
620 | } | ||
621 | } | ||
622 | |||
623 | pub struct bar; | ||
624 | "#, | ||
625 | crate_graph! { | ||
626 | "main": ("/main.rs", ["std"]), | ||
627 | "std": ("/std.rs", ["core"]), | ||
628 | "core": ("/core.rs", []), | ||
629 | }, | ||
630 | ); | ||
631 | assert_snapshot!(map, @r###" | ||
632 | â‹®crate | ||
633 | â‹®bar: t v | ||
634 | "###); | ||
635 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests/mod_resolution.rs b/crates/ra_hir/src/nameres/tests/mod_resolution.rs deleted file mode 100644 index abfe8b1c3..000000000 --- a/crates/ra_hir/src/nameres/tests/mod_resolution.rs +++ /dev/null | |||
@@ -1,759 +0,0 @@ | |||
1 | use super::*; | ||
2 | |||
3 | #[test] | ||
4 | fn name_res_works_for_broken_modules() { | ||
5 | // covers!(name_res_works_for_broken_modules); | ||
6 | let map = def_map( | ||
7 | " | ||
8 | //- /lib.rs | ||
9 | mod foo // no `;`, no body | ||
10 | |||
11 | use self::foo::Baz; | ||
12 | |||
13 | //- /foo/mod.rs | ||
14 | pub mod bar; | ||
15 | |||
16 | pub use self::bar::Baz; | ||
17 | |||
18 | //- /foo/bar.rs | ||
19 | pub struct Baz; | ||
20 | ", | ||
21 | ); | ||
22 | assert_snapshot!(map, @r###" | ||
23 | â‹®crate | ||
24 | â‹®Baz: _ | ||
25 | "###); | ||
26 | } | ||
27 | |||
28 | #[test] | ||
29 | fn nested_module_resolution() { | ||
30 | let map = def_map( | ||
31 | " | ||
32 | //- /lib.rs | ||
33 | mod n1; | ||
34 | |||
35 | //- /n1.rs | ||
36 | mod n2; | ||
37 | |||
38 | //- /n1/n2.rs | ||
39 | struct X; | ||
40 | ", | ||
41 | ); | ||
42 | |||
43 | assert_snapshot!(map, @r###" | ||
44 | â‹®crate | ||
45 | â‹®n1: t | ||
46 | â‹® | ||
47 | â‹®crate::n1 | ||
48 | â‹®n2: t | ||
49 | â‹® | ||
50 | â‹®crate::n1::n2 | ||
51 | â‹®X: t v | ||
52 | "###); | ||
53 | } | ||
54 | |||
55 | #[test] | ||
56 | fn module_resolution_works_for_non_standard_filenames() { | ||
57 | let map = def_map_with_crate_graph( | ||
58 | " | ||
59 | //- /my_library.rs | ||
60 | mod foo; | ||
61 | use self::foo::Bar; | ||
62 | |||
63 | //- /foo/mod.rs | ||
64 | pub struct Bar; | ||
65 | ", | ||
66 | crate_graph! { | ||
67 | "my_library": ("/my_library.rs", []), | ||
68 | }, | ||
69 | ); | ||
70 | |||
71 | assert_snapshot!(map, @r###" | ||
72 | â‹®crate | ||
73 | â‹®Bar: t v | ||
74 | â‹®foo: t | ||
75 | â‹® | ||
76 | â‹®crate::foo | ||
77 | â‹®Bar: t v | ||
78 | "###); | ||
79 | } | ||
80 | |||
81 | #[test] | ||
82 | fn module_resolution_works_for_raw_modules() { | ||
83 | let map = def_map( | ||
84 | " | ||
85 | //- /lib.rs | ||
86 | mod r#async; | ||
87 | use self::r#async::Bar; | ||
88 | |||
89 | //- /async.rs | ||
90 | pub struct Bar; | ||
91 | ", | ||
92 | ); | ||
93 | |||
94 | assert_snapshot!(map, @r###" | ||
95 | â‹®crate | ||
96 | â‹®Bar: t v | ||
97 | â‹®async: t | ||
98 | â‹® | ||
99 | â‹®crate::async | ||
100 | â‹®Bar: t v | ||
101 | "###); | ||
102 | } | ||
103 | |||
104 | #[test] | ||
105 | fn module_resolution_decl_path() { | ||
106 | let map = def_map( | ||
107 | r###" | ||
108 | //- /lib.rs | ||
109 | #[path = "bar/baz/foo.rs"] | ||
110 | mod foo; | ||
111 | use self::foo::Bar; | ||
112 | |||
113 | //- /bar/baz/foo.rs | ||
114 | pub struct Bar; | ||
115 | "###, | ||
116 | ); | ||
117 | |||
118 | assert_snapshot!(map, @r###" | ||
119 | â‹®crate | ||
120 | â‹®Bar: t v | ||
121 | â‹®foo: t | ||
122 | â‹® | ||
123 | â‹®crate::foo | ||
124 | â‹®Bar: t v | ||
125 | "###); | ||
126 | } | ||
127 | |||
128 | #[test] | ||
129 | fn module_resolution_module_with_path_in_mod_rs() { | ||
130 | let map = def_map( | ||
131 | r###" | ||
132 | //- /main.rs | ||
133 | mod foo; | ||
134 | |||
135 | //- /foo/mod.rs | ||
136 | #[path = "baz.rs"] | ||
137 | pub mod bar; | ||
138 | |||
139 | use self::bar::Baz; | ||
140 | |||
141 | //- /foo/baz.rs | ||
142 | pub struct Baz; | ||
143 | "###, | ||
144 | ); | ||
145 | |||
146 | assert_snapshot!(map, @r###" | ||
147 | â‹®crate | ||
148 | â‹®foo: t | ||
149 | â‹® | ||
150 | â‹®crate::foo | ||
151 | â‹®Baz: t v | ||
152 | â‹®bar: t | ||
153 | â‹® | ||
154 | â‹®crate::foo::bar | ||
155 | â‹®Baz: t v | ||
156 | "###); | ||
157 | } | ||
158 | |||
159 | #[test] | ||
160 | fn module_resolution_module_with_path_non_crate_root() { | ||
161 | let map = def_map( | ||
162 | r###" | ||
163 | //- /main.rs | ||
164 | mod foo; | ||
165 | |||
166 | //- /foo.rs | ||
167 | #[path = "baz.rs"] | ||
168 | pub mod bar; | ||
169 | |||
170 | use self::bar::Baz; | ||
171 | |||
172 | //- /baz.rs | ||
173 | pub struct Baz; | ||
174 | "###, | ||
175 | ); | ||
176 | |||
177 | assert_snapshot!(map, @r###" | ||
178 | â‹®crate | ||
179 | â‹®foo: t | ||
180 | â‹® | ||
181 | â‹®crate::foo | ||
182 | â‹®Baz: t v | ||
183 | â‹®bar: t | ||
184 | â‹® | ||
185 | â‹®crate::foo::bar | ||
186 | â‹®Baz: t v | ||
187 | "###); | ||
188 | } | ||
189 | |||
190 | #[test] | ||
191 | fn module_resolution_module_decl_path_super() { | ||
192 | let map = def_map( | ||
193 | r###" | ||
194 | //- /main.rs | ||
195 | #[path = "bar/baz/module.rs"] | ||
196 | mod foo; | ||
197 | pub struct Baz; | ||
198 | |||
199 | //- /bar/baz/module.rs | ||
200 | use super::Baz; | ||
201 | "###, | ||
202 | ); | ||
203 | |||
204 | assert_snapshot!(map, @r###" | ||
205 | â‹®crate | ||
206 | â‹®Baz: t v | ||
207 | â‹®foo: t | ||
208 | â‹® | ||
209 | â‹®crate::foo | ||
210 | â‹®Baz: t v | ||
211 | "###); | ||
212 | } | ||
213 | |||
214 | #[test] | ||
215 | fn module_resolution_explicit_path_mod_rs() { | ||
216 | let map = def_map( | ||
217 | r###" | ||
218 | //- /main.rs | ||
219 | #[path = "module/mod.rs"] | ||
220 | mod foo; | ||
221 | |||
222 | //- /module/mod.rs | ||
223 | pub struct Baz; | ||
224 | "###, | ||
225 | ); | ||
226 | |||
227 | assert_snapshot!(map, @r###" | ||
228 | â‹®crate | ||
229 | â‹®foo: t | ||
230 | â‹® | ||
231 | â‹®crate::foo | ||
232 | â‹®Baz: t v | ||
233 | "###); | ||
234 | } | ||
235 | |||
236 | #[test] | ||
237 | fn module_resolution_relative_path() { | ||
238 | let map = def_map( | ||
239 | r###" | ||
240 | //- /main.rs | ||
241 | mod foo; | ||
242 | |||
243 | //- /foo.rs | ||
244 | #[path = "./sub.rs"] | ||
245 | pub mod foo_bar; | ||
246 | |||
247 | //- /sub.rs | ||
248 | pub struct Baz; | ||
249 | "###, | ||
250 | ); | ||
251 | |||
252 | assert_snapshot!(map, @r###" | ||
253 | â‹®crate | ||
254 | â‹®foo: t | ||
255 | â‹® | ||
256 | â‹®crate::foo | ||
257 | â‹®foo_bar: t | ||
258 | â‹® | ||
259 | â‹®crate::foo::foo_bar | ||
260 | â‹®Baz: t v | ||
261 | "###); | ||
262 | } | ||
263 | |||
264 | #[test] | ||
265 | fn module_resolution_relative_path_2() { | ||
266 | let map = def_map( | ||
267 | r###" | ||
268 | //- /main.rs | ||
269 | mod foo; | ||
270 | |||
271 | //- /foo/mod.rs | ||
272 | #[path="../sub.rs"] | ||
273 | pub mod foo_bar; | ||
274 | |||
275 | //- /sub.rs | ||
276 | pub struct Baz; | ||
277 | "###, | ||
278 | ); | ||
279 | |||
280 | assert_snapshot!(map, @r###" | ||
281 | â‹®crate | ||
282 | â‹®foo: t | ||
283 | â‹® | ||
284 | â‹®crate::foo | ||
285 | â‹®foo_bar: t | ||
286 | â‹® | ||
287 | â‹®crate::foo::foo_bar | ||
288 | â‹®Baz: t v | ||
289 | "###); | ||
290 | } | ||
291 | |||
292 | #[test] | ||
293 | fn module_resolution_explicit_path_mod_rs_2() { | ||
294 | let map = def_map( | ||
295 | r###" | ||
296 | //- /main.rs | ||
297 | #[path = "module/bar/mod.rs"] | ||
298 | mod foo; | ||
299 | |||
300 | //- /module/bar/mod.rs | ||
301 | pub struct Baz; | ||
302 | "###, | ||
303 | ); | ||
304 | |||
305 | assert_snapshot!(map, @r###" | ||
306 | â‹®crate | ||
307 | â‹®foo: t | ||
308 | â‹® | ||
309 | â‹®crate::foo | ||
310 | â‹®Baz: t v | ||
311 | "###); | ||
312 | } | ||
313 | |||
314 | #[test] | ||
315 | fn module_resolution_explicit_path_mod_rs_with_win_separator() { | ||
316 | let map = def_map( | ||
317 | r###" | ||
318 | //- /main.rs | ||
319 | #[path = "module\bar\mod.rs"] | ||
320 | mod foo; | ||
321 | |||
322 | //- /module/bar/mod.rs | ||
323 | pub struct Baz; | ||
324 | "###, | ||
325 | ); | ||
326 | |||
327 | assert_snapshot!(map, @r###" | ||
328 | â‹®crate | ||
329 | â‹®foo: t | ||
330 | â‹® | ||
331 | â‹®crate::foo | ||
332 | â‹®Baz: t v | ||
333 | "###); | ||
334 | } | ||
335 | |||
336 | #[test] | ||
337 | fn module_resolution_decl_inside_inline_module_with_path_attribute() { | ||
338 | let map = def_map( | ||
339 | r###" | ||
340 | //- /main.rs | ||
341 | #[path = "models"] | ||
342 | mod foo { | ||
343 | mod bar; | ||
344 | } | ||
345 | |||
346 | //- /models/bar.rs | ||
347 | pub struct Baz; | ||
348 | "###, | ||
349 | ); | ||
350 | |||
351 | assert_snapshot!(map, @r###" | ||
352 | â‹®crate | ||
353 | â‹®foo: t | ||
354 | â‹® | ||
355 | â‹®crate::foo | ||
356 | â‹®bar: t | ||
357 | â‹® | ||
358 | â‹®crate::foo::bar | ||
359 | â‹®Baz: t v | ||
360 | "###); | ||
361 | } | ||
362 | |||
363 | #[test] | ||
364 | fn module_resolution_decl_inside_inline_module() { | ||
365 | let map = def_map( | ||
366 | r###" | ||
367 | //- /main.rs | ||
368 | mod foo { | ||
369 | mod bar; | ||
370 | } | ||
371 | |||
372 | //- /foo/bar.rs | ||
373 | pub struct Baz; | ||
374 | "###, | ||
375 | ); | ||
376 | |||
377 | assert_snapshot!(map, @r###" | ||
378 | â‹®crate | ||
379 | â‹®foo: t | ||
380 | â‹® | ||
381 | â‹®crate::foo | ||
382 | â‹®bar: t | ||
383 | â‹® | ||
384 | â‹®crate::foo::bar | ||
385 | â‹®Baz: t v | ||
386 | "###); | ||
387 | } | ||
388 | |||
389 | #[test] | ||
390 | fn module_resolution_decl_inside_inline_module_2_with_path_attribute() { | ||
391 | let map = def_map( | ||
392 | r###" | ||
393 | //- /main.rs | ||
394 | #[path = "models/db"] | ||
395 | mod foo { | ||
396 | mod bar; | ||
397 | } | ||
398 | |||
399 | //- /models/db/bar.rs | ||
400 | pub struct Baz; | ||
401 | "###, | ||
402 | ); | ||
403 | |||
404 | assert_snapshot!(map, @r###" | ||
405 | â‹®crate | ||
406 | â‹®foo: t | ||
407 | â‹® | ||
408 | â‹®crate::foo | ||
409 | â‹®bar: t | ||
410 | â‹® | ||
411 | â‹®crate::foo::bar | ||
412 | â‹®Baz: t v | ||
413 | "###); | ||
414 | } | ||
415 | |||
416 | #[test] | ||
417 | fn module_resolution_decl_inside_inline_module_3() { | ||
418 | let map = def_map( | ||
419 | r###" | ||
420 | //- /main.rs | ||
421 | #[path = "models/db"] | ||
422 | mod foo { | ||
423 | #[path = "users.rs"] | ||
424 | mod bar; | ||
425 | } | ||
426 | |||
427 | //- /models/db/users.rs | ||
428 | pub struct Baz; | ||
429 | "###, | ||
430 | ); | ||
431 | |||
432 | assert_snapshot!(map, @r###" | ||
433 | â‹®crate | ||
434 | â‹®foo: t | ||
435 | â‹® | ||
436 | â‹®crate::foo | ||
437 | â‹®bar: t | ||
438 | â‹® | ||
439 | â‹®crate::foo::bar | ||
440 | â‹®Baz: t v | ||
441 | "###); | ||
442 | } | ||
443 | |||
444 | #[test] | ||
445 | fn module_resolution_decl_inside_inline_module_empty_path() { | ||
446 | let map = def_map( | ||
447 | r###" | ||
448 | //- /main.rs | ||
449 | #[path = ""] | ||
450 | mod foo { | ||
451 | #[path = "users.rs"] | ||
452 | mod bar; | ||
453 | } | ||
454 | |||
455 | //- /users.rs | ||
456 | pub struct Baz; | ||
457 | "###, | ||
458 | ); | ||
459 | |||
460 | assert_snapshot!(map, @r###" | ||
461 | â‹®crate | ||
462 | â‹®foo: t | ||
463 | â‹® | ||
464 | â‹®crate::foo | ||
465 | â‹®bar: t | ||
466 | â‹® | ||
467 | â‹®crate::foo::bar | ||
468 | â‹®Baz: t v | ||
469 | "###); | ||
470 | } | ||
471 | |||
472 | #[test] | ||
473 | fn module_resolution_decl_empty_path() { | ||
474 | let map = def_map( | ||
475 | r###" | ||
476 | //- /main.rs | ||
477 | #[path = ""] // Should try to read `/` (a directory) | ||
478 | mod foo; | ||
479 | |||
480 | //- /foo.rs | ||
481 | pub struct Baz; | ||
482 | "###, | ||
483 | ); | ||
484 | |||
485 | assert_snapshot!(map, @r###" | ||
486 | â‹®crate | ||
487 | "###); | ||
488 | } | ||
489 | |||
490 | #[test] | ||
491 | fn module_resolution_decl_inside_inline_module_relative_path() { | ||
492 | let map = def_map( | ||
493 | r###" | ||
494 | //- /main.rs | ||
495 | #[path = "./models"] | ||
496 | mod foo { | ||
497 | mod bar; | ||
498 | } | ||
499 | |||
500 | //- /models/bar.rs | ||
501 | pub struct Baz; | ||
502 | "###, | ||
503 | ); | ||
504 | |||
505 | assert_snapshot!(map, @r###" | ||
506 | â‹®crate | ||
507 | â‹®foo: t | ||
508 | â‹® | ||
509 | â‹®crate::foo | ||
510 | â‹®bar: t | ||
511 | â‹® | ||
512 | â‹®crate::foo::bar | ||
513 | â‹®Baz: t v | ||
514 | "###); | ||
515 | } | ||
516 | |||
517 | #[test] | ||
518 | fn module_resolution_decl_inside_inline_module_in_crate_root() { | ||
519 | let map = def_map( | ||
520 | r###" | ||
521 | //- /main.rs | ||
522 | mod foo { | ||
523 | #[path = "baz.rs"] | ||
524 | mod bar; | ||
525 | } | ||
526 | use self::foo::bar::Baz; | ||
527 | |||
528 | //- /foo/baz.rs | ||
529 | pub struct Baz; | ||
530 | "###, | ||
531 | ); | ||
532 | |||
533 | assert_snapshot!(map, @r###" | ||
534 | â‹®crate | ||
535 | â‹®Baz: t v | ||
536 | â‹®foo: t | ||
537 | â‹® | ||
538 | â‹®crate::foo | ||
539 | â‹®bar: t | ||
540 | â‹® | ||
541 | â‹®crate::foo::bar | ||
542 | â‹®Baz: t v | ||
543 | "###); | ||
544 | } | ||
545 | |||
546 | #[test] | ||
547 | fn module_resolution_decl_inside_inline_module_in_mod_rs() { | ||
548 | let map = def_map( | ||
549 | r###" | ||
550 | //- /main.rs | ||
551 | mod foo; | ||
552 | |||
553 | //- /foo/mod.rs | ||
554 | mod bar { | ||
555 | #[path = "qwe.rs"] | ||
556 | pub mod baz; | ||
557 | } | ||
558 | use self::bar::baz::Baz; | ||
559 | |||
560 | //- /foo/bar/qwe.rs | ||
561 | pub struct Baz; | ||
562 | "###, | ||
563 | ); | ||
564 | |||
565 | assert_snapshot!(map, @r###" | ||
566 | â‹®crate | ||
567 | â‹®foo: t | ||
568 | â‹® | ||
569 | â‹®crate::foo | ||
570 | â‹®Baz: t v | ||
571 | â‹®bar: t | ||
572 | â‹® | ||
573 | â‹®crate::foo::bar | ||
574 | â‹®baz: t | ||
575 | â‹® | ||
576 | â‹®crate::foo::bar::baz | ||
577 | â‹®Baz: t v | ||
578 | "###); | ||
579 | } | ||
580 | |||
581 | #[test] | ||
582 | fn module_resolution_decl_inside_inline_module_in_non_crate_root() { | ||
583 | let map = def_map( | ||
584 | r###" | ||
585 | //- /main.rs | ||
586 | mod foo; | ||
587 | |||
588 | //- /foo.rs | ||
589 | mod bar { | ||
590 | #[path = "qwe.rs"] | ||
591 | pub mod baz; | ||
592 | } | ||
593 | use self::bar::baz::Baz; | ||
594 | |||
595 | //- /foo/bar/qwe.rs | ||
596 | pub struct Baz; | ||
597 | "###, | ||
598 | ); | ||
599 | |||
600 | assert_snapshot!(map, @r###" | ||
601 | â‹®crate | ||
602 | â‹®foo: t | ||
603 | â‹® | ||
604 | â‹®crate::foo | ||
605 | â‹®Baz: t v | ||
606 | â‹®bar: t | ||
607 | â‹® | ||
608 | â‹®crate::foo::bar | ||
609 | â‹®baz: t | ||
610 | â‹® | ||
611 | â‹®crate::foo::bar::baz | ||
612 | â‹®Baz: t v | ||
613 | "###); | ||
614 | } | ||
615 | |||
616 | #[test] | ||
617 | fn module_resolution_decl_inside_inline_module_in_non_crate_root_2() { | ||
618 | let map = def_map( | ||
619 | r###" | ||
620 | //- /main.rs | ||
621 | mod foo; | ||
622 | |||
623 | //- /foo.rs | ||
624 | #[path = "bar"] | ||
625 | mod bar { | ||
626 | pub mod baz; | ||
627 | } | ||
628 | use self::bar::baz::Baz; | ||
629 | |||
630 | //- /bar/baz.rs | ||
631 | pub struct Baz; | ||
632 | "###, | ||
633 | ); | ||
634 | |||
635 | assert_snapshot!(map, @r###" | ||
636 | â‹®crate | ||
637 | â‹®foo: t | ||
638 | â‹® | ||
639 | â‹®crate::foo | ||
640 | â‹®Baz: t v | ||
641 | â‹®bar: t | ||
642 | â‹® | ||
643 | â‹®crate::foo::bar | ||
644 | â‹®baz: t | ||
645 | â‹® | ||
646 | â‹®crate::foo::bar::baz | ||
647 | â‹®Baz: t v | ||
648 | "###); | ||
649 | } | ||
650 | |||
651 | #[test] | ||
652 | fn unresolved_module_diagnostics() { | ||
653 | let diagnostics = MockDatabase::with_files( | ||
654 | r" | ||
655 | //- /lib.rs | ||
656 | mod foo; | ||
657 | mod bar; | ||
658 | mod baz {} | ||
659 | //- /foo.rs | ||
660 | ", | ||
661 | ) | ||
662 | .diagnostics(); | ||
663 | |||
664 | assert_snapshot!(diagnostics, @r###" | ||
665 | "mod bar;": unresolved module | ||
666 | "### | ||
667 | ); | ||
668 | } | ||
669 | |||
670 | #[test] | ||
671 | fn module_resolution_decl_inside_module_in_non_crate_root_2() { | ||
672 | let map = def_map( | ||
673 | r###" | ||
674 | //- /main.rs | ||
675 | #[path="module/m2.rs"] | ||
676 | mod module; | ||
677 | |||
678 | //- /module/m2.rs | ||
679 | pub mod submod; | ||
680 | |||
681 | //- /module/submod.rs | ||
682 | pub struct Baz; | ||
683 | "###, | ||
684 | ); | ||
685 | |||
686 | assert_snapshot!(map, @r###" | ||
687 | â‹®crate | ||
688 | â‹®module: t | ||
689 | â‹® | ||
690 | â‹®crate::module | ||
691 | â‹®submod: t | ||
692 | â‹® | ||
693 | â‹®crate::module::submod | ||
694 | â‹®Baz: t v | ||
695 | "###); | ||
696 | } | ||
697 | |||
698 | #[test] | ||
699 | fn nested_out_of_line_module() { | ||
700 | let map = def_map( | ||
701 | r###" | ||
702 | //- /lib.rs | ||
703 | mod a { | ||
704 | mod b { | ||
705 | mod c; | ||
706 | } | ||
707 | } | ||
708 | |||
709 | //- /a/b/c.rs | ||
710 | struct X; | ||
711 | "###, | ||
712 | ); | ||
713 | |||
714 | assert_snapshot!(map, @r###" | ||
715 | crate | ||
716 | a: t | ||
717 | |||
718 | crate::a | ||
719 | b: t | ||
720 | |||
721 | crate::a::b | ||
722 | c: t | ||
723 | |||
724 | crate::a::b::c | ||
725 | X: t v | ||
726 | "###); | ||
727 | } | ||
728 | |||
729 | #[test] | ||
730 | fn nested_out_of_line_module_with_path() { | ||
731 | let map = def_map( | ||
732 | r###" | ||
733 | //- /lib.rs | ||
734 | mod a { | ||
735 | #[path = "d/e"] | ||
736 | mod b { | ||
737 | mod c; | ||
738 | } | ||
739 | } | ||
740 | |||
741 | //- /a/d/e/c.rs | ||
742 | struct X; | ||
743 | "###, | ||
744 | ); | ||
745 | |||
746 | assert_snapshot!(map, @r###" | ||
747 | crate | ||
748 | a: t | ||
749 | |||
750 | crate::a | ||
751 | b: t | ||
752 | |||
753 | crate::a::b | ||
754 | c: t | ||
755 | |||
756 | crate::a::b::c | ||
757 | X: t v | ||
758 | "###); | ||
759 | } | ||
diff --git a/crates/ra_hir/src/nameres/tests/primitives.rs b/crates/ra_hir/src/nameres/tests/primitives.rs deleted file mode 100644 index 0e2708658..000000000 --- a/crates/ra_hir/src/nameres/tests/primitives.rs +++ /dev/null | |||
@@ -1,24 +0,0 @@ | |||
1 | use super::*; | ||
2 | |||
3 | #[test] | ||
4 | fn primitive_reexport() { | ||
5 | let map = def_map( | ||
6 | " | ||
7 | //- /lib.rs | ||
8 | mod foo; | ||
9 | use foo::int; | ||
10 | |||
11 | //- /foo.rs | ||
12 | pub use i32 as int; | ||
13 | ", | ||
14 | ); | ||
15 | assert_snapshot!(map, @r###" | ||
16 | â‹®crate | ||
17 | â‹®foo: t | ||
18 | â‹®int: t | ||
19 | â‹® | ||
20 | â‹®crate::foo | ||
21 | â‹®int: t | ||
22 | "### | ||
23 | ); | ||
24 | } | ||
diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs index 75b24d386..b932b0c8c 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 | ||
4 | use hir_def::{ | 4 | use 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 | }; |
9 | use hir_expand::name::{self, Name}; | 10 | use hir_expand::name::{self, Name}; |
10 | use rustc_hash::FxHashSet; | 11 | use rustc_hash::FxHashSet; |
@@ -18,8 +19,8 @@ use crate::{ | |||
18 | }, | 19 | }, |
19 | generics::GenericParams, | 20 | generics::GenericParams, |
20 | impl_block::ImplBlock, | 21 | impl_block::ImplBlock, |
21 | nameres::{CrateDefMap, PerNs}, | 22 | Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, PerNs, Static, Struct, Trait, |
22 | Adt, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias, | 23 | TypeAlias, |
23 | }; | 24 | }; |
24 | 25 | ||
25 | #[derive(Debug, Clone, Default)] | 26 | #[derive(Debug, Clone, Default)] |
@@ -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/infer.rs b/crates/ra_hir/src/ty/infer.rs index 6694467a3..2370e8d4f 100644 --- a/crates/ra_hir/src/ty/infer.rs +++ b/crates/ra_hir/src/ty/infer.rs | |||
@@ -25,7 +25,7 @@ use hir_def::{ | |||
25 | path::known, | 25 | path::known, |
26 | type_ref::{Mutability, TypeRef}, | 26 | type_ref::{Mutability, TypeRef}, |
27 | }; | 27 | }; |
28 | use hir_expand::name; | 28 | use hir_expand::{diagnostics::DiagnosticSink, name}; |
29 | use ra_arena::map::ArenaMap; | 29 | use ra_arena::map::ArenaMap; |
30 | use ra_prof::profile; | 30 | use ra_prof::profile; |
31 | use test_utils::tested_by; | 31 | use test_utils::tested_by; |
@@ -40,7 +40,6 @@ use crate::{ | |||
40 | adt::VariantDef, | 40 | adt::VariantDef, |
41 | code_model::TypeAlias, | 41 | code_model::TypeAlias, |
42 | db::HirDatabase, | 42 | db::HirDatabase, |
43 | diagnostics::DiagnosticSink, | ||
44 | expr::{BindingAnnotation, Body, ExprId, PatId}, | 43 | expr::{BindingAnnotation, Body, ExprId, PatId}, |
45 | resolve::{Resolver, TypeNs}, | 44 | resolve::{Resolver, TypeNs}, |
46 | ty::infer::diagnostics::InferenceDiagnostic, | 45 | ty::infer::diagnostics::InferenceDiagnostic, |
@@ -719,12 +718,9 @@ impl Expectation { | |||
719 | } | 718 | } |
720 | 719 | ||
721 | mod diagnostics { | 720 | mod diagnostics { |
722 | use crate::{ | 721 | use hir_expand::diagnostics::DiagnosticSink; |
723 | db::HirDatabase, | 722 | |
724 | diagnostics::{DiagnosticSink, NoSuchField}, | 723 | use crate::{db::HirDatabase, diagnostics::NoSuchField, expr::ExprId, Function, HasSource}; |
725 | expr::ExprId, | ||
726 | Function, HasSource, | ||
727 | }; | ||
728 | 724 | ||
729 | #[derive(Debug, PartialEq, Eq, Clone)] | 725 | #[derive(Debug, PartialEq, Eq, Clone)] |
730 | pub(super) enum InferenceDiagnostic { | 726 | pub(super) enum InferenceDiagnostic { |
diff --git a/crates/ra_hir/src/ty/infer/expr.rs b/crates/ra_hir/src/ty/infer/expr.rs index fed52df39..a09ef5c5d 100644 --- a/crates/ra_hir/src/ty/infer/expr.rs +++ b/crates/ra_hir/src/ty/infer/expr.rs | |||
@@ -11,12 +11,11 @@ use crate::{ | |||
11 | db::HirDatabase, | 11 | db::HirDatabase, |
12 | expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp}, | 12 | expr::{self, Array, BinaryOp, Expr, ExprId, Literal, Statement, UnaryOp}, |
13 | generics::{GenericParams, HasGenericParams}, | 13 | generics::{GenericParams, HasGenericParams}, |
14 | nameres::Namespace, | ||
15 | ty::{ | 14 | ty::{ |
16 | autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Obligation, | 15 | autoderef, method_resolution, op, primitive, CallableDef, InferTy, Mutability, Obligation, |
17 | ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk, | 16 | ProjectionPredicate, ProjectionTy, Substs, TraitRef, Ty, TypeCtor, TypeWalk, |
18 | }, | 17 | }, |
19 | Adt, Name, | 18 | Adt, Name, Namespace, |
20 | }; | 19 | }; |
21 | 20 | ||
22 | impl<'a, D: HirDatabase> InferenceContext<'a, D> { | 21 | impl<'a, D: HirDatabase> InferenceContext<'a, D> { |
diff --git a/crates/ra_hir/src/ty/lower.rs b/crates/ra_hir/src/ty/lower.rs index 8e2834307..e29ab8492 100644 --- a/crates/ra_hir/src/ty/lower.rs +++ b/crates/ra_hir/src/ty/lower.rs | |||
@@ -23,15 +23,14 @@ use crate::{ | |||
23 | db::HirDatabase, | 23 | db::HirDatabase, |
24 | generics::HasGenericParams, | 24 | generics::HasGenericParams, |
25 | generics::{GenericDef, WherePredicate}, | 25 | generics::{GenericDef, WherePredicate}, |
26 | nameres::Namespace, | ||
27 | resolve::{Resolver, TypeNs}, | 26 | resolve::{Resolver, TypeNs}, |
28 | ty::{ | 27 | ty::{ |
29 | primitive::{FloatTy, IntTy}, | 28 | primitive::{FloatTy, IntTy}, |
30 | Adt, | 29 | Adt, |
31 | }, | 30 | }, |
32 | util::make_mut_slice, | 31 | util::make_mut_slice, |
33 | Const, Enum, EnumVariant, Function, ModuleDef, Path, Static, Struct, StructField, Trait, | 32 | Const, Enum, EnumVariant, Function, ModuleDef, Namespace, Path, Static, Struct, StructField, |
34 | TypeAlias, Union, | 33 | Trait, TypeAlias, Union, |
35 | }; | 34 | }; |
36 | 35 | ||
37 | impl Ty { | 36 | impl Ty { |
diff --git a/crates/ra_hir/src/ty/tests.rs b/crates/ra_hir/src/ty/tests.rs index bfef48b16..4b7e34878 100644 --- a/crates/ra_hir/src/ty/tests.rs +++ b/crates/ra_hir/src/ty/tests.rs | |||
@@ -2,8 +2,7 @@ use std::fmt::Write; | |||
2 | use std::sync::Arc; | 2 | use std::sync::Arc; |
3 | 3 | ||
4 | use insta::assert_snapshot; | 4 | use insta::assert_snapshot; |
5 | 5 | use ra_db::{fixture::WithFixture, salsa::Database, FilePosition, SourceDatabase}; | |
6 | use ra_db::{salsa::Database, FilePosition, SourceDatabase}; | ||
7 | use ra_syntax::{ | 6 | use ra_syntax::{ |
8 | algo, | 7 | algo, |
9 | ast::{self, AstNode}, | 8 | ast::{self, AstNode}, |
@@ -25,9 +24,9 @@ mod coercion; | |||
25 | 24 | ||
26 | #[test] | 25 | #[test] |
27 | fn cfg_impl_block() { | 26 | fn cfg_impl_block() { |
28 | let (mut db, pos) = MockDatabase::with_position( | 27 | let (db, pos) = MockDatabase::with_position( |
29 | r#" | 28 | r#" |
30 | //- /main.rs | 29 | //- /main.rs crate:main deps:foo cfg:test |
31 | use foo::S as T; | 30 | use foo::S as T; |
32 | struct S; | 31 | struct S; |
33 | 32 | ||
@@ -46,7 +45,7 @@ fn test() { | |||
46 | t<|>; | 45 | t<|>; |
47 | } | 46 | } |
48 | 47 | ||
49 | //- /foo.rs | 48 | //- /foo.rs crate:foo |
50 | struct S; | 49 | struct S; |
51 | 50 | ||
52 | #[cfg(not(test))] | 51 | #[cfg(not(test))] |
@@ -60,18 +59,14 @@ impl S { | |||
60 | } | 59 | } |
61 | "#, | 60 | "#, |
62 | ); | 61 | ); |
63 | db.set_crate_graph_from_fixture(crate_graph! { | ||
64 | "main": ("/main.rs", ["foo"], cfg = { "test" }), | ||
65 | "foo": ("/foo.rs", []), | ||
66 | }); | ||
67 | assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos)); | 62 | assert_eq!("(i32, {unknown}, i32, {unknown})", type_at_pos(&db, pos)); |
68 | } | 63 | } |
69 | 64 | ||
70 | #[test] | 65 | #[test] |
71 | fn infer_await() { | 66 | fn infer_await() { |
72 | let (mut db, pos) = MockDatabase::with_position( | 67 | let (db, pos) = MockDatabase::with_position( |
73 | r#" | 68 | r#" |
74 | //- /main.rs | 69 | //- /main.rs crate:main deps:std |
75 | 70 | ||
76 | struct IntFuture; | 71 | struct IntFuture; |
77 | 72 | ||
@@ -85,7 +80,7 @@ fn test() { | |||
85 | v<|>; | 80 | v<|>; |
86 | } | 81 | } |
87 | 82 | ||
88 | //- /std.rs | 83 | //- /std.rs crate:std |
89 | #[prelude_import] use future::*; | 84 | #[prelude_import] use future::*; |
90 | mod future { | 85 | mod future { |
91 | trait Future { | 86 | trait Future { |
@@ -95,18 +90,14 @@ mod future { | |||
95 | 90 | ||
96 | "#, | 91 | "#, |
97 | ); | 92 | ); |
98 | db.set_crate_graph_from_fixture(crate_graph! { | ||
99 | "main": ("/main.rs", ["std"]), | ||
100 | "std": ("/std.rs", []), | ||
101 | }); | ||
102 | assert_eq!("u64", type_at_pos(&db, pos)); | 93 | assert_eq!("u64", type_at_pos(&db, pos)); |
103 | } | 94 | } |
104 | 95 | ||
105 | #[test] | 96 | #[test] |
106 | fn infer_box() { | 97 | fn infer_box() { |
107 | let (mut db, pos) = MockDatabase::with_position( | 98 | let (db, pos) = MockDatabase::with_position( |
108 | r#" | 99 | r#" |
109 | //- /main.rs | 100 | //- /main.rs crate:main deps:std |
110 | 101 | ||
111 | fn test() { | 102 | fn test() { |
112 | let x = box 1; | 103 | let x = box 1; |
@@ -114,7 +105,7 @@ fn test() { | |||
114 | t<|>; | 105 | t<|>; |
115 | } | 106 | } |
116 | 107 | ||
117 | //- /std.rs | 108 | //- /std.rs crate:std |
118 | #[prelude_import] use prelude::*; | 109 | #[prelude_import] use prelude::*; |
119 | mod prelude {} | 110 | mod prelude {} |
120 | 111 | ||
@@ -126,10 +117,6 @@ mod boxed { | |||
126 | 117 | ||
127 | "#, | 118 | "#, |
128 | ); | 119 | ); |
129 | db.set_crate_graph_from_fixture(crate_graph! { | ||
130 | "main": ("/main.rs", ["std"]), | ||
131 | "std": ("/std.rs", []), | ||
132 | }); | ||
133 | assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32;_]>)", type_at_pos(&db, pos)); | 120 | assert_eq!("(Box<i32>, Box<Box<i32>>, Box<&i32>, Box<[i32;_]>)", type_at_pos(&db, pos)); |
134 | } | 121 | } |
135 | 122 | ||
@@ -154,9 +141,9 @@ fn test() { | |||
154 | 141 | ||
155 | #[test] | 142 | #[test] |
156 | fn infer_try() { | 143 | fn infer_try() { |
157 | let (mut db, pos) = MockDatabase::with_position( | 144 | let (db, pos) = MockDatabase::with_position( |
158 | r#" | 145 | r#" |
159 | //- /main.rs | 146 | //- /main.rs crate:main deps:std |
160 | 147 | ||
161 | fn test() { | 148 | fn test() { |
162 | let r: Result<i32, u64> = Result::Ok(1); | 149 | let r: Result<i32, u64> = Result::Ok(1); |
@@ -164,7 +151,7 @@ fn test() { | |||
164 | v<|>; | 151 | v<|>; |
165 | } | 152 | } |
166 | 153 | ||
167 | //- /std.rs | 154 | //- /std.rs crate:std |
168 | 155 | ||
169 | #[prelude_import] use ops::*; | 156 | #[prelude_import] use ops::*; |
170 | mod ops { | 157 | mod ops { |
@@ -189,18 +176,14 @@ mod result { | |||
189 | 176 | ||
190 | "#, | 177 | "#, |
191 | ); | 178 | ); |
192 | db.set_crate_graph_from_fixture(crate_graph! { | ||
193 | "main": ("/main.rs", ["std"]), | ||
194 | "std": ("/std.rs", []), | ||
195 | }); | ||
196 | assert_eq!("i32", type_at_pos(&db, pos)); | 179 | assert_eq!("i32", type_at_pos(&db, pos)); |
197 | } | 180 | } |
198 | 181 | ||
199 | #[test] | 182 | #[test] |
200 | fn infer_for_loop() { | 183 | fn infer_for_loop() { |
201 | let (mut db, pos) = MockDatabase::with_position( | 184 | let (db, pos) = MockDatabase::with_position( |
202 | r#" | 185 | r#" |
203 | //- /main.rs | 186 | //- /main.rs crate:main deps:std |
204 | 187 | ||
205 | use std::collections::Vec; | 188 | use std::collections::Vec; |
206 | 189 | ||
@@ -212,7 +195,7 @@ fn test() { | |||
212 | } | 195 | } |
213 | } | 196 | } |
214 | 197 | ||
215 | //- /std.rs | 198 | //- /std.rs crate:std |
216 | 199 | ||
217 | #[prelude_import] use iter::*; | 200 | #[prelude_import] use iter::*; |
218 | mod iter { | 201 | mod iter { |
@@ -234,10 +217,6 @@ mod collections { | |||
234 | } | 217 | } |
235 | "#, | 218 | "#, |
236 | ); | 219 | ); |
237 | db.set_crate_graph_from_fixture(crate_graph! { | ||
238 | "main": ("/main.rs", ["std"]), | ||
239 | "std": ("/std.rs", []), | ||
240 | }); | ||
241 | assert_eq!("&str", type_at_pos(&db, pos)); | 220 | assert_eq!("&str", type_at_pos(&db, pos)); |
242 | } | 221 | } |
243 | 222 | ||
@@ -2505,15 +2484,15 @@ pub fn main_loop() { | |||
2505 | 2484 | ||
2506 | #[test] | 2485 | #[test] |
2507 | fn cross_crate_associated_method_call() { | 2486 | fn cross_crate_associated_method_call() { |
2508 | let (mut db, pos) = MockDatabase::with_position( | 2487 | let (db, pos) = MockDatabase::with_position( |
2509 | r#" | 2488 | r#" |
2510 | //- /main.rs | 2489 | //- /main.rs crate:main deps:other_crate |
2511 | fn test() { | 2490 | fn test() { |
2512 | let x = other_crate::foo::S::thing(); | 2491 | let x = other_crate::foo::S::thing(); |
2513 | x<|>; | 2492 | x<|>; |
2514 | } | 2493 | } |
2515 | 2494 | ||
2516 | //- /lib.rs | 2495 | //- /lib.rs crate:other_crate |
2517 | mod foo { | 2496 | mod foo { |
2518 | struct S; | 2497 | struct S; |
2519 | impl S { | 2498 | impl S { |
@@ -2522,10 +2501,6 @@ mod foo { | |||
2522 | } | 2501 | } |
2523 | "#, | 2502 | "#, |
2524 | ); | 2503 | ); |
2525 | db.set_crate_graph_from_fixture(crate_graph! { | ||
2526 | "main": ("/main.rs", ["other_crate"]), | ||
2527 | "other_crate": ("/lib.rs", []), | ||
2528 | }); | ||
2529 | assert_eq!("i128", type_at_pos(&db, pos)); | 2504 | assert_eq!("i128", type_at_pos(&db, pos)); |
2530 | } | 2505 | } |
2531 | 2506 | ||
@@ -3403,16 +3378,15 @@ fn test() { S.foo()<|>; } | |||
3403 | 3378 | ||
3404 | #[test] | 3379 | #[test] |
3405 | fn infer_macro_with_dollar_crate_is_correct_in_expr() { | 3380 | fn infer_macro_with_dollar_crate_is_correct_in_expr() { |
3406 | covers!(macro_dollar_crate_other); | 3381 | let (db, pos) = MockDatabase::with_position( |
3407 | let (mut db, pos) = MockDatabase::with_position( | ||
3408 | r#" | 3382 | r#" |
3409 | //- /main.rs | 3383 | //- /main.rs crate:main deps:foo |
3410 | fn test() { | 3384 | fn test() { |
3411 | let x = (foo::foo!(1), foo::foo!(2)); | 3385 | let x = (foo::foo!(1), foo::foo!(2)); |
3412 | x<|>; | 3386 | x<|>; |
3413 | } | 3387 | } |
3414 | 3388 | ||
3415 | //- /lib.rs | 3389 | //- /lib.rs crate:foo |
3416 | #[macro_export] | 3390 | #[macro_export] |
3417 | macro_rules! foo { | 3391 | macro_rules! foo { |
3418 | (1) => { $crate::bar!() }; | 3392 | (1) => { $crate::bar!() }; |
@@ -3427,10 +3401,6 @@ macro_rules! bar { | |||
3427 | pub fn baz() -> usize { 31usize } | 3401 | pub fn baz() -> usize { 31usize } |
3428 | "#, | 3402 | "#, |
3429 | ); | 3403 | ); |
3430 | db.set_crate_graph_from_fixture(crate_graph! { | ||
3431 | "main": ("/main.rs", ["foo"]), | ||
3432 | "foo": ("/lib.rs", []), | ||
3433 | }); | ||
3434 | assert_eq!("(i32, usize)", type_at_pos(&db, pos)); | 3404 | assert_eq!("(i32, usize)", type_at_pos(&db, pos)); |
3435 | } | 3405 | } |
3436 | 3406 | ||
@@ -3512,9 +3482,9 @@ fn test() { (&S).foo()<|>; } | |||
3512 | 3482 | ||
3513 | #[test] | 3483 | #[test] |
3514 | fn method_resolution_trait_from_prelude() { | 3484 | fn method_resolution_trait_from_prelude() { |
3515 | let (mut db, pos) = MockDatabase::with_position( | 3485 | let (db, pos) = MockDatabase::with_position( |
3516 | r#" | 3486 | r#" |
3517 | //- /main.rs | 3487 | //- /main.rs crate:main deps:other_crate |
3518 | struct S; | 3488 | struct S; |
3519 | impl Clone for S {} | 3489 | impl Clone for S {} |
3520 | 3490 | ||
@@ -3522,7 +3492,7 @@ fn test() { | |||
3522 | S.clone()<|>; | 3492 | S.clone()<|>; |
3523 | } | 3493 | } |
3524 | 3494 | ||
3525 | //- /lib.rs | 3495 | //- /lib.rs crate:other_crate |
3526 | #[prelude_import] use foo::*; | 3496 | #[prelude_import] use foo::*; |
3527 | 3497 | ||
3528 | mod foo { | 3498 | mod foo { |
@@ -3532,10 +3502,6 @@ mod foo { | |||
3532 | } | 3502 | } |
3533 | "#, | 3503 | "#, |
3534 | ); | 3504 | ); |
3535 | db.set_crate_graph_from_fixture(crate_graph! { | ||
3536 | "main": ("/main.rs", ["other_crate"]), | ||
3537 | "other_crate": ("/lib.rs", []), | ||
3538 | }); | ||
3539 | assert_eq!("S", type_at_pos(&db, pos)); | 3505 | assert_eq!("S", type_at_pos(&db, pos)); |
3540 | } | 3506 | } |
3541 | 3507 | ||