mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge #2600

Browse Source 
2600: Plumbing for local items support r=matklad a=matklad

bors r+

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

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

@ -17,7 +17,7 @@ use crate::{
nameres::{BuiltinShadowMode, CrateDefMap},
path::{ModPath, Path},
src::HasSource,
DefWithBodyId, HasModule, Lookup, ModuleId,
DefWithBodyId, HasModule, Lookup, ModuleDefId, ModuleId,
};
struct Expander {
@ -119,6 +119,7 @@ pub struct Body {
pub params: Vec<PatId>,
/// The `ExprId` of the actual body expression.
pub body_expr: ExprId,
pub defs: Vec<ModuleDefId>,
}
pub type ExprPtr = Either<AstPtr<ast::Expr>, AstPtr<ast::RecordField>>;

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

@ -41,6 +41,7 @@ pub(super) fn lower(
pats: Arena::default(),
params: Vec::new(),
body_expr: ExprId::dummy(),
defs: Vec::new(),
},
}
.collect(params, body)

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

@ -11,8 +11,8 @@ use crate::{
dyn_map::DynMap,
keys,
src::{HasChildSource, HasSource},
AdtId, AssocItemId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId, ModuleId,
StructFieldId, TraitId, VariantId,
AdtId, AssocItemId, DefWithBodyId, EnumId, EnumVariantId, ImplId, Lookup, ModuleDefId,
ModuleId, StructFieldId, TraitId, VariantId,
};
pub trait ChildBySource {
@ -76,47 +76,11 @@ impl ChildBySource for ModuleId {
let mut res = DynMap::default();
let crate_def_map = db.crate_def_map(self.krate);
for item in crate_def_map[self.local_id].scope.declarations() {
match item {
ModuleDefId::FunctionId(func) => {
let src = func.lookup(db).source(db);
res[keys::FUNCTION].insert(src, func)
}
ModuleDefId::ConstId(konst) => {
let src = konst.lookup(db).source(db);
res[keys::CONST].insert(src, konst)
}
ModuleDefId::StaticId(statik) => {
let src = statik.lookup(db).source(db);
res[keys::STATIC].insert(src, statik)
}
ModuleDefId::TypeAliasId(ty) => {
let src = ty.lookup(db).source(db);
res[keys::TYPE_ALIAS].insert(src, ty)
}
ModuleDefId::TraitId(trait_) => {
let src = trait_.lookup(db).source(db);
res[keys::TRAIT].insert(src, trait_)
}
ModuleDefId::AdtId(adt) => match adt {
AdtId::StructId(strukt) => {
let src = strukt.lookup(db).source(db);
res[keys::STRUCT].insert(src, strukt)
}
AdtId::UnionId(union_) => {
let src = union_.lookup(db).source(db);
res[keys::UNION].insert(src, union_)
}
AdtId::EnumId(enum_) => {
let src = enum_.lookup(db).source(db);
res[keys::ENUM].insert(src, enum_)
}
},
_ => (),
}
}
let module_data = &crate_def_map[self.local_id];
for &impl_ in crate_def_map[self.local_id].impls.iter() {
module_data.scope.declarations().for_each(|item| add_module_def(db, &mut res, item));
for &impl_ in module_data.impls.iter() {
let src = impl_.lookup(db).source(db);
res[keys::IMPL].insert(src, impl_)
}
@ -125,6 +89,46 @@ impl ChildBySource for ModuleId {
}
}
fn add_module_def(db: &impl DefDatabase, map: &mut DynMap, item: ModuleDefId) {
match item {
ModuleDefId::FunctionId(func) => {
let src = func.lookup(db).source(db);
map[keys::FUNCTION].insert(src, func)
}
ModuleDefId::ConstId(konst) => {
let src = konst.lookup(db).source(db);
map[keys::CONST].insert(src, konst)
}
ModuleDefId::StaticId(statik) => {
let src = statik.lookup(db).source(db);
map[keys::STATIC].insert(src, statik)
}
ModuleDefId::TypeAliasId(ty) => {
let src = ty.lookup(db).source(db);
map[keys::TYPE_ALIAS].insert(src, ty)
}
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_)
}
},
_ => (),
}
}
impl ChildBySource for VariantId {
fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
let mut res = DynMap::default();
@ -160,3 +164,12 @@ impl ChildBySource for EnumId {
res
}
}
impl ChildBySource for DefWithBodyId {
fn child_by_source(&self, db: &impl DefDatabase) -> DynMap {
let mut res = DynMap::default();
let body = db.body(*self);
body.defs.iter().copied().for_each(|item| add_module_def(db, &mut res, item));
res
}
}

