Skip to content

Commit e10284a

Browse files
borsbors
committed
Auto merge of #12003 - Veykril:hir-ty-simplify, r=Veykril
internal: Remove duplicated crate id field from hir::Type
2 parents 9ed4597 + 17691ee commit e10284a

File tree

3 files changed

+55
-87
lines changed

3 files changed

+55
-87
lines changed

‎crates/hir/src/lib.rs

Lines changed: 45 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -809,7 +809,7 @@ impl Field {
809809
};
810810
let substs = TyBuilder::placeholder_subst(db, generic_def_id);
811811
let ty = db.field_types(var_id)[self.id].clone().substitute(Interner, &substs);
812-
Type::new(db, self.parent.module(db).id.krate(), var_id, ty)
812+
Type::new(db, var_id, ty)
813813
}
814814

815815
pub fn parent_def(&self, _db: &dyn HirDatabase) -> VariantDef {
@@ -850,7 +850,7 @@ impl Struct {
850850
}
851851

852852
pub fn ty(self, db: &dyn HirDatabase) -> Type {
853-
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
853+
Type::from_def(db, self.id)
854854
}
855855

856856
pub fn repr(self, db: &dyn HirDatabase) -> Option<ReprKind> {
@@ -887,7 +887,7 @@ impl Union {
887887
}
888888

889889
pub fn ty(self, db: &dyn HirDatabase) -> Type {
890-
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
890+
Type::from_def(db, self.id)
891891
}
892892

893893
pub fn fields(self, db: &dyn HirDatabase) -> Vec<Field> {
@@ -929,7 +929,7 @@ impl Enum {
929929
}
930930

931931
pub fn ty(self, db: &dyn HirDatabase) -> Type {
932-
Type::from_def(db, self.id.lookup(db.upcast()).container.krate(), self.id)
932+
Type::from_def(db, self.id)
933933
}
934934
}
935935

@@ -1005,7 +1005,7 @@ impl Adt {
10051005
/// general set of completions, but will not look very nice when printed.
10061006
pub fn ty(self, db: &dyn HirDatabase) -> Type {
10071007
let id = AdtId::from(self);
1008-
Type::from_def(db, id.module(db.upcast()).krate(), id)
1008+
Type::from_def(db, id)
10091009
}
10101010

10111011
/// Turns this ADT into a type with the given type parameters. This isn't
@@ -1022,8 +1022,7 @@ impl Adt {
10221022
}
10231023
})
10241024
.build();
1025-
let krate = id.module(db.upcast()).krate();
1026-
Type::new(db, krate, id, ty)
1025+
Type::new(db, id, ty)
10271026
}
10281027

