Remove remaining unneeded substitutions

jackh726 · Oct 22, 2020 · 1ade318 · 1ade318
1 parent 2eb55ac
commit 1ade318
Show file tree

Hide file tree

Showing 17 changed files with 169 additions and 218 deletions.
diff --git a/chalk-engine/src/slg.rs b/chalk-engine/src/slg.rs
@@ -439,11 +439,13 @@ impl<I: Interner> MayInvalidate<'_, I> {
             (TyKind::FnDef(id_a, substitution_a), TyKind::FnDef(id_b, substitution_b)) => {
                 self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
             }
-            (TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => {
-                self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
+            (TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => {
+                id_a != id_b
+                    || self.aggregate_lifetimes(lifetime_a, lifetime_b)
+                    || self.aggregate_tys(ty_a, ty_b)
             }
-            (TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => {
-                self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
+            (TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => {
+                id_a != id_b || self.aggregate_tys(ty_a, ty_b)
             }
             (TyKind::Never, TyKind::Never) => false,
             (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => {
@@ -459,9 +461,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
                 TyKind::GeneratorWitness(id_a, substitution_a),
                 TyKind::GeneratorWitness(id_b, substitution_b),
             ) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
-            (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => {
-                self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
-            }
+            (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a != id_b,
             (TyKind::Error, TyKind::Error) => false,
 
             (_, _) => true,

diff --git a/chalk-engine/src/slg/aggregate.rs b/chalk-engine/src/slg/aggregate.rs
@@ -303,14 +303,25 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
                 .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
                 .map(|(&name, substitution)| TyKind::FnDef(name, substitution).intern(interner))
                 .unwrap_or_else(|| self.new_ty_variable()),
-            (TyKind::Ref(id_a, substitution_a), TyKind::Ref(id_b, substitution_b)) => self
-                .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
-                .map(|(&name, substitution)| TyKind::Ref(name, substitution).intern(interner))
-                .unwrap_or_else(|| self.new_ty_variable()),
-            (TyKind::Raw(id_a, substitution_a), TyKind::Raw(id_b, substitution_b)) => self
-                .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
-                .map(|(&name, substitution)| TyKind::Raw(name, substitution).intern(interner))
-                .unwrap_or_else(|| self.new_ty_variable()),
+            (TyKind::Ref(id_a, lifetime_a, ty_a), TyKind::Ref(id_b, lifetime_b, ty_b)) => {
+                if id_a == id_b {
+                    TyKind::Ref(
+                        *id_a,
+                        self.aggregate_lifetimes(lifetime_a, lifetime_b),
+                        self.aggregate_tys(ty_a, ty_b),
+                    )
+                    .intern(interner)
+                } else {
+                    self.new_ty_variable()
+                }
+            }
+            (TyKind::Raw(id_a, ty_a), TyKind::Raw(id_b, ty_b)) => {
+                if id_a == id_b {
+                    TyKind::Raw(*id_a, self.aggregate_tys(ty_a, ty_b)).intern(interner)
+                } else {
+                    self.new_ty_variable()
+                }
+            }
             (TyKind::Never, TyKind::Never) => TyKind::Never.intern(interner),
             (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => TyKind::Array(
                 self.aggregate_tys(ty_a, ty_b),
@@ -337,10 +348,13 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
                     TyKind::GeneratorWitness(name, substitution).intern(interner)
                 })
                 .unwrap_or_else(|| self.new_ty_variable()),
-            (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => self
-                .aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b)
-                .map(|(&name, substitution)| TyKind::Foreign(name, substitution).intern(interner))
-                .unwrap_or_else(|| self.new_ty_variable()),
+            (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => {
+                if id_a == id_b {
+                    TyKind::Foreign(*id_a).intern(interner)
+                } else {
+                    self.new_ty_variable()
+                }
+            }
             (TyKind::Error, TyKind::Error) => TyKind::Error.intern(interner),
 
             (_, _) => self.new_ty_variable(),

diff --git a/chalk-engine/src/slg/resolvent.rs b/chalk-engine/src/slg/resolvent.rs
@@ -443,18 +443,16 @@ impl<'i, I: Interner> Zipper<'i, I> for AnswerSubstitutor<'i, I> {
                 Zip::zip_with(self, substitution_a, substitution_b)
             }
             (
-                TyKind::Ref(mutability_a, substitution_a),
-                TyKind::Ref(mutability_b, substitution_b),
+                TyKind::Ref(mutability_a, lifetime_a, ty_a),
+                TyKind::Ref(mutability_b, lifetime_b, ty_b),
             ) => {
                 Zip::zip_with(self, mutability_a, mutability_b)?;
-                Zip::zip_with(self, substitution_a, substitution_b)
+                Zip::zip_with(self, lifetime_a, lifetime_b)?;
+                Zip::zip_with(self, ty_a, ty_b)
             }
-            (
-                TyKind::Raw(mutability_a, substitution_a),
-                TyKind::Raw(mutability_b, substitution_b),
-            ) => {
+            (TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => {
                 Zip::zip_with(self, mutability_a, mutability_b)?;
-                Zip::zip_with(self, substitution_a, substitution_b)
+                Zip::zip_with(self, ty_a, ty_b)
             }
             (TyKind::Never, TyKind::Never) => Ok(()),
             (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> {
                 Zip::zip_with(self, id_a, id_b)?;
                 Zip::zip_with(self, substitution_a, substitution_b)
             }
-            (TyKind::Foreign(id_a, substitution_a), TyKind::Foreign(id_b, substitution_b)) => {
-                Zip::zip_with(self, id_a, id_b)?;
-                Zip::zip_with(self, substitution_a, substitution_b)
-            }
+            (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => Zip::zip_with(self, id_a, id_b),
             (TyKind::Error, TyKind::Error) => Ok(()),
 
             (_, _) => panic!(

diff --git a/chalk-integration/src/lowering.rs b/chalk-integration/src/lowering.rs
@@ -788,30 +788,16 @@ impl LowerWithEnv for Ty {
 
             Ty::Slice { ty } => chalk_ir::TyKind::Slice(ty.lower(env)?).intern(interner),
 
-            Ty::Raw { mutability, ty } => chalk_ir::TyKind::Raw(
-                mutability.lower(),
-                chalk_ir::Substitution::from_fallible(
-                    interner,
-                    std::iter::once(Ok(ty.lower(env)?)),
-                )?,
-            )
-            .intern(interner),
+            Ty::Raw { mutability, ty } => {
+                chalk_ir::TyKind::Raw(mutability.lower(), ty.lower(env)?).intern(interner)
+            }
 
             Ty::Ref {
                 mutability,
                 lifetime,
                 ty,
-            } => chalk_ir::TyKind::Ref(
-                mutability.lower(),
-                chalk_ir::Substitution::from_iter(
-                    interner,
-                    &[
-                        lifetime.lower(env)?.cast(interner),
-                        ty.lower(env)?.cast(interner),
-                    ],
-                ),
-            )
-            .intern(interner),
+            } => chalk_ir::TyKind::Ref(mutability.lower(), lifetime.lower(env)?, ty.lower(env)?)
+                .intern(interner),
 
             Ty::Str => chalk_ir::TyKind::Str.intern(interner),
 

diff --git a/chalk-integration/src/lowering/env.rs b/chalk-integration/src/lowering/env.rs
@@ -162,12 +162,9 @@ impl Env<'_> {
             ))
             .intern(interner)
             .cast(interner)),
-            Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign(
-                id,
-                chalk_ir::Substitution::empty(interner),
-            )
-            .intern(interner)
-            .cast(interner)),
+            Ok(TypeLookup::Foreign(id)) => Ok(chalk_ir::TyKind::Foreign(id)
+                .intern(interner)
+                .cast(interner)),
             Ok(TypeLookup::Trait(_)) => Err(RustIrError::NotStruct(name.clone())),
             Err(_) => Err(RustIrError::InvalidParameterName(name.clone())),
         }

diff --git a/chalk-integration/src/program.rs b/chalk-integration/src/program.rs
@@ -464,7 +464,7 @@ impl RustIrDatabase<ChalkIr> for Program {
                 (TyKind::OpaqueType(id_a, _), TyKind::OpaqueType(id_b, _)) => id_a == id_b,
                 (TyKind::Slice(_), TyKind::Slice(_)) => true,
                 (TyKind::FnDef(id_a, _), TyKind::FnDef(id_b, _)) => id_a == id_b,
-                (TyKind::Ref(id_a, _), TyKind::Ref(id_b, _)) => id_a == id_b,
+                (TyKind::Ref(id_a, _, _), TyKind::Ref(id_b, _, _)) => id_a == id_b,
                 (TyKind::Raw(id_a, _), TyKind::Raw(id_b, _)) => id_a == id_b,
                 (TyKind::Never, TyKind::Never) => true,
                 (TyKind::Array(_, _), TyKind::Array(_, _)) => true,
@@ -473,7 +473,7 @@ impl RustIrDatabase<ChalkIr> for Program {
                 (TyKind::GeneratorWitness(id_a, _), TyKind::GeneratorWitness(id_b, _)) => {
                     id_a == id_b
                 }
-                (TyKind::Foreign(id_a, _), TyKind::Foreign(id_b, _)) => id_a == id_b,
+                (TyKind::Foreign(id_a), TyKind::Foreign(id_b)) => id_a == id_b,
                 (TyKind::Error, TyKind::Error) => true,
                 (_, _) => false,
             }

diff --git a/chalk-ir/src/could_match.rs b/chalk-ir/src/could_match.rs
@@ -55,13 +55,16 @@ where
                         TyKind::FnDef(fn_def_b, substitution_b),
                     ) => fn_def_a == fn_def_b && matches(substitution_a, substitution_b),
                     (
-                        TyKind::Ref(mutability_a, substitution_a),
-                        TyKind::Ref(mutability_b, substitution_b),
-                    ) => mutability_a == mutability_b && matches(substitution_a, substitution_b),
-                    (
-                        TyKind::Raw(mutability_a, substitution_a),
-                        TyKind::Raw(mutability_b, substitution_b),
-                    ) => mutability_a == mutability_b && matches(substitution_a, substitution_b),
+                        TyKind::Ref(mutability_a, lifetime_a, ty_a),
+                        TyKind::Ref(mutability_b, lifetime_b, ty_b),
+                    ) => {
+                        mutability_a == mutability_b
+                            && lifetime_a.could_match(interner, &lifetime_b)
+                            && ty_a.could_match(interner, &ty_b)
+                    }
+                    (TyKind::Raw(mutability_a, ty_a), TyKind::Raw(mutability_b, ty_b)) => {
+                        mutability_a == mutability_b && ty_a.could_match(interner, &ty_b)
+                    }
                     (TyKind::Never, TyKind::Never) => true,
                     (TyKind::Array(ty_a, const_a), TyKind::Array(ty_b, const_b)) => {
                         ty_a.could_match(interner, ty_b) && const_a.could_match(interner, const_b)
@@ -78,10 +81,9 @@ where
                         TyKind::GeneratorWitness(generator_a, substitution_a),
                         TyKind::GeneratorWitness(generator_b, substitution_b),
                     ) => generator_a == generator_b && matches(substitution_a, substitution_b),
-                    (
-                        TyKind::Foreign(foreign_ty_a, substitution_a),
-                        TyKind::Foreign(foreign_ty_b, substitution_b),
-                    ) => foreign_ty_a == foreign_ty_b && matches(substitution_a, substitution_b),
+                    (TyKind::Foreign(foreign_ty_a), TyKind::Foreign(foreign_ty_b)) => {
+                        foreign_ty_a == foreign_ty_b
+                    }
                     (TyKind::Error, TyKind::Error) => true,
 
                     _ => true,

diff --git a/chalk-ir/src/debug.rs b/chalk-ir/src/debug.rs
@@ -205,24 +205,14 @@ impl<I: Interner> Debug for TyKind<I> {
             }
             TyKind::Slice(substitution) => write!(fmt, "{{slice}}<{:?}>", substitution),
             TyKind::FnDef(fn_def, substitution) => write!(fmt, "{:?}<{:?}>", fn_def, substitution),
-            TyKind::Ref(mutability, substitution) => write!(
-                fmt,
-                "{}<{:?}>",
-                match mutability {
-                    Mutability::Mut => "{{&mut}}",
-                    Mutability::Not => "{{&}}",
-                },
-                substitution,
-            ),
-            TyKind::Raw(mutability, substitution) => write!(
-                fmt,
-                "{}<{:?}>",
-                match mutability {
-                    Mutability::Mut => "{{*mut}}",
-                    Mutability::Not => "{{*const}}",
-                },
-                substitution,
-            ),
+            TyKind::Ref(mutability, lifetime, ty) => match mutability {
+                Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty),
+                Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty),
+            },
+            TyKind::Raw(mutability, ty) => match mutability {
+                Mutability::Mut => write!(fmt, "(*mut {:?})", ty),
+                Mutability::Not => write!(fmt, "(*const {:?})", ty),
+            },
             TyKind::Never => write!(fmt, "Never"),
             TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_),
             TyKind::Closure(id, substitution) => {
@@ -234,9 +224,7 @@ impl<I: Interner> Debug for TyKind<I> {
             TyKind::GeneratorWitness(witness, substitution) => {
                 write!(fmt, "{:?}<{:?}>", witness, substitution)
             }
-            TyKind::Foreign(foreign_ty, substitution) => {
-                write!(fmt, "{:?}<{:?}>", foreign_ty, substitution)
-            }
+            TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty),
             TyKind::Error => write!(fmt, "{{error}}"),
         }
     }
@@ -505,24 +493,14 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> {
             TyKind::FnDef(fn_def, substitution) => {
                 write!(fmt, "{:?}{:?}", fn_def, substitution.with_angle(interner))
             }
-            TyKind::Ref(mutability, substitution) => write!(
-                fmt,
-                "{}{:?}",
-                match mutability {
-                    Mutability::Mut => "{{&mut}}",
-                    Mutability::Not => "{{&}}",
-                },
-                substitution.with_angle(interner),
-            ),
-            TyKind::Raw(mutability, substitution) => write!(
-                fmt,
-                "{}{:?}",
-                match mutability {
-                    Mutability::Mut => "{{*mut}}",
-                    Mutability::Not => "{{*const}}",
-                },
-                substitution.with_angle(interner),
-            ),
+            TyKind::Ref(mutability, lifetime, ty) => match mutability {
+                Mutability::Mut => write!(fmt, "(&{:?} mut {:?})", lifetime, ty),
+                Mutability::Not => write!(fmt, "(&{:?} {:?})", lifetime, ty),
+            },
+            TyKind::Raw(mutability, ty) => match mutability {
+                Mutability::Mut => write!(fmt, "(*mut {:?})", ty),
+                Mutability::Not => write!(fmt, "(*const {:?})", ty),
+            },
             TyKind::Never => write!(fmt, "Never"),
             TyKind::Array(ty, const_) => write!(fmt, "[{:?}; {:?}]", ty, const_),
             TyKind::Closure(id, substitution) => write!(
@@ -540,12 +518,7 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> {
             TyKind::GeneratorWitness(witness, substitution) => {
                 write!(fmt, "{:?}{:?}", witness, substitution.with_angle(interner))
             }
-            TyKind::Foreign(foreign_ty, substitution) => write!(
-                fmt,
-                "{:?}{:?}",
-                foreign_ty,
-                substitution.with_angle(interner)
-            ),
+            TyKind::Foreign(foreign_ty) => write!(fmt, "{:?}", foreign_ty,),
             TyKind::Error => write!(fmt, "{{error}}"),
         }
     }

diff --git a/chalk-ir/src/fold.rs b/chalk-ir/src/fold.rs
@@ -463,14 +463,15 @@ where
                 substitution.fold_with(folder, outer_binder)?,
             )
             .intern(folder.target_interner()),
-            TyKind::Ref(mutability, substitution) => TyKind::Ref(
+            TyKind::Ref(mutability, lifetime, ty) => TyKind::Ref(
                 mutability.fold_with(folder, outer_binder)?,
-                substitution.fold_with(folder, outer_binder)?,
+                lifetime.fold_with(folder, outer_binder)?,
+                ty.fold_with(folder, outer_binder)?,
             )
             .intern(folder.target_interner()),
-            TyKind::Raw(mutability, substitution) => TyKind::Raw(
+            TyKind::Raw(mutability, ty) => TyKind::Raw(
                 mutability.fold_with(folder, outer_binder)?,
-                substitution.fold_with(folder, outer_binder)?,
+                ty.fold_with(folder, outer_binder)?,
             )
             .intern(folder.target_interner()),
             TyKind::Never => TyKind::Never.intern(folder.target_interner()),
@@ -494,11 +495,8 @@ where
                 substitution.fold_with(folder, outer_binder)?,
             )
             .intern(folder.target_interner()),
-            TyKind::Foreign(id, substitution) => TyKind::Foreign(
-                id.fold_with(folder, outer_binder)?,
-                substitution.fold_with(folder, outer_binder)?,
-            )
-            .intern(folder.target_interner()),
+            TyKind::Foreign(id) => TyKind::Foreign(id.fold_with(folder, outer_binder)?)
+                .intern(folder.target_interner()),
             TyKind::Error => TyKind::Error.intern(folder.target_interner()),
         })
     }

diff --git a/chalk-ir/src/lib.rs b/chalk-ir/src/lib.rs
@@ -471,10 +471,10 @@ pub enum TyKind<I: Interner> {
     Slice(Ty<I>),
 
     /// a raw pointer type like `*const T` or `*mut T`
-    Raw(Mutability, Substitution<I>),
+    Raw(Mutability, Ty<I>),
 
     /// a reference type like `&T` or `&mut T`
-    Ref(Mutability, Substitution<I>),
+    Ref(Mutability, Lifetime<I>, Ty<I>),
 
     /// a placeholder for opaque types like `impl Trait`
     OpaqueType(OpaqueTyId<I>, Substitution<I>),
@@ -498,7 +498,7 @@ pub enum TyKind<I: Interner> {
     GeneratorWitness(GeneratorId<I>, Substitution<I>),
 
     /// foreign types
-    Foreign(ForeignDefId<I>, Substitution<I>),
+    Foreign(ForeignDefId<I>),
 
     /// This can be used to represent an error, e.g. during name resolution of a type.
     /// Chalk itself will not produce this, just pass it through when given.