Support assoc type defaults for assoc type constraints for trait objects

Author: ShoyuVanilla

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs

@@ -234,7 +234,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                                 .filter(|item| item.is_type() || item.is_const())
                                 // Traits with RPITITs are simply not dyn compatible (for now).
                                 .filter(|item| !item.is_impl_trait_in_trait())
-                                .map(|item| (item.def_id, trait_ref)),
+                                .map(|item| (item, trait_ref)),
                         );
                     }
                     ty::ClauseKind::Projection(pred) => {
@@ -314,14 +314,24 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let mut missing_assoc_items = FxIndexSet::default();
         let projection_bounds: Vec<_> = ordered_associated_items
             .into_iter()
-            .filter_map(|key @ (def_id, _)| {
-                if let Some(&assoc) = projection_bounds.get(&key) {
+            .filter_map(|(item, trait_ref)| {
+                let def_id = item.def_id;
+                let key = (def_id, trait_ref);
+                if let Some(&(assoc, _)) = projection_bounds.get(&key) {
                     return Some(assoc);
                 }
-                if !tcx.generics_require_sized_self(def_id) {
+                let has_default = item.defaultness(tcx).has_value();
+                if !has_default && !tcx.generics_require_sized_self(def_id) {
                     missing_assoc_items.insert(key);
                 }
-                None
+                if has_default {
+                    Some(trait_ref.map_bound(|trait_ref| ty::ProjectionPredicate {
+                        projection_term: ty::AliasTerm::new_from_args(tcx, def_id, trait_ref.args),
+                        term: tcx.type_of(def_id).instantiate(tcx, trait_ref.args).into(),
+                    }))
+                } else {
+                    None
+                }
             })
             .collect();
 
@@ -394,7 +404,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
             })
         });
 
-        let existential_projections = projection_bounds.into_iter().map(|(bound, _)| {
+        let existential_projections = projection_bounds.into_iter().map(|bound| {
             bound.map_bound(|mut b| {
                 assert_eq!(b.projection_term.self_ty(), dummy_self);
 

tests/ui/associated-types/defaults-on-trait-object.rs

@@ -0,0 +1,33 @@
+#![feature(associated_type_defaults)]
+
+trait Foo {
+    type Assoc: Default = ();
+
+    fn foo(&self) -> Self::Assoc {
+        Default::default()
+    }
+}
+
+// The assoc type constraint can be omitted for the assoc type with a default.
+type FooObj = Box<dyn Foo>;
+
+trait Bar {
+    type Assoc1 = i32;
+    type Assoc2;
+}
+
+// We can't omit assoc type constraints for an assoc type without a default value.
+type BarObj1 = Box<dyn Bar>;
+//~^ ERROR: the value of the associated type `Assoc2` in `Bar` must be specified
+
+type BarObj2 = Box<dyn Bar<Assoc2 = ()>>;
+
+type BarObj3 = Box<dyn Bar<Assoc1 = u32, Assoc2 = i32>>;
+
+fn check_projs(foo1: &dyn Foo, foo2: &dyn Foo<Assoc = bool>) {
+    let _: () = foo1.foo();
+    let _: () = foo2.foo();
+    //~^ ERROR: mismatched types
+}
+
+fn main() {}

tests/ui/associated-types/defaults-on-trait-object.stderr

@@ -0,0 +1,26 @@
+error[E0191]: the value of the associated type `Assoc2` in `Bar` must be specified
+  --> $DIR/defaults-on-trait-object.rs:20:24
+   |
+LL |     type Assoc2;
+   |     ----------- `Assoc2` defined here
+...
+LL | type BarObj1 = Box<dyn Bar>;
+   |                        ^^^
+   |
+help: specify the associated type
+   |
+LL | type BarObj1 = Box<dyn Bar<Assoc2 = /* Type */>>;
+   |                           +++++++++++++++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/defaults-on-trait-object.rs:29:17
+   |
+LL |     let _: () = foo2.foo();
+   |            --   ^^^^^^^^^^ expected `()`, found `bool`
+   |            |
+   |            expected due to this
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0191, E0308.
+For more information about an error, try `rustc --explain E0191`.