24
crates/ra_hir_def/src/lib.rs
View File

@ -335,6 +335,7 @@ pub enum ContainerId {
ModuleId(ModuleId),
ImplId(ImplId),
TraitId(TraitId),
DefWithBodyId(DefWithBodyId),
}
/// A Data Type
@ -478,33 +479,32 @@ pub trait HasModule {
fn module(&self, db: &impl db::DefDatabase) -> ModuleId;
}
impl HasModule for FunctionLoc {
impl HasModule for ContainerId {
fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
match self.container {
match *self {
ContainerId::ModuleId(it) => it,
ContainerId::ImplId(it) => it.lookup(db).container,
ContainerId::TraitId(it) => it.lookup(db).container,
ContainerId::DefWithBodyId(it) => it.module(db),
}
}
}
impl HasModule for FunctionLoc {
fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
self.container.module(db)
}
}
impl HasModule for TypeAliasLoc {
fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
match self.container {
ContainerId::ModuleId(it) => it,
ContainerId::ImplId(it) => it.lookup(db).container,
ContainerId::TraitId(it) => it.lookup(db).container,
}
self.container.module(db)
}
}
impl HasModule for ConstLoc {
fn module(&self, db: &impl db::DefDatabase) -> ModuleId {
match self.container {
ContainerId::ModuleId(it) => it,
ContainerId::ImplId(it) => it.lookup(db).container,
ContainerId::TraitId(it) => it.lookup(db).container,
}
self.container.module(db)
}
}

1
crates/ra_hir_def/src/resolver.rs
View File

@ -586,6 +586,7 @@ impl HasResolver for ContainerId {
ContainerId::TraitId(it) => it.resolver(db),
ContainerId::ImplId(it) => it.resolver(db),
ContainerId::ModuleId(it) => it.resolver(db),
ContainerId::DefWithBodyId(it) => it.resolver(db),
}
}
}

2
crates/ra_hir_ty/src/infer/path.rs
View File

@ -237,7 +237,7 @@ impl<'a, D: HirDatabase> InferenceContext<'a, D> {
}));
Some(substs)
}
ContainerId::ModuleId(_) => None,
ContainerId::ModuleId(_) | ContainerId::DefWithBodyId(_) => None,
};
self.write_assoc_resolution(id, item.into());

10
crates/ra_hir_ty/src/method_resolution.rs
View File

@ -6,8 +6,8 @@ use std::sync::Arc;
use arrayvec::ArrayVec;
use hir_def::{
lang_item::LangItemTarget, resolver::Resolver, type_ref::Mutability, AssocItemId, FunctionId,
HasModule, ImplId, Lookup, TraitId,
lang_item::LangItemTarget, resolver::Resolver, type_ref::Mutability, AssocItemId, ContainerId,
FunctionId, HasModule, ImplId, Lookup, TraitId,
};
use hir_expand::name::Name;
use ra_db::CrateId;
@ -451,12 +451,12 @@ fn transform_receiver_ty(
self_ty: &Canonical<Ty>,
) -> Option<Ty> {
let substs = match function_id.lookup(db).container {
hir_def::ContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
ContainerId::TraitId(_) => Substs::build_for_def(db, function_id)
.push(self_ty.value.clone())
.fill_with_unknown()
.build(),
hir_def::ContainerId::ImplId(impl_id) => inherent_impl_substs(db, impl_id, &self_ty)?,
hir_def::ContainerId::ModuleId(_) => unreachable!(),
ContainerId::ImplId(impl_id) => inherent_impl_substs(db, impl_id, &self_ty)?,
ContainerId::ModuleId(_) | ContainerId::DefWithBodyId(_) => unreachable!(),
};
let sig = db.callable_item_signature(function_id.into());
Some(sig.params()[0].clone().subst(&substs))

2
crates/ra_hir_ty/src/utils.rs
View File

@ -157,6 +157,6 @@ fn parent_generic_def(db: &impl DefDatabase, def: GenericDefId) -> Option<Generi
match container {
ContainerId::ImplId(it) => Some(it.into()),
ContainerId::TraitId(it) => Some(it.into()),
ContainerId::ModuleId(_) => None,
ContainerId::ModuleId(_) | ContainerId::DefWithBodyId(_) => None,
}
}