Make HR trait object conversions a coercion

Author: spastorino

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -1055,57 +1055,99 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             (&ty::Dynamic(data_a, r_a), &ty::Dynamic(data_b, r_b)) => {
                 // See `assemble_candidates_for_unsizing` for more info.
                 // We already checked the compatibility of auto traits within `assemble_candidates_for_unsizing`.
-                let existential_predicates = if data_b.principal().is_some() {
-                    tcx.mk_poly_existential_predicates_from_iter(
-                        data_a
-                            .principal()
-                            .map(|b| b.map_bound(ty::ExistentialPredicate::Trait))
-                            .into_iter()
-                            .chain(
-                                data_a
-                                    .projection_bounds()
-                                    .map(|b| b.map_bound(ty::ExistentialPredicate::Projection)),
+                if let Some(hr_target_principal) = data_b.principal() {
+                    let hr_source_principal = data_a.principal().unwrap_or_else(|| {
+                        span_bug!(obligation.cause.span, "unsizing to an object with no principal")
+                    });
+                    let mut obligations = self
+                        .infcx
+                        .enter_forall(hr_target_principal, |target_principal| {
+                            let source_principal = self.infcx.instantiate_binder_with_fresh_vars(
+                                obligation.cause.span,
+                                BoundRegionConversionTime::HigherRankedType,
+                                hr_source_principal,
+                            );
+                            self.infcx.at(&obligation.cause, obligation.param_env).eq(
+                                DefineOpaqueTypes::Yes,
+                                target_principal,
+                                source_principal,
                             )
-                            .chain(
-                                data_b
-                                    .auto_traits()
-                                    .map(ty::ExistentialPredicate::AutoTrait)
-                                    .map(ty::Binder::dummy),
-                            ),
-                    )
+                        })
+                        .map_err(|_| SelectionError::Unimplemented)?
+                        .into_obligations();
+
+                    debug_assert_eq!(
+                        data_a.projection_bounds().count(),
+                        data_b.projection_bounds().count(),
+                        "source and target object types have a different number of projection bounds",
+                    );
+                    for (hr_source_projection, hr_target_projection) in
+                        data_a.projection_bounds().zip(data_b.projection_bounds())
+                    {
+                        obligations.extend(
+                            self.infcx
+                                .enter_forall(hr_target_projection, |target_projection| {
+                                    let source_projection =
+                                        self.infcx.instantiate_binder_with_fresh_vars(
+                                            obligation.cause.span,
+                                            BoundRegionConversionTime::HigherRankedType,
+                                            hr_source_projection,
+                                        );
+                                    self.infcx.at(&obligation.cause, obligation.param_env).eq(
+                                        DefineOpaqueTypes::Yes,
+                                        target_projection,
+                                        source_projection,
+                                    )
+                                })
+                                .map_err(|_| SelectionError::Unimplemented)?
+                                .into_obligations(),
+                        );
+                    }
+
+                    // Register one obligation for 'a: 'b.
+                    let outlives = ty::OutlivesPredicate(r_a, r_b);
+                    obligations.push(Obligation::with_depth(
+                        tcx,
+                        obligation.cause.clone(),
+                        obligation.recursion_depth + 1,
+                        obligation.param_env,
+                        obligation.predicate.rebind(outlives),
+                    ));
+
+                    ImplSource::Builtin(BuiltinImplSource::Misc, obligations)
                 } else {
                     // If we're unsizing to a dyn type that has no principal, then drop
                     // the principal and projections from the type. We use the auto traits
                     // from the RHS type since as we noted that we've checked for auto
                     // trait compatibility during unsizing.
-                    tcx.mk_poly_existential_predicates_from_iter(
+                    let existential_predicates = tcx.mk_poly_existential_predicates_from_iter(
                         data_b
                             .auto_traits()
                             .map(ty::ExistentialPredicate::AutoTrait)
                             .map(ty::Binder::dummy),
-                    )
-                };
-                let source_trait = Ty::new_dynamic(tcx, existential_predicates, r_b);
-
-                // Require that the traits involved in this upcast are **equal**;
-                // only the **lifetime bound** is changed.
-                let InferOk { mut obligations, .. } = self
-                    .infcx
-                    .at(&obligation.cause, obligation.param_env)
-                    .sup(DefineOpaqueTypes::Yes, target, source_trait)
-                    .map_err(|_| SelectionError::Unimplemented)?;
-
-                // Register one obligation for 'a: 'b.
-                let outlives = ty::OutlivesPredicate(r_a, r_b);
-                obligations.push(Obligation::with_depth(
-                    tcx,
-                    obligation.cause.clone(),
-                    obligation.recursion_depth + 1,
-                    obligation.param_env,
-                    obligation.predicate.rebind(outlives),
-                ));
+                    );
+                    let source_trait = Ty::new_dynamic(tcx, existential_predicates, r_b);
+
+                    // Require that the traits involved in this upcast are **equal**;
+                    // only the **lifetime bound** is changed.
+                    let InferOk { mut obligations, .. } = self
+                        .infcx
+                        .at(&obligation.cause, obligation.param_env)
+                        .sup(DefineOpaqueTypes::Yes, target, source_trait)
+                        .map_err(|_| SelectionError::Unimplemented)?;
+
+                    // Register one obligation for 'a: 'b.
+                    let outlives = ty::OutlivesPredicate(r_a, r_b);
+                    obligations.push(Obligation::with_depth(
+                        tcx,
+                        obligation.cause.clone(),
+                        obligation.recursion_depth + 1,
+                        obligation.param_env,
+                        obligation.predicate.rebind(outlives),
+                    ));
 
-                ImplSource::Builtin(BuiltinImplSource::Misc, obligations)
+                    ImplSource::Builtin(BuiltinImplSource::Misc, obligations)
+                }
             }
 
             // `T` -> `dyn Trait`

tests/ui/cast/ptr-to-trait-obj-different-regions-misc.stderr

@@ -107,8 +107,8 @@ error[E0308]: mismatched types
 LL |     x as _
    |     ^^^^^^ one type is more general than the other
    |
-   = note: expected trait object `dyn for<'b> Trait<'b>`
-              found trait object `dyn Trait<'_>`
+   = note: expected existential trait ref `for<'b> Trait<'b>`
+              found existential trait ref `Trait<'_>`
 
 error: lifetime may not live long enough
   --> $DIR/ptr-to-trait-obj-different-regions-misc.rs:32:5

tests/ui/cast/ptr-to-trait-obj-ok.rs

@@ -1,13 +1,18 @@
-//@ known-bug: unknown
-
 // Casting pointers to object types has some special rules in order to
 // ensure VTables stay valid. E.g.
 // - Cannot introduce new autotraits
 // - Cannot extend or shrink lifetimes in trait arguments
 // - Cannot extend the lifetime of the object type
 //
 // This test is a mostly miscellaneous set of examples of casts that do
-// uphold these rules
+// uphold these rules.
+//
+// FIXME(higher-ranked-coercions): `cast_away_higher_ranked_wrap` below
+// regressed when higher-ranked subtyping was removed: casting away a
+// higher-ranked principal through a (non-coercion) wrapped raw-pointer cast no
+// longer type-checks. This is entangled with the raw-pointer-cast lifetime rules
+// of #141402 and is left as a follow-up; the conversion still works for the
+// unwrapped case (`cast_away_higher_ranked`) via an unsizing coercion.
 
 trait Trait<'a> {}
 
@@ -52,6 +57,8 @@ fn cast_inherent_lt_wrap<'a: 'b, 'b>(
 
 fn cast_away_higher_ranked_wrap<'a>(x: *mut dyn for<'b> Trait<'b>) -> *mut Wrapper<dyn Trait<'a>> {
     x as _
+    //~^ ERROR lifetime may not live long enough
+    //~| ERROR mismatched types
 }
 
 fn unprincipled_wrap<'a: 'b, 'b>(x: *mut (dyn Send + 'a)) -> *mut Wrapper<dyn Sync + 'b> {

tests/ui/cast/ptr-to-trait-obj-ok.stderr

@@ -1,33 +1,5 @@
 error: lifetime may not live long enough
-  --> $DIR/ptr-to-trait-obj-ok.rs:25:5
-   |
-LL | fn cast_away_higher_ranked<'a>(x: *mut dyn for<'b> Trait<'b>) -> *mut dyn Trait<'a> {
-   |                            -- lifetime `'a` defined here
-LL |     x as _
-   |     ^^^^^^ returning this value requires that `'a` must outlive `'static`
-   |
-   = note: requirement occurs because of a mutable pointer to `dyn Trait<'_>`
-   = note: mutable pointers are invariant over their type parameter
-   = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
-note: raw pointer casts of trait objects cannot extend lifetimes
-  --> $DIR/ptr-to-trait-obj-ok.rs:25:5
-   |
-LL |     x as _
-   |     ^^^^^^
-   = note: this was previously accepted by the compiler but was changed recently
-   = help: see <https://github.com/rust-lang/rust/issues/141402> for more information
-
-error[E0308]: mismatched types
-  --> $DIR/ptr-to-trait-obj-ok.rs:25:5
-   |
-LL |     x as _
-   |     ^^^^^^ one type is more general than the other
-   |
-   = note: expected trait object `dyn Trait<'_>`
-              found trait object `dyn for<'b> Trait<'b>`
-
-error: lifetime may not live long enough
-  --> $DIR/ptr-to-trait-obj-ok.rs:54:5
+  --> $DIR/ptr-to-trait-obj-ok.rs:59:5
    |
 LL | fn cast_away_higher_ranked_wrap<'a>(x: *mut dyn for<'b> Trait<'b>) -> *mut Wrapper<dyn Trait<'a>> {
    |                                 -- lifetime `'a` defined here
@@ -38,22 +10,22 @@ LL |     x as _
    = note: mutable pointers are invariant over their type parameter
    = help: see <https://doc.rust-lang.org/nomicon/subtyping.html> for more information about variance
 note: raw pointer casts of trait objects cannot extend lifetimes
-  --> $DIR/ptr-to-trait-obj-ok.rs:54:5
+  --> $DIR/ptr-to-trait-obj-ok.rs:59:5
    |
 LL |     x as _
    |     ^^^^^^
    = note: this was previously accepted by the compiler but was changed recently
    = help: see <https://github.com/rust-lang/rust/issues/141402> for more information
 
 error[E0308]: mismatched types
-  --> $DIR/ptr-to-trait-obj-ok.rs:54:5
+  --> $DIR/ptr-to-trait-obj-ok.rs:59:5
    |
 LL |     x as _
    |     ^^^^^^ one type is more general than the other
    |
    = note: expected trait object `dyn Trait<'_>`
               found trait object `dyn for<'b> Trait<'b>`
 
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0308`.

tests/ui/closures/closure-to-fn-pointer-lifetime-error.stderr

@@ -4,18 +4,17 @@ error[E0308]: mismatched types
 LL |     foo(bar);
    |         ^^^ one type is more general than the other
    |
-   = note: expected trait object `dyn for<'a> Fn(&'a i32)`
-              found trait object `dyn Fn(&i32)`
+   = note: expected existential trait ref `for<'a> Fn<(&'a i32,)>`
+              found existential trait ref `Fn<(&i32,)>`
 
 error[E0308]: mismatched types
   --> $DIR/closure-to-fn-pointer-lifetime-error.rs:8:9
    |
 LL |     foo(bar);
    |         ^^^ one type is more general than the other
    |
-   = note: expected trait object `dyn for<'a> Fn(&'a i32)`
-              found trait object `dyn Fn(&i32)`
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+   = note: expected existential projection `for<'a> Output = ()`
+              found existential projection `Output = ()`
 
 error: aborting due to 2 previous errors
 

tests/ui/codegen/sub-principals-in-codegen.rs

@@ -1,4 +1,4 @@
-//@ known-bug: unknown
+//@ build-pass
 
 // Regression test for an overly aggressive assertion in #130855.
 

tests/ui/codegen/sub-principals-in-codegen.stderr

@@ -1,6 +1,5 @@
+//@ check-pass
 //@ revisions: current next
-//@[next] check-pass
-//@[current] known-bug: unknown
 //@ ignore-compare-mode-next-solver (explicit revisions)
 //@[next] compile-flags: -Znext-solver
 

tests/ui/coercion/sub-principals.current.stderr

@@ -1,4 +1,3 @@
-//@ known-bug: unknown
 // Test that we give a note when the old LUB/GLB algorithm would have
 // succeeded but the new code (which is stricter) gives an error.
 
@@ -8,6 +7,8 @@ fn foo(x: &dyn for<'a, 'b> Foo<&'a u8, &'b u8>, y: &dyn for<'a> Foo<&'a u8, &'a
     let z = match 22 {
         0 => x,
         _ => y,
+        //~^ ERROR mismatched types
+        //~| ERROR mismatched types
     };
 }