nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-07 20:43:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge #2646

Browse Source 
2646: Share impl Scope between modules and blocks r=matklad a=matklad



Co-authored-by: Aleksey Kladov <aleksey.kladov@gmail.com>
This commit is contained in:
bors[bot] 2019-12-22 14:57:34 +00:00 committed by GitHub
commit 78f7683b9a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 57 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
crates/ra_hir_def/src/body.rs
View File

@ -19,10 +19,11 @@ use crate::{
db::DefDatabase, db::DefDatabase,
expr::{Expr, ExprId, Pat, PatId}, expr::{Expr, ExprId, Pat, PatId},
item_scope::BuiltinShadowMode, item_scope::BuiltinShadowMode,
item_scope::ItemScope,
nameres::CrateDefMap, nameres::CrateDefMap,
path::{ModPath, Path}, path::{ModPath, Path},
src::HasSource, src::HasSource,
DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId, DefWithBodyId, HasModule, Lookup, ModuleId,
}; };
pub(crate) struct Expander { pub(crate) struct Expander {
@ -135,7 +136,7 @@ pub struct Body {
pub params: Vec<PatId>, pub params: Vec<PatId>,
/// The `ExprId` of the actual body expression. /// The `ExprId` of the actual body expression.
pub body_expr: ExprId, pub body_expr: ExprId,
pub defs: Vec<ModuleDefId>, pub item_scope: ItemScope,
} }
pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>; pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;

4
crates/ra_hir_def/src/body/lower.rs
View File

@ -46,7 +46,7 @@ pub(super) fn lower(
pats: Arena::default(), pats: Arena::default(),
params: Vec::new(), params: Vec::new(),
body_expr: ExprId::dummy(), body_expr: ExprId::dummy(),
defs: Vec::new(), item_scope: Default::default(),
}, },
} }
.collect(params, body) .collect(params, body)
@ -532,7 +532,7 @@ where
| ast::ModuleItem::ExternCrateItem(_) | ast::ModuleItem::ExternCrateItem(_)
| ast::ModuleItem::Module(_) => continue, | ast::ModuleItem::Module(_) => continue,
}; };
self.body.defs.push(def) self.body.item_scope.define_def(def)
} }
} }

102
crates/ra_hir_def/src/child_by_source.rs
View File

@ -9,6 +9,7 @@ use either::Either;
use crate::{ use crate::{
db::DefDatabase, db::DefDatabase,
dyn_map::DynMap, dyn_map::DynMap,
item_scope::ItemScope,
keys, keys,
src::{HasChildSource, HasSource}, src::{HasChildSource, HasSource},
AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId, AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId,
@ -73,59 +74,62 @@ impl ChildBySource for ImplId {
impl ChildBySource for ModuleId { impl ChildBySource for ModuleId {
fn child_by_source(&self, db: &impl DefDatabase) -> DynMap { fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
let mut res = DynMap::default();
let crate_def_map = db.crate_def_map(self.krate); let crate_def_map = db.crate_def_map(self.krate);
let module_data = &crate_def_map[self.local_id]; let module_data = &crate_def_map[self.local_id];
module_data.scope.child_by_source(db)
module_data.scope.declarations().for_each(|item| add_module_def(db, &mut res, item));
for imp in module_data.scope.impls() {
let src = imp.lookup(db).source(db);
res[keys::IMPL].insert(src, imp)
}
res
} }
} }
fn add_module_def(db: &impl DefDatabase, map: &mut DynMap, item: ModuleDefId) { impl ChildBySource for ItemScope {
match item { fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
ModuleDefId::FunctionId(func) => { let mut res = DynMap::default();
let src = func.lookup(db).source(db); self.declarations().for_each(|item| add_module_def(db, &mut res, item));
map[keys::FUNCTION].insert(src, func) self.impls().for_each(|imp| add_impl(db, &mut res, imp));
} return res;
ModuleDefId::ConstId(konst) => {
let src = konst.lookup(db).source(db); fn add_module_def(db: &impl DefDatabase, map: &mut DynMap, item: ModuleDefId) {
map[keys::CONST].insert(src, konst) match item {
} ModuleDefId::FunctionId(func) => {
ModuleDefId::StaticId(statik) => { let src = func.lookup(db).source(db);
let src = statik.lookup(db).source(db); map[keys::FUNCTION].insert(src, func)
map[keys::STATIC].insert(src, statik) }
} ModuleDefId::ConstId(konst) => {
ModuleDefId::TypeAliasId(ty) => { let src = konst.lookup(db).source(db);
let src = ty.lookup(db).source(db); map[keys::CONST].insert(src, konst)
map[keys::TYPE_ALIAS].insert(src, ty) }
} ModuleDefId::StaticId(statik) => {
ModuleDefId::TraitId(trait_) => { let src = statik.lookup(db).source(db);
let src = trait_.lookup(db).source(db); map[keys::STATIC].insert(src, statik)
map[keys::TRAIT].insert(src, trait_) }
} ModuleDefId::TypeAliasId(ty) => {
ModuleDefId::AdtId(adt) => match adt { let src = ty.lookup(db).source(db);
AdtId::StructId(strukt) => { map[keys::TYPE_ALIAS].insert(src, ty)
let src = strukt.lookup(db).source(db); }
map[keys::STRUCT].insert(src, strukt) ModuleDefId::TraitId(trait_) => {
let src = trait_.lookup(db).source(db);
map[keys::TRAIT].insert(src, trait_)
}
ModuleDefId::AdtId(adt) => match adt {
AdtId::StructId(strukt) => {
let src = strukt.lookup(db).source(db);
map[keys::STRUCT].insert(src, strukt)
}
AdtId::UnionId(union_) => {
let src = union_.lookup(db).source(db);
map[keys::UNION].insert(src, union_)
}
AdtId::EnumId(enum_) => {
let src = enum_.lookup(db).source(db);
map[keys::ENUM].insert(src, enum_)
}
},
_ => (),
} }
AdtId::UnionId(union_) => { }
let src = union_.lookup(db).source(db); fn add_impl(db: &impl DefDatabase, map: &mut DynMap, imp: ImplId) {
map[keys::UNION].insert(src, union_) let src = imp.lookup(db).source(db);
} map[keys::IMPL].insert(src, imp)
AdtId::EnumId(enum_) => { }
let src = enum_.lookup(db).source(db);
map[keys::ENUM].insert(src, enum_)
}
},
_ => (),
} }
} }
@ -167,9 +171,7 @@ impl ChildBySource for EnumId {
impl ChildBySource for DefWithBodyId { impl ChildBySource for DefWithBodyId {
fn child_by_source(&self, db: &impl DefDatabase) -> DynMap { fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
let mut res = DynMap::default();
let body = db.body(*self); let body = db.body(*self);
body.defs.iter().copied().for_each(|item| add_module_def(db, &mut res, item)); body.item_scope.child_by_source(db)
res
} }
} }