Make DispatchFromDyn a well-known trait

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

Author: nrc

chalk-integration/src/lowering.rs

@@ -1138,6 +1138,7 @@ impl Lower for WellKnownTrait {
             WellKnownTrait::CoerceUnsized => rust_ir::WellKnownTrait::CoerceUnsized,
             WellKnownTrait::DiscriminantKind => rust_ir::WellKnownTrait::DiscriminantKind,
             WellKnownTrait::Generator => rust_ir::WellKnownTrait::Generator,
+            WellKnownTrait::DispatchFromDyn => rust_ir::WellKnownTrait::DispatchFromDyn,
         }
     }
 }

chalk-parse/src/ast.rs

@@ -159,6 +159,7 @@ pub enum WellKnownTrait {
     CoerceUnsized,
     DiscriminantKind,
     Generator,
+    DispatchFromDyn,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug)]

chalk-parse/src/parser.lalrpop

@@ -67,6 +67,7 @@ WellKnownTrait: WellKnownTrait = {
      "#" "[" "lang" "(" "coerce_unsized" ")" "]" => WellKnownTrait::CoerceUnsized,
      "#" "[" "lang" "(" "discriminant_kind" ")" "]" => WellKnownTrait::DiscriminantKind,
      "#" "[" "lang" "(" "generator" ")" "]" => WellKnownTrait::Generator,
+     "#" "[" "lang" "(" "dispatch_from_dyn" ")" "]" => WellKnownTrait::DispatchFromDyn,
 };
 
 AdtReprAttr: AdtReprAttr = {

chalk-solve/src/clauses/builtin_traits.rs

@@ -28,8 +28,6 @@ pub fn add_builtin_program_clauses<I: Interner>(
         let ty = self_ty.kind(db.interner()).clone();
 
         match well_known {
-            // There are no builtin impls provided for the following traits:
-            WellKnownTrait::Unpin | WellKnownTrait::Drop | WellKnownTrait::CoerceUnsized => (),
             // Built-in traits are non-enumerable.
             _ if self_ty.is_general_var(db.interner(), binders) => return Err(Floundered),
             WellKnownTrait::Sized => {
@@ -52,6 +50,11 @@ pub fn add_builtin_program_clauses<I: Interner>(
             WellKnownTrait::Generator => {
                 generator::add_generator_program_clauses(db, builder, self_ty)?;
             }
+            // There are no builtin impls provided for the following traits:
+            WellKnownTrait::Unpin
+            | WellKnownTrait::Drop
+            | WellKnownTrait::CoerceUnsized
+            | WellKnownTrait::DispatchFromDyn => (),
         }
         Ok(())
     })

chalk-solve/src/display/items.rs

@@ -204,6 +204,7 @@ impl<I: Interner> RenderAsRust<I> for TraitDatum<I> {
                 WellKnownTrait::CoerceUnsized => "coerce_unsized",
                 WellKnownTrait::DiscriminantKind => "discriminant_kind",
                 WellKnownTrait::Generator => "generator",
+                WellKnownTrait::DispatchFromDyn => "dispatch_from_dyn",
             };
             writeln!(f, "#[lang({})]", name)?;
         }

chalk-solve/src/rust_ir.rs

@@ -259,6 +259,7 @@ pub enum WellKnownTrait {
     CoerceUnsized,
     DiscriminantKind,
     Generator,
+    DispatchFromDyn,
 }
 
 chalk_ir::const_visit!(WellKnownTrait);

chalk-solve/src/wf.rs

@@ -420,6 +420,13 @@ where
                     &impl_datum,
                 )
             }
+            WellKnownTrait::DispatchFromDyn => {
+                WfWellKnownConstraints::dispatch_from_dyn_constraint(
+                    &mut *solver,
+                    self.db,
+                    &impl_datum,
+                )
+            }
             WellKnownTrait::Clone | WellKnownTrait::Unpin => true,
             // You can't add a manual implementation for the following traits:
             WellKnownTrait::Fn
@@ -1061,4 +1068,133 @@ impl WfWellKnownConstraints {
             _ => false,
         }
     }
+
+    /// Verify constraints ofa DispatchForDyn impl.
+    ///
+    /// Rules for DispatchForDyn 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:
+    ///   - 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)
+    ///   - `DispatchForDyn` 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>,
+        impl_datum: &ImplDatum<I>,
+    ) -> bool {
+        let interner = db.interner();
+        let mut gb = GoalBuilder::new(db);
+
+        let (binders, impl_datum) = impl_datum.binders.as_ref().into();
+
+        let trait_ref: &TraitRef<I> = &impl_datum.trait_ref;
+
+        // DispatchForDyn 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
+            .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.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 =>
+            {
+                true
+            }
+            (TyKind::Adt(source_id, subst_a), TyKind::Adt(target_id, subst_b)) => {
+                let adt_datum = db.adt_datum(*source_id);
+
+                // Definitions are equal and are structs.
+                if source_id != target_id || adt_datum.kind != AdtKind::Struct {
+                    return false;
+                }
+
+                // Not repr(C) or repr(packed).
+                let repr = db.adt_repr(*source_id);
+                if repr.c || repr.packed {
+                    return false;
+                }
+
+                // Collect non 1-ZST fields; there must be exactly one.
+                let fields = adt_datum
+                    .binders
+                    .map_ref(|bound| &bound.variants.last().unwrap().fields)
+                    .cloned();
+
+                let (source_fields, target_fields) = (
+                    fields.clone().substitute(interner, subst_a),
+                    fields.substitute(interner, subst_b),
+                );
+
+                let mut non_zst_fields: Vec<_> = source_fields
+                    .iter()
+                    .zip(target_fields.iter())
+                    .filter(|(sf, tf)| {
+                        // TODO ignore 1-ZST fields
+                        true
+                    })
+                    .collect();
+
+                if non_zst_fields.len() != 1 {
+                    return false;
+                }
+
+                // The field being coerced (the interesting field).
+                let (field_src, field_tgt) = non_zst_fields.pop().unwrap();
+
+                // The interesting field is different in the source and target types.
+                let eq_goal: Goal<I> = EqGoal {
+                    a: field_src.clone().cast(interner),
+                    b: field_tgt.clone().cast(interner),
+                }
+                .cast(interner);
+                let eq_goal = place_in_environment(eq_goal);
+                if solver.has_unique_solution(db, &eq_goal.into_closed_goal(interner)) {
+                    return false;
+                }
+
+                // Type(field_src): DispatchForDyn<Type(field_tgt)>
+                let field_dispatch_goal: Goal<I> = TraitRef {
+                    trait_id: trait_ref.trait_id,
+                    substitution: Substitution::from_iter(
+                        interner,
+                        [field_src.clone(), field_tgt.clone()].iter().cloned(),
+                    ),
+                }
+                .cast(interner);
+                let field_dispatch_goal = place_in_environment(field_dispatch_goal);
+                if !solver.has_unique_solution(db, &field_dispatch_goal.into_closed_goal(interner))
+                {
+                    return false;
+                }
+
+                true
+            }
+            _ => false,
+        }
+    }
 }