From a136cc0653d2b4133fb6387009cfdbaf3e2cf275 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 30 Oct 2019 12:27:54 +0300 Subject: introduce ra_hir_def --- crates/ra_hir/Cargo.toml | 1 + crates/ra_hir/src/code_model.rs | 77 ++++++++++++++++--------------- crates/ra_hir/src/code_model/src.rs | 10 ++-- crates/ra_hir/src/from_source.rs | 2 +- crates/ra_hir/src/impl_block.rs | 2 +- crates/ra_hir/src/lang_item.rs | 16 +++---- crates/ra_hir/src/nameres.rs | 36 ++++++--------- crates/ra_hir/src/nameres/collector.rs | 23 +++++---- crates/ra_hir/src/resolve.rs | 17 ++++--- crates/ra_hir/src/ty/method_resolution.rs | 12 ++--- crates/ra_hir/src/ty/traits/chalk.rs | 4 +- crates/ra_hir_def/Cargo.toml | 13 ++++++ crates/ra_hir_def/src/lib.rs | 14 ++++++ 13 files changed, 127 insertions(+), 100 deletions(-) create mode 100644 crates/ra_hir_def/Cargo.toml create mode 100644 crates/ra_hir_def/src/lib.rs (limited to 'crates') diff --git a/crates/ra_hir/Cargo.toml b/crates/ra_hir/Cargo.toml index 143dae6bd..5df371bc0 100644 --- a/crates/ra_hir/Cargo.toml +++ b/crates/ra_hir/Cargo.toml @@ -20,6 +20,7 @@ ra_db = { path = "../ra_db" } mbe = { path = "../ra_mbe", package = "ra_mbe" } tt = { path = "../ra_tt", package = "ra_tt" } hir_expand = { path = "../ra_hir_expand", package = "ra_hir_expand" } +hir_def = { path = "../ra_hir_def", package = "ra_hir_def" } test_utils = { path = "../test_utils" } ra_prof = { path = "../ra_prof" } diff --git a/crates/ra_hir/src/code_model.rs b/crates/ra_hir/src/code_model.rs index 8eb3c577d..3f1c36941 100644 --- a/crates/ra_hir/src/code_model.rs +++ b/crates/ra_hir/src/code_model.rs @@ -5,6 +5,7 @@ pub(crate) mod docs; use std::sync::Arc; +use hir_def::{CrateModuleId, ModuleId}; use ra_db::{CrateId, Edition, FileId}; use ra_syntax::ast::{self, NameOwner, TypeAscriptionOwner}; @@ -23,7 +24,7 @@ use crate::{ BOOL, CHAR, F32, F64, I128, I16, I32, I64, I8, ISIZE, SELF_TYPE, STR, U128, U16, U32, U64, U8, USIZE, }, - nameres::{CrateModuleId, ImportId, ModuleScope, Namespace}, + nameres::{ImportId, ModuleScope, Namespace}, resolve::{Resolver, Scope, TypeNs}, traits::TraitData, ty::{ @@ -67,8 +68,7 @@ impl Crate { pub fn root_module(self, db: &impl DefDatabase) -> Option { let module_id = db.crate_def_map(self).root(); - let module = Module { krate: self, module_id }; - Some(module) + Some(Module::new(self, module_id)) } pub fn edition(self, db: &impl DefDatabase) -> Edition { @@ -83,8 +83,7 @@ impl Crate { #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] pub struct Module { - pub(crate) krate: Crate, - pub(crate) module_id: CrateModuleId, + pub(crate) id: ModuleId, } #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] @@ -175,12 +174,16 @@ impl ModuleSource { } impl Module { + pub(crate) fn new(krate: Crate, crate_module_id: CrateModuleId) -> Module { + Module { id: ModuleId { krate: krate.crate_id, module_id: crate_module_id } } + } + /// Name of this module. pub fn name(self, db: &impl DefDatabase) -> Option { - let def_map = db.crate_def_map(self.krate); - let parent = def_map[self.module_id].parent?; + let def_map = db.crate_def_map(self.krate()); + let parent = def_map[self.id.module_id].parent?; def_map[parent].children.iter().find_map(|(name, module_id)| { - if *module_id == self.module_id { + if *module_id == self.id.module_id { Some(name.clone()) } else { None @@ -200,29 +203,29 @@ impl Module { } /// Returns the crate this module is part of. - pub fn krate(self, _db: &impl DefDatabase) -> Option { - Some(self.krate) + pub fn krate(self) -> Crate { + Crate { crate_id: self.id.krate } } /// Topmost parent of this module. Every module has a `crate_root`, but some /// might be missing `krate`. This can happen if a module's file is not included /// in the module tree of any target in `Cargo.toml`. pub fn crate_root(self, db: &impl DefDatabase) -> Module { - let def_map = db.crate_def_map(self.krate); + let def_map = db.crate_def_map(self.krate()); self.with_module_id(def_map.root()) } /// Finds a child module with the specified name. pub fn child(self, db: &impl HirDatabase, name: &Name) -> Option { - let def_map = db.crate_def_map(self.krate); - let child_id = def_map[self.module_id].children.get(name)?; + let def_map = db.crate_def_map(self.krate()); + let child_id = def_map[self.id.module_id].children.get(name)?; Some(self.with_module_id(*child_id)) } /// Iterates over all child modules. pub fn children(self, db: &impl DefDatabase) -> impl Iterator { - let def_map = db.crate_def_map(self.krate); - let children = def_map[self.module_id] + let def_map = db.crate_def_map(self.krate()); + let children = def_map[self.id.module_id] .children .iter() .map(|(_, module_id)| self.with_module_id(*module_id)) @@ -232,8 +235,8 @@ impl Module { /// Finds a parent module. pub fn parent(self, db: &impl DefDatabase) -> Option { - let def_map = db.crate_def_map(self.krate); - let parent_id = def_map[self.module_id].parent?; + let def_map = db.crate_def_map(self.krate()); + let parent_id = def_map[self.id.module_id].parent?; Some(self.with_module_id(parent_id)) } @@ -249,11 +252,11 @@ impl Module { /// Returns a `ModuleScope`: a set of items, visible in this module. pub fn scope(self, db: &impl HirDatabase) -> ModuleScope { - db.crate_def_map(self.krate)[self.module_id].scope.clone() + db.crate_def_map(self.krate())[self.id.module_id].scope.clone() } pub fn diagnostics(self, db: &impl HirDatabase, sink: &mut DiagnosticSink) { - db.crate_def_map(self.krate).add_diagnostics(db, self.module_id, sink); + db.crate_def_map(self.krate()).add_diagnostics(db, self.id.module_id, sink); for decl in self.declarations(db) { match decl { crate::ModuleDef::Function(f) => f.diagnostics(db, sink), @@ -277,13 +280,13 @@ impl Module { } pub(crate) fn resolver(self, db: &impl DefDatabase) -> Resolver { - let def_map = db.crate_def_map(self.krate); - Resolver::default().push_module_scope(def_map, self.module_id) + let def_map = db.crate_def_map(self.krate()); + Resolver::default().push_module_scope(def_map, self.id.module_id) } pub fn declarations(self, db: &impl DefDatabase) -> Vec { - let def_map = db.crate_def_map(self.krate); - def_map[self.module_id] + let def_map = db.crate_def_map(self.krate()); + def_map[self.id.module_id] .scope .entries() .filter_map(|(_name, res)| if res.import.is_none() { Some(res.def) } else { None }) @@ -303,7 +306,7 @@ impl Module { } fn with_module_id(self, module_id: CrateModuleId) -> Module { - Module { module_id, krate: self.krate } + Module::new(self.krate(), module_id) } } @@ -344,7 +347,7 @@ impl Struct { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } pub fn name(self, db: &impl DefDatabase) -> Option { @@ -432,7 +435,7 @@ impl Enum { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } pub fn name(self, db: &impl DefDatabase) -> Option { @@ -523,12 +526,14 @@ impl Adt { } pub fn krate(self, db: &impl HirDatabase) -> Option { - match self { - Adt::Struct(s) => s.module(db), - Adt::Union(s) => s.module(db), - Adt::Enum(e) => e.module(db), - } - .krate(db) + Some( + match self { + Adt::Struct(s) => s.module(db), + Adt::Union(s) => s.module(db), + Adt::Enum(e) => e.module(db), + } + .krate(), + ) } pub(crate) fn resolver(self, db: &impl HirDatabase) -> Resolver { @@ -696,7 +701,7 @@ impl Function { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } pub fn name(self, db: &impl HirDatabase) -> Name { @@ -774,7 +779,7 @@ impl Const { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } pub fn data(self, db: &impl HirDatabase) -> Arc { @@ -871,7 +876,7 @@ impl Static { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } pub fn data(self, db: &impl HirDatabase) -> Arc { @@ -1002,7 +1007,7 @@ impl TypeAlias { } pub fn krate(self, db: &impl DefDatabase) -> Option { - self.module(db).krate(db) + Some(self.module(db).krate()) } /// The containing impl block, if this is a method. diff --git a/crates/ra_hir/src/code_model/src.rs b/crates/ra_hir/src/code_model/src.rs index fdae26906..8b33f25f7 100644 --- a/crates/ra_hir/src/code_model/src.rs +++ b/crates/ra_hir/src/code_model/src.rs @@ -37,9 +37,9 @@ impl Source { impl Module { /// Returns a node which defines this module. That is, a file or a `mod foo {}` with items. pub fn definition_source(self, db: &(impl DefDatabase + AstDatabase)) -> Source { - let def_map = db.crate_def_map(self.krate); - let decl_id = def_map[self.module_id].declaration; - let file_id = def_map[self.module_id].definition; + let def_map = db.crate_def_map(self.krate()); + let decl_id = def_map[self.id.module_id].declaration; + let file_id = def_map[self.id.module_id].definition; let ast = ModuleSource::new(db, file_id, decl_id); let file_id = file_id.map(HirFileId::from).unwrap_or_else(|| decl_id.unwrap().file_id()); Source { file_id, ast } @@ -51,8 +51,8 @@ impl Module { self, db: &(impl DefDatabase + AstDatabase), ) -> Option> { - let def_map = db.crate_def_map(self.krate); - let decl = def_map[self.module_id].declaration?; + let def_map = db.crate_def_map(self.krate()); + let decl = def_map[self.id.module_id].declaration?; let ast = decl.to_node(db); Some(Source { file_id: decl.file_id(), ast }) } diff --git a/crates/ra_hir/src/from_source.rs b/crates/ra_hir/src/from_source.rs index 7954c04b2..291f2a14a 100644 --- a/crates/ra_hir/src/from_source.rs +++ b/crates/ra_hir/src/from_source.rs @@ -195,7 +195,7 @@ impl Module { .find_map(|krate| { let def_map = db.crate_def_map(krate); let module_id = def_map.find_module_by_source(src.file_id, decl_id)?; - Some(Module { krate, module_id }) + Some(Module::new(krate, module_id)) }) } } diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs index 1a5223680..fde47c264 100644 --- a/crates/ra_hir/src/impl_block.rs +++ b/crates/ra_hir/src/impl_block.rs @@ -182,7 +182,7 @@ impl ModuleImplBlocks { ) -> (Arc, Arc) { let mut source_map = ImplSourceMap::default(); let crate_graph = db.crate_graph(); - let cfg_options = crate_graph.cfg_options(module.krate.crate_id()); + let cfg_options = crate_graph.cfg_options(module.id.krate); let result = ModuleImplBlocks::collect(db, cfg_options, module, &mut source_map); (Arc::new(result), Arc::new(source_map)) diff --git a/crates/ra_hir/src/lang_item.rs b/crates/ra_hir/src/lang_item.rs index 6c4e8ffbd..e1780ed38 100644 --- a/crates/ra_hir/src/lang_item.rs +++ b/crates/ra_hir/src/lang_item.rs @@ -22,14 +22,14 @@ pub enum LangItemTarget { impl LangItemTarget { pub(crate) fn krate(&self, db: &impl HirDatabase) -> Option { - match self { - LangItemTarget::Enum(e) => e.module(db).krate(db), - LangItemTarget::Function(f) => f.module(db).krate(db), - LangItemTarget::ImplBlock(i) => i.module().krate(db), - LangItemTarget::Static(s) => s.module(db).krate(db), - LangItemTarget::Struct(s) => s.module(db).krate(db), - LangItemTarget::Trait(t) => t.module(db).krate(db), - } + Some(match self { + LangItemTarget::Enum(e) => e.module(db).krate(), + LangItemTarget::Function(f) => f.module(db).krate(), + LangItemTarget::ImplBlock(i) => i.module().krate(), + LangItemTarget::Static(s) => s.module(db).krate(), + LangItemTarget::Struct(s) => s.module(db).krate(), + LangItemTarget::Trait(t) => t.module(db).krate(), + }) } } diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs index 67adcfa28..b325979f5 100644 --- a/crates/ra_hir/src/nameres.rs +++ b/crates/ra_hir/src/nameres.rs @@ -56,8 +56,9 @@ mod tests; use std::sync::Arc; +use hir_def::CrateModuleId; use once_cell::sync::Lazy; -use ra_arena::{impl_arena_id, Arena, RawId}; +use ra_arena::Arena; use ra_db::{Edition, FileId}; use ra_prof::profile; use ra_syntax::ast; @@ -115,13 +116,8 @@ impl std::ops::Index for CrateDefMap { } } -/// An ID of a module, **local** to a specific crate -#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] -pub(crate) struct CrateModuleId(RawId); -impl_arena_id!(CrateModuleId); - #[derive(Default, Debug, PartialEq, Eq)] -pub(crate) struct ModuleData { +pub struct ModuleData { pub(crate) parent: Option, pub(crate) children: FxHashMap, pub(crate) scope: ModuleScope, @@ -335,7 +331,7 @@ impl CrateDefMap { PathKind::DollarCrate(krate) => { if krate == self.krate { tested_by!(macro_dollar_crate_self); - PerNs::types(Module { krate: self.krate, module_id: self.root }.into()) + PerNs::types(Module::new(self.krate, self.root).into()) } else { match krate.root_module(db) { Some(module) => { @@ -346,12 +342,8 @@ impl CrateDefMap { } } } - PathKind::Crate => { - PerNs::types(Module { krate: self.krate, module_id: self.root }.into()) - } - PathKind::Self_ => { - PerNs::types(Module { krate: self.krate, module_id: original_module }.into()) - } + PathKind::Crate => PerNs::types(Module::new(self.krate, self.root).into()), + PathKind::Self_ => PerNs::types(Module::new(self.krate, original_module).into()), // plain import or absolute path in 2015: crate-relative with // fallback to extern prelude (with the simplification in // rust-lang/rust#57745) @@ -377,7 +369,7 @@ impl CrateDefMap { } PathKind::Super => { if let Some(p) = self.modules[original_module].parent { - PerNs::types(Module { krate: self.krate, module_id: p }.into()) + PerNs::types(Module::new(self.krate, p).into()) } else { log::debug!("super path in root module"); return ResolvePathResult::empty(ReachedFixedPoint::Yes); @@ -419,12 +411,12 @@ impl CrateDefMap { curr_per_ns = match curr { ModuleDef::Module(module) => { - if module.krate != self.krate { + if module.krate() != self.krate { let path = Path { segments: path.segments[i..].to_vec(), kind: PathKind::Self_ }; log::debug!("resolving {:?} in other crate", path); - let defp_map = db.crate_def_map(module.krate); - let (def, s) = defp_map.resolve_path(db, module.module_id, &path); + let defp_map = db.crate_def_map(module.krate()); + let (def, s) = defp_map.resolve_path(db, module.id.module_id, &path); return ResolvePathResult::with( def, ReachedFixedPoint::Yes, @@ -433,7 +425,7 @@ impl CrateDefMap { } // Since it is a qualified path here, it should not contains legacy macros - match self[module.module_id].scope.get(&segment.name) { + match self[module.id.module_id].scope.get(&segment.name) { Some(res) => res.def, _ => { log::debug!("path segment {:?} not found", segment.name); @@ -511,14 +503,14 @@ impl CrateDefMap { fn resolve_in_prelude(&self, db: &impl DefDatabase, name: &Name) -> PerNs { if let Some(prelude) = self.prelude { let keep; - let def_map = if prelude.krate == self.krate { + let def_map = if prelude.krate() == self.krate { self } else { // Extend lifetime - keep = db.crate_def_map(prelude.krate); + keep = db.crate_def_map(prelude.krate()); &keep }; - def_map[prelude.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def) + def_map[prelude.id.module_id].scope.get(name).map_or_else(PerNs::none, |res| res.def) } else { PerNs::none() } diff --git a/crates/ra_hir/src/nameres/collector.rs b/crates/ra_hir/src/nameres/collector.rs index dc591e8d3..dd5f9d4ba 100644 --- a/crates/ra_hir/src/nameres/collector.rs +++ b/crates/ra_hir/src/nameres/collector.rs @@ -212,7 +212,7 @@ where if let Some(ModuleDef::Module(m)) = res.take_types() { tested_by!(macro_rules_from_other_crates_are_visible_with_macro_use); - self.import_all_macros_exported(current_module_id, m.krate); + self.import_all_macros_exported(current_module_id, m.krate()); } } @@ -289,11 +289,11 @@ where if import.is_prelude { tested_by!(std_prelude); self.def_map.prelude = Some(m); - } else if m.krate != self.def_map.krate { + } else if m.krate() != self.def_map.krate { tested_by!(glob_across_crates); // glob import from other crate => we can just import everything once - let item_map = self.db.crate_def_map(m.krate); - let scope = &item_map[m.module_id].scope; + let item_map = self.db.crate_def_map(m.krate()); + let scope = &item_map[m.id.module_id].scope; // Module scoped macros is included let items = scope @@ -307,7 +307,7 @@ where // glob import from same crate => we do an initial // import, and then need to propagate any further // additions - let scope = &self.def_map[m.module_id].scope; + let scope = &self.def_map[m.id.module_id].scope; // Module scoped macros is included let items = scope @@ -319,7 +319,7 @@ where self.update(module_id, Some(import_id), &items); // record the glob import in case we add further items self.glob_imports - .entry(m.module_id) + .entry(m.id.module_id) .or_default() .push((module_id, import_id)); } @@ -523,9 +523,10 @@ where // Prelude module is always considered to be `#[macro_use]`. if let Some(prelude_module) = self.def_collector.def_map.prelude { - if prelude_module.krate != self.def_collector.def_map.krate { + if prelude_module.krate() != self.def_collector.def_map.krate { tested_by!(prelude_is_macro_use); - self.def_collector.import_all_macros_exported(self.module_id, prelude_module.krate); + self.def_collector + .import_all_macros_exported(self.module_id, prelude_module.krate()); } } @@ -631,9 +632,7 @@ where modules[res].scope.legacy_macros = modules[self.module_id].scope.legacy_macros.clone(); modules[self.module_id].children.insert(name.clone(), res); let resolution = Resolution { - def: PerNs::types( - Module { krate: self.def_collector.def_map.krate, module_id: res }.into(), - ), + def: PerNs::types(Module::new(self.def_collector.def_map.krate, res).into()), import: None, }; self.def_collector.update(self.module_id, None, &[(name, resolution)]); @@ -641,7 +640,7 @@ where } fn define_def(&mut self, def: &raw::DefData) { - let module = Module { krate: self.def_collector.def_map.krate, module_id: self.module_id }; + let module = Module::new(self.def_collector.def_map.krate, self.module_id); let ctx = LocationCtx::new(self.def_collector.db, module, self.file_id); macro_rules! def { diff --git a/crates/ra_hir/src/resolve.rs b/crates/ra_hir/src/resolve.rs index 3c797c0c3..8b6269407 100644 --- a/crates/ra_hir/src/resolve.rs +++ b/crates/ra_hir/src/resolve.rs @@ -1,6 +1,7 @@ //! Name resolution. use std::sync::Arc; +use hir_def::CrateModuleId; use rustc_hash::FxHashSet; use crate::{ @@ -13,7 +14,7 @@ use crate::{ generics::GenericParams, impl_block::ImplBlock, name::{Name, SELF_PARAM, SELF_TYPE}, - nameres::{CrateDefMap, CrateModuleId, PerNs}, + nameres::{CrateDefMap, PerNs}, path::{Path, PathKind}, Adt, BuiltinType, Const, Enum, EnumVariant, Function, MacroDef, ModuleDef, Static, Struct, Trait, TypeAlias, @@ -330,8 +331,8 @@ impl Resolver { for scope in &self.scopes { if let Scope::ModuleScope(m) = scope { if let Some(prelude) = m.crate_def_map.prelude() { - let prelude_def_map = db.crate_def_map(prelude.krate); - traits.extend(prelude_def_map[prelude.module_id].scope.traits()); + let prelude_def_map = db.crate_def_map(prelude.krate()); + traits.extend(prelude_def_map[prelude.id.module_id].scope.traits()); } traits.extend(m.crate_def_map[m.module_id].scope.traits()); } @@ -444,10 +445,12 @@ impl Scope { f(name.clone(), ScopeDef::ModuleDef(*def)); }); if let Some(prelude) = m.crate_def_map.prelude() { - let prelude_def_map = db.crate_def_map(prelude.krate); - prelude_def_map[prelude.module_id].scope.entries().for_each(|(name, res)| { - f(name.clone(), res.def.into()); - }); + let prelude_def_map = db.crate_def_map(prelude.krate()); + prelude_def_map[prelude.id.module_id].scope.entries().for_each( + |(name, res)| { + f(name.clone(), res.def.into()); + }, + ); } } Scope::GenericParams(gp) => { diff --git a/crates/ra_hir/src/ty/method_resolution.rs b/crates/ra_hir/src/ty/method_resolution.rs index ad2ab560d..50583a142 100644 --- a/crates/ra_hir/src/ty/method_resolution.rs +++ b/crates/ra_hir/src/ty/method_resolution.rs @@ -5,13 +5,13 @@ use std::sync::Arc; use arrayvec::ArrayVec; +use hir_def::CrateModuleId; use rustc_hash::FxHashMap; use super::{autoderef, lower, Canonical, InEnvironment, TraitEnvironment, TraitRef}; use crate::{ db::HirDatabase, impl_block::{ImplBlock, ImplId}, - nameres::CrateModuleId, resolve::Resolver, ty::primitive::{FloatBitness, UncertainFloatTy, UncertainIntTy}, ty::{Ty, TypeCtor}, @@ -50,7 +50,7 @@ impl CrateImplBlocks { let fingerprint = TyFingerprint::for_impl(ty); fingerprint.and_then(|f| self.impls.get(&f)).into_iter().flat_map(|i| i.iter()).map( move |(module_id, impl_id)| { - let module = Module { krate: self.krate, module_id: *module_id }; + let module = Module::new(self.krate, *module_id); ImplBlock::from_id(module, *impl_id) }, ) @@ -62,7 +62,7 @@ impl CrateImplBlocks { ) -> impl Iterator + 'a { self.impls_by_trait.get(&tr).into_iter().flat_map(|i| i.iter()).map( move |(module_id, impl_id)| { - let module = Module { krate: self.krate, module_id: *module_id }; + let module = Module::new(self.krate, *module_id); ImplBlock::from_id(module, *impl_id) }, ) @@ -71,7 +71,7 @@ impl CrateImplBlocks { pub fn all_impls<'a>(&'a self) -> impl Iterator + 'a { self.impls.values().chain(self.impls_by_trait.values()).flat_map(|i| i.iter()).map( move |(module_id, impl_id)| { - let module = Module { krate: self.krate, module_id: *module_id }; + let module = Module::new(self.krate, *module_id); ImplBlock::from_id(module, *impl_id) }, ) @@ -90,14 +90,14 @@ impl CrateImplBlocks { self.impls_by_trait .entry(tr.trait_) .or_insert_with(Vec::new) - .push((module.module_id, impl_id)); + .push((module.id.module_id, impl_id)); } } else { if let Some(target_ty_fp) = TyFingerprint::for_impl(&target_ty) { self.impls .entry(target_ty_fp) .or_insert_with(Vec::new) - .push((module.module_id, impl_id)); + .push((module.id.module_id, impl_id)); } } } diff --git a/crates/ra_hir/src/ty/traits/chalk.rs b/crates/ra_hir/src/ty/traits/chalk.rs index e18c28cf6..aec484feb 100644 --- a/crates/ra_hir/src/ty/traits/chalk.rs +++ b/crates/ra_hir/src/ty/traits/chalk.rs @@ -537,7 +537,7 @@ pub(crate) fn trait_datum_query( let trait_ref = trait_.trait_ref(db).subst(&bound_vars).to_chalk(db); let flags = chalk_rust_ir::TraitFlags { auto: trait_.is_auto(db), - upstream: trait_.module(db).krate(db) != Some(krate), + upstream: trait_.module(db).krate() != krate, non_enumerable: true, // FIXME set these flags correctly marker: false, @@ -625,7 +625,7 @@ fn impl_block_datum( .target_trait_ref(db) .expect("FIXME handle unresolved impl block trait ref") .subst(&bound_vars); - let impl_type = if impl_block.module().krate(db) == Some(krate) { + let impl_type = if impl_block.module().krate() == krate { chalk_rust_ir::ImplType::Local } else { chalk_rust_ir::ImplType::External diff --git a/crates/ra_hir_def/Cargo.toml b/crates/ra_hir_def/Cargo.toml new file mode 100644 index 000000000..f22a678eb --- /dev/null +++ b/crates/ra_hir_def/Cargo.toml @@ -0,0 +1,13 @@ +[package] +edition = "2018" +name = "ra_hir_def" +version = "0.1.0" +authors = ["rust-analyzer developers"] + +[dependencies] +log = "0.4.5" + +ra_arena = { path = "../ra_arena" } +ra_db = { path = "../ra_db" } +ra_syntax = { path = "../ra_syntax" } +ra_prof = { path = "../ra_prof" } diff --git a/crates/ra_hir_def/src/lib.rs b/crates/ra_hir_def/src/lib.rs new file mode 100644 index 000000000..f5dd2ae6f --- /dev/null +++ b/crates/ra_hir_def/src/lib.rs @@ -0,0 +1,14 @@ +use ra_arena::{impl_arena_id, RawId}; +use ra_db::CrateId; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +pub struct ModuleId { + pub krate: CrateId, + pub module_id: CrateModuleId, +} + +/// An ID of a module, **local** to a specific crate +// FIXME: rename to `LocalModuleId`. +#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] +pub struct CrateModuleId(RawId); +impl_arena_id!(CrateModuleId); -- cgit v1.2.3