Address review comments

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

Author: nrc

chalk-solve/src/lib.rs

@@ -67,6 +67,7 @@ pub trait RustIrDatabase<I: Interner>: Debug {
     /// Returns the representation for the ADT definition with the given id.
     fn adt_repr(&self, id: AdtId<I>) -> Arc<AdtRepr<I>>;
 
+    /// Returns the siza and alignment of the ADT definition with the given id.
     fn adt_size_align(&self, id: AdtId<I>) -> Arc<AdtSizeAlign>;
 
     /// Returns the datum for the fn definition with the given id.

chalk-solve/src/wf.rs

@@ -1078,8 +1078,9 @@ impl WfWellKnownConstraints {
     ///   - Self and the type parameter must be structs
     ///   - Self and the type parameter must have the same definitions
     ///   - 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)
+    ///   - Self must have exactly one field which is not a 1-ZST (there may be any number of 1-ZST
+    ///     fields), and that field must have a different type in the type parameter (i.e., it is
+    ///     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>,

tests/test/dispatch_from_dyn.rs

@@ -0,0 +1,198 @@
+use crate::test::*;
+
+#[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 Zst<T> {}
+
+            struct Foo<T> {
+                f: *mut T,
+                f2: Zst<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 Zst<T> {}
+
+            struct Foo<T> {
+                f: Zst<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 Zst<T> {}
+
+            struct Foo<T> {
+                f: *const u8,
+                f2: Zst<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"
+        }
+    }
+}