Auto merge of rust-lang#125610 - oli-obk:define_opaque_types14, r=compiler-errors

Allow constraining opaque types during various unsizing casts

allows unsizing of tuples, arrays and Adts to constraint opaque types in their generic parameters to concrete types on either side of the unsizing cast.

Also allows constraining opaque types during trait object casts that only differ in auto traits or lifetimes.

cc rust-lang#116652

Author: bors

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

@@ -1162,7 +1162,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 let InferOk { mut obligations, .. } = self
                     .infcx
                     .at(&obligation.cause, obligation.param_env)
-                    .sup(DefineOpaqueTypes::No, target, source_trait)
+                    .sup(DefineOpaqueTypes::Yes, target, source_trait)
                     .map_err(|_| Unimplemented)?;
 
                 // Register one obligation for 'a: 'b.
@@ -1229,7 +1229,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 let InferOk { obligations, .. } = self
                     .infcx
                     .at(&obligation.cause, obligation.param_env)
-                    .eq(DefineOpaqueTypes::No, b, a)
+                    .eq(DefineOpaqueTypes::Yes, b, a)
                     .map_err(|_| Unimplemented)?;
 
                 ImplSource::Builtin(BuiltinImplSource::Misc, obligations)
@@ -1277,7 +1277,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 let InferOk { obligations, .. } = self
                     .infcx
                     .at(&obligation.cause, obligation.param_env)
-                    .eq(DefineOpaqueTypes::No, target, new_struct)
+                    .eq(DefineOpaqueTypes::Yes, target, new_struct)
                     .map_err(|_| Unimplemented)?;
                 nested.extend(obligations);
 
@@ -1310,7 +1310,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 let InferOk { mut obligations, .. } = self
                     .infcx
                     .at(&obligation.cause, obligation.param_env)
-                    .eq(DefineOpaqueTypes::No, target, new_tuple)
+                    .eq(DefineOpaqueTypes::Yes, target, new_tuple)
                     .map_err(|_| Unimplemented)?;
 
                 // Add a nested `T: Unsize<U>` predicate.

tests/ui/impl-trait/trait_upcasting.rs

@@ -0,0 +1,26 @@
+//! Test that we allow unsizing `Trait<Concrete>` to `Trait<Opaque>` and vice versa
+
+//@ check-pass
+
+trait Trait<T> {}
+
+impl<T, U> Trait<T> for U {}
+
+fn hello() -> &'static (dyn Trait<impl Sized> + Send) {
+    if false {
+        let x = hello();
+        let _: &'static dyn Trait<()> = x;
+    }
+    todo!()
+}
+
+fn bye() -> &'static dyn Trait<impl Sized> {
+    if false {
+        let mut x = bye();
+        let y: &'static (dyn Trait<()> + Send) = &();
+        x = y;
+    }
+    todo!()
+}
+
+fn main() {}

tests/ui/impl-trait/trait_upcasting_reference_mismatch.rs

@@ -0,0 +1,18 @@
+//! Show an uninformative diagnostic that we could possibly improve in the future
+
+trait Trait<T> {}
+
+impl<T, U> Trait<T> for U {}
+
+fn hello() -> &'static (dyn Trait<impl Sized> + Send) {
+    //~^ ERROR: type annotations needed
+    if false {
+        let x = hello();
+        let _: &'static dyn Trait<()> = &x;
+        //^ Note the extra `&`, paired with the blanket impl causing
+        // `impl Sized` to never get a hidden type registered.
+    }
+    todo!()
+}
+
+fn main() {}

tests/ui/impl-trait/trait_upcasting_reference_mismatch.stderr

@@ -0,0 +1,9 @@
+error[E0282]: type annotations needed
+  --> $DIR/trait_upcasting_reference_mismatch.rs:7:35
+   |
+LL | fn hello() -> &'static (dyn Trait<impl Sized> + Send) {
+   |                                   ^^^^^^^^^^ cannot infer type
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.

tests/ui/impl-trait/unsize_adt.rs

@@ -1,12 +1,13 @@
-//! Test that we do not allow unsizing `Foo<[Opaque; N]>` to `Foo<[Concrete]>`.
+//! Test that we allow unsizing `Foo<[Opaque; N]>` to `Foo<[Concrete]>`.
+
+//@check-pass
 
 struct Foo<T: ?Sized>(T);
 
 fn hello() -> Foo<[impl Sized; 2]> {
     if false {
         let x = hello();
         let _: &Foo<[i32]> = &x;
-        //~^ ERROR: mismatched types
     }
     todo!()
 }

tests/ui/impl-trait/unsize_adt.stderr

@@ -1,10 +1,11 @@
-//! Test that we do not allow unsizing `[Opaque; N]` to `[Concrete]`.
+//! Test that we allow unsizing `[Opaque; N]` to `[Concrete]`.
+
+//@check-pass
 
 fn hello() -> [impl Sized; 2] {
     if false {
         let x = hello();
         let _: &[i32] = &x;
-        //~^ ERROR: mismatched types
     }
     todo!()
 }

tests/ui/impl-trait/unsize_slice.rs

@@ -1,12 +1,13 @@
-//! Test that we do not allow unsizing `([Opaque; N],)` to `([Concrete],)`.
+//! Test that we allow unsizing `([Opaque; N],)` to `([Concrete],)`.
+
+//@check-pass
 
 #![feature(unsized_tuple_coercion)]
 
 fn hello() -> ([impl Sized; 2],) {
     if false {
         let x = hello();
         let _: &([i32],) = &x;
-        //~^ ERROR: mismatched types
     }
     todo!()
 }