add CoerceUnsized impl for structs

Author: basil-cow

chalk-ir/src/lib.rs

@@ -477,6 +477,17 @@ impl<I: Interner> Ty<I> {
         }
     }
 
+    /// Returns `Some(adt_id)` if this is an ADT, `None` otherwise
+    pub fn adt_id(&self, interner: &I) -> Option<AdtId<I>> {
+        match self.data(interner) {
+            TyData::Apply(ApplicationTy {
+                name: TypeName::Adt(adt_id),
+                ..
+            }) => Some(*adt_id),
+            _ => None,
+        }
+    }
+
     /// True if this type contains "bound" types/lifetimes, and hence
     /// needs to be shifted across binders. This is a very inefficient
     /// check, intended only for debug assertions, because I am lazy.

chalk-solve/src/wf.rs

@@ -872,13 +872,31 @@ impl WfWellKnownConstraints {
             .at(interner, 1)
             .assert_ty_ref(interner)
             .clone();
+
+        let mut place_in_environment = |goal| -> Goal<I> {
+            gb.forall(
+                &Binders::new(
+                    binders.clone(),
+                    (goal, trait_ref, &impl_datum.where_clauses),
+                ),
+                (),
+                |gb, _, (goal, trait_ref, where_clauses), ()| {
+                    let interner = gb.interner();
+                    gb.implies(
+                        impl_wf_environment(interner, &where_clauses, &trait_ref),
+                        |_| goal,
+                    )
+                },
+            )
+        };
+
         match (source.data(interner), target.data(interner)) {
             (TyData::Apply(source_app), TyData::Apply(target_app)) => {
                 match (&source_app.name, &target_app.name) {
                     (TypeName::Ref(s_m), TypeName::Ref(t_m))
                     | (TypeName::Ref(s_m), TypeName::Raw(t_m))
                     | (TypeName::Raw(s_m), TypeName::Raw(t_m)) => {
-                        if matches!((*s_m, *t_m), (Mutability::Not, Mutability::Mut)) {
+                        if (*s_m, *t_m) == (Mutability::Not, Mutability::Mut) {
                             return false;
                         }
 
@@ -892,6 +910,7 @@ impl WfWellKnownConstraints {
                                 return false;
                             };
 
+                        // Source: Unsize<Target>
                         let unsize_goal: Goal<I> = TraitRef {
                             trait_id: unsize_trait_id,
                             substitution: Substitution::from_iter(
@@ -901,23 +920,80 @@ impl WfWellKnownConstraints {
                         }
                         .cast(interner);
 
-                        let unsize_goal = gb.forall(
-                            &Binders::new(
-                                binders,
-                                (unsize_goal, trait_ref, &impl_datum.where_clauses),
-                            ),
-                            (),
-                            |gb, _, (unsize_goal, trait_ref, where_clauses), ()| {
-                                let interner = gb.interner();
-                                gb.implies(
-                                    impl_wf_environment(interner, &where_clauses, &trait_ref),
-                                    |_| unsize_goal,
-                                )
-                            },
-                        );
+                        // ImplEnv -> Source: Unsize<Target>
+                        let unsize_goal = place_in_environment(unsize_goal);
 
                         solver.has_unique_solution(db, &unsize_goal.into_closed_goal(interner))
                     }
+                    (TypeName::Adt(source_id), TypeName::Adt(target_id)) => {
+                        let adt_datum = db.adt_datum(*source_id);
+
+                        if source_id != target_id || adt_datum.kind != AdtKind::Struct {
+                            return false;
+                        }
+
+                        let fields = adt_datum
+                            .binders
+                            .map_ref(|bound| &bound.variants.last().unwrap().fields);
+
+                        let (source_fields, target_fields) = (
+                            fields.substitute(interner, &source_app.substitution),
+                            fields.substitute(interner, &target_app.substitution),
+                        );
+
+                        // collect fields with unequal ids
+                        let uneq_field_ids: Vec<usize> = (0..source_fields.len())
+                            .filter(|&i| {
+                                // ignore phantom data fields
+                                if let Some(adt_id) = source_fields[i].adt_id(interner) {
+                                    if db.adt_datum(adt_id).flags.phantom_data {
+                                        return false;
+                                    }
+                                }
+
+                                let eq_goal: Goal<I> = EqGoal {
+                                    a: source_fields[i].clone().cast(interner),
+                                    b: target_fields[i].clone().cast(interner),
+                                }
+                                .cast(interner);
+
+                                // ImplEnv -> Source.fields[i] = Target.fields[i]
+                                let eq_goal = place_in_environment(eq_goal);
+
+                                // We are interested in !UNEQUAL! fields
+                                !solver.has_unique_solution(db, &eq_goal.into_closed_goal(interner))
+                            })
+                            .collect();
+
+                        if uneq_field_ids.len() != 1 {
+                            return false;
+                        }
+
+                        let field_id = uneq_field_ids[0];
+
+                        // Source.fields[i]: CoerceUnsized<TargetFields[i]>
+                        let coerce_unsized_goal: Goal<I> = TraitRef {
+                            trait_id: trait_ref.trait_id,
+                            substitution: Substitution::from_iter(
+                                interner,
+                                [
+                                    source_fields[field_id].clone(),
+                                    target_fields[field_id].clone(),
+                                ]
+                                .iter()
+                                .cloned(),
+                            ),
+                        }
+                        .cast(interner);
+
+                        // ImplEnv -> Source.fields[i]: CoerceUnsized<TargetFields[i]>
+                        let coerce_unsized_goal = place_in_environment(coerce_unsized_goal);
+
+                        solver.has_unique_solution(
+                            db,
+                            &coerce_unsized_goal.into_closed_goal(interner),
+                        )
+                    }
                     _ => false,
                 }
             }

tests/test/wf_lowering.rs

@@ -1141,9 +1141,11 @@ fn coerce_unsized_pointer() {
             trait CoerceUnsized<T> {}
 
             impl<'a, T, U> CoerceUnsized<*mut U> for &'a mut T where T: Unsize<U> {}
+            impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
         }
     }
 
+    // T: Unsize<U> is not in the environment
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1158,6 +1160,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Test with builtin Unsize impl
     lowering_success! {
         program {
             #[lang(unsize)]
@@ -1177,6 +1180,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Test with builtin Unsize impl
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1198,6 +1202,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Test with builtin Unsize impl
     lowering_success! {
         program {
             #[lang(unsize)]
@@ -1210,6 +1215,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Coercing from shared to mut
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1224,6 +1230,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Coercing from shared to mut
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1238,6 +1245,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Coercing from shared to mut
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1252,6 +1260,7 @@ fn coerce_unsized_pointer() {
         }
     }
 
+    // Coercing from raw pointer to ref
     lowering_error! {
         program {
             #[lang(unsize)]
@@ -1265,7 +1274,10 @@ fn coerce_unsized_pointer() {
             "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
         }
     }
+}
 
+#[test]
+fn coerce_unsized_struct() {
     lowering_success! {
         program {
             #[lang(unsize)]
@@ -1274,7 +1286,155 @@ fn coerce_unsized_pointer() {
             #[lang(coerce_unsized)]
             trait CoerceUnsized<T> {}
 
+            struct Foo<'a, T> {
+                t: &'a T
+            }
+
+            struct Bar<T, U> {
+                extra: T,
+                ptr: *mut U,
+            }
+
+            impl<'a, T, U> CoerceUnsized<&'a U> for &'a T where T: Unsize<U> {}
+            impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
+            impl<'a> CoerceUnsized<Foo<'a, [u32]>> for Foo<'a, [u32; 3]> {}
+            impl<T, U, V> CoerceUnsized<Bar<T, V>> for Bar<T, U> where U: Unsize<V> {}
+        }
+    }
+
+    // Unsizing different structs
+    lowering_error! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            struct S1<T> {
+                t: T,
+            }
+
+            struct S2<T> {
+                t: T,
+            }
+
+            impl<T, U> CoerceUnsized<S2<U>> for S1<T> where T: CoerceUnsized<U> {}
+        } error_msg {
+            "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
+        }
+    }
+
+    // Unsizing enums
+    lowering_error! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            enum Foo<T> {
+                A {
+                    t: T
+                }
+            }
+
+            impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {}
+        } error_msg {
+            "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
+        }
+    }
+
+    // Unsizing two fields
+    lowering_error! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            struct Bar<T, U> {
+                ptr1: *mut T,
+                ptr2: *mut U,
+            }
+
+            impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
+            impl<T, S, U, V> CoerceUnsized<Bar<T, V>> for Bar<S, U> where U: Unsize<V>, T: Unsize<S> {}
+        } error_msg {
+            "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
+        }
+    }
+
+    // Unsizing no fields
+    lowering_error! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            struct Bar<T, U> {
+                ptr1: *mut T,
+                ptr2: *mut U,
+            }
+
+            impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
+            impl<T> CoerceUnsized<Bar<T, T>> for Bar<T, T> where T: Unsize<T> {}
+        } error_msg {
+            "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
+        }
+    }
+
+    // No unsize in the environment
+    lowering_error! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            struct Bar<T, U> {
+                extra: T,
+                ptr: *mut U,
+            }
+
+            impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
+            impl<T, U, V> CoerceUnsized<Bar<T, V>> for Bar<T, U> {}
+        } error_msg {
+            "trait impl for `CoerceUnsized` does not meet well-formedness requirements"
+        }
+    }
+
+    // Phantom data test & CoerceUnsized in the environment test
+    lowering_success! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[lang(coerce_unsized)]
+            trait CoerceUnsized<T> {}
+
+            #[phantom_data]
+            struct PhantomData<T> {}
+
+            struct Foo<T, V> {
+                coerce: T,
+                phantom: PhantomData<V>,
+            }
+
+            struct Bar<T, U, V> {
+                extra: T,
+                phantom: PhantomData<V>,
+                ptr: *mut U,
+            }
+
             impl<T, U> CoerceUnsized<*mut U> for *mut T where T: Unsize<U> {}
+            impl<T, U, V, N, M> CoerceUnsized<Bar<T, V, N>> for Bar<T, U, M> where U: Unsize<V> {}
+            impl<T, U, V> CoerceUnsized<Foo<U, V>> for Foo<T, V> where T: CoerceUnsized<U> {}
         }
     }
 }