Skip to content

Commit 1ade318

Browse files
jackh726jackh726
committed
Remove remaining unneeded substitutions
1 parent 2eb55ac commit 1ade318

File tree

17 files changed

+169
-218
lines changed

17 files changed

+169
-218
lines changed

‎chalk-engine/src/slg.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -439,11 +439,13 @@ impl<I: Interner> MayInvalidate<'_, I> {
439439
(TyKind::FnDef(id_a, substitution_a), TyKind::FnDef(id_b, substitution_b)) => {
440440
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
441441
}
442-
(TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => {
443-
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
442+
(TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => {
443+
id_a != id_b
444+
|| self.aggregate_lifetimes(lifetime_a, lifetime_b)
445+
|| self.aggregate_tys(ty_a, ty_b)
444446
}
445-
(TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => {
446-
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
447+
(TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => {
448+
id_a != id_b || self.aggregate_tys(ty_a, ty_b)
447449
}
448450
(TyKind::Never, TyKind::Never) => false,
449451
(TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => {
@@ -459,9 +461,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
459461
TyKind::GeneratorWitness(id_a, substitution_a),
460462
TyKind::GeneratorWitness(id_b, substitution_b),
461463
) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
462-
(TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => {
463-
self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
464-
}
464+
(TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a != id_b,
465465
(TyKind::Error, TyKind::Error) => false,
466466

467467
(_, _) => true,

‎chalk-engine/src/slg/aggregate.rs‎

Lines changed: 26 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -303,14 +303,25 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
303303
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
304304
.map(|(&name, substitution)| TyKind::FnDef(name, substitution).intern(interner))
305305
.unwrap_or_else(|| self.new_ty_variable()),
306-
(TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => self
307-
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
308-
.map(|(&name, substitution)| TyKind::Ref(name, substitution).intern(interner))
309-
.unwrap_or_else(|| self.new_ty_variable()),
310-
(TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => self
311-
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
312-
.map(|(&name, substitution)| TyKind::Raw(name, substitution).intern(interner))
313-
.unwrap_or_else(|| self.new_ty_variable()),
306+
(TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => {
307+
if id_a == id_b {
308+
TyKind::Ref(
309+
*id_a,
310+
self.aggregate_lifetimes(lifetime_a, lifetime_b),
311+
self.aggregate_tys(ty_a, ty_b),
312+
)
313+
.intern(interner)
314+
} else {
315+
self.new_ty_variable()
316+
}
317+
}
318+
(TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => {
319+
if id_a == id_b {
320+
TyKind::Raw(*id_a, self.aggregate_tys(ty_a, ty_b)).intern(interner)
321+
} else {
322+
self.new_ty_variable()
323+
}
324+
}
314325
(TyKind::Never, TyKind::Never) => TyKind::Never.intern(interner),
315326
(TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => TyKind::Array(
316327
self.aggregate_tys(ty_a, ty_b),
@@ -337,10 +348,13 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
337348
TyKind::GeneratorWitness(name, substitution).intern(interner)
338349
})
339350
.unwrap_or_else(|| self.new_ty_variable()),
340-
(TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => self
341-
.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
342-
.map(|(&name, substitution)| TyKind::Foreign(name, substitution).intern(interner))
343-
.unwrap_or_else(|| self.new_ty_variable()),
351+
(TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => {
352+
if id_a == id_b {
353+
TyKind::Foreign(*id_a).intern(interner)
354+
} else {
355+
self.new_ty_variable()
356+
}
357+
}
344358
(TyKind::Error, TyKind::Error) => TyKind::Error.intern(interner),
345359

346360
(_, _) => self.new_ty_variable(),

‎chalk-engine/src/slg/resolvent.rs‎

Lines changed: 7 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -443,18 +443,16 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
443443
Zip::zip_with(self, substitution_a, substitution_b)
444444
}
445445
(
446-
TyKind::Ref(mutability_a, substitution_a),
447-
TyKind::Ref(mutability_b, substitution_b),
446+
TyKind::Ref(mutability_a, lifetime_a, ty_a),
447+
TyKind::Ref(mutability_b, lifetime_b, ty_b),
448448
) => {
449449
Zip::zip_with(self, mutability_a, mutability_b)?;
450-
Zip::zip_with(self, substitution_a, substitution_b)
450+
Zip::zip_with(self, lifetime_a, lifetime_b)?;
451+
Zip::zip_with(self, ty_a, ty_b)
451452
}
452-
(
453-
TyKind::Raw(mutability_a, substitution_a),
454-
TyKind::Raw(mutability_b, substitution_b),
455-
) => {
453+
(TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => {
456454
Zip::zip_with(self, mutability_a, mutability_b)?;
457-
Zip::zip_with(self, substitution_a, substitution_b)
455+
Zip::zip_with(self, ty_a, ty_b)
458456
}
459457
(TyKind::Never, TyKind::Never) => Ok(()),
460458
(TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => {
@@ -476,10 +474,7 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
476474
Zip::zip_with(self, id_a, id_b)?;
477475
Zip::zip_with(self, substitution_a, substitution_b)
478476
}
479-
(TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => {
480-
Zip::zip_with(self, id_a, id_b)?;
481-
Zip::zip_with(self, substitution_a, substitution_b)
482-
}
477+
(TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => Zip::zip_with(self, id_a, id_b),
483478
(TyKind::Error, TyKind::Error) => Ok(()),
484479

485480
(_, _) => panic!(

‎chalk-integration/src/lowering.rs‎

Lines changed: 5 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -788,30 +788,16 @@ impl LowerWithEnv for Ty {
788788

789789
Ty::Slice { ty } => chalk_ir::TyKind::Slice(ty.lower(env)?).intern(interner),
790790

791-
Ty::Raw { mutability, ty } => chalk_ir::TyKind::Raw(
792-
mutability.lower(),
793-
chalk_ir::Substitution::from_fallible(
794-
interner,
795-
std::iter::once(Ok(ty.lower(env)?)),
796-
)?,
797-
)
798-
.intern(interner),
791+
Ty::Raw { mutability, ty } => {
792+
chalk_ir::TyKind::Raw(mutability.lower(), ty.lower(env)?).intern(interner)
793+
}
799794

800795
Ty::Ref {
801796
mutability,
802797
lifetime,
803798
ty,
804-
} => chalk_ir::TyKind::Ref(
805-
mutability.lower(),
806-
chalk_ir::Substitution::from_iter(
807-
interner,
808-
&[
809-
lifetime.lower(env)?.cast(interner),
810-
ty.lower(env)?.cast(interner),
811-
],
812-
),
813-
)
814-
.intern(interner),
799+
} => chalk_ir::TyKind::Ref(mutability.lower(), lifetime.lower(env)?, ty.lower(env)?)
800+
.intern(interner),
815801

816802
Ty::Str => chalk_ir::TyKind::Str.intern(interner),
817803

‎chalk-integration/src/lowering/env.rs‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -162,12 +162,9 @@ impl Env<'_> {
162162
))
163163
.intern(interner)
164164
.cast(interner)),
165-
Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign(
166-
id,
167-
chalk_ir::Substitution::empty(interner),
168-
)
169-
.intern(interner)
170-
.cast(interner)),
165+
Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign(id)
166+
.intern(interner)
167+
.cast(interner)),
171168
Ok(TypeLookup::Trait(_)) => Err(RustIrError::NotStruct(name.clone())),
172169
Err(_) => Err(RustIrError::InvalidParameterName(name.clone())),
173170
}

‎chalk-integration/src/program.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -464,7 +464,7 @@ impl RustIrDatabase<ChalkIr> for Program {
464464
(TyKind::OpaqueType(id_a, _), TyKind::OpaqueType(id_b, _)) => id_a == id_b,
465465
(TyKind::Slice(_), TyKind::Slice(_)) => true,
466466
(TyKind::FnDef(id_a, _), TyKind::FnDef(id_b, _)) => id_a == id_b,
467-
(TyKind::Ref(id_a, _), TyKind::Ref(id_b, _)) => id_a == id_b,
467+
(TyKind::Ref(id_a, _, _), TyKind::Ref(id_b, _, _)) => id_a == id_b,
468468
(TyKind::Raw(id_a, _), TyKind::Raw(id_b, _)) => id_a == id_b,
469469
(TyKind::Never, TyKind::Never) => true,
470470
(TyKind::Array(_, _), TyKind::Array(_, _)) => true,
@@ -473,7 +473,7 @@ impl RustIrDatabase<ChalkIr> for Program {
473473
(TyKind::GeneratorWitness(id_a, _), TyKind::GeneratorWitness(id_b, _)) => {
474474
id_a == id_b
475475
}
476-
(TyKind::Foreign(id_a, _), TyKind::Foreign(id_b, _)) => id_a == id_b,
476+
(TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a == id_b,
477477
(TyKind::Error, TyKind::Error) => true,
478478
(_, _) => false,
479479
}

‎chalk-ir/src/could_match.rs‎

Lines changed: 13 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -55,13 +55,16 @@ where
5555
TyKind::FnDef(fn_def_b, substitution_b),
5656
) => fn_def_a == fn_def_b && matches(substitution_a, substitution_b),
5757
(
58-
TyKind::Ref(mutability_a, substitution_a),
59-
TyKind::Ref(mutability_b, substitution_b),
60-
) => mutability_a == mutability_b && matches(substitution_a, substitution_b),
61-
(
62-
TyKind::Raw(mutability_a, substitution_a),
63-
TyKind::Raw(mutability_b, substitution_b),
64-
) => mutability_a == mutability_b && matches(substitution_a, substitution_b),
58+
TyKind::Ref(mutability_a, lifetime_a, ty_a),
59+
TyKind::Ref(mutability_b, lifetime_b, ty_b),
60+
) => {
61+
mutability_a == mutability_b
62+
&& lifetime_a.could_match(interner, &lifetime_b)
63+
&& ty_a.could_match(interner, &ty_b)
64+
}
65+
(TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => {
66+
mutability_a == mutability_b && ty_a.could_match(interner, &ty_b)
67+
}
6568
(TyKind::Never, TyKind::Never) => true,
6669
(TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => {
6770
ty_a.could_match(interner, ty_b) && const_a.could_match(interner, const_b)
@@ -78,10 +81,9 @@ where
7881
TyKind::GeneratorWitness(generator_a, substitution_a),
7982
TyKind::GeneratorWitness(generator_b, substitution_b),
8083
) => generator_a == generator_b && matches(substitution_a, substitution_b),
81-
(
82-
TyKind::Foreign(foreign_ty_a, substitution_a),
83-
TyKind::Foreign(foreign_ty_b, substitution_b),
84-
) => foreign_ty_a == foreign_ty_b && matches(substitution_a, substitution_b),
84+
(TyKind::Foreign(foreign_ty_a), TyKind::Foreign(foreign_ty_b)) => {
85+
foreign_ty_a == foreign_ty_b
86+
}
8587
(TyKind::Error, TyKind::Error) => true,
8688

8789
_ => true,

‎chalk-ir/src/debug.rs‎

Lines changed: 18 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -205,24 +205,14 @@ impl<I: Interner> Debug for TyKind<I> {
205205
}
206206
TyKind::Slice(substitution) => write!(fmt, "{{slice}}<{:?}>", substitution),
207207
TyKind::FnDef(fn_def, substitution) => write!(fmt, "{:?}<{:?}>", fn_def, substitution),
208-
TyKind::Ref(mutability, substitution) => write!(
209-
fmt,
210-
"{}<{:?}>",
211-
match mutability {
212-
Mutability::Mut => "{{&mut}}",
213-
Mutability::Not => "{{&}}",
214-
},
215-
substitution,
216-
),
217-
TyKind::Raw(mutability, substitution) => write!(
218-
fmt,
219-
"{}<{:?}>",
220-
match mutability {
221-
Mutability::Mut => "{{*mut}}",
222-
Mutability::Not => "{{*const}}",
223-
},
224-
substitution,
225-
),
208+
TyKind::Ref(mutability, lifetime, ty) => match mutability {
209+
Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty),
210+
Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty),
211+
},
212+
TyKind::Raw(mutability, ty) => match mutability {
213+
Mutability::Mut => write!(fmt, "(*mut {:?})", ty),
214+
Mutability::Not => write!(fmt, "(*const {:?})", ty),
215+
},
226216
TyKind::Never => write!(fmt, "Never"),
227217
TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_),
228218
TyKind::Closure(id, substitution) => {
@@ -234,9 +224,7 @@ impl<I: Interner> Debug for TyKind<I> {
234224
TyKind::GeneratorWitness(witness, substitution) => {
235225
write!(fmt, "{:?}<{:?}>", witness, substitution)
236226
}
237-
TyKind::Foreign(foreign_ty, substitution) => {
238-
write!(fmt, "{:?}<{:?}>", foreign_ty, substitution)
239-
}
227+
TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty),
240228
TyKind::Error => write!(fmt, "{{error}}"),
241229
}
242230
}
@@ -505,24 +493,14 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> {
505493
TyKind::FnDef(fn_def, substitution) => {
506494
write!(fmt, "{:?}{:?}", fn_def, substitution.with_angle(interner))
507495
}
508-
TyKind::Ref(mutability, substitution) => write!(
509-
fmt,
510-
"{}{:?}",
511-
match mutability {
512-
Mutability::Mut => "{{&mut}}",
513-
Mutability::Not => "{{&}}",
514-
},
515-
substitution.with_angle(interner),
516-
),
517-
TyKind::Raw(mutability, substitution) => write!(
518-
fmt,
519-
"{}{:?}",
520-
match mutability {
521-
Mutability::Mut => "{{*mut}}",
522-
Mutability::Not => "{{*const}}",
523-
},
524-
substitution.with_angle(interner),
525-
),
496+
TyKind::Ref(mutability, lifetime, ty) => match mutability {
497+
Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty),
498+
Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty),
499+
},
500+
TyKind::Raw(mutability, ty) => match mutability {
501+
Mutability::Mut => write!(fmt, "(*mut {:?})", ty),
502+
Mutability::Not => write!(fmt, "(*const {:?})", ty),
503+
},
526504
TyKind::Never => write!(fmt, "Never"),
527505
TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_),
528506
TyKind::Closure(id, substitution) => write!(
@@ -540,12 +518,7 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> {
540518
TyKind::GeneratorWitness(witness, substitution) => {
541519
write!(fmt, "{:?}{:?}", witness, substitution.with_angle(interner))
542520
}
543-
TyKind::Foreign(foreign_ty, substitution) => write!(
544-
fmt,
545-
"{:?}{:?}",
546-
foreign_ty,
547-
substitution.with_angle(interner)
548-
),
521+
TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty,),
549522
TyKind::Error => write!(fmt, "{{error}}"),
550523
}
551524
}

‎chalk-ir/src/fold.rs‎

Lines changed: 7 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -463,14 +463,15 @@ where
463463
substitution.fold_with(folder, outer_binder)?,
464464
)
465465
.intern(folder.target_interner()),
466-
TyKind::Ref(mutability, substitution) => TyKind::Ref(
466+
TyKind::Ref(mutability, lifetime, ty) => TyKind::Ref(
467467
mutability.fold_with(folder, outer_binder)?,
468-
substitution.fold_with(folder, outer_binder)?,
468+
lifetime.fold_with(folder, outer_binder)?,
469+
ty.fold_with(folder, outer_binder)?,
469470
)
470471
.intern(folder.target_interner()),
471-
TyKind::Raw(mutability, substitution) => TyKind::Raw(
472+
TyKind::Raw(mutability, ty) => TyKind::Raw(
472473
mutability.fold_with(folder, outer_binder)?,
473-
substitution.fold_with(folder, outer_binder)?,
474+
ty.fold_with(folder, outer_binder)?,
474475
)
475476
.intern(folder.target_interner()),
476477
TyKind::Never => TyKind::Never.intern(folder.target_interner()),
@@ -494,11 +495,8 @@ where
494495
substitution.fold_with(folder, outer_binder)?,
495496
)
496497
.intern(folder.target_interner()),
497-
TyKind::Foreign(id, substitution) => TyKind::Foreign(
498-
id.fold_with(folder, outer_binder)?,
499-
substitution.fold_with(folder, outer_binder)?,
500-
)
501-
.intern(folder.target_interner()),
498+
TyKind::Foreign(id) => TyKind::Foreign(id.fold_with(folder, outer_binder)?)
499+
.intern(folder.target_interner()),
502500
TyKind::Error => TyKind::Error.intern(folder.target_interner()),
503501
})
504502
}

‎chalk-ir/src/lib.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -471,10 +471,10 @@ pub enum TyKind<I: Interner> {
471471
Slice(Ty<I>),
472472

473473
/// a raw pointer type like `*const T` or `*mut T`
474-
Raw(Mutability, Substitution<I>),
474+
Raw(Mutability, Ty<I>),
475475

476476
/// a reference type like `&T` or `&mut T`
477-
Ref(Mutability, Substitution<I>),
477+
Ref(Mutability, Lifetime<I>, Ty<I>),
478478

479479
/// a placeholder for opaque types like `impl Trait`
480480
OpaqueType(OpaqueTyId<I>, Substitution<I>),
@@ -498,7 +498,7 @@ pub enum TyKind<I: Interner> {
498498
GeneratorWitness(GeneratorId<I>, Substitution<I>),
499499

500500
/// foreign types
501-
Foreign(ForeignDefId<I>, Substitution<I>),
501+
Foreign(ForeignDefId<I>),
502502

503503
/// This can be used to represent an error, e.g. during name resolution of a type.
504504
/// Chalk itself will not produce this, just pass it through when given.

0 commit comments

Comments
 (0)