More work on DispatchFromDyn

Signed-off-by: Nick Cameron <nrc@ncameron.org>

Author: nrc

chalk-solve/src/wf.rs

@@ -1069,9 +1069,9 @@ impl WfWellKnownConstraints {
         }
     }
 
-    /// Verify constraints ofa DispatchForDyn impl.
+    /// Verify constraints of a DispatchFromDyn impl.
     ///
-    /// Rules for DispatchForDyn impl to be considered well-formed:
+    /// Rules for DispatchFromDyn impl to be considered well-formed:
     ///
     /// * Self and the type parameter must both be references or raw pointers with the same mutabilty
     /// * OR all the following hold:
@@ -1080,7 +1080,7 @@ impl WfWellKnownConstraints {
     ///   - Self must not be `#[repr(packed)]` or `#[repr(C)]`
     ///   - Self must have exactly one field which is not a 1-ZST, and that field must have a
     /// different type in the type parameter (i.e., it is a field being coerced)
-    ///   - `DispatchForDyn` is implemented for the type of the field being coerced.
+    ///   - `DispatchFromDyn` is implemented for the type of the field being coerced.
     fn dispatch_from_dyn_constraint<I: Interner>(
         solver: &mut dyn Solver<I>,
         db: &dyn RustIrDatabase<I>,
@@ -1093,7 +1093,7 @@ impl WfWellKnownConstraints {
 
         let trait_ref: &TraitRef<I> = &impl_datum.trait_ref;
 
-        // DispatchForDyn specifies that Self (source) can be coerced to T (target; its single type parameter).
+        // DispatchFromDyn specifies that Self (source) can be coerced to T (target; its single type parameter).
         let source = trait_ref.self_type_parameter(interner);
         let target = trait_ref
             .substitution
@@ -1121,7 +1121,7 @@ impl WfWellKnownConstraints {
         match (source.kind(interner), target.kind(interner)) {
             (TyKind::Ref(s_m, _, _), TyKind::Ref(t_m, _, _))
             | (TyKind::Raw(s_m, _), TyKind::Raw(t_m, _))
-                if s_m != t_m =>
+                if s_m == t_m =>
             {
                 true
             }
@@ -1153,9 +1153,9 @@ impl WfWellKnownConstraints {
                 let mut non_zst_fields: Vec<_> = source_fields
                     .iter()
                     .zip(target_fields.iter())
-                    .filter(|(sf, tf)| {
-                        // TODO ignore 1-ZST fields
-                        true
+                    .filter(|(sf, _)| match sf.adt_id(interner) {
+                        Some(adt) => !db.adt_size_align(adt).one_zst(),
+                        None => true,
                     })
                     .collect();
 
@@ -1177,7 +1177,7 @@ impl WfWellKnownConstraints {
                     return false;
                 }
 
-                // Type(field_src): DispatchForDyn<Type(field_tgt)>
+                // Type(field_src): DispatchFromDyn<Type(field_tgt)>
                 let field_dispatch_goal: Goal<I> = TraitRef {
                     trait_id: trait_ref.trait_id,
                     substitution: Substitution::from_iter(

tests/test/unsize.rs

@@ -586,3 +586,200 @@ fn struct_unsizing() {
         }
     }
 }
+
+#[test]
+fn dispatch_from_dyn() {
+    test! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            impl<'a, T, U> DispatchFromDyn<&'a U> for &'a T {}
+        }
+
+        // Smoke test that DispatchFromDyn works just like any other impl.
+        goal {
+            forall<'a> {
+                &'a u8: DispatchFromDyn<&'a u8>
+            }
+        } yields {
+            "Unique"
+        }
+    }
+}
+
+#[test]
+fn dispatch_from_dyn_wf() {
+    lowering_success! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            #[one_zst]
+            struct PhantomData<T> {}
+
+            struct Foo<T> {
+                f: *mut T,
+                f2: PhantomData<u8>,
+            }
+
+            // References and pointers
+            impl<'a, T, U> DispatchFromDyn<&'a U> for &'a T {}
+            impl<'a, T, U> DispatchFromDyn<&'a mut U> for &'a mut T {}
+            impl<T, U> DispatchFromDyn<*const U> for *const T {}
+            impl<T, U> DispatchFromDyn<*mut U> for *mut T {}
+
+            // Struct
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        }
+    }
+
+    // Reference: mutability mismatch
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            impl<'a, T, U> DispatchFromDyn<&'a U> for &'a mut T {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Raw pointer: mutability mismatch
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            impl<'a, T, U> DispatchFromDyn<*mut U> for *const T {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // No non-ZST fields
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            #[one_zst]
+            struct PhantomData<T> {}
+
+            struct Foo<T> {
+                f: PhantomData<T>,
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Too many fields
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            struct Foo<T> {
+                f: *mut T,
+                f2: u8,
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Field does not impl DispatchFromDyn
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            struct Foo<T> {
+                f: T,
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Field type does not change
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            #[one_zst]
+            struct PhantomData<T> {}
+
+            struct Foo<T> {
+                f: *const u8,
+                f2: PhantomData<T>,
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Different definitions
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            struct Foo<T> {
+                f: *const T,
+            }
+
+            struct Bar<T> {
+                f: *const T,
+            }
+
+            impl<T, U> DispatchFromDyn<Bar<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // Not a struct
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            enum Foo<T> {
+                Bar(*const T),
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+
+    // repr(C)
+    lowering_error! {
+        program {
+            #[lang(dispatch_from_dyn)]
+            trait DispatchFromDyn<T> {}
+
+            #[repr(C)]
+            struct Foo<T> {
+                f: *mut T,
+            }
+
+            impl<T, U> DispatchFromDyn<Foo<U>> for Foo<T> {}
+        } error_msg {
+            "trait impl for `DispatchFromDyn` does not meet well-formedness requirements"
+        }
+    }
+}