Allow unsizing dyn Trait -> dyn Trait + Auto if Trait: Auto

Author: WaffleLapkin

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

@@ -3,6 +3,7 @@ use std::iter;
 use std::ops::ControlFlow;
 
 use crate::clauses::ClauseBuilder;
+use crate::clauses::super_traits::super_traits;
 use crate::rust_ir::AdtKind;
 use crate::{Interner, RustIrDatabase, TraitRef, WellKnownTrait};
 use chalk_ir::{
@@ -204,7 +205,20 @@ pub fn add_unsize_program_clauses<I: Interner>(
             let principal_a = principal_id(db, bounds_a);
             let principal_b = principal_id(db, bounds_b);
 
-            let auto_trait_ids_a: Vec<_> = auto_trait_ids(db, bounds_a).collect();
+            // Include super traits in a list of auto traits for A,
+            // to allow `dyn Trait -> dyn Trait + X` if `Trait: X`.
+            let auto_trait_ids_a: Vec<_> = auto_trait_ids(db, bounds_a)
+                .chain(principal_a.into_iter().flat_map(|principal_a| {
+                    super_traits(db, principal_a)
+                        .into_value_and_skipped_binders()
+                        .0
+                        .0
+                        .into_iter()
+                        .map(|x| x.skip_binders().trait_id)
+                        .filter(|&x| db.trait_datum(x).is_auto_trait())
+                }))
+                .collect();
+
             let auto_trait_ids_b: Vec<_> = auto_trait_ids(db, bounds_b).collect();
 
             let may_apply = principal_a == principal_b
@@ -234,7 +248,7 @@ pub fn add_unsize_program_clauses<I: Interner>(
             // ------------------
 
             // Construct a new trait object type by taking the source ty,
-            // filtering out auto traits of source that are not present in target
+            // replacing auto traits of source with those of target,
             // and changing source lifetime to target lifetime.
             //
             // In order for the coercion to be valid, this new type
@@ -243,17 +257,33 @@ pub fn add_unsize_program_clauses<I: Interner>(
                 bounds: bounds_a.map_ref(|bounds| {
                     QuantifiedWhereClauses::from_iter(
                         interner,
-                        bounds.iter(interner).filter(|bound| {
-                            let trait_id = match bound.trait_id() {
-                                Some(id) => id,
-                                None => return true,
-                            };
-
-                            if auto_trait_ids_a.iter().all(|&id_a| id_a != trait_id) {
-                                return true;
-                            }
-                            auto_trait_ids_b.iter().any(|&id_b| id_b == trait_id)
-                        }),
+                        bounds
+                            .iter(interner)
+                            .cloned()
+                            .filter_map(|bound| {
+                                let Some(trait_id) = bound.trait_id() else {
+                                    // Keep non-"implements" bounds as-is
+                                    return Some(bound);
+                                };
+
+                                // Auto traits are already checked above, ignore them
+                                // (we'll use the ones from B below)
+                                if db.trait_datum(trait_id).is_auto_trait() {
+                                    return None;
+                                }
+
+                                // The only "implements" bound that is not an auto trait, is the principal
+                                assert_eq!(Some(trait_id), principal_a);
+                                Some(bound)
+                            })
+                            // Add auto traits from B (again, they are already checked above).
+                            .chain(bounds_b.skip_binders().iter(interner).cloned().filter(
+                                |bound| {
+                                    bound.trait_id().is_some_and(|trait_id| {
+                                        db.trait_datum(trait_id).is_auto_trait()
+                                    })
+                                },
+                            )),
                     )
                 }),
                 lifetime: lifetime_b.clone(),

chalk-solve/src/clauses/super_traits.rs

@@ -73,7 +73,7 @@ pub(super) fn push_trait_super_clauses<I: Interner>(
     }
 }
 
-fn super_traits<I: Interner>(
+pub(crate) fn super_traits<I: Interner>(
     db: &dyn RustIrDatabase<I>,
     trait_id: TraitId<I>,
 ) -> Binders<(

tests/test/unsize.rs

@@ -142,6 +142,43 @@ fn dyn_to_dyn_unsizing() {
     }
 }
 
+#[test]
+fn super_auto_trait() {
+    test! {
+        program {
+            #[lang(unsize)]
+            trait Unsize<T> {}
+
+            #[object_safe]
+            trait Principal where Self: SuperAuto {}
+
+            #[auto]
+            #[object_safe]
+            trait SuperAuto {}
+
+            #[auto]
+            #[object_safe]
+            trait Auto {}
+        }
+
+        goal {
+            forall<'a> {
+                dyn Principal + 'a: Unsize<dyn Principal + SuperAuto + 'a>
+            }
+        } yields {
+            expect!["Unique; lifetime constraints [InEnvironment { environment: Env([]), goal: '!1_0: '!1_0 }]"]
+        }
+
+        goal {
+            forall<'a> {
+                dyn Principal + Auto + 'a: Unsize<dyn Principal + Auto + SuperAuto + 'a>
+            }
+        } yields {
+            expect!["Unique; lifetime constraints [InEnvironment { environment: Env([]), goal: '!1_0: '!1_0 }]"]
+        }
+    }
+}
+
 #[test]
 fn ty_to_dyn_unsizing() {
     test! {