10291028
pub fn module(self, db: &dyn HirDatabase) -> Module {
@@ -1213,18 +1212,8 @@ impl DefWithBody {
12131212
acc.push(
12141213
TypeMismatch {
12151214
expr,
1216-
expected: Type::new(
1217-
db,
1218-
krate,
1219-
DefWithBodyId::from(self),
1220-
mismatch.expected.clone(),
1221-
),
1222-
actual: Type::new(
1223-
db,
1224-
krate,
1225-
DefWithBodyId::from(self),
1226-
mismatch.actual.clone(),
1227-
),
1215+
expected: Type::new(db, DefWithBodyId::from(self), mismatch.expected.clone()),
1216+
actual: Type::new(db, DefWithBodyId::from(self), mismatch.actual.clone()),
12281217
}
12291218
.into(),
12301219
);
@@ -1369,11 +1358,10 @@ impl Function {
13691358
/// Get this function's return type
13701359
pub fn ret_type(self, db: &dyn HirDatabase) -> Type {
13711360
let resolver = self.id.resolver(db.upcast());
1372-
let krate = self.krate_id(db);
13731361
let ret_type = &db.function_data(self.id).ret_type;
13741362
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
13751363
let ty = ctx.lower_ty(ret_type);
1376-
Type::new_with_resolver_inner(db, krate, &resolver, ty)
1364+
Type::new_with_resolver_inner(db, &resolver, ty)
13771365
}
13781366

13791367
pub fn self_param(self, db: &dyn HirDatabase) -> Option<SelfParam> {
@@ -1385,15 +1373,14 @@ impl Function {
13851373

13861374
pub fn assoc_fn_params(self, db: &dyn HirDatabase) -> Vec<Param> {
13871375
let resolver = self.id.resolver(db.upcast());
1388-
let krate = self.krate_id(db);
13891376
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
13901377
let environment = db.trait_environment(self.id.into());
13911378
db.function_data(self.id)
13921379
.params
13931380
.iter()
13941381
.enumerate()
13951382
.map(|(idx, (_, type_ref))| {
1396-
let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) };
1383+
let ty = Type { env: environment.clone(), ty: ctx.lower_ty(type_ref) };
13971384
Param { func: self, ty, idx }
13981385
})
13991386
.collect()
@@ -1408,7 +1395,6 @@ impl Function {
14081395

14091396
pub fn params_without_self(self, db: &dyn HirDatabase) -> Vec<Param> {
14101397
let resolver = self.id.resolver(db.upcast());
1411-
let krate = self.krate_id(db);
14121398
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
14131399
let environment = db.trait_environment(self.id.into());
14141400
let skip = if db.function_data(self.id).has_self_param() { 1 } else { 0 };
@@ -1418,7 +1404,7 @@ impl Function {
14181404
.enumerate()
14191405
.skip(skip)
14201406
.map(|(idx, (_, type_ref))| {
1421-
let ty = Type { krate, env: environment.clone(), ty: ctx.lower_ty(type_ref) };
1407+
let ty = Type { env: environment.clone(), ty: ctx.lower_ty(type_ref) };
14221408
Param { func: self, ty, idx }
14231409
})
14241410
.collect()
@@ -1470,10 +1456,6 @@ impl Function {
14701456

14711457
result
14721458
}
1473-
1474-
fn krate_id(self, db: &dyn HirDatabase) -> CrateId {
1475-
self.id.lookup(db.upcast()).module(db.upcast()).krate()
1476-
}
14771459
}
14781460

14791461
// Note: logically, this belongs to `hir_ty`, but we are not using it there yet.
@@ -1575,11 +1557,10 @@ impl SelfParam {
15751557

15761558
pub fn ty(&self, db: &dyn HirDatabase) -> Type {
15771559
let resolver = self.func.resolver(db.upcast());
1578-
let krate = self.func.lookup(db.upcast()).container.module(db.upcast()).krate();
15791560
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
15801561
let environment = db.trait_environment(self.func.into());
15811562

1582-
Type { krate, env: environment, ty: ctx.lower_ty(&db.function_data(self.func).params[0].1) }
1563+
Type { env: environment, ty: ctx.lower_ty(&db.function_data(self.func).params[0].1) }
15831564
}
15841565
}
15851566

@@ -1610,10 +1591,9 @@ impl Const {
16101591
pub fn ty(self, db: &dyn HirDatabase) -> Type {
16111592
let data = db.const_data(self.id);
16121593
let resolver = self.id.resolver(db.upcast());
1613-
let krate = self.id.lookup(db.upcast()).container.krate(db);
16141594
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
16151595
let ty = ctx.lower_ty(&data.type_ref);
1616-
Type::new_with_resolver_inner(db, krate.id, &resolver, ty)
1596+
Type::new_with_resolver_inner(db, &resolver, ty)
16171597
}
16181598

16191599
pub fn eval(self, db: &dyn HirDatabase) -> Result<ComputedExpr, ConstEvalError> {
@@ -1652,10 +1632,9 @@ impl Static {
16521632
pub fn ty(self, db: &dyn HirDatabase) -> Type {
16531633
let data = db.static_data(self.id);
16541634
let resolver = self.id.resolver(db.upcast());
1655-
let krate = self.id.lookup(db.upcast()).container.module(db.upcast()).krate();
16561635
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
16571636
let ty = ctx.lower_ty(&data.type_ref);
1658-
Type::new_with_resolver_inner(db, krate, &resolver, ty)
1637+
Type::new_with_resolver_inner(db, &resolver, ty)
16591638
}
16601639
}
16611640

@@ -1727,7 +1706,7 @@ impl TypeAlias {
17271706
}
17281707

17291708
pub fn ty(self, db: &dyn HirDatabase) -> Type {
1730-
Type::from_def(db, self.id.lookup(db.upcast()).module(db.upcast()).krate(), self.id)
1709+
Type::from_def(db, self.id)
17311710
}
17321711

17331712
pub fn name(self, db: &dyn HirDatabase) -> Name {
@@ -2185,8 +2164,7 @@ impl Local {
21852164
let def = self.parent;
21862165
let infer = db.infer(def);
21872166
let ty = infer[self.pat_id].clone();
2188-
let krate = def.module(db.upcast()).krate();
2189-
Type::new(db, krate, def, ty)
2167+
Type::new(db, def, ty)
21902168
}
21912169

21922170
pub fn associated_locals(self, db: &dyn HirDatabase) -> Box<[Local]> {
@@ -2373,10 +2351,9 @@ impl TypeParam {
23732351

23742352
pub fn ty(self, db: &dyn HirDatabase) -> Type {
23752353
let resolver = self.id.parent().resolver(db.upcast());
2376-
let krate = self.id.parent().module(db.upcast()).krate();
23772354
let ty =
23782355
TyKind::Placeholder(hir_ty::to_placeholder_idx(db, self.id.into())).intern(Interner);
2379-
Type::new_with_resolver_inner(db, krate, &resolver, ty)
2356+
Type::new_with_resolver_inner(db, &resolver, ty)
23802357
}
23812358

23822359
/// FIXME: this only lists trait bounds from the item defining the type
@@ -2398,14 +2375,11 @@ impl TypeParam {
23982375
let params = db.generic_defaults(self.id.parent());
23992376
let local_idx = hir_ty::param_idx(db, self.id.into())?;
24002377
let resolver = self.id.parent().resolver(db.upcast());
2401-
let krate = self.id.parent().module(db.upcast()).krate();
24022378
let ty = params.get(local_idx)?.clone();
24032379
let subst = TyBuilder::placeholder_subst(db, self.id.parent());
24042380
let ty = ty.substitute(Interner, &subst_prefix(&subst, local_idx));
24052381
match ty.data(Interner) {
2406-
GenericArgData::Ty(x) => {
2407-
Some(Type::new_with_resolver_inner(db, krate, &resolver, x.clone()))
2408-
}
2382+
GenericArgData::Ty(x) => Some(Type::new_with_resolver_inner(db, &resolver, x.clone())),
24092383
_ => None,
24102384
}
24112385
}
@@ -2461,9 +2435,7 @@ impl ConstParam {
24612435
}
24622436

24632437
pub fn ty(self, db: &dyn HirDatabase) -> Type {
2464-
let def = self.id.parent();
2465-
let krate = def.module(db.upcast()).krate();
2466-
Type::new(db, krate, def, db.const_param_ty(self.id))
2438+
Type::new(db, self.id.parent(), db.const_param_ty(self.id))
24672439
}
24682440
}
24692441

@@ -2522,8 +2494,8 @@ impl Impl {
25222494
inherent.all_impls().chain(trait_.all_impls()).map(Self::from).collect()
25232495
}
25242496

2525-
pub fn all_for_type(db: &dyn HirDatabase, Type { krate, ty, .. }: Type) -> Vec<Impl> {
2526-
let def_crates = match method_resolution::def_crates(db, &ty, krate) {
2497+
pub fn all_for_type(db: &dyn HirDatabase, Type { ty, env }: Type) -> Vec<Impl> {
2498+
let def_crates = match method_resolution::def_crates(db, &ty, env.krate) {
25272499
Some(def_crates) => def_crates,
25282500
None => return Vec::new(),
25292501
};
@@ -2589,10 +2561,9 @@ impl Impl {
25892561
pub fn self_ty(self, db: &dyn HirDatabase) -> Type {
25902562
let impl_data = db.impl_data(self.id);
25912563
let resolver = self.id.resolver(db.upcast());
2592-
let krate = self.id.lookup(db.upcast()).container.krate();
25932564
let ctx = hir_ty::TyLoweringContext::new(db, &resolver);
25942565
let ty = ctx.lower_ty(&impl_data.self_ty);
2595-
Type::new_with_resolver_inner(db, krate, &resolver, ty)
2566+
Type::new_with_resolver_inner(db, &resolver, ty)
25962567
}
25972568

25982569
pub fn items(self, db: &dyn HirDatabase) -> Vec<AssocItem> {
@@ -2615,31 +2586,29 @@ impl Impl {
26152586

26162587
#[derive(Clone, PartialEq, Eq, Debug)]
26172588
pub struct Type {
2618-
krate: CrateId, // FIXME this is probably redundant with the TraitEnvironment
26192589
env: Arc<TraitEnvironment>,
26202590
ty: Ty,
26212591
}
26222592

26232593
impl Type {
26242594
pub(crate) fn new_with_resolver(db: &dyn HirDatabase, resolver: &Resolver, ty: Ty) -> Type {
2625-
let krate = resolver.krate();
2626-
Type::new_with_resolver_inner(db, krate, resolver, ty)
2595+
Type::new_with_resolver_inner(db, resolver, ty)
26272596
}
26282597

26292598
pub(crate) fn new_with_resolver_inner(
26302599
db: &dyn HirDatabase,
2631-
krate: CrateId,
26322600
resolver: &Resolver,
26332601
ty: Ty,
26342602
) -> Type {
2635-
let environment = resolver
2636-
.generic_def()
2637-
.map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d));
2638-
Type { krate, env: environment, ty }
2603+
let environment = resolver.generic_def().map_or_else(
2604+
|| Arc::new(TraitEnvironment::empty(resolver.krate())),
2605+
|d| db.trait_environment(d),
2606+
);
2607+
Type { env: environment, ty }
26392608
}
26402609

26412610
pub(crate) fn new_for_crate(krate: CrateId, ty: Ty) -> Type {
2642-
Type { krate, env: Arc::new(TraitEnvironment::empty(krate)), ty }
2611+
Type { env: Arc::new(TraitEnvironment::empty(krate)), ty }
26432612
}
26442613

26452614
pub fn reference(inner: &Type, m: Mutability) -> Type {
@@ -2653,25 +2622,22 @@ impl Type {
26532622
)
26542623
}
26552624

2656-
fn new(db: &dyn HirDatabase, krate: CrateId, lexical_env: impl HasResolver, ty: Ty) -> Type {
2625+
fn new(db: &dyn HirDatabase, lexical_env: impl HasResolver, ty: Ty) -> Type {
26572626
let resolver = lexical_env.resolver(db.upcast());
2658-
let environment = resolver
2659-
.generic_def()
2660-
.map_or_else(|| Arc::new(TraitEnvironment::empty(krate)), |d| db.trait_environment(d));
2661-
Type { krate, env: environment, ty }
2627+
let environment = resolver.generic_def().map_or_else(
2628+
|| Arc::new(TraitEnvironment::empty(resolver.krate())),
2629+
|d| db.trait_environment(d),
2630+
);
2631+
Type { env: environment, ty }
26622632
}
26632633

2664-
fn from_def(
2665-
db: &dyn HirDatabase,
2666-
krate: CrateId,
2667-
def: impl HasResolver + Into<TyDefId>,
2668-
) -> Type {
2634+
fn from_def(db: &dyn HirDatabase, def: impl HasResolver + Into<TyDefId>) -> Type {
26692635
let ty = TyBuilder::def_ty(db, def.into()).fill_with_unknown().build();
2670-
Type::new(db, krate, def, ty)
2636+
Type::new(db, def, ty)
26712637
}
26722638

26732639
pub fn new_slice(ty: Type) -> Type {
2674-
Type { krate: ty.krate, env: ty.env, ty: TyBuilder::slice(ty.ty) }
2640+
Type { env: ty.env, ty: TyBuilder::slice(ty.ty) }
26752641
}
26762642

26772643
pub fn is_unit(&self) -> bool {
@@ -2727,7 +2693,7 @@ impl Type {
27272693
/// This function is used in `.await` syntax completion.
27282694
pub fn impls_future(&self, db: &dyn HirDatabase) -> bool {
27292695
let std_future_trait = db
2730-
.lang_item(self.krate, SmolStr::new_inline("future_trait"))
2696+
.lang_item(self.env.krate, SmolStr::new_inline("future_trait"))
27312697
.and_then(|it| it.as_trait());
27322698
let std_future_trait = match std_future_trait {
27332699
Some(it) => it,
@@ -2744,7 +2710,7 @@ impl Type {
27442710
/// This function can be used to check if a particular type is callable, since FnOnce is a
27452711
/// supertrait of Fn and FnMut, so all callable types implements at least FnOnce.
27462712
pub fn impls_fnonce(&self, db: &dyn HirDatabase) -> bool {
2747-
let fnonce_trait = match FnTrait::FnOnce.get_id(db, self.krate) {
2713+
let fnonce_trait = match FnTrait::FnOnce.get_id(db, self.env.krate) {
27482714
Some(it) => it,
27492715
None => return false,
27502716
};
@@ -2780,7 +2746,7 @@ impl Type {
27802746
binders: CanonicalVarKinds::empty(Interner),
27812747
};
27822748

2783-
db.trait_solve(self.krate, goal).is_some()
2749+
db.trait_solve(self.env.krate, goal).is_some()
27842750
}
27852751

27862752
pub fn normalize_trait_assoc_type(
@@ -2815,7 +2781,7 @@ impl Type {
28152781
[TyVariableKind::General].into_iter(),
28162782
);
28172783

2818-
match db.trait_solve(self.krate, goal)? {
2784+
match db.trait_solve(self.env.krate, goal)? {
28192785
Solution::Unique(s) => s
28202786
.value
28212787
.subst
@@ -2827,7 +2793,7 @@ impl Type {
28272793
}
28282794

28292795
pub fn is_copy(&self, db: &dyn HirDatabase) -> bool {
2830-
let lang_item = db.lang_item(self.krate, SmolStr::new_inline("copy"));
2796+
let lang_item = db.lang_item(self.env.krate, SmolStr::new_inline("copy"));
28312797
let copy_trait = match lang_item {
28322798
Some(LangItemTarget::TraitId(it)) => it,
28332799
_ => return false,
@@ -3170,7 +3136,7 @@ impl Type {
31703136
}
31713137

31723138
fn derived(&self, ty: Ty) -> Type {
3173-
Type { krate: self.krate, env: self.env.clone(), ty }
3139+
Type { env: self.env.clone(), ty }
31743140
}
31753141

31763142
pub fn walk(&self, db: &dyn HirDatabase, mut cb: impl FnMut(Type)) {
@@ -3480,7 +3446,7 @@ impl HasCrate for TypeAlias {
34803446

34813447
impl HasCrate for Type {
34823448
fn krate(&self, _db: &dyn HirDatabase) -> Crate {
3483-
self.krate.into()
3449+
self.env.krate.into()
34843450
}
34853451
}
34863452

0 commit comments

Comments
 (0)