From 9a820dc0ee23051137e4909d4698fe71930c04bc Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 5 Jan 2019 00:02:05 +0300 Subject: [PATCH 01/15] move crate to code_model_api --- crates/ra_hir/src/code_model_api.rs | 26 +++++++++++++++++++ .../src/{krate.rs => code_model_impl.rs} | 22 +++------------- crates/ra_hir/src/lib.rs | 7 ++--- 3 files changed, 34 insertions(+), 21 deletions(-) create mode 100644 crates/ra_hir/src/code_model_api.rs rename crates/ra_hir/src/{krate.rs => code_model_impl.rs} (62%) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs new file mode 100644 index 000000000000..e8b3a1fb6a5b --- /dev/null +++ b/crates/ra_hir/src/code_model_api.rs @@ -0,0 +1,26 @@ +use ra_db::{CrateId, Cancelable}; + +use crate::{Module, Name, db::HirDatabase}; + +/// hir::Crate describes a single crate. It's the main inteface with which +/// crate's dependencies interact. Mostly, it should be just a proxy for the +/// root module. +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Crate { + pub(crate) crate_id: CrateId, +} + +#[derive(Debug)] +pub struct CrateDependency { + pub krate: Crate, + pub name: Name, +} + +impl Crate { + pub fn dependencies(&self, db: &impl HirDatabase) -> Vec { + self.dependencies_impl(db) + } + pub fn root_module(&self, db: &impl HirDatabase) -> Cancelable> { + self.root_module_impl(db) + } +} diff --git a/crates/ra_hir/src/krate.rs b/crates/ra_hir/src/code_model_impl.rs similarity index 62% rename from crates/ra_hir/src/krate.rs rename to crates/ra_hir/src/code_model_impl.rs index 5194e280b751..75d4e04c1af4 100644 --- a/crates/ra_hir/src/krate.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,26 +1,12 @@ -pub use ra_db::{CrateId, Cancelable}; +use ra_db::{CrateId, Cancelable}; -use crate::{HirDatabase, Module, Name, AsName, HirFileId}; - -/// hir::Crate describes a single crate. It's the main inteface with which -/// crate's dependencies interact. Mostly, it should be just a proxy for the -/// root module. -#[derive(Debug, Clone, PartialEq, Eq, Hash)] -pub struct Crate { - crate_id: CrateId, -} - -#[derive(Debug)] -pub struct CrateDependency { - pub krate: Crate, - pub name: Name, -} +use crate::{Module, HirFileId, db::HirDatabase, Crate, CrateDependency, AsName}; impl Crate { pub(crate) fn new(crate_id: CrateId) -> Crate { Crate { crate_id } } - pub fn dependencies(&self, db: &impl HirDatabase) -> Vec { + pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec { let crate_graph = db.crate_graph(); crate_graph .dependencies(self.crate_id) @@ -31,7 +17,7 @@ impl Crate { }) .collect() } - pub fn root_module(&self, db: &impl HirDatabase) -> Cancelable> { + pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Cancelable> { let crate_graph = db.crate_graph(); let file_id = crate_graph.crate_root(self.crate_id); let source_root_id = db.file_source_root(file_id); diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index d600b91df318..0fe80deb59a9 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -24,8 +24,6 @@ pub mod source_binder; mod ids; mod macros; mod name; -// can't use `crate` or `r#crate` here :( -mod krate; mod module; mod function; mod adt; @@ -34,16 +32,19 @@ mod ty; mod impl_block; mod expr; +pub mod code_model_api; +mod code_model_impl; + use crate::{ db::HirDatabase, name::{AsName, KnownName}, ids::{DefKind, SourceItemId, SourceFileItemId, SourceFileItems}, + code_model_api::{Crate, CrateDependency} }; pub use self::{ path::{Path, PathKind}, name::Name, - krate::Crate, ids::{HirFileId, DefId, DefLoc, MacroCallId, MacroCallLoc}, macros::{MacroDef, MacroInput, MacroExpansion}, module::{Module, ModuleId, Problem, nameres::{ItemMap, PerNs, Namespace}, ModuleScope, Resolution}, From 147b0f94e60f66c73ee1ca1726de97d76721bfda Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 5 Jan 2019 01:37:40 +0300 Subject: [PATCH 02/15] Start code_model::Module --- crates/ra_hir/src/code_model_api.rs | 23 ++++++++++- crates/ra_hir/src/code_model_impl.rs | 59 +++++++++++++++++++++++++++- crates/ra_hir/src/module.rs | 6 +-- crates/ra_hir/src/module/nameres.rs | 2 +- 4 files changed, 83 insertions(+), 7 deletions(-) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index e8b3a1fb6a5b..63e2e34e83c0 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,6 +1,6 @@ use ra_db::{CrateId, Cancelable}; -use crate::{Module, Name, db::HirDatabase}; +use crate::{Name, db::HirDatabase, DefId}; /// hir::Crate describes a single crate. It's the main inteface with which /// crate's dependencies interact. Mostly, it should be just a proxy for the @@ -24,3 +24,24 @@ impl Crate { self.root_module_impl(db) } } + +#[derive(Debug, Clone, PartialEq, Eq, Hash)] +pub struct Module { + pub(crate) def_id: DefId, +} + +impl Module { + /// Returns the crate this module is part of. + pub fn krate(&self, db: &impl HirDatabase) -> Cancelable> { + self.krate_impl(db) + } + + pub fn crate_root(&self, db: &impl HirDatabase) -> Cancelable { + self.crate_root_impl(db) + } + + /// Finds a child module with the specified name. + pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + self.child_impl(db, name) + } +} diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 75d4e04c1af4..22079ba3348e 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,6 +1,9 @@ use ra_db::{CrateId, Cancelable}; -use crate::{Module, HirFileId, db::HirDatabase, Crate, CrateDependency, AsName}; +use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name}; + +use crate::code_model_api::Module; + impl Crate { pub(crate) fn new(crate_id: CrateId) -> Crate { @@ -28,7 +31,59 @@ impl Crate { .modules_with_sources() .find(|(_, src)| src.file_id() == file_id)); - let module = Module::new(db, source_root_id, module_id)?; + let def_loc = DefLoc { + kind: DefKind::Module, + source_root_id, + module_id, + source_item_id: module_id.source(&module_tree).0, + }; + let def_id = def_loc.id(db); + + let module = Module::new(def_id); + Ok(Some(module)) + } +} + +impl Module { + fn new(def_id: DefId) -> Self { + crate::code_model_api::Module { def_id } + } + + pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let root = self.crate_root(db)?; + let loc = root.def_id.loc(db); + let file_id = loc.source_item_id.file_id.as_original_file(); + + let crate_graph = db.crate_graph(); + let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id)); + Ok(Some(Crate::new(crate_id))) + } + + pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let module_id = loc.module_id.crate_root(&module_tree); + let def_loc = DefLoc { + module_id, + source_item_id: module_id.source(&module_tree).0, + ..loc + }; + let def_id = def_loc.id(db); + let module = Module::new(def_id); + Ok(module) + } + /// Finds a child module with the specified name. + pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let child_id = ctry!(loc.module_id.child(&module_tree, name)); + let def_loc = DefLoc { + module_id: child_id, + source_item_id: child_id.source(&module_tree).0, + ..loc + }; + let def_id = def_loc.id(db); + let module = Module::new(def_id); Ok(Some(module)) } } diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs index b9821115ce8b..f0b673908f83 100644 --- a/crates/ra_hir/src/module.rs +++ b/crates/ra_hir/src/module.rs @@ -224,7 +224,7 @@ impl ModuleTree { /// `ModuleSource` is the syntax tree element that produced this module: /// either a file, or an inlinde module. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] -pub struct ModuleSource(SourceItemId); +pub struct ModuleSource(pub(crate) SourceItemId); /// An owned syntax node for a module. Unlike `ModuleSource`, /// this holds onto the AST for the whole file. @@ -255,12 +255,12 @@ impl ModuleId { let link = self.parent_link(tree)?; Some(tree.links[link].owner) } - fn crate_root(self, tree: &ModuleTree) -> ModuleId { + pub(crate) fn crate_root(self, tree: &ModuleTree) -> ModuleId { generate(Some(self), move |it| it.parent(tree)) .last() .unwrap() } - fn child(self, tree: &ModuleTree, name: &Name) -> Option { + pub(crate) fn child(self, tree: &ModuleTree, name: &Name) -> Option { let link = tree.mods[self] .children .iter() diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs index 3c6851a0a3d2..cd634e42f962 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/module/nameres.rs @@ -346,7 +346,7 @@ where let krate = Crate::new(crate_id); for dep in krate.dependencies(self.db) { if let Some(module) = dep.krate.root_module(self.db)? { - let def_id = module.def_id(self.db); + let def_id = module.def_id; self.add_module_item( &mut module_items, dep.name.clone(), From 8c4d2770362f3c2950f110f8e116ed8f537ec1a1 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sat, 5 Jan 2019 12:13:16 +0300 Subject: [PATCH 03/15] switch source-binders to Module --- crates/ra_hir/src/code_model_impl.rs | 3 +-- crates/ra_hir/src/source_binder.rs | 26 +++++++++++++++++++------- 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 22079ba3348e..659af548caac 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -4,7 +4,6 @@ use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, D use crate::code_model_api::Module; - impl Crate { pub(crate) fn new(crate_id: CrateId) -> Crate { Crate { crate_id } @@ -45,7 +44,7 @@ impl Crate { } impl Module { - fn new(def_id: DefId) -> Self { + pub(crate) fn new(def_id: DefId) -> Self { crate::code_model_api::Module { def_id } } diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index 29a3960e9190..ac097e81a83e 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -13,11 +13,13 @@ use ra_syntax::{ }; use crate::{ - HirDatabase, Module, Function, SourceItemId, + HirDatabase, Function, SourceItemId, module::ModuleSource, DefKind, DefLoc, AsName, }; +use crate::code_model_api::Module; + /// Locates the module by `FileId`. Picks topmost module in the file. pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable> { let module_source = ModuleSource::new_file(file_id.into()); @@ -34,7 +36,7 @@ pub fn module_from_declaration( let child_name = decl.name(); match (parent_module, child_name) { (Some(parent_module), Some(child_name)) => { - if let Some(child) = parent_module.child(&child_name.as_name()) { + if let Some(child) = parent_module.child(db, &child_name.as_name())? { return Ok(Some(child)); } } @@ -84,7 +86,15 @@ fn module_from_source( .modules_with_sources() .find(|(_id, src)| src == &module_source); let module_id = ctry!(m).0; - Ok(Some(Module::new(db, source_root_id, module_id)?)) + let def_loc = DefLoc { + kind: DefKind::Module, + source_root_id, + module_id, + source_item_id: module_source.0, + }; + let def_id = def_loc.id(db); + + Ok(Some(Module::new(def_id))) } pub fn function_from_position( @@ -114,7 +124,8 @@ pub fn function_from_module( module: &Module, fn_def: ast::FnDef, ) -> Function { - let file_id = module.source().file_id(); + let loc = module.def_id.loc(db); + let file_id = loc.source_item_id.file_id; let file_items = db.file_items(file_id); let item_id = file_items.id_of(file_id, fn_def.syntax()); let source_item_id = SourceItemId { @@ -123,8 +134,8 @@ pub fn function_from_module( }; let def_loc = DefLoc { kind: DefKind::Function, - source_root_id: module.source_root_id, - module_id: module.module_id, + source_root_id: loc.source_root_id, + module_id: loc.module_id, source_item_id, }; Function::new(def_loc.id(db)) @@ -147,7 +158,8 @@ pub fn macro_symbols( Some(it) => it, None => return Ok(Vec::new()), }; - let items = db.input_module_items(module.source_root_id, module.module_id)?; + let loc = module.def_id.loc(db); + let items = db.input_module_items(loc.source_root_id, loc.module_id)?; let mut res = Vec::new(); for macro_call_id in items From 61687b9db67d34bbcce8596496448c0717d98316 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 13:41:12 +0300 Subject: [PATCH 04/15] fix tests --- crates/ra_analysis/src/imp.rs | 31 ++++++++++------------- crates/ra_hir/src/code_model_api.rs | 10 +++++++- crates/ra_hir/src/code_model_impl.rs | 19 +++++++++++++- crates/ra_hir/src/module/nameres/tests.rs | 4 +-- 4 files changed, 43 insertions(+), 21 deletions(-) diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs index 5988fb7794e3..44e7aca44f26 100644 --- a/crates/ra_analysis/src/imp.rs +++ b/crates/ra_analysis/src/imp.rs @@ -105,39 +105,36 @@ impl db::RootDatabase { &self, position: FilePosition, ) -> Cancelable> { - let descr = match source_binder::module_from_position(self, position)? { + let module = match source_binder::module_from_position(self, position)? { None => return Ok(Vec::new()), Some(it) => it, }; - let (file_id, decl) = match descr.parent_link_source(self) { + let (file_id, ast_module) = module.source(self); + let ast_module = match ast_module { None => return Ok(Vec::new()), Some(it) => it, }; - let decl = decl.borrowed(); - let decl_name = decl.name().unwrap(); + let ast_module = ast_module.borrowed(); + let name = ast_module.name().unwrap(); Ok(vec![NavigationTarget { file_id, - name: decl_name.text(), - range: decl_name.syntax().range(), + name: name.text(), + range: name.syntax().range(), kind: MODULE, ptr: None, }]) } /// Returns `Vec` for the same reason as `parent_module` pub(crate) fn crate_for(&self, file_id: FileId) -> Cancelable> { - let descr = match source_binder::module_from_file_id(self, file_id)? { - None => return Ok(Vec::new()), + let module = match source_binder::module_from_file_id(self, file_id)? { Some(it) => it, + None => return Ok(Vec::new()), }; - let root = descr.crate_root(); - let file_id = root.file_id(); - - let crate_graph = self.crate_graph(); - let crate_id = crate_graph.crate_id_for_crate_root(file_id); - Ok(crate_id.into_iter().collect()) - } - pub(crate) fn crate_root(&self, crate_id: CrateId) -> FileId { - self.crate_graph().crate_root(crate_id) + let krate = match module.krate(self)? { + Some(it) => it, + None => return Ok(Vec::new()), + }; + Ok(vec![krate.crate_id()]) } pub(crate) fn find_all_refs( &self, diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 63e2e34e83c0..2f968d97c6a9 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,4 +1,5 @@ -use ra_db::{CrateId, Cancelable}; +use ra_db::{CrateId, Cancelable, FileId}; +use ra_syntax::ast; use crate::{Name, db::HirDatabase, DefId}; @@ -17,6 +18,9 @@ pub struct CrateDependency { } impl Crate { + pub fn crate_id(&self) -> CrateId { + self.crate_id + } pub fn dependencies(&self, db: &impl HirDatabase) -> Vec { self.dependencies_impl(db) } @@ -31,6 +35,10 @@ pub struct Module { } impl Module { + pub fn source(&self, db: &impl HirDatabase) -> (FileId, Option) { + self.source_impl(db) + } + /// Returns the crate this module is part of. pub fn krate(&self, db: &impl HirDatabase) -> Cancelable> { self.krate_impl(db) diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 659af548caac..83ee8186e479 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,4 +1,5 @@ -use ra_db::{CrateId, Cancelable}; +use ra_db::{CrateId, Cancelable, FileId}; +use ra_syntax::{AstNode, ast}; use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name}; @@ -48,6 +49,22 @@ impl Module { crate::code_model_api::Module { def_id } } + pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> (FileId, Option) { + let loc = self.def_id.loc(db); + let source_item_id = loc.source_item_id; + let module = match source_item_id.item_id { + None => None, + Some(_) => { + let syntax_node = db.file_item(source_item_id); + let module = ast::Module::cast(syntax_node.borrowed()).unwrap().owned(); + Some(module) + } + }; + // FIXME: remove `as_original_file` here + let file_id = source_item_id.file_id.as_original_file(); + (file_id, module) + } + pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { let root = self.crate_root(db)?; let loc = root.def_id.loc(db); diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/module/nameres/tests.rs index a6a0bea3160e..dcbe65aec36a 100644 --- a/crates/ra_hir/src/module/nameres/tests.rs +++ b/crates/ra_hir/src/module/nameres/tests.rs @@ -17,7 +17,7 @@ fn item_map(fixture: &str) -> (Arc, hir::ModuleId) { let module = hir::source_binder::module_from_position(&db, pos) .unwrap() .unwrap(); - let module_id = module.module_id; + let module_id = module.def_id.loc(&db).module_id; (db.item_map(source_root).unwrap(), module_id) } @@ -155,7 +155,7 @@ fn item_map_across_crates() { let module = hir::source_binder::module_from_file_id(&db, main_id) .unwrap() .unwrap(); - let module_id = module.module_id; + let module_id = module.def_id.loc(&db).module_id; let item_map = db.item_map(source_root).unwrap(); check_module_item_map( From b37fba7136c0191ae0becb3104d2d5746c50c3f1 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 13:45:41 +0300 Subject: [PATCH 05/15] make deps cancelable --- crates/ra_hir/src/code_model_api.rs | 4 ++-- crates/ra_hir/src/module/nameres.rs | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 2f968d97c6a9..f1e891722c8a 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -21,8 +21,8 @@ impl Crate { pub fn crate_id(&self) -> CrateId { self.crate_id } - pub fn dependencies(&self, db: &impl HirDatabase) -> Vec { - self.dependencies_impl(db) + pub fn dependencies(&self, db: &impl HirDatabase) -> Cancelable> { + Ok(self.dependencies_impl(db)) } pub fn root_module(&self, db: &impl HirDatabase) -> Cancelable> { self.root_module_impl(db) diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs index cd634e42f962..059301b05d66 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/module/nameres.rs @@ -344,7 +344,7 @@ where if let Some(crate_id) = crate_graph.crate_id_for_crate_root(file_id.as_original_file()) { let krate = Crate::new(crate_id); - for dep in krate.dependencies(self.db) { + for dep in krate.dependencies(self.db)? { if let Some(module) = dep.krate.root_module(self.db)? { let def_id = module.def_id; self.add_module_item( From 1836f4db35b29cd325b04978776a902679bd9ce6 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 13:45:55 +0300 Subject: [PATCH 06/15] make source cancelable --- crates/ra_hir/src/code_model_api.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index f1e891722c8a..6bbc80e17ce0 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -35,8 +35,8 @@ pub struct Module { } impl Module { - pub fn source(&self, db: &impl HirDatabase) -> (FileId, Option) { - self.source_impl(db) + pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, Option)> { + Ok(self.source_impl(db)) } /// Returns the crate this module is part of. From 3c2cb89087c87f29ad3bc3856625b83017b7a294 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 14:05:03 +0300 Subject: [PATCH 07/15] add parent & resolve_path --- crates/ra_hir/src/code_model_api.rs | 10 ++++- crates/ra_hir/src/code_model_impl.rs | 56 +++++++++++++++++++++++++++- crates/ra_hir/src/module.rs | 2 +- crates/ra_hir/src/module/nameres.rs | 4 +- 4 files changed, 67 insertions(+), 5 deletions(-) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 6bbc80e17ce0..236cb3ab4d23 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,7 +1,7 @@ use ra_db::{CrateId, Cancelable, FileId}; use ra_syntax::ast; -use crate::{Name, db::HirDatabase, DefId}; +use crate::{Name, db::HirDatabase, DefId, Path, PerNs}; /// hir::Crate describes a single crate. It's the main inteface with which /// crate's dependencies interact. Mostly, it should be just a proxy for the @@ -52,4 +52,12 @@ impl Module { pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { self.child_impl(db, name) } + /// Finds a parent module. + pub fn parent(&self, db: &impl HirDatabase) -> Cancelable> { + self.parent_impl(db) + } + + pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable> { + self.resolve_path_impl(db, path) + } } diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 83ee8186e479..678758956a44 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,7 +1,7 @@ use ra_db::{CrateId, Cancelable, FileId}; use ra_syntax::{AstNode, ast}; -use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name}; +use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def}; use crate::code_model_api::Module; @@ -102,4 +102,58 @@ impl Module { let module = Module::new(def_id); Ok(Some(module)) } + pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let parent_id = ctry!(loc.module_id.parent(&module_tree)); + let def_loc = DefLoc { + module_id: parent_id, + source_item_id: parent_id.source(&module_tree).0, + ..loc + }; + let def_id = def_loc.id(db); + let module = Module::new(def_id); + Ok(Some(module)) + } + pub fn resolve_path_impl( + &self, + db: &impl HirDatabase, + path: &Path, + ) -> Cancelable> { + let mut curr_per_ns = PerNs::types( + match path.kind { + PathKind::Crate => self.crate_root(db)?, + PathKind::Self_ | PathKind::Plain => self.clone(), + PathKind::Super => { + if let Some(p) = self.parent(db)? { + p + } else { + return Ok(PerNs::none()); + } + } + } + .def_id, + ); + + let segments = &path.segments; + for name in segments.iter() { + let curr = if let Some(r) = curr_per_ns.as_ref().take_types() { + r + } else { + return Ok(PerNs::none()); + }; + let module = match curr.resolve(db)? { + Def::Module(it) => it, + // TODO here would be the place to handle enum variants... + _ => return Ok(PerNs::none()), + }; + let scope = module.scope(db)?; + curr_per_ns = if let Some(r) = scope.get(&name) { + r.def_id + } else { + return Ok(PerNs::none()); + }; + } + Ok(curr_per_ns) + } } diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs index f0b673908f83..11e3f6782c35 100644 --- a/crates/ra_hir/src/module.rs +++ b/crates/ra_hir/src/module.rs @@ -251,7 +251,7 @@ impl ModuleId { fn parent_link(self, tree: &ModuleTree) -> Option { tree.mods[self].parent } - fn parent(self, tree: &ModuleTree) -> Option { + pub(crate) fn parent(self, tree: &ModuleTree) -> Option { let link = self.parent_link(tree)?; Some(tree.links[link].owner) } diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs index 059301b05d66..dac524384afe 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/module/nameres.rs @@ -177,11 +177,11 @@ impl PerNs { } pub fn take_types(self) -> Option { - self.types + self.take(Namespace::Types) } pub fn take_values(self) -> Option { - self.values + self.take(Namespace::Values) } pub fn get(&self, namespace: Namespace) -> Option<&T> { From 9cb02fd931f436a7b39c33c752799f5530b8491b Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 15:16:21 +0300 Subject: [PATCH 08/15] kill old module --- crates/ra_hir/src/code_model_api.rs | 13 +- crates/ra_hir/src/code_model_impl.rs | 76 ++++++------ crates/ra_hir/src/ids.rs | 10 +- crates/ra_hir/src/impl_block.rs | 24 ++-- crates/ra_hir/src/lib.rs | 2 + crates/ra_hir/src/module.rs | 172 +-------------------------- crates/ra_hir/src/module/nameres.rs | 4 +- 7 files changed, 67 insertions(+), 234 deletions(-) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 236cb3ab4d23..eca7d0225627 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,7 +1,6 @@ -use ra_db::{CrateId, Cancelable, FileId}; -use ra_syntax::ast; +use ra_db::{CrateId, Cancelable}; -use crate::{Name, db::HirDatabase, DefId, Path, PerNs}; +use crate::{Name, db::HirDatabase, DefId, Path, PerNs, module::{ModuleSource, ModuleScope}}; /// hir::Crate describes a single crate. It's the main inteface with which /// crate's dependencies interact. Mostly, it should be just a proxy for the @@ -35,7 +34,8 @@ pub struct Module { } impl Module { - pub fn source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, Option)> { + // FIXME: what is a module source exactly? It should contain two nodes + pub fn source(&self, db: &impl HirDatabase) -> Cancelable { Ok(self.source_impl(db)) } @@ -56,7 +56,10 @@ impl Module { pub fn parent(&self, db: &impl HirDatabase) -> Cancelable> { self.parent_impl(db) } - + /// Returns a `ModuleScope`: a set of items, visible in this module. + pub fn scope(&self, db: &impl HirDatabase) -> Cancelable { + self.scope_impl(db) + } pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable> { self.resolve_path_impl(db, path) } diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 678758956a44..7f5669c8f1a2 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,7 +1,10 @@ -use ra_db::{CrateId, Cancelable, FileId}; -use ra_syntax::{AstNode, ast}; +use ra_db::{CrateId, Cancelable, SourceRootId}; -use crate::{HirFileId, db::HirDatabase, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def}; +use crate::{ + HirFileId, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def, ModuleId, + module::{ModuleSource, ModuleScope}, + db::HirDatabase, +}; use crate::code_model_api::Module; @@ -48,21 +51,26 @@ impl Module { pub(crate) fn new(def_id: DefId) -> Self { crate::code_model_api::Module { def_id } } - - pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> (FileId, Option) { - let loc = self.def_id.loc(db); - let source_item_id = loc.source_item_id; - let module = match source_item_id.item_id { - None => None, - Some(_) => { - let syntax_node = db.file_item(source_item_id); - let module = ast::Module::cast(syntax_node.borrowed()).unwrap().owned(); - Some(module) - } + pub(crate) fn from_module_id( + db: &impl HirDatabase, + source_root_id: SourceRootId, + module_id: ModuleId, + ) -> Cancelable { + let module_tree = db.module_tree(source_root_id)?; + let def_loc = DefLoc { + kind: DefKind::Module, + source_root_id, + module_id, + source_item_id: module_id.source(&module_tree).0, }; - // FIXME: remove `as_original_file` here - let file_id = source_item_id.file_id.as_original_file(); - (file_id, module) + let def_id = def_loc.id(db); + let module = Module::new(def_id); + Ok(module) + } + + pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> ModuleSource { + let loc = self.def_id.loc(db); + ModuleSource(loc.source_item_id) } pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { @@ -79,41 +87,27 @@ impl Module { let loc = self.def_id.loc(db); let module_tree = db.module_tree(loc.source_root_id)?; let module_id = loc.module_id.crate_root(&module_tree); - let def_loc = DefLoc { - module_id, - source_item_id: module_id.source(&module_tree).0, - ..loc - }; - let def_id = def_loc.id(db); - let module = Module::new(def_id); - Ok(module) + Module::from_module_id(db, loc.source_root_id, module_id) } /// Finds a child module with the specified name. pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { let loc = self.def_id.loc(db); let module_tree = db.module_tree(loc.source_root_id)?; let child_id = ctry!(loc.module_id.child(&module_tree, name)); - let def_loc = DefLoc { - module_id: child_id, - source_item_id: child_id.source(&module_tree).0, - ..loc - }; - let def_id = def_loc.id(db); - let module = Module::new(def_id); - Ok(Some(module)) + Module::from_module_id(db, loc.source_root_id, child_id).map(Some) } pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable> { let loc = self.def_id.loc(db); let module_tree = db.module_tree(loc.source_root_id)?; let parent_id = ctry!(loc.module_id.parent(&module_tree)); - let def_loc = DefLoc { - module_id: parent_id, - source_item_id: parent_id.source(&module_tree).0, - ..loc - }; - let def_id = def_loc.id(db); - let module = Module::new(def_id); - Ok(Some(module)) + Module::from_module_id(db, loc.source_root_id, parent_id).map(Some) + } + /// Returns a `ModuleScope`: a set of items, visible in this module. + pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable { + let loc = self.def_id.loc(db); + let item_map = db.item_map(loc.source_root_id)?; + let res = item_map.per_module[&loc.module_id].clone(); + Ok(res) } pub fn resolve_path_impl( &self, diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs index 4d6378e02863..c7391ee05606 100644 --- a/crates/ra_hir/src/ids.rs +++ b/crates/ra_hir/src/ids.rs @@ -2,7 +2,9 @@ use ra_db::{SourceRootId, LocationIntener, Cancelable, FileId}; use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, SourceFile, AstNode, ast}; use ra_arena::{Arena, RawId, impl_arena_id}; -use crate::{HirDatabase, PerNs, ModuleId, Module, Def, Function, Struct, Enum, ImplBlock, Crate}; +use crate::{HirDatabase, PerNs, ModuleId, Def, Function, Struct, Enum, ImplBlock, Crate}; + +use crate::code_model_api::Module; /// hir makes a heavy use of ids: integer (u32) handlers to various things. You /// can think of id as a pointer (but without a lifetime) or a file descriptor @@ -151,7 +153,7 @@ impl DefId { let loc = self.loc(db); let res = match loc.kind { DefKind::Module => { - let module = Module::new(db, loc.source_root_id, loc.module_id)?; + let module = Module::from_module_id(db, loc.source_root_id, loc.module_id)?; Def::Module(module) } DefKind::Function => { @@ -175,12 +177,12 @@ impl DefId { /// For a module, returns that module; for any other def, returns the containing module. pub fn module(self, db: &impl HirDatabase) -> Cancelable { let loc = self.loc(db); - Module::new(db, loc.source_root_id, loc.module_id) + Module::from_module_id(db, loc.source_root_id, loc.module_id) } /// Returns the containing crate. pub fn krate(&self, db: &impl HirDatabase) -> Cancelable> { - Ok(self.module(db)?.krate(db)) + Ok(self.module(db)?.krate(db)?) } /// Returns the containing impl block, if this is an impl item. diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 01afa84c4964..891c93434ea7 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -7,12 +7,14 @@ use ra_db::{LocationIntener, Cancelable, SourceRootId}; use crate::{ DefId, DefLoc, DefKind, SourceItemId, SourceFileItems, - Module, Function, + Function, db::HirDatabase, type_ref::TypeRef, module::{ModuleSourceNode, ModuleId}, }; +use crate::code_model_api::Module; + #[derive(Debug, Clone, PartialEq, Eq)] pub struct ImplBlock { module_impl_blocks: Arc, @@ -64,7 +66,7 @@ impl ImplData { ) -> Self { let target_trait = node.target_type().map(TypeRef::from_ast); let target_type = TypeRef::from_ast_opt(node.target_type()); - let file_id = module.source().file_id(); + let module_loc = module.def_id.loc(db); let items = if let Some(item_list) = node.item_list() { item_list .impl_items() @@ -75,14 +77,14 @@ impl ImplData { ast::ImplItem::TypeDef(..) => DefKind::Item, }; let item_id = file_items.id_of_unchecked(item_node.syntax()); + let source_item_id = SourceItemId { + file_id: module_loc.source_item_id.file_id, + item_id: Some(item_id), + }; let def_loc = DefLoc { kind, - source_root_id: module.source_root_id, - module_id: module.module_id, - source_item_id: SourceItemId { - file_id, - item_id: Some(item_id), - }, + source_item_id, + ..module_loc }; let def_id = def_loc.id(db); match item_node { @@ -148,13 +150,13 @@ impl ModuleImplBlocks { } fn collect(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> { - let module_source_node = module.source().resolve(db); + let module_source_node = module.source(db)?.resolve(db); let node = match &module_source_node { ModuleSourceNode::SourceFile(node) => node.borrowed().syntax(), ModuleSourceNode::Module(node) => node.borrowed().syntax(), }; - let source_file_items = db.file_items(module.source().file_id()); + let source_file_items = db.file_items(module.source(db)?.file_id()); for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) { let impl_block = ImplData::from_ast(db, &source_file_items, &module, impl_block_ast); @@ -174,7 +176,7 @@ pub(crate) fn impls_in_module( module_id: ModuleId, ) -> Cancelable> { let mut result = ModuleImplBlocks::new(); - let module = Module::new(db, source_root_id, module_id)?; + let module = Module::from_module_id(db, source_root_id, module_id)?; result.collect(db, module)?; Ok(Arc::new(result)) } diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 0fe80deb59a9..2fa357fecff6 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -56,6 +56,8 @@ pub use self::{ pub use self::function::FnSignatureInfo; +pub use self::code_model_api::Module; + pub enum Def { Module(Module), Function(Function), diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs index 11e3f6782c35..d1005eab6e31 100644 --- a/crates/ra_hir/src/module.rs +++ b/crates/ra_hir/src/module.rs @@ -1,7 +1,6 @@ pub(super) mod imp; pub(super) mod nameres; -use std::sync::Arc; use log; use ra_syntax::{ @@ -10,184 +9,15 @@ use ra_syntax::{ SyntaxNode, }; use ra_arena::{Arena, RawId, impl_arena_id}; -use ra_db::{SourceRootId, FileId, Cancelable}; use relative_path::RelativePathBuf; use crate::{ - Def, DefKind, DefLoc, DefId, - Name, Path, PathKind, HirDatabase, SourceItemId, SourceFileItemId, Crate, + Name, HirDatabase, SourceItemId, SourceFileItemId, HirFileId, }; pub use self::nameres::{ModuleScope, Resolution, Namespace, PerNs}; -/// `Module` is API entry point to get all the information -/// about a particular module. -#[derive(Debug, Clone)] -pub struct Module { - tree: Arc, - pub(crate) source_root_id: SourceRootId, - pub(crate) module_id: ModuleId, -} - -impl Module { - pub(super) fn new( - db: &impl HirDatabase, - source_root_id: SourceRootId, - module_id: ModuleId, - ) -> Cancelable { - let module_tree = db.module_tree(source_root_id)?; - let res = Module { - tree: module_tree, - source_root_id, - module_id, - }; - Ok(res) - } - - /// Returns `mod foo;` or `mod foo {}` node whihc declared this module. - /// Returns `None` for the root module - pub fn parent_link_source(&self, db: &impl HirDatabase) -> Option<(FileId, ast::ModuleNode)> { - let link = self.module_id.parent_link(&self.tree)?; - let file_id = link - .owner(&self.tree) - .source(&self.tree) - .file_id() - .as_original_file(); - let src = link.bind_source(&self.tree, db); - Some((file_id, src)) - } - - pub fn file_id(&self) -> FileId { - self.source().file_id().as_original_file() - } - - /// Parent module. Returns `None` if this is a root module. - pub fn parent(&self) -> Option { - let parent_id = self.module_id.parent(&self.tree)?; - Some(Module { - module_id: parent_id, - ..self.clone() - }) - } - - /// Returns an iterator of all children of this module. - pub fn children<'a>(&'a self) -> impl Iterator + 'a { - self.module_id - .children(&self.tree) - .map(move |(name, module_id)| { - ( - name, - Module { - module_id, - ..self.clone() - }, - ) - }) - } - - /// Returns the crate this module is part of. - pub fn krate(&self, db: &impl HirDatabase) -> Option { - let root_id = self.module_id.crate_root(&self.tree); - let file_id = root_id.source(&self.tree).file_id().as_original_file(); - let crate_graph = db.crate_graph(); - let crate_id = crate_graph.crate_id_for_crate_root(file_id)?; - Some(Crate::new(crate_id)) - } - - /// Returns the all modules on the way to the root. - pub fn path_to_root(&self) -> Vec { - generate(Some(self.clone()), move |it| it.parent()).collect::>() - } - - /// The root of the tree this module is part of - pub fn crate_root(&self) -> Module { - let root_id = self.module_id.crate_root(&self.tree); - Module { - module_id: root_id, - ..self.clone() - } - } - - /// `name` is `None` for the crate's root module - pub fn name(&self) -> Option<&Name> { - let link = self.module_id.parent_link(&self.tree)?; - Some(link.name(&self.tree)) - } - - pub fn def_id(&self, db: &impl HirDatabase) -> DefId { - let def_loc = DefLoc { - kind: DefKind::Module, - source_root_id: self.source_root_id, - module_id: self.module_id, - source_item_id: self.module_id.source(&self.tree).0, - }; - def_loc.id(db) - } - - /// Finds a child module with the specified name. - pub fn child(&self, name: &Name) -> Option { - let child_id = self.module_id.child(&self.tree, name)?; - Some(Module { - module_id: child_id, - ..self.clone() - }) - } - - /// Returns a `ModuleScope`: a set of items, visible in this module. - pub fn scope(&self, db: &impl HirDatabase) -> Cancelable { - let item_map = db.item_map(self.source_root_id)?; - let res = item_map.per_module[&self.module_id].clone(); - Ok(res) - } - - pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable> { - let mut curr_per_ns = PerNs::types( - match path.kind { - PathKind::Crate => self.crate_root(), - PathKind::Self_ | PathKind::Plain => self.clone(), - PathKind::Super => { - if let Some(p) = self.parent() { - p - } else { - return Ok(PerNs::none()); - } - } - } - .def_id(db), - ); - - let segments = &path.segments; - for name in segments.iter() { - let curr = if let Some(r) = curr_per_ns.as_ref().take(Namespace::Types) { - r - } else { - return Ok(PerNs::none()); - }; - let module = match curr.resolve(db)? { - Def::Module(it) => it, - // TODO here would be the place to handle enum variants... - _ => return Ok(PerNs::none()), - }; - let scope = module.scope(db)?; - curr_per_ns = if let Some(r) = scope.get(&name) { - r.def_id - } else { - return Ok(PerNs::none()); - }; - } - Ok(curr_per_ns) - } - - pub fn problems(&self, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> { - self.module_id.problems(&self.tree, db) - } - - pub(crate) fn source(&self) -> ModuleSource { - self.module_id.source(&self.tree) - } -} - #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ModuleId(RawId); impl_arena_id!(ModuleId); diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/module/nameres.rs index dac524384afe..7d5e86c89b99 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/module/nameres.rs @@ -31,7 +31,7 @@ use crate::{ Path, PathKind, HirDatabase, Crate, Name, AsName, - module::{Module, ModuleId, ModuleTree}, + module::{ModuleId, ModuleTree}, }; /// Item map is the result of the name resolution. Item map contains, for each @@ -466,7 +466,7 @@ where if source_root_id == self.source_root { target_module_id } else { - let module = Module::new(self.db, source_root_id, target_module_id)?; + let module = crate::code_model_api::Module::new(type_def_id); let path = Path { segments: import.path.segments[i + 1..].iter().cloned().collect(), kind: PathKind::Crate, From a7f4f7bfcc524a55ba559e0141a70aa799a8686d Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 15:58:45 +0300 Subject: [PATCH 09/15] split module source into decl/defin --- crates/ra_analysis/src/lib.rs | 2 +- crates/ra_analysis/src/runnables.rs | 6 ++-- crates/ra_hir/src/code_model_api.rs | 40 +++++++++++++++++++--- crates/ra_hir/src/code_model_impl.rs | 51 +++++++++++++++++++++++++--- crates/ra_hir/src/impl_block.rs | 14 ++++---- crates/ra_hir/src/module.rs | 25 ++++++++------ 6 files changed, 106 insertions(+), 32 deletions(-) diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs index 390c31c3fa0d..77f77e9a8c94 100644 --- a/crates/ra_analysis/src/lib.rs +++ b/crates/ra_analysis/src/lib.rs @@ -397,7 +397,7 @@ impl Analysis { } /// Returns the root file of the given crate. pub fn crate_root(&self, crate_id: CrateId) -> Cancelable { - Ok(self.db.crate_root(crate_id)) + Ok(self.db.crate_graph().crate_root(crate_id)) } /// Returns the set of possible targets to run for the current file. pub fn runnables(&self, file_id: FileId) -> Cancelable> { diff --git a/crates/ra_analysis/src/runnables.rs b/crates/ra_analysis/src/runnables.rs index 4742676059c0..f24aa514a526 100644 --- a/crates/ra_analysis/src/runnables.rs +++ b/crates/ra_analysis/src/runnables.rs @@ -73,11 +73,11 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax()).ok()??; let path = module - .path_to_root() + .path_to_root(db) + .ok()? .into_iter() .rev() - .into_iter() - .filter_map(|it| it.name().map(Clone::clone)) + .filter_map(|it| it.name(db).map(Clone::clone)) .join("::"); Some(Runnable { range, diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index eca7d0225627..0c7f743d4441 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,6 +1,7 @@ -use ra_db::{CrateId, Cancelable}; +use ra_db::{CrateId, Cancelable, FileId}; +use ra_syntax::{ast, SyntaxNode}; -use crate::{Name, db::HirDatabase, DefId, Path, PerNs, module::{ModuleSource, ModuleScope}}; +use crate::{Name, db::HirDatabase, DefId, Path, PerNs, module::{Problem, ModuleScope}}; /// hir::Crate describes a single crate. It's the main inteface with which /// crate's dependencies interact. Mostly, it should be just a proxy for the @@ -33,10 +34,27 @@ pub struct Module { pub(crate) def_id: DefId, } +/// An owned syntax node for a module. Unlike `ModuleSource`, +/// this holds onto the AST for the whole file. +pub enum ModuleSource { + SourceFile(ast::SourceFileNode), + Module(ast::ModuleNode), +} + impl Module { - // FIXME: what is a module source exactly? It should contain two nodes - pub fn source(&self, db: &impl HirDatabase) -> Cancelable { - Ok(self.source_impl(db)) + pub fn name(&self, db: &impl HirDatabase) -> Cancelable> { + self.name_impl(db) + } + + pub fn defenition_source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, ModuleSource)> { + self.defenition_source_impl(db) + } + + pub fn declaration_source( + &self, + db: &impl HirDatabase, + ) -> Cancelable> { + self.declaration_source_impl(db) } /// Returns the crate this module is part of. @@ -56,6 +74,15 @@ impl Module { pub fn parent(&self, db: &impl HirDatabase) -> Cancelable> { self.parent_impl(db) } + pub fn path_to_root(&self, db: &impl HirDatabase) -> Cancelable> { + let mut res = vec![self.clone()]; + let mut curr = self.clone(); + while let Some(next) = curr.parent(db)? { + res.push(next.clone()); + curr = next + } + Ok(res) + } /// Returns a `ModuleScope`: a set of items, visible in this module. pub fn scope(&self, db: &impl HirDatabase) -> Cancelable { self.scope_impl(db) @@ -63,4 +90,7 @@ impl Module { pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable> { self.resolve_path_impl(db, path) } + pub fn problems(&self, db: &impl HirDatabase) -> Cancelable> { + self.problems_impl(db) + } } diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 7f5669c8f1a2..4f4b506dd9c1 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,12 +1,13 @@ -use ra_db::{CrateId, Cancelable, SourceRootId}; +use ra_db::{CrateId, Cancelable, SourceRootId, FileId}; +use ra_syntax::{ast, SyntaxNode, AstNode}; use crate::{ HirFileId, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def, ModuleId, - module::{ModuleSource, ModuleScope}, + module::{ModuleScope, Problem}, db::HirDatabase, }; -use crate::code_model_api::Module; +use crate::code_model_api::{Module, ModuleSource}; impl Crate { pub(crate) fn new(crate_id: CrateId) -> Crate { @@ -68,9 +69,44 @@ impl Module { Ok(module) } - pub(crate) fn source_impl(&self, db: &impl HirDatabase) -> ModuleSource { + pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable> { let loc = self.def_id.loc(db); - ModuleSource(loc.source_item_id) + let module_tree = db.module_tree(loc.source_root_id)?; + let link = ctry!(loc.module_id.parent_link(&module_tree)); + Ok(Some(link.name(&module_tree).clone())) + } + + pub fn defenition_source_impl( + &self, + db: &impl HirDatabase, + ) -> Cancelable<(FileId, ModuleSource)> { + let loc = self.def_id.loc(db); + let file_id = loc.source_item_id.file_id.as_original_file(); + let syntax_node = db.file_item(loc.source_item_id); + let syntax_node = syntax_node.borrowed(); + let module_source = if let Some(source_file) = ast::SourceFile::cast(syntax_node) { + ModuleSource::SourceFile(source_file.owned()) + } else { + let module = ast::Module::cast(syntax_node).unwrap(); + ModuleSource::Module(module.owned()) + }; + Ok((file_id, module_source)) + } + + pub fn declaration_source_impl( + &self, + db: &impl HirDatabase, + ) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let link = ctry!(loc.module_id.parent_link(&module_tree)); + let file_id = link + .owner(&module_tree) + .source(&module_tree) + .file_id() + .as_original_file(); + let src = link.bind_source(&module_tree, db); + Ok(Some((file_id, src))) } pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { @@ -150,4 +186,9 @@ impl Module { } Ok(curr_per_ns) } + pub fn problems_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + Ok(loc.module_id.problems(&module_tree, db)) + } } diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 891c93434ea7..0d1b94c42579 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -10,10 +10,10 @@ use crate::{ Function, db::HirDatabase, type_ref::TypeRef, - module::{ModuleSourceNode, ModuleId}, + module::ModuleId, }; -use crate::code_model_api::Module; +use crate::code_model_api::{Module, ModuleSource}; #[derive(Debug, Clone, PartialEq, Eq)] pub struct ImplBlock { @@ -150,13 +150,13 @@ impl ModuleImplBlocks { } fn collect(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> { - let module_source_node = module.source(db)?.resolve(db); - let node = match &module_source_node { - ModuleSourceNode::SourceFile(node) => node.borrowed().syntax(), - ModuleSourceNode::Module(node) => node.borrowed().syntax(), + let (file_id, module_source) = module.defenition_source(db)?; + let node = match &module_source { + ModuleSource::SourceFile(node) => node.borrowed().syntax(), + ModuleSource::Module(node) => node.borrowed().syntax(), }; - let source_file_items = db.file_items(module.source(db)?.file_id()); + let source_file_items = db.file_items(file_id.into()); for impl_block_ast in node.children().filter_map(ast::ImplBlock::cast) { let impl_block = ImplData::from_ast(db, &source_file_items, &module, impl_block_ast); diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module.rs index d1005eab6e31..ebaf5f47a52b 100644 --- a/crates/ra_hir/src/module.rs +++ b/crates/ra_hir/src/module.rs @@ -1,8 +1,6 @@ pub(super) mod imp; pub(super) mod nameres; -use log; - use ra_syntax::{ algo::generate, ast::{self, AstNode, NameOwner}, @@ -11,10 +9,7 @@ use ra_syntax::{ use ra_arena::{Arena, RawId, impl_arena_id}; use relative_path::RelativePathBuf; -use crate::{ - Name, HirDatabase, SourceItemId, SourceFileItemId, - HirFileId, -}; +use crate::{Name, HirDatabase, SourceItemId, SourceFileItemId, HirFileId}; pub use self::nameres::{ModuleScope, Resolution, Namespace, PerNs}; @@ -78,7 +73,7 @@ impl ModuleId { pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource { tree.mods[self].source } - fn parent_link(self, tree: &ModuleTree) -> Option { + pub(crate) fn parent_link(self, tree: &ModuleTree) -> Option { tree.mods[self].parent } pub(crate) fn parent(self, tree: &ModuleTree) -> Option { @@ -105,7 +100,11 @@ impl ModuleId { Some((link.name.clone(), module)) }) } - fn problems(self, tree: &ModuleTree, db: &impl HirDatabase) -> Vec<(SyntaxNode, Problem)> { + pub(crate) fn problems( + self, + tree: &ModuleTree, + db: &impl HirDatabase, + ) -> Vec<(SyntaxNode, Problem)> { tree.mods[self] .children .iter() @@ -120,13 +119,17 @@ impl ModuleId { } impl LinkId { - fn owner(self, tree: &ModuleTree) -> ModuleId { + pub(crate) fn owner(self, tree: &ModuleTree) -> ModuleId { tree.links[self].owner } - fn name(self, tree: &ModuleTree) -> &Name { + pub(crate) fn name(self, tree: &ModuleTree) -> &Name { &tree.links[self].name } - fn bind_source<'a>(self, tree: &ModuleTree, db: &impl HirDatabase) -> ast::ModuleNode { + pub(crate) fn bind_source<'a>( + self, + tree: &ModuleTree, + db: &impl HirDatabase, + ) -> ast::ModuleNode { let owner = self.owner(tree); match owner.source(tree).resolve(db) { ModuleSourceNode::SourceFile(root) => { From c303e6fbdfd8d04b645796489766e912d2cb3009 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 16:05:59 +0300 Subject: [PATCH 10/15] fix ra_analysis to work with the new API --- crates/ra_analysis/src/completion/complete_scope.rs | 5 ++++- crates/ra_analysis/src/goto_defenition.rs | 4 ++-- crates/ra_analysis/src/imp.rs | 5 ++--- crates/ra_analysis/src/runnables.rs | 5 ++++- 4 files changed, 12 insertions(+), 7 deletions(-) diff --git a/crates/ra_analysis/src/completion/complete_scope.rs b/crates/ra_analysis/src/completion/complete_scope.rs index 21d77aa97801..ee9052d3d5d5 100644 --- a/crates/ra_analysis/src/completion/complete_scope.rs +++ b/crates/ra_analysis/src/completion/complete_scope.rs @@ -20,14 +20,17 @@ pub(super) fn complete_scope(acc: &mut Completions, ctx: &CompletionContext) -> } let module_scope = module.scope(ctx.db)?; + let (file_id, _) = module.defenition_source(ctx.db)?; module_scope .entries() .filter(|(_name, res)| { // Don't expose this item + // FIXME: this penetrates through all kinds of abstractions, + // we need to figura out the way to do it less ugly. match res.import { None => true, Some(import) => { - let range = import.range(ctx.db, module.file_id()); + let range = import.range(ctx.db, file_id); !range.is_subrange(&ctx.leaf.range()) } } diff --git a/crates/ra_analysis/src/goto_defenition.rs b/crates/ra_analysis/src/goto_defenition.rs index 68b6ac3ba493..aa0616e3b3b6 100644 --- a/crates/ra_analysis/src/goto_defenition.rs +++ b/crates/ra_analysis/src/goto_defenition.rs @@ -60,8 +60,8 @@ fn name_defenition( if let Some(child_module) = hir::source_binder::module_from_declaration(db, file_id, module)? { - let file_id = child_module.file_id(); - let name = match child_module.name() { + let (file_id, _) = child_module.defenition_source(db)?; + let name = match child_module.name(db)? { Some(name) => name.to_string().into(), None => "".into(), }; diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs index 44e7aca44f26..07a966290524 100644 --- a/crates/ra_analysis/src/imp.rs +++ b/crates/ra_analysis/src/imp.rs @@ -109,8 +109,7 @@ impl db::RootDatabase { None => return Ok(Vec::new()), Some(it) => it, }; - let (file_id, ast_module) = module.source(self); - let ast_module = match ast_module { + let (file_id, ast_module) = match module.declaration_source(self)? { None => return Ok(Vec::new()), Some(it) => it, }; @@ -206,7 +205,7 @@ impl db::RootDatabase { }) .collect::>(); if let Some(m) = source_binder::module_from_file_id(self, file_id)? { - for (name_node, problem) in m.problems(self) { + for (name_node, problem) in m.problems(self)? { let source_root = self.file_source_root(file_id); let diag = match problem { Problem::UnresolvedModule { candidate } => { diff --git a/crates/ra_analysis/src/runnables.rs b/crates/ra_analysis/src/runnables.rs index f24aa514a526..216209098d3b 100644 --- a/crates/ra_analysis/src/runnables.rs +++ b/crates/ra_analysis/src/runnables.rs @@ -72,12 +72,15 @@ fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Opti let range = module.syntax().range(); let module = hir::source_binder::module_from_child_node(db, file_id, module.syntax()).ok()??; + + // FIXME: thread cancellation instead of `.ok`ing let path = module .path_to_root(db) .ok()? .into_iter() .rev() - .filter_map(|it| it.name(db).map(Clone::clone)) + .filter_map(|it| it.name(db).ok()) + .filter_map(|it| it) .join("::"); Some(Runnable { range, From 5a505189a8f7ed274893a45aed0d0249083d1277 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 16:10:25 +0300 Subject: [PATCH 11/15] adjust comments --- crates/ra_analysis/tests/test/main.rs | 1 + crates/ra_hir/src/code_model_api.rs | 12 +++++++----- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/crates/ra_analysis/tests/test/main.rs b/crates/ra_analysis/tests/test/main.rs index 26da7c10c96e..85911de921bd 100644 --- a/crates/ra_analysis/tests/test/main.rs +++ b/crates/ra_analysis/tests/test/main.rs @@ -31,6 +31,7 @@ fn test_unresolved_module_diagnostic() { ); } +// FIXME: move this test to hir #[test] fn test_unresolved_module_diagnostic_no_diag_for_inline_mode() { let (analysis, file_id) = single_file("mod foo {}"); diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index 0c7f743d4441..d00d3246f09e 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -34,22 +34,23 @@ pub struct Module { pub(crate) def_id: DefId, } -/// An owned syntax node for a module. Unlike `ModuleSource`, -/// this holds onto the AST for the whole file. pub enum ModuleSource { SourceFile(ast::SourceFileNode), Module(ast::ModuleNode), } impl Module { + /// Name of this module. pub fn name(&self, db: &impl HirDatabase) -> Cancelable> { self.name_impl(db) } + /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items. pub fn defenition_source(&self, db: &impl HirDatabase) -> Cancelable<(FileId, ModuleSource)> { self.defenition_source_impl(db) } - + /// Returns a node which declares this module, either a `mod foo;` or a `mod foo {}`. + /// `None` for the crate root. pub fn declaration_source( &self, db: &impl HirDatabase, @@ -61,11 +62,12 @@ impl Module { pub fn krate(&self, db: &impl HirDatabase) -> Cancelable> { self.krate_impl(db) } - + /// Topmost parent of this module. Every module has a `crate_root`, but some + /// might miss `krate`. This can happen if a module's file is not included + /// into any module tree of any target from Cargo.toml. pub fn crate_root(&self, db: &impl HirDatabase) -> Cancelable { self.crate_root_impl(db) } - /// Finds a child module with the specified name. pub fn child(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { self.child_impl(db, name) From fd4456d0ec88e3433a7a8be6f27d8af9afedefe5 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 17:33:27 +0300 Subject: [PATCH 12/15] flatten module structure --- crates/ra_hir/src/code_model_api.rs | 14 +- crates/ra_hir/src/code_model_impl.rs | 196 +-------------- crates/ra_hir/src/code_model_impl/krate.rs | 45 ++++ crates/ra_hir/src/code_model_impl/module.rs | 154 ++++++++++++ crates/ra_hir/src/db.rs | 8 +- crates/ra_hir/src/impl_block.rs | 2 +- crates/ra_hir/src/lib.rs | 11 +- crates/ra_hir/src/module/imp.rs | 190 -------------- .../ra_hir/src/{module.rs => module_tree.rs} | 232 +++++++++++++++--- crates/ra_hir/src/{module => }/nameres.rs | 2 +- .../ra_hir/src/{module => }/nameres/tests.rs | 4 +- crates/ra_hir/src/query_definitions.rs | 7 +- crates/ra_hir/src/source_binder.rs | 2 +- 13 files changed, 431 insertions(+), 436 deletions(-) create mode 100644 crates/ra_hir/src/code_model_impl/krate.rs create mode 100644 crates/ra_hir/src/code_model_impl/module.rs delete mode 100644 crates/ra_hir/src/module/imp.rs rename crates/ra_hir/src/{module.rs => module_tree.rs} (50%) rename crates/ra_hir/src/{module => }/nameres.rs (99%) rename crates/ra_hir/src/{module => }/nameres/tests.rs (98%) diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs index d00d3246f09e..09b532f74647 100644 --- a/crates/ra_hir/src/code_model_api.rs +++ b/crates/ra_hir/src/code_model_api.rs @@ -1,7 +1,8 @@ +use relative_path::RelativePathBuf; use ra_db::{CrateId, Cancelable, FileId}; use ra_syntax::{ast, SyntaxNode}; -use crate::{Name, db::HirDatabase, DefId, Path, PerNs, module::{Problem, ModuleScope}}; +use crate::{Name, db::HirDatabase, DefId, Path, PerNs, nameres::ModuleScope}; /// hir::Crate describes a single crate. It's the main inteface with which /// crate's dependencies interact. Mostly, it should be just a proxy for the @@ -39,6 +40,17 @@ pub enum ModuleSource { Module(ast::ModuleNode), } +#[derive(Clone, Debug, Hash, PartialEq, Eq)] +pub enum Problem { + UnresolvedModule { + candidate: RelativePathBuf, + }, + NotDirOwner { + move_to: RelativePathBuf, + candidate: RelativePathBuf, + }, +} + impl Module { /// Name of this module. pub fn name(&self, db: &impl HirDatabase) -> Cancelable> { diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index 4f4b506dd9c1..d602a439df6b 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,194 +1,2 @@ -use ra_db::{CrateId, Cancelable, SourceRootId, FileId}; -use ra_syntax::{ast, SyntaxNode, AstNode}; - -use crate::{ - HirFileId, Crate, CrateDependency, AsName, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def, ModuleId, - module::{ModuleScope, Problem}, - db::HirDatabase, -}; - -use crate::code_model_api::{Module, ModuleSource}; - -impl Crate { - pub(crate) fn new(crate_id: CrateId) -> Crate { - Crate { crate_id } - } - pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec { - let crate_graph = db.crate_graph(); - crate_graph - .dependencies(self.crate_id) - .map(|dep| { - let krate = Crate::new(dep.crate_id()); - let name = dep.as_name(); - CrateDependency { krate, name } - }) - .collect() - } - pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Cancelable> { - let crate_graph = db.crate_graph(); - let file_id = crate_graph.crate_root(self.crate_id); - let source_root_id = db.file_source_root(file_id); - let file_id = HirFileId::from(file_id); - let module_tree = db.module_tree(source_root_id)?; - // FIXME: teach module tree about crate roots instead of guessing - let (module_id, _) = ctry!(module_tree - .modules_with_sources() - .find(|(_, src)| src.file_id() == file_id)); - - let def_loc = DefLoc { - kind: DefKind::Module, - source_root_id, - module_id, - source_item_id: module_id.source(&module_tree).0, - }; - let def_id = def_loc.id(db); - - let module = Module::new(def_id); - Ok(Some(module)) - } -} - -impl Module { - pub(crate) fn new(def_id: DefId) -> Self { - crate::code_model_api::Module { def_id } - } - pub(crate) fn from_module_id( - db: &impl HirDatabase, - source_root_id: SourceRootId, - module_id: ModuleId, - ) -> Cancelable { - let module_tree = db.module_tree(source_root_id)?; - let def_loc = DefLoc { - kind: DefKind::Module, - source_root_id, - module_id, - source_item_id: module_id.source(&module_tree).0, - }; - let def_id = def_loc.id(db); - let module = Module::new(def_id); - Ok(module) - } - - pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable> { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - let link = ctry!(loc.module_id.parent_link(&module_tree)); - Ok(Some(link.name(&module_tree).clone())) - } - - pub fn defenition_source_impl( - &self, - db: &impl HirDatabase, - ) -> Cancelable<(FileId, ModuleSource)> { - let loc = self.def_id.loc(db); - let file_id = loc.source_item_id.file_id.as_original_file(); - let syntax_node = db.file_item(loc.source_item_id); - let syntax_node = syntax_node.borrowed(); - let module_source = if let Some(source_file) = ast::SourceFile::cast(syntax_node) { - ModuleSource::SourceFile(source_file.owned()) - } else { - let module = ast::Module::cast(syntax_node).unwrap(); - ModuleSource::Module(module.owned()) - }; - Ok((file_id, module_source)) - } - - pub fn declaration_source_impl( - &self, - db: &impl HirDatabase, - ) -> Cancelable> { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - let link = ctry!(loc.module_id.parent_link(&module_tree)); - let file_id = link - .owner(&module_tree) - .source(&module_tree) - .file_id() - .as_original_file(); - let src = link.bind_source(&module_tree, db); - Ok(Some((file_id, src))) - } - - pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { - let root = self.crate_root(db)?; - let loc = root.def_id.loc(db); - let file_id = loc.source_item_id.file_id.as_original_file(); - - let crate_graph = db.crate_graph(); - let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id)); - Ok(Some(Crate::new(crate_id))) - } - - pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - let module_id = loc.module_id.crate_root(&module_tree); - Module::from_module_id(db, loc.source_root_id, module_id) - } - /// Finds a child module with the specified name. - pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - let child_id = ctry!(loc.module_id.child(&module_tree, name)); - Module::from_module_id(db, loc.source_root_id, child_id).map(Some) - } - pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable> { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - let parent_id = ctry!(loc.module_id.parent(&module_tree)); - Module::from_module_id(db, loc.source_root_id, parent_id).map(Some) - } - /// Returns a `ModuleScope`: a set of items, visible in this module. - pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable { - let loc = self.def_id.loc(db); - let item_map = db.item_map(loc.source_root_id)?; - let res = item_map.per_module[&loc.module_id].clone(); - Ok(res) - } - pub fn resolve_path_impl( - &self, - db: &impl HirDatabase, - path: &Path, - ) -> Cancelable> { - let mut curr_per_ns = PerNs::types( - match path.kind { - PathKind::Crate => self.crate_root(db)?, - PathKind::Self_ | PathKind::Plain => self.clone(), - PathKind::Super => { - if let Some(p) = self.parent(db)? { - p - } else { - return Ok(PerNs::none()); - } - } - } - .def_id, - ); - - let segments = &path.segments; - for name in segments.iter() { - let curr = if let Some(r) = curr_per_ns.as_ref().take_types() { - r - } else { - return Ok(PerNs::none()); - }; - let module = match curr.resolve(db)? { - Def::Module(it) => it, - // TODO here would be the place to handle enum variants... - _ => return Ok(PerNs::none()), - }; - let scope = module.scope(db)?; - curr_per_ns = if let Some(r) = scope.get(&name) { - r.def_id - } else { - return Ok(PerNs::none()); - }; - } - Ok(curr_per_ns) - } - pub fn problems_impl(&self, db: &impl HirDatabase) -> Cancelable> { - let loc = self.def_id.loc(db); - let module_tree = db.module_tree(loc.source_root_id)?; - Ok(loc.module_id.problems(&module_tree, db)) - } -} +mod krate; // `crate` is invalid ident :( +pub(crate) mod module; diff --git a/crates/ra_hir/src/code_model_impl/krate.rs b/crates/ra_hir/src/code_model_impl/krate.rs new file mode 100644 index 000000000000..591a81597da6 --- /dev/null +++ b/crates/ra_hir/src/code_model_impl/krate.rs @@ -0,0 +1,45 @@ +use ra_db::{CrateId, Cancelable}; + +use crate::{ + HirFileId, Crate, CrateDependency, AsName, DefLoc, DefKind, Module, + db::HirDatabase, +}; + +impl Crate { + pub(crate) fn new(crate_id: CrateId) -> Crate { + Crate { crate_id } + } + pub(crate) fn dependencies_impl(&self, db: &impl HirDatabase) -> Vec { + let crate_graph = db.crate_graph(); + crate_graph + .dependencies(self.crate_id) + .map(|dep| { + let krate = Crate::new(dep.crate_id()); + let name = dep.as_name(); + CrateDependency { krate, name } + }) + .collect() + } + pub(crate) fn root_module_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let crate_graph = db.crate_graph(); + let file_id = crate_graph.crate_root(self.crate_id); + let source_root_id = db.file_source_root(file_id); + let file_id = HirFileId::from(file_id); + let module_tree = db.module_tree(source_root_id)?; + // FIXME: teach module tree about crate roots instead of guessing + let (module_id, _) = ctry!(module_tree + .modules_with_sources() + .find(|(_, src)| src.file_id() == file_id)); + + let def_loc = DefLoc { + kind: DefKind::Module, + source_root_id, + module_id, + source_item_id: module_id.source(&module_tree).0, + }; + let def_id = def_loc.id(db); + + let module = Module::new(def_id); + Ok(Some(module)) + } +} diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs new file mode 100644 index 000000000000..02078f188dcc --- /dev/null +++ b/crates/ra_hir/src/code_model_impl/module.rs @@ -0,0 +1,154 @@ +use ra_db::{Cancelable, SourceRootId, FileId}; +use ra_syntax::{ast, SyntaxNode, AstNode}; + +use crate::{ + Module, ModuleSource, Problem, + Crate, DefId, DefLoc, DefKind, Name, Path, PathKind, PerNs, Def, ModuleId, + nameres::ModuleScope, + db::HirDatabase, +}; + +impl Module { + pub(crate) fn new(def_id: DefId) -> Self { + crate::code_model_api::Module { def_id } + } + pub(crate) fn from_module_id( + db: &impl HirDatabase, + source_root_id: SourceRootId, + module_id: ModuleId, + ) -> Cancelable { + let module_tree = db.module_tree(source_root_id)?; + let def_loc = DefLoc { + kind: DefKind::Module, + source_root_id, + module_id, + source_item_id: module_id.source(&module_tree).0, + }; + let def_id = def_loc.id(db); + let module = Module::new(def_id); + Ok(module) + } + + pub(crate) fn name_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let link = ctry!(loc.module_id.parent_link(&module_tree)); + Ok(Some(link.name(&module_tree).clone())) + } + + pub fn defenition_source_impl( + &self, + db: &impl HirDatabase, + ) -> Cancelable<(FileId, ModuleSource)> { + let loc = self.def_id.loc(db); + let file_id = loc.source_item_id.file_id.as_original_file(); + let syntax_node = db.file_item(loc.source_item_id); + let syntax_node = syntax_node.borrowed(); + let module_source = if let Some(source_file) = ast::SourceFile::cast(syntax_node) { + ModuleSource::SourceFile(source_file.owned()) + } else { + let module = ast::Module::cast(syntax_node).unwrap(); + ModuleSource::Module(module.owned()) + }; + Ok((file_id, module_source)) + } + + pub fn declaration_source_impl( + &self, + db: &impl HirDatabase, + ) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let link = ctry!(loc.module_id.parent_link(&module_tree)); + let file_id = link + .owner(&module_tree) + .source(&module_tree) + .file_id() + .as_original_file(); + let src = link.bind_source(&module_tree, db); + Ok(Some((file_id, src))) + } + + pub(crate) fn krate_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let root = self.crate_root(db)?; + let loc = root.def_id.loc(db); + let file_id = loc.source_item_id.file_id.as_original_file(); + + let crate_graph = db.crate_graph(); + let crate_id = ctry!(crate_graph.crate_id_for_crate_root(file_id)); + Ok(Some(Crate::new(crate_id))) + } + + pub(crate) fn crate_root_impl(&self, db: &impl HirDatabase) -> Cancelable { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let module_id = loc.module_id.crate_root(&module_tree); + Module::from_module_id(db, loc.source_root_id, module_id) + } + /// Finds a child module with the specified name. + pub fn child_impl(&self, db: &impl HirDatabase, name: &Name) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let child_id = ctry!(loc.module_id.child(&module_tree, name)); + Module::from_module_id(db, loc.source_root_id, child_id).map(Some) + } + pub fn parent_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + let parent_id = ctry!(loc.module_id.parent(&module_tree)); + Module::from_module_id(db, loc.source_root_id, parent_id).map(Some) + } + /// Returns a `ModuleScope`: a set of items, visible in this module. + pub fn scope_impl(&self, db: &impl HirDatabase) -> Cancelable { + let loc = self.def_id.loc(db); + let item_map = db.item_map(loc.source_root_id)?; + let res = item_map.per_module[&loc.module_id].clone(); + Ok(res) + } + pub fn resolve_path_impl( + &self, + db: &impl HirDatabase, + path: &Path, + ) -> Cancelable> { + let mut curr_per_ns = PerNs::types( + match path.kind { + PathKind::Crate => self.crate_root(db)?, + PathKind::Self_ | PathKind::Plain => self.clone(), + PathKind::Super => { + if let Some(p) = self.parent(db)? { + p + } else { + return Ok(PerNs::none()); + } + } + } + .def_id, + ); + + let segments = &path.segments; + for name in segments.iter() { + let curr = if let Some(r) = curr_per_ns.as_ref().take_types() { + r + } else { + return Ok(PerNs::none()); + }; + let module = match curr.resolve(db)? { + Def::Module(it) => it, + // TODO here would be the place to handle enum variants... + _ => return Ok(PerNs::none()), + }; + let scope = module.scope(db)?; + curr_per_ns = if let Some(r) = scope.get(&name) { + r.def_id + } else { + return Ok(PerNs::none()); + }; + } + Ok(curr_per_ns) + } + pub fn problems_impl(&self, db: &impl HirDatabase) -> Cancelable> { + let loc = self.def_id.loc(db); + let module_tree = db.module_tree(loc.source_root_id)?; + Ok(loc.module_id.problems(&module_tree, db)) + } +} diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 96a3c60b9e85..2702961ba751 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -9,8 +9,8 @@ use crate::{ query_definitions, FnSignature, FnScopes, macros::MacroExpansion, - module::{ModuleId, ModuleTree, ModuleSource, - nameres::{ItemMap, InputModuleItems}}, + module_tree::{ModuleId, ModuleTree, ModuleSource}, + nameres::{ItemMap, InputModuleItems}, ty::{InferenceResult, Ty}, adt::{StructData, EnumData}, impl_block::ModuleImplBlocks, @@ -71,7 +71,7 @@ pub trait HirDatabase: SyntaxDatabase use fn query_definitions::file_item; } - fn submodules(source: ModuleSource) -> Cancelable>> { + fn submodules(source: ModuleSource) -> Cancelable>> { type SubmodulesQuery; use fn query_definitions::submodules; } @@ -86,7 +86,7 @@ pub trait HirDatabase: SyntaxDatabase } fn module_tree(source_root_id: SourceRootId) -> Cancelable> { type ModuleTreeQuery; - use fn crate::module::imp::module_tree; + use fn crate::module_tree::ModuleTree::module_tree_query; } fn impls_in_module(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable> { diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 0d1b94c42579..7ce8d17e6642 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -10,7 +10,7 @@ use crate::{ Function, db::HirDatabase, type_ref::TypeRef, - module::ModuleId, + module_tree::ModuleId, }; use crate::code_model_api::{Module, ModuleSource}; diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 2fa357fecff6..7e74f2eaf818 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -24,7 +24,8 @@ pub mod source_binder; mod ids; mod macros; mod name; -mod module; +mod module_tree; +mod nameres; mod function; mod adt; mod type_ref; @@ -32,14 +33,13 @@ mod ty; mod impl_block; mod expr; -pub mod code_model_api; +mod code_model_api; mod code_model_impl; use crate::{ db::HirDatabase, name::{AsName, KnownName}, ids::{DefKind, SourceItemId, SourceFileItemId, SourceFileItems}, - code_model_api::{Crate, CrateDependency} }; pub use self::{ @@ -56,7 +56,10 @@ pub use self::{ pub use self::function::FnSignatureInfo; -pub use self::code_model_api::Module; +pub use self::code_model_api::{ + Crate, CrateDependency, + Module, ModuleSource, Problem, +}; pub enum Def { Module(Module), diff --git a/crates/ra_hir/src/module/imp.rs b/crates/ra_hir/src/module/imp.rs deleted file mode 100644 index 3849026dbdd7..000000000000 --- a/crates/ra_hir/src/module/imp.rs +++ /dev/null @@ -1,190 +0,0 @@ -use std::sync::Arc; - -use ra_syntax::ast::{self, NameOwner}; -use relative_path::RelativePathBuf; -use rustc_hash::{FxHashMap, FxHashSet}; -use arrayvec::ArrayVec; -use ra_db::{SourceRoot, SourceRootId, Cancelable, FileId}; - -use crate::{ - HirDatabase, Name, AsName, -}; - -use super::{ - LinkData, LinkId, ModuleData, ModuleId, ModuleSource, - ModuleTree, Problem, -}; - -#[derive(Clone, Hash, PartialEq, Eq, Debug)] -pub enum Submodule { - Declaration(Name), - Definition(Name, ModuleSource), -} - -impl Submodule { - fn name(&self) -> &Name { - match self { - Submodule::Declaration(name) => name, - Submodule::Definition(name, _) => name, - } - } -} - -pub(crate) fn modules<'a>( - root: impl ast::ModuleItemOwner<'a>, -) -> impl Iterator)> { - root.items() - .filter_map(|item| match item { - ast::ModuleItem::Module(m) => Some(m), - _ => None, - }) - .filter_map(|module| { - let name = module.name()?.as_name(); - Some((name, module)) - }) -} - -pub(crate) fn module_tree( - db: &impl HirDatabase, - source_root: SourceRootId, -) -> Cancelable> { - db.check_canceled()?; - let res = create_module_tree(db, source_root)?; - Ok(Arc::new(res)) -} - -fn create_module_tree<'a>( - db: &impl HirDatabase, - source_root: SourceRootId, -) -> Cancelable { - let mut tree = ModuleTree::default(); - - let mut roots = FxHashMap::default(); - let mut visited = FxHashSet::default(); - - let source_root = db.source_root(source_root); - for &file_id in source_root.files.values() { - let source = ModuleSource::new_file(file_id.into()); - if visited.contains(&source) { - continue; // TODO: use explicit crate_roots here - } - assert!(!roots.contains_key(&file_id)); - let module_id = build_subtree( - db, - &source_root, - &mut tree, - &mut visited, - &mut roots, - None, - source, - )?; - roots.insert(file_id, module_id); - } - Ok(tree) -} - -fn build_subtree( - db: &impl HirDatabase, - source_root: &SourceRoot, - tree: &mut ModuleTree, - visited: &mut FxHashSet, - roots: &mut FxHashMap, - parent: Option, - source: ModuleSource, -) -> Cancelable { - visited.insert(source); - let id = tree.push_mod(ModuleData { - source, - parent, - children: Vec::new(), - }); - for sub in db.submodules(source)?.iter() { - let link = tree.push_link(LinkData { - name: sub.name().clone(), - owner: id, - points_to: Vec::new(), - problem: None, - }); - - let (points_to, problem) = match sub { - Submodule::Declaration(name) => { - let (points_to, problem) = resolve_submodule(db, source, &name); - let points_to = points_to - .into_iter() - .map(|file_id| match roots.remove(&file_id) { - Some(module_id) => { - tree.mods[module_id].parent = Some(link); - Ok(module_id) - } - None => build_subtree( - db, - source_root, - tree, - visited, - roots, - Some(link), - ModuleSource::new_file(file_id.into()), - ), - }) - .collect::>>()?; - (points_to, problem) - } - Submodule::Definition(_name, submodule_source) => { - let points_to = build_subtree( - db, - source_root, - tree, - visited, - roots, - Some(link), - *submodule_source, - )?; - (vec![points_to], None) - } - }; - - tree.links[link].points_to = points_to; - tree.links[link].problem = problem; - } - Ok(id) -} - -fn resolve_submodule( - db: &impl HirDatabase, - source: ModuleSource, - name: &Name, -) -> (Vec, Option) { - // FIXME: handle submodules of inline modules properly - let file_id = source.file_id().original_file(db); - let source_root_id = db.file_source_root(file_id); - let path = db.file_relative_path(file_id); - let root = RelativePathBuf::default(); - let dir_path = path.parent().unwrap_or(&root); - let mod_name = path.file_stem().unwrap_or("unknown"); - let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main"; - - let file_mod = dir_path.join(format!("{}.rs", name)); - let dir_mod = dir_path.join(format!("{}/mod.rs", name)); - let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name)); - let mut candidates = ArrayVec::<[_; 2]>::new(); - if is_dir_owner { - candidates.push(file_mod.clone()); - candidates.push(dir_mod); - } else { - candidates.push(file_dir_mod.clone()); - }; - let sr = db.source_root(source_root_id); - let points_to = candidates - .into_iter() - .filter_map(|path| sr.files.get(&path)) - .map(|&it| it) - .collect::>(); - let problem = if points_to.is_empty() { - Some(Problem::UnresolvedModule { - candidate: if is_dir_owner { file_mod } else { file_dir_mod }, - }) - } else { - None - }; - (points_to, problem) -} diff --git a/crates/ra_hir/src/module.rs b/crates/ra_hir/src/module_tree.rs similarity index 50% rename from crates/ra_hir/src/module.rs rename to crates/ra_hir/src/module_tree.rs index ebaf5f47a52b..cd82f25dbe25 100644 --- a/crates/ra_hir/src/module.rs +++ b/crates/ra_hir/src/module_tree.rs @@ -1,17 +1,32 @@ -pub(super) mod imp; -pub(super) mod nameres; +use std::sync::Arc; +use rustc_hash::{FxHashMap, FxHashSet}; +use arrayvec::ArrayVec; +use relative_path::RelativePathBuf; +use ra_db::{FileId, SourceRootId, Cancelable, SourceRoot}; use ra_syntax::{ algo::generate, ast::{self, AstNode, NameOwner}, SyntaxNode, }; use ra_arena::{Arena, RawId, impl_arena_id}; -use relative_path::RelativePathBuf; -use crate::{Name, HirDatabase, SourceItemId, SourceFileItemId, HirFileId}; +use crate::{Name, AsName, HirDatabase, SourceItemId, SourceFileItemId, HirFileId, Problem}; -pub use self::nameres::{ModuleScope, Resolution, Namespace, PerNs}; +#[derive(Clone, Hash, PartialEq, Eq, Debug)] +pub enum Submodule { + Declaration(Name), + Definition(Name, ModuleSource), +} + +impl Submodule { + fn name(&self) -> &Name { + match self { + Submodule::Declaration(name) => name, + Submodule::Definition(name, _) => name, + } + } +} #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ModuleId(RawId); @@ -34,7 +49,31 @@ pub struct ModuleTree { links: Arena, } +#[derive(Debug, PartialEq, Eq, Hash)] +pub struct ModuleData { + source: ModuleSource, + parent: Option, + children: Vec, +} + +#[derive(Hash, Debug, PartialEq, Eq)] +struct LinkData { + owner: ModuleId, + name: Name, + points_to: Vec, + problem: Option, +} + impl ModuleTree { + pub(crate) fn module_tree_query( + db: &impl HirDatabase, + source_root: SourceRootId, + ) -> Cancelable> { + db.check_canceled()?; + let res = create_module_tree(db, source_root)?; + Ok(Arc::new(res)) + } + pub(crate) fn modules<'a>(&'a self) -> impl Iterator + 'a { self.mods.iter().map(|(id, _)| id) } @@ -58,17 +97,6 @@ pub(crate) enum ModuleSourceNode { Module(ast::ModuleNode), } -#[derive(Clone, Debug, Hash, PartialEq, Eq)] -pub enum Problem { - UnresolvedModule { - candidate: RelativePathBuf, - }, - NotDirOwner { - move_to: RelativePathBuf, - candidate: RelativePathBuf, - }, -} - impl ModuleId { pub(crate) fn source(self, tree: &ModuleTree) -> ModuleSource { tree.mods[self].source @@ -93,7 +121,10 @@ impl ModuleId { .find(|it| it.name == *name)?; Some(*link.points_to.first()?) } - fn children<'a>(self, tree: &'a ModuleTree) -> impl Iterator + 'a { + pub(crate) fn children<'a>( + self, + tree: &'a ModuleTree, + ) -> impl Iterator + 'a { tree.mods[self].children.iter().filter_map(move |&it| { let link = &tree.links[it]; let module = *link.points_to.first()?; @@ -133,7 +164,7 @@ impl LinkId { let owner = self.owner(tree); match owner.source(tree).resolve(db) { ModuleSourceNode::SourceFile(root) => { - let ast = imp::modules(root.borrowed()) + let ast = modules(root.borrowed()) .find(|(name, _)| name == &tree.links[self].name) .unwrap() .1; @@ -144,13 +175,6 @@ impl LinkId { } } -#[derive(Debug, PartialEq, Eq, Hash)] -pub struct ModuleData { - source: ModuleSource, - parent: Option, - children: Vec, -} - impl ModuleSource { // precondition: item_id **must** point to module fn new(file_id: HirFileId, item_id: Option) -> ModuleSource { @@ -188,14 +212,6 @@ impl ModuleSource { } } -#[derive(Hash, Debug, PartialEq, Eq)] -struct LinkData { - owner: ModuleId, - name: Name, - points_to: Vec, - problem: Option, -} - impl ModuleTree { fn push_mod(&mut self, data: ModuleData) -> ModuleId { self.mods.alloc(data) @@ -207,3 +223,153 @@ impl ModuleTree { id } } + +fn modules<'a>( + root: impl ast::ModuleItemOwner<'a>, +) -> impl Iterator)> { + root.items() + .filter_map(|item| match item { + ast::ModuleItem::Module(m) => Some(m), + _ => None, + }) + .filter_map(|module| { + let name = module.name()?.as_name(); + Some((name, module)) + }) +} + +fn create_module_tree<'a>( + db: &impl HirDatabase, + source_root: SourceRootId, +) -> Cancelable { + let mut tree = ModuleTree::default(); + + let mut roots = FxHashMap::default(); + let mut visited = FxHashSet::default(); + + let source_root = db.source_root(source_root); + for &file_id in source_root.files.values() { + let source = ModuleSource::new_file(file_id.into()); + if visited.contains(&source) { + continue; // TODO: use explicit crate_roots here + } + assert!(!roots.contains_key(&file_id)); + let module_id = build_subtree( + db, + &source_root, + &mut tree, + &mut visited, + &mut roots, + None, + source, + )?; + roots.insert(file_id, module_id); + } + Ok(tree) +} + +fn build_subtree( + db: &impl HirDatabase, + source_root: &SourceRoot, + tree: &mut ModuleTree, + visited: &mut FxHashSet, + roots: &mut FxHashMap, + parent: Option, + source: ModuleSource, +) -> Cancelable { + visited.insert(source); + let id = tree.push_mod(ModuleData { + source, + parent, + children: Vec::new(), + }); + for sub in db.submodules(source)?.iter() { + let link = tree.push_link(LinkData { + name: sub.name().clone(), + owner: id, + points_to: Vec::new(), + problem: None, + }); + + let (points_to, problem) = match sub { + Submodule::Declaration(name) => { + let (points_to, problem) = resolve_submodule(db, source, &name); + let points_to = points_to + .into_iter() + .map(|file_id| match roots.remove(&file_id) { + Some(module_id) => { + tree.mods[module_id].parent = Some(link); + Ok(module_id) + } + None => build_subtree( + db, + source_root, + tree, + visited, + roots, + Some(link), + ModuleSource::new_file(file_id.into()), + ), + }) + .collect::>>()?; + (points_to, problem) + } + Submodule::Definition(_name, submodule_source) => { + let points_to = build_subtree( + db, + source_root, + tree, + visited, + roots, + Some(link), + *submodule_source, + )?; + (vec![points_to], None) + } + }; + + tree.links[link].points_to = points_to; + tree.links[link].problem = problem; + } + Ok(id) +} + +fn resolve_submodule( + db: &impl HirDatabase, + source: ModuleSource, + name: &Name, +) -> (Vec, Option) { + // FIXME: handle submodules of inline modules properly + let file_id = source.file_id().original_file(db); + let source_root_id = db.file_source_root(file_id); + let path = db.file_relative_path(file_id); + let root = RelativePathBuf::default(); + let dir_path = path.parent().unwrap_or(&root); + let mod_name = path.file_stem().unwrap_or("unknown"); + let is_dir_owner = mod_name == "mod" || mod_name == "lib" || mod_name == "main"; + + let file_mod = dir_path.join(format!("{}.rs", name)); + let dir_mod = dir_path.join(format!("{}/mod.rs", name)); + let file_dir_mod = dir_path.join(format!("{}/{}.rs", mod_name, name)); + let mut candidates = ArrayVec::<[_; 2]>::new(); + if is_dir_owner { + candidates.push(file_mod.clone()); + candidates.push(dir_mod); + } else { + candidates.push(file_dir_mod.clone()); + }; + let sr = db.source_root(source_root_id); + let points_to = candidates + .into_iter() + .filter_map(|path| sr.files.get(&path)) + .map(|&it| it) + .collect::>(); + let problem = if points_to.is_empty() { + Some(Problem::UnresolvedModule { + candidate: if is_dir_owner { file_mod } else { file_dir_mod }, + }) + } else { + None + }; + (points_to, problem) +} diff --git a/crates/ra_hir/src/module/nameres.rs b/crates/ra_hir/src/nameres.rs similarity index 99% rename from crates/ra_hir/src/module/nameres.rs rename to crates/ra_hir/src/nameres.rs index 7d5e86c89b99..e65cbcb2707b 100644 --- a/crates/ra_hir/src/module/nameres.rs +++ b/crates/ra_hir/src/nameres.rs @@ -31,7 +31,7 @@ use crate::{ Path, PathKind, HirDatabase, Crate, Name, AsName, - module::{ModuleId, ModuleTree}, + module_tree::{ModuleId, ModuleTree}, }; /// Item map is the result of the name resolution. Item map contains, for each diff --git a/crates/ra_hir/src/module/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs similarity index 98% rename from crates/ra_hir/src/module/nameres/tests.rs rename to crates/ra_hir/src/nameres/tests.rs index dcbe65aec36a..a6a0bea3160e 100644 --- a/crates/ra_hir/src/module/nameres/tests.rs +++ b/crates/ra_hir/src/nameres/tests.rs @@ -17,7 +17,7 @@ fn item_map(fixture: &str) -> (Arc, hir::ModuleId) { let module = hir::source_binder::module_from_position(&db, pos) .unwrap() .unwrap(); - let module_id = module.def_id.loc(&db).module_id; + let module_id = module.module_id; (db.item_map(source_root).unwrap(), module_id) } @@ -155,7 +155,7 @@ fn item_map_across_crates() { let module = hir::source_binder::module_from_file_id(&db, main_id) .unwrap() .unwrap(); - let module_id = module.def_id.loc(&db).module_id; + let module_id = module.module_id; let item_map = db.item_map(source_root).unwrap(); check_module_item_map( diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs index d9ee9d37f09c..b17c00e26f33 100644 --- a/crates/ra_hir/src/query_definitions.rs +++ b/crates/ra_hir/src/query_definitions.rs @@ -15,11 +15,8 @@ use crate::{ MacroCallLoc, db::HirDatabase, function::FnScopes, - module::{ - ModuleSource, ModuleSourceNode, ModuleId, - imp::Submodule, - nameres::{InputModuleItems, ItemMap, Resolver}, - }, + module_tree::{ModuleId, Submodule, ModuleSource, ModuleSourceNode}, + nameres::{InputModuleItems, ItemMap, Resolver}, adt::{StructData, EnumData}, }; diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs index ac097e81a83e..b7e3ff9b0c56 100644 --- a/crates/ra_hir/src/source_binder.rs +++ b/crates/ra_hir/src/source_binder.rs @@ -14,7 +14,7 @@ use ra_syntax::{ use crate::{ HirDatabase, Function, SourceItemId, - module::ModuleSource, + module_tree::ModuleSource, DefKind, DefLoc, AsName, }; From 5b0267ecf7a3840270de72d446d5e60e1eb2ba12 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 17:37:18 +0300 Subject: [PATCH 13/15] fix after rebase --- crates/ra_hir/src/lib.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/crates/ra_hir/src/lib.rs b/crates/ra_hir/src/lib.rs index 7e74f2eaf818..9f133f174915 100644 --- a/crates/ra_hir/src/lib.rs +++ b/crates/ra_hir/src/lib.rs @@ -47,7 +47,8 @@ pub use self::{ name::Name, ids::{HirFileId, DefId, DefLoc, MacroCallId, MacroCallLoc}, macros::{MacroDef, MacroInput, MacroExpansion}, - module::{Module, ModuleId, Problem, nameres::{ItemMap, PerNs, Namespace}, ModuleScope, Resolution}, + module_tree::ModuleId, + nameres::{ItemMap, PerNs, Namespace, Resolution}, function::{Function, FnSignature, FnScopes, ScopesWithSyntaxMapping}, adt::{Struct, Enum}, ty::Ty, From 17b2994b99394562b5e515c953a3a83c5977da76 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 17:38:20 +0300 Subject: [PATCH 14/15] fix the test --- crates/ra_hir/src/nameres/tests.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/ra_hir/src/nameres/tests.rs b/crates/ra_hir/src/nameres/tests.rs index a6a0bea3160e..dcbe65aec36a 100644 --- a/crates/ra_hir/src/nameres/tests.rs +++ b/crates/ra_hir/src/nameres/tests.rs @@ -17,7 +17,7 @@ fn item_map(fixture: &str) -> (Arc, hir::ModuleId) { let module = hir::source_binder::module_from_position(&db, pos) .unwrap() .unwrap(); - let module_id = module.module_id; + let module_id = module.def_id.loc(&db).module_id; (db.item_map(source_root).unwrap(), module_id) } @@ -155,7 +155,7 @@ fn item_map_across_crates() { let module = hir::source_binder::module_from_file_id(&db, main_id) .unwrap() .unwrap(); - let module_id = module.module_id; + let module_id = module.def_id.loc(&db).module_id; let item_map = db.item_map(source_root).unwrap(); check_module_item_map( From 733383446fc229a35d4432d14c295c5a01e5a87f Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Sun, 6 Jan 2019 17:44:50 +0300 Subject: [PATCH 15/15] move submodule computationt to module_tree --- crates/ra_hir/src/code_model_impl.rs | 2 +- crates/ra_hir/src/db.rs | 2 +- crates/ra_hir/src/module_tree.rs | 34 ++++++++++++++++ crates/ra_hir/src/query_definitions.rs | 54 ++------------------------ 4 files changed, 39 insertions(+), 53 deletions(-) diff --git a/crates/ra_hir/src/code_model_impl.rs b/crates/ra_hir/src/code_model_impl.rs index d602a439df6b..157b0c616887 100644 --- a/crates/ra_hir/src/code_model_impl.rs +++ b/crates/ra_hir/src/code_model_impl.rs @@ -1,2 +1,2 @@ mod krate; // `crate` is invalid ident :( -pub(crate) mod module; +mod module; diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs index 2702961ba751..e4249de141e4 100644 --- a/crates/ra_hir/src/db.rs +++ b/crates/ra_hir/src/db.rs @@ -73,7 +73,7 @@ pub trait HirDatabase: SyntaxDatabase fn submodules(source: ModuleSource) -> Cancelable>> { type SubmodulesQuery; - use fn query_definitions::submodules; + use fn crate::module_tree::Submodule::submodules_query; } fn input_module_items(source_root_id: SourceRootId, module_id: ModuleId) -> Cancelable> { diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs index cd82f25dbe25..b7912ba5edb3 100644 --- a/crates/ra_hir/src/module_tree.rs +++ b/crates/ra_hir/src/module_tree.rs @@ -20,6 +20,40 @@ pub enum Submodule { } impl Submodule { + pub(crate) fn submodules_query( + db: &impl HirDatabase, + source: ModuleSource, + ) -> Cancelable>> { + db.check_canceled()?; + let file_id = source.file_id(); + let submodules = match source.resolve(db) { + ModuleSourceNode::SourceFile(it) => collect_submodules(db, file_id, it.borrowed()), + ModuleSourceNode::Module(it) => it + .borrowed() + .item_list() + .map(|it| collect_submodules(db, file_id, it)) + .unwrap_or_else(Vec::new), + }; + return Ok(Arc::new(submodules)); + + fn collect_submodules<'a>( + db: &impl HirDatabase, + file_id: HirFileId, + root: impl ast::ModuleItemOwner<'a>, + ) -> Vec { + modules(root) + .map(|(name, m)| { + if m.has_semi() { + Submodule::Declaration(name) + } else { + let src = ModuleSource::new_inline(db, file_id, m); + Submodule::Definition(name, src) + } + }) + .collect() + } + } + fn name(&self) -> &Name { match self { Submodule::Declaration(name) => name, diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs index b17c00e26f33..f4b380022ebc 100644 --- a/crates/ra_hir/src/query_definitions.rs +++ b/crates/ra_hir/src/query_definitions.rs @@ -6,16 +6,16 @@ use std::{ use rustc_hash::FxHashMap; use ra_syntax::{ AstNode, SyntaxNode, - ast::{self, NameOwner, ModuleItemOwner} + ast::{self, ModuleItemOwner} }; use ra_db::{SourceRootId, Cancelable,}; use crate::{ - SourceFileItems, SourceItemId, DefKind, DefId, Name, AsName, HirFileId, + SourceFileItems, SourceItemId, DefKind, DefId, HirFileId, MacroCallLoc, db::HirDatabase, function::FnScopes, - module_tree::{ModuleId, Submodule, ModuleSource, ModuleSourceNode}, + module_tree::{ModuleId, ModuleSourceNode}, nameres::{InputModuleItems, ItemMap, Resolver}, adt::{StructData, EnumData}, }; @@ -58,54 +58,6 @@ pub(super) fn file_item(db: &impl HirDatabase, source_item_id: SourceItemId) -> } } -pub(crate) fn submodules( - db: &impl HirDatabase, - source: ModuleSource, -) -> Cancelable>> { - db.check_canceled()?; - let file_id = source.file_id(); - let submodules = match source.resolve(db) { - ModuleSourceNode::SourceFile(it) => collect_submodules(db, file_id, it.borrowed()), - ModuleSourceNode::Module(it) => it - .borrowed() - .item_list() - .map(|it| collect_submodules(db, file_id, it)) - .unwrap_or_else(Vec::new), - }; - return Ok(Arc::new(submodules)); - - fn collect_submodules<'a>( - db: &impl HirDatabase, - file_id: HirFileId, - root: impl ast::ModuleItemOwner<'a>, - ) -> Vec { - modules(root) - .map(|(name, m)| { - if m.has_semi() { - Submodule::Declaration(name) - } else { - let src = ModuleSource::new_inline(db, file_id, m); - Submodule::Definition(name, src) - } - }) - .collect() - } -} - -pub(crate) fn modules<'a>( - root: impl ast::ModuleItemOwner<'a>, -) -> impl Iterator)> { - root.items() - .filter_map(|item| match item { - ast::ModuleItem::Module(m) => Some(m), - _ => None, - }) - .filter_map(|module| { - let name = module.name()?.as_name(); - Some((name, module)) - }) -} - pub(super) fn input_module_items( db: &impl HirDatabase, source_root_id: SourceRootId,