language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-09-29 21:35:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 4

Auto merge of #12003 - Veykril:hir-ty-simplify, r=Veykril

Browse source 
internal: Remove duplicated crate id field from hir::Type
This commit is contained in:
bors 2022-04-15 18:25:02 +00:00
commit e10284a10c
3 changed files with 55 additions and 87 deletions
Download patch file Download diff file Expand all files Collapse all files

124
crates/hir/src/lib.rs
View file

@ -809,7 +809,7 @@ impl Field {
}; };
let substs = TyBuilder::placeholder_subst(db, generic_def_id); let substs = TyBuilder::placeholder_subst(db, generic_def_id);
let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs); let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs);
Type::new(db, self.parent.module(db).id.krate(), var_id, ty) Type::new(db, var_id, ty)
} }
pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef { pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
@ -850,7 +850,7 @@ impl Struct {
} }
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id) Type::from_def(db, self.id)
} }
pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprKind> { pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprKind> {
@ -887,7 +887,7 @@ impl Union {
} }
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id) Type::from_def(db, self.id)
} }
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> { pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@ -929,7 +929,7 @@ impl Enum {
} }
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id) Type::from_def(db, self.id)
} }
} }
@ -1005,7 +1005,7 @@ impl Adt {
/// general set of completions, but will not look very nice when printed. /// general set of completions, but will not look very nice when printed.
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
let id = AdtId::from(self); let id = AdtId::from(self);
Type::from_def(db, id.module(db.upcast()).krate(), id) Type::from_def(db, id)
} }
/// Turns this ADT into a type with the given type parameters. This isn't /// Turns this ADT into a type with the given type parameters. This isn't
@ -1022,8 +1022,7 @@ impl Adt {
} }
}) })
.build(); .build();
let krate = id.module(db.upcast()).krate(); Type::new(db, id, ty)
Type::new(db, krate, id, ty)
} }
pub fn module(self, db: &dyn HirDatabase) -> Module { pub fn module(self, db: &dyn HirDatabase) -> Module {
@ -1213,18 +1212,8 @@ impl DefWithBody {
acc.push( acc.push(
TypeMismatch { TypeMismatch {
expr, expr,
expected: Type::new( expected: Type::new(db, DefWithBodyId::from(self), mismatch.expected.clone()),
db, actual: Type::new(db, DefWithBodyId::from(self), mismatch.actual.clone()),
krate,
DefWithBodyId::from(self),
mismatch.expected.clone(),
),
actual: Type::new(
db,
krate,
DefWithBodyId::from(self),
mismatch.actual.clone(),
),
} }
.into(), .into(),
); );
@ -1369,11 +1358,10 @@ impl Function {
/// Get this function's return type /// Get this function's return type
pub fn ret_type(self, db: &dyn HirDatabase) -> Type { pub fn ret_type(self, db: &dyn HirDatabase) -> Type {
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.krate_id(db);
let ret_type = &db.function_data(self.id).ret_type; let ret_type = &db.function_data(self.id).ret_type;
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let ty = ctx.lower_ty(ret_type); let ty = ctx.lower_ty(ret_type);
Type::new_with_resolver_inner(db, krate, &resolver, ty) Type::new_with_resolver_inner(db, &resolver, ty)
} }
pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> { pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
@ -1385,7 +1373,6 @@ impl Function {
pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param> { pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param> {
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.krate_id(db);
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let environment = db.trait_environment(self.id.into()); let environment = db.trait_environment(self.id.into());
db.function_data(self.id) db.function_data(self.id)
@ -1393,7 +1380,7 @@ impl Function {
.iter() .iter()
.enumerate() .enumerate()
.map(|(idx, (_, type_ref))| { .map(|(idx, (_, type_ref))| {
let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) }; let ty = Type { env: environment.clone(), ty: ctx.lower_ty(type_ref) };
Param { func: self, ty, idx } Param { func: self, ty, idx }
}) })
.collect() .collect()
@ -1408,7 +1395,6 @@ impl Function {
pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param> { pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param> {
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.krate_id(db);
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let environment = db.trait_environment(self.id.into()); let environment = db.trait_environment(self.id.into());
let skip = if db.function_data(self.id).has_self_param() { 1 } else { 0 }; let skip = if db.function_data(self.id).has_self_param() { 1 } else { 0 };
@ -1418,7 +1404,7 @@ impl Function {
.enumerate() .enumerate()
.skip(skip) .skip(skip)
.map(|(idx, (_, type_ref))| { .map(|(idx, (_, type_ref))| {
let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) }; let ty = Type { env: environment.clone(), ty: ctx.lower_ty(type_ref) };
Param { func: self, ty, idx } Param { func: self, ty, idx }
}) })
.collect() .collect()
@ -1470,10 +1456,6 @@ impl Function {
result result
} }
fn krate_id(self, db: &dyn HirDatabase) -> CrateId {
self.id.lookup(db.upcast()).module(db.upcast()).krate()
}
} }
// Note: logically, this belongs to `hir_ty`, but we are not using it there yet. // Note: logically, this belongs to `hir_ty`, but we are not using it there yet.
@ -1575,11 +1557,10 @@ impl SelfParam {
pub fn ty(&self, db: &dyn HirDatabase) -> Type { pub fn ty(&self, db: &dyn HirDatabase) -> Type {
let resolver = self.func.resolver(db.upcast()); let resolver = self.func.resolver(db.upcast());
let krate = self.func.lookup(db.upcast()).container.module(db.upcast()).krate();
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let environment = db.trait_environment(self.func.into()); let environment = db.trait_environment(self.func.into());
Type { krate, env: environment, ty: ctx.lower_ty(&db.function_data(self.func).params[0].1) } Type { env: environment, ty: ctx.lower_ty(&db.function_data(self.func).params[0].1) }
} }
} }
@ -1610,10 +1591,9 @@ impl Const {
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
let data = db.const_data(self.id); let data = db.const_data(self.id);
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.id.lookup(db.upcast()).container.krate(db);
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let ty = ctx.lower_ty(&data.type_ref); let ty = ctx.lower_ty(&data.type_ref);
Type::new_with_resolver_inner(db, krate.id, &resolver, ty) Type::new_with_resolver_inner(db, &resolver, ty)
} }
pub fn eval(self, db: &dyn HirDatabase) -> Result<ComputedExpr, ConstEvalError> { pub fn eval(self, db: &dyn HirDatabase) -> Result<ComputedExpr, ConstEvalError> {
@ -1652,10 +1632,9 @@ impl Static {
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
let data = db.static_data(self.id); let data = db.static_data(self.id);
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.id.lookup(db.upcast()).container.module(db.upcast()).krate();
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let ty = ctx.lower_ty(&data.type_ref); let ty = ctx.lower_ty(&data.type_ref);
Type::new_with_resolver_inner(db, krate, &resolver, ty) Type::new_with_resolver_inner(db, &resolver, ty)
} }
} }
@ -1727,7 +1706,7 @@ impl TypeAlias {
} }
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
Type::from_def(db, self.id.lookup(db.upcast()).module(db.upcast()).krate(), self.id) Type::from_def(db, self.id)
} }
pub fn name(self, db: &dyn HirDatabase) -> Name { pub fn name(self, db: &dyn HirDatabase) -> Name {
@ -2185,8 +2164,7 @@ impl Local {
let def = self.parent; let def = self.parent;
let infer = db.infer(def); let infer = db.infer(def);
let ty = infer[self.pat_id].clone(); let ty = infer[self.pat_id].clone();
let krate = def.module(db.upcast()).krate(); Type::new(db, def, ty)
Type::new(db, krate, def, ty)
} }
pub fn associated_locals(self, db: &dyn HirDatabase) -> Box<[Local]> { pub fn associated_locals(self, db: &dyn HirDatabase) -> Box<[Local]> {
@ -2373,10 +2351,9 @@ impl TypeParam {
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
let resolver = self.id.parent().resolver(db.upcast()); let resolver = self.id.parent().resolver(db.upcast());
let krate = self.id.parent().module(db.upcast()).krate();
let ty = let ty =
TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner); TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);
Type::new_with_resolver_inner(db, krate, &resolver, ty) Type::new_with_resolver_inner(db, &resolver, ty)
} }
/// FIXME: this only lists trait bounds from the item defining the type /// FIXME: this only lists trait bounds from the item defining the type
@ -2398,14 +2375,11 @@ impl TypeParam {
let params = db.generic_defaults(self.id.parent()); let params = db.generic_defaults(self.id.parent());
let local_idx = hir_ty::param_idx(db, self.id.into())?; let local_idx = hir_ty::param_idx(db, self.id.into())?;
let resolver = self.id.parent().resolver(db.upcast()); let resolver = self.id.parent().resolver(db.upcast());
let krate = self.id.parent().module(db.upcast()).krate();
let ty = params.get(local_idx)?.clone(); let ty = params.get(local_idx)?.clone();
let subst = TyBuilder::placeholder_subst(db, self.id.parent()); let subst = TyBuilder::placeholder_subst(db, self.id.parent());
let ty = ty.substitute(Interner, &subst_prefix(&subst, local_idx)); let ty = ty.substitute(Interner, &subst_prefix(&subst, local_idx));
match ty.data(Interner) { match ty.data(Interner) {
GenericArgData::Ty(x) => { GenericArgData::Ty(x) => Some(Type::new_with_resolver_inner(db, &resolver, x.clone())),
Some(Type::new_with_resolver_inner(db, krate, &resolver, x.clone()))
}
_ => None, _ => None,
} }
} }
@ -2461,9 +2435,7 @@ impl ConstParam {
} }
pub fn ty(self, db: &dyn HirDatabase) -> Type { pub fn ty(self, db: &dyn HirDatabase) -> Type {
let def = self.id.parent(); Type::new(db, self.id.parent(), db.const_param_ty(self.id))
let krate = def.module(db.upcast()).krate();
Type::new(db, krate, def, db.const_param_ty(self.id))
} }
} }
@ -2522,8 +2494,8 @@ impl Impl {
inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect() inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
} }
pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> { pub fn all_for_type(db: &dyn HirDatabase, Type { ty, env }: Type) -> Vec<Impl> {
let def_crates = match method_resolution::def_crates(db, &ty, krate) { let def_crates = match method_resolution::def_crates(db, &ty, env.krate) {
Some(def_crates) => def_crates, Some(def_crates) => def_crates,
None => return Vec::new(), None => return Vec::new(),
}; };
@ -2589,10 +2561,9 @@ impl Impl {
pub fn self_ty(self, db: &dyn HirDatabase) -> Type { pub fn self_ty(self, db: &dyn HirDatabase) -> Type {
let impl_data = db.impl_data(self.id); let impl_data = db.impl_data(self.id);
let resolver = self.id.resolver(db.upcast()); let resolver = self.id.resolver(db.upcast());
let krate = self.id.lookup(db.upcast()).container.krate();
let ctx = hir_ty::TyLoweringContext::new(db, &resolver); let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
let ty = ctx.lower_ty(&impl_data.self_ty); let ty = ctx.lower_ty(&impl_data.self_ty);
Type::new_with_resolver_inner(db, krate, &resolver, ty) Type::new_with_resolver_inner(db, &resolver, ty)
} }
pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> { pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
@ -2615,31 +2586,29 @@ impl Impl {
#[derive(Clone, PartialEq, Eq, Debug)] #[derive(Clone, PartialEq, Eq, Debug)]
pub struct Type { pub struct Type {
krate: CrateId, // FIXME this is probably redundant with the TraitEnvironment
env: Arc<TraitEnvironment>, env: Arc<TraitEnvironment>,
ty: Ty, ty: Ty,
} }
impl Type { impl Type {
pub(crate) fn new_with_resolver(db: &dyn HirDatabase, resolver: &Resolver, ty: Ty) -> Type { pub(crate) fn new_with_resolver(db: &dyn HirDatabase, resolver: &Resolver, ty: Ty) -> Type {
let krate = resolver.krate(); Type::new_with_resolver_inner(db, resolver, ty)
Type::new_with_resolver_inner(db, krate, resolver, ty)
} }
pub(crate) fn new_with_resolver_inner( pub(crate) fn new_with_resolver_inner(
db: &dyn HirDatabase, db: &dyn HirDatabase,
krate: CrateId,
resolver: &Resolver, resolver: &Resolver,
ty: Ty, ty: Ty,
) -> Type { ) -> Type {
let environment = resolver let environment = resolver.generic_def().map_or_else(
.generic_def() || Arc::new(TraitEnvironment::empty(resolver.krate())),
.map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d)); |d| db.trait_environment(d),
Type { krate, env: environment, ty } );
Type { env: environment, ty }
} }
pub(crate) fn new_for_crate(krate: CrateId, ty: Ty) -> Type { pub(crate) fn new_for_crate(krate: CrateId, ty: Ty) -> Type {
Type { krate, env: Arc::new(TraitEnvironment::empty(krate)), ty } Type { env: Arc::new(TraitEnvironment::empty(krate)), ty }
} }
pub fn reference(inner: &Type, m: Mutability) -> Type { pub fn reference(inner: &Type, m: Mutability) -> Type {
@ -2653,25 +2622,22 @@ impl Type {
) )
} }
fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type { fn new(db: &dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty) -> Type {
let resolver = lexical_env.resolver(db.upcast()); let resolver = lexical_env.resolver(db.upcast());
let environment = resolver let environment = resolver.generic_def().map_or_else(
.generic_def() || Arc::new(TraitEnvironment::empty(resolver.krate())),
.map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d)); |d| db.trait_environment(d),
Type { krate, env: environment, ty } );
Type { env: environment, ty }
} }
fn from_def( fn from_def(db: &dyn HirDatabase, def: impl HasResolver + Into<TyDefId>) -> Type {
db: &dyn HirDatabase,
krate: CrateId,
def: impl HasResolver + Into<TyDefId>,
) -> Type {
let ty = TyBuilder::def_ty(db, def.into()).fill_with_unknown().build(); let ty = TyBuilder::def_ty(db, def.into()).fill_with_unknown().build();
Type::new(db, krate, def, ty) Type::new(db, def, ty)
} }
pub fn new_slice(ty: Type) -> Type { pub fn new_slice(ty: Type) -> Type {
Type { krate: ty.krate, env: ty.env, ty: TyBuilder::slice(ty.ty) } Type { env: ty.env, ty: TyBuilder::slice(ty.ty) }
} }
pub fn is_unit(&self) -> bool { pub fn is_unit(&self) -> bool {
@ -2727,7 +2693,7 @@ impl Type {
/// This function is used in `.await` syntax completion. /// This function is used in `.await` syntax completion.
pub fn impls_future(&self, db: &dyn HirDatabase) -> bool { pub fn impls_future(&self, db: &dyn HirDatabase) -> bool {
let std_future_trait = db let std_future_trait = db
.lang_item(self.krate, SmolStr::new_inline("future_trait")) .lang_item(self.env.krate, SmolStr::new_inline("future_trait"))
.and_then(|it| it.as_trait()); .and_then(|it| it.as_trait());
let std_future_trait = match std_future_trait { let std_future_trait = match std_future_trait {
Some(it) => it, Some(it) => it,
@ -2744,7 +2710,7 @@ impl Type {
/// This function can be used to check if a particular type is callable, since FnOnce is a /// This function can be used to check if a particular type is callable, since FnOnce is a
/// supertrait of Fn and FnMut, so all callable types implements at least FnOnce. /// supertrait of Fn and FnMut, so all callable types implements at least FnOnce.
pub fn impls_fnonce(&self, db: &dyn HirDatabase) -> bool { pub fn impls_fnonce(&self, db: &dyn HirDatabase) -> bool {
let fnonce_trait = match FnTrait::FnOnce.get_id(db, self.krate) { let fnonce_trait = match FnTrait::FnOnce.get_id(db, self.env.krate) {
Some(it) => it, Some(it) => it,
None => return false, None => return false,
}; };
@ -2780,7 +2746,7 @@ impl Type {
binders: CanonicalVarKinds::empty(Interner), binders: CanonicalVarKinds::empty(Interner),
}; };
db.trait_solve(self.krate, goal).is_some() db.trait_solve(self.env.krate, goal).is_some()
} }
pub fn normalize_trait_assoc_type( pub fn normalize_trait_assoc_type(
@ -2815,7 +2781,7 @@ impl Type {
[TyVariableKind::General].into_iter(), [TyVariableKind::General].into_iter(),
); );
match db.trait_solve(self.krate, goal)? { match db.trait_solve(self.env.krate, goal)? {
Solution::Unique(s) => s Solution::Unique(s) => s
.value .value
.subst .subst
@ -2827,7 +2793,7 @@ impl Type {
} }
pub fn is_copy(&self, db: &dyn HirDatabase) -> bool { pub fn is_copy(&self, db: &dyn HirDatabase) -> bool {
let lang_item = db.lang_item(self.krate, SmolStr::new_inline("copy")); let lang_item = db.lang_item(self.env.krate, SmolStr::new_inline("copy"));
let copy_trait = match lang_item { let copy_trait = match lang_item {
Some(LangItemTarget::TraitId(it)) => it, Some(LangItemTarget::TraitId(it)) => it,
_ => return false, _ => return false,
@ -3170,7 +3136,7 @@ impl Type {
} }
fn derived(&self, ty: Ty) -> Type { fn derived(&self, ty: Ty) -> Type {
Type { krate: self.krate, env: self.env.clone(), ty } Type { env: self.env.clone(), ty }
} }
pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) { pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
@ -3480,7 +3446,7 @@ impl HasCrate for TypeAlias {
impl HasCrate for Type { impl HasCrate for Type {
fn krate(&self, _db: &dyn HirDatabase) -> Crate { fn krate(&self, _db: &dyn HirDatabase) -> Crate {
self.krate.into() self.env.krate.into()
} }
} }

10
crates/hir/src/source_analyzer.rs
View file

@ -44,7 +44,6 @@ use crate::{
Field, Function, Local, Macro, ModuleDef, Static, Struct, ToolModule, Trait, Type, TypeAlias, Field, Function, Local, Macro, ModuleDef, Static, Struct, ToolModule, Trait, Type, TypeAlias,
Variant, Variant,
}; };
use base_db::CrateId;
/// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of /// `SourceAnalyzer` is a convenience wrapper which exposes HIR API in terms of
/// original source files. It should not be used inside the HIR itself. /// original source files. It should not be used inside the HIR itself.
@ -414,7 +413,6 @@ impl SourceAnalyzer {
db: &dyn HirDatabase, db: &dyn HirDatabase,
literal: &ast::RecordExpr, literal: &ast::RecordExpr,
) -> Option<Vec<(Field, Type)>> { ) -> Option<Vec<(Field, Type)>> {
let krate = self.resolver.krate();
let body = self.body()?; let body = self.body()?;
let infer = self.infer.as_ref()?; let infer = self.infer.as_ref()?;
@ -423,7 +421,7 @@ impl SourceAnalyzer {
let (variant, missing_fields, _exhaustive) = let (variant, missing_fields, _exhaustive) =
record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?; record_literal_missing_fields(db, infer, expr_id, &body[expr_id])?;
let res = self.missing_fields(db, krate, substs, variant, missing_fields); let res = self.missing_fields(db, substs, variant, missing_fields);
Some(res) Some(res)
} }
@ -432,7 +430,6 @@ impl SourceAnalyzer {
db: &dyn HirDatabase, db: &dyn HirDatabase,
pattern: &ast::RecordPat, pattern: &ast::RecordPat,
) -> Option<Vec<(Field, Type)>> { ) -> Option<Vec<(Field, Type)>> {
let krate = self.resolver.krate();
let body = self.body()?; let body = self.body()?;
let infer = self.infer.as_ref()?; let infer = self.infer.as_ref()?;
@ -441,14 +438,13 @@ impl SourceAnalyzer {
let (variant, missing_fields, _exhaustive) = let (variant, missing_fields, _exhaustive) =
record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?; record_pattern_missing_fields(db, infer, pat_id, &body[pat_id])?;
let res = self.missing_fields(db, krate, substs, variant, missing_fields); let res = self.missing_fields(db, substs, variant, missing_fields);
Some(res) Some(res)
} }
fn missing_fields( fn missing_fields(
&self, &self,
db: &dyn HirDatabase, db: &dyn HirDatabase,
krate: CrateId,
substs: &Substitution, substs: &Substitution,
variant: VariantId, variant: VariantId,
missing_fields: Vec<LocalFieldId>, missing_fields: Vec<LocalFieldId>,
@ -460,7 +456,7 @@ impl SourceAnalyzer {
.map(|local_id| { .map(|local_id| {
let field = FieldId { parent: variant, local_id }; let field = FieldId { parent: variant, local_id };
let ty = field_types[local_id].clone().substitute(Interner, substs); let ty = field_types[local_id].clone().substitute(Interner, substs);
(field.into(), Type::new_with_resolver_inner(db, krate, &self.resolver, ty)) (field.into(), Type::new_with_resolver_inner(db, &self.resolver, ty))
}) })
.collect() .collect()
} }

8
crates/hir_def/src/resolver.rs
View file

@ -448,7 +448,13 @@ impl Resolver {
} }
pub fn krate(&self) -> CrateId { pub fn krate(&self) -> CrateId {
self.module_scope().0.krate() self.scopes
.get(0)
.and_then(|scope| match scope {
Scope::ModuleScope(m) => Some(m.def_map.krate()),
_ => None,
})
.expect("module scope invariant violated")
} }
pub fn where_predicates_in_scope( pub fn where_predicates_in_scope(