Change Substitution in Slice to Ty

Author: jackh726

chalk-engine/src/slg.rs

@@ -435,10 +435,7 @@ impl<I: Interner> MayInvalidate<'_, I> {
                 TyKind::OpaqueType(id_a, substitution_a),
                 TyKind::OpaqueType(id_b, substitution_b),
             ) => self.aggregate_name_and_substs(id_a, substitution_a, id_b, substitution_b),
-            (TyKind::Slice(substitution_a), TyKind::Slice(substitution_b)) => substitution_a
-                .iter(interner)
-                .zip(substitution_b.iter(interner))
-                .any(|(new, current)| self.aggregate_generic_args(new, current)),
+            (TyKind::Slice(ty_a), TyKind::Slice(ty_b)) => self.aggregate_tys(ty_a, ty_b),
             (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)
             }

chalk-engine/src/slg/aggregate.rs

@@ -296,15 +296,8 @@ impl<I: Interner> AntiUnifier<'_, '_, I> {
                     TyKind::OpaqueType(name, substitution).intern(interner)
                 })
                 .unwrap_or_else(|| self.new_ty_variable()),
-            (TyKind::Slice(substitution_a), TyKind::Slice(substitution_b)) => {
-                let substitution = Substitution::from_iter(
-                    interner,
-                    substitution_a
-                        .iter(interner)
-                        .zip(substitution_b.iter(interner))
-                        .map(|(p1, p2)| self.aggregate_generic_args(p1, p2)),
-                );
-                TyKind::Slice(substitution).intern(interner)
+            (TyKind::Slice(ty_a), TyKind::Slice(ty_b)) => {
+                TyKind::Slice(self.aggregate_tys(ty_a, ty_b)).intern(interner)
             }
             (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)

chalk-integration/src/lowering.rs

@@ -786,11 +786,7 @@ impl LowerWithEnv for Ty {
                 chalk_ir::TyKind::Array(ty.lower(env)?, len.lower(env)?).intern(interner)
             }
 
-            Ty::Slice { ty } => chalk_ir::TyKind::Slice(chalk_ir::Substitution::from_fallible(
-                interner,
-                std::iter::once(ty.lower(env)),
-            )?)
-            .intern(interner),
+            Ty::Slice { ty } => chalk_ir::TyKind::Slice(ty.lower(env)?).intern(interner),
 
             Ty::Raw { mutability, ty } => chalk_ir::TyKind::Raw(
                 mutability.lower(),

chalk-ir/src/could_match.rs

@@ -49,9 +49,7 @@ where
                         TyKind::OpaqueType(opaque_ty_a, substitution_a),
                         TyKind::OpaqueType(opaque_ty_b, substitution_b),
                     ) => opaque_ty_a == opaque_ty_b && matches(substitution_a, substitution_b),
-                    (TyKind::Slice(substitution_a), TyKind::Slice(substitution_b)) => {
-                        matches(substitution_a, substitution_b)
-                    }
+                    (TyKind::Slice(ty_a), TyKind::Slice(ty_b)) => ty_a.could_match(interner, ty_b),
                     (
                         TyKind::FnDef(fn_def_a, substitution_a),
                         TyKind::FnDef(fn_def_b, substitution_b),

chalk-ir/src/debug.rs

@@ -501,9 +501,7 @@ impl<'a, I: Interner> Debug for TyKindDebug<'a, I> {
                 opaque_ty,
                 substitution.with_angle(interner)
             ),
-            TyKind::Slice(substitution) => {
-                write!(fmt, "{{slice}}{:?}", substitution.with_angle(interner))
-            }
+            TyKind::Slice(ty) => write!(fmt, "[{:?}]", ty),
             TyKind::FnDef(fn_def, substitution) => {
                 write!(fmt, "{:?}{:?}", fn_def, substitution.with_angle(interner))
             }

chalk-ir/src/lib.rs

@@ -468,7 +468,7 @@ pub enum TyKind<I: Interner> {
     Array(Ty<I>, Const<I>),
 
     /// a slice type like `[T]`
-    Slice(Substitution<I>),
+    Slice(Ty<I>),
 
     /// a raw pointer type like `*const T` or `*mut T`
     Raw(Mutability, Substitution<I>),

chalk-solve/src/clauses.rs

@@ -37,7 +37,6 @@ fn constituent_types<I: Interner>(db: &dyn RustIrDatabase<I>, ty: &TyKind<I>) ->
         // And for `PhantomData<T>`, we pass `T`.
         TyKind::Adt(_, substitution)
         | TyKind::Tuple(_, substitution)
-        | TyKind::Slice(substitution)
         | TyKind::Raw(_, substitution)
         | TyKind::Ref(_, substitution)
         | TyKind::FnDef(_, substitution) => substitution
@@ -46,6 +45,8 @@ fn constituent_types<I: Interner>(db: &dyn RustIrDatabase<I>, ty: &TyKind<I>) ->
             .cloned()
             .collect(),
 
+        TyKind::Slice(ty) => vec![ty.clone()],
+
         TyKind::Array(_, _) | TyKind::Str | TyKind::Never | TyKind::Scalar(_) => Vec::new(),
 
         TyKind::Generator(generator_id, substitution) => {

chalk-solve/src/clauses/builtin_traits/unsize.rs

@@ -312,12 +312,10 @@ pub fn add_unsize_program_clauses<I: Interner>(
             );
         }
 
-        (TyKind::Array(array_ty, _array_const), TyKind::Slice(slice_subst)) => {
-            let slice_ty = slice_subst.at(interner, 0);
-
+        (TyKind::Array(array_ty, _array_const), TyKind::Slice(slice_ty)) => {
             let eq_goal = EqGoal {
                 a: array_ty.clone().cast(interner),
-                b: slice_ty.clone(),
+                b: slice_ty.clone().cast(interner),
             };
 
             builder.push_clause(trait_ref.clone(), iter::once(eq_goal));

chalk-solve/src/display/ty.rs

@@ -108,16 +108,7 @@ impl<I: Interner> RenderAsRust<I> for TyKind<I> {
                 )
             }
             TyKind::Str => write!(f, "str"),
-            TyKind::Slice(substitution) => write!(
-                f,
-                "[{}]",
-                substitution
-                    .iter(interner)
-                    .filter_map(move |p| p.ty(interner))
-                    .next()
-                    .unwrap()
-                    .display(s)
-            ),
+            TyKind::Slice(ty) => write!(f, "[{}]", ty.display(s)),
             TyKind::Error => write!(f, "{{error}}"),
             TyKind::Never => write!(f, "!"),