Rework supertrait lint once again

Author: compiler-errors

compiler/rustc_lint/messages.ftl

@@ -490,8 +490,9 @@ lint_requested_level = requested on the command line with `{$level} {$lint_name}
 
 lint_span_use_eq_ctxt = use `.eq_ctxt()` instead of `.ctxt() == .ctxt()`
 
-lint_supertrait_as_deref_target = `{$t}` implements `Deref` with supertrait `{$target_principal}` as target
+lint_supertrait_as_deref_target = `{$self_ty}` implements `Deref<Target = dyn {$target_principal}>` which conflicts with supertrait `{$supertrait_principal}`
     .label = target type is set here
+    .note = inference and runtime behavior may change after `#[feature(trait_upcasting)]` is enabled by default
 
 lint_suspicious_double_ref_clone =
     using `.clone()` on a double reference, which returns `{$ty}` instead of cloning the inner type

compiler/rustc_lint/src/deref_into_dyn_supertrait.rs

@@ -62,26 +62,25 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
         let tcx = cx.tcx;
         // `Deref` is being implemented for `t`
         if let hir::ItemKind::Impl(impl_) = item.kind
+            // the trait is a `Deref` implementation
             && let Some(trait_) = &impl_.of_trait
-            && let t = tcx.type_of(item.owner_id).instantiate_identity()
-            && let opt_did @ Some(did) = trait_.trait_def_id()
-            && opt_did == tcx.lang_items().deref_trait()
-            // `t` is `dyn t_principal`
-            && let ty::Dynamic(data, _, ty::Dyn) = t.kind()
-            && let Some(t_principal) = data.principal()
+            && let Some(did) = trait_.trait_def_id()
+            && Some(did) == tcx.lang_items().deref_trait()
+            // the self type is `dyn t_principal`
+            && let self_ty = tcx.type_of(item.owner_id).instantiate_identity()
+            && let ty::Dynamic(data, _, ty::Dyn) = self_ty.kind()
+            && let Some(self_principal) = data.principal()
             // `<T as Deref>::Target` is `dyn target_principal`
-            && let Some(target) = cx.get_associated_type(t, did, "Target")
+            && let Some(target) = cx.get_associated_type(self_ty, did, "Target")
             && let ty::Dynamic(data, _, ty::Dyn) = target.kind()
             && let Some(target_principal) = data.principal()
             // `target_principal` is a supertrait of `t_principal`
-            && supertraits(tcx, t_principal.with_self_ty(tcx, tcx.types.trait_object_dummy_self))
-                .any(|sup| {
-                    tcx.erase_regions(
-                        sup.map_bound(|x| ty::ExistentialTraitRef::erase_self_ty(tcx, x)),
-                    ) == tcx.erase_regions(target_principal)
-                })
+            && let Some(supertrait_principal) = supertraits(tcx, self_principal.with_self_ty(tcx, self_ty))
+                .find(|supertrait| supertrait.def_id() == target_principal.def_id())
         {
-            let t = tcx.erase_regions(t);
+            // erase regions in self type for better diagnostic presentation
+            let (self_ty, target_principal, supertrait_principal) =
+                tcx.erase_regions((self_ty, target_principal, supertrait_principal));
             let label = impl_
                 .items
                 .iter()
@@ -90,7 +89,14 @@ impl<'tcx> LateLintPass<'tcx> for DerefIntoDynSupertrait {
             cx.emit_spanned_lint(
                 DEREF_INTO_DYN_SUPERTRAIT,
                 tcx.def_span(item.owner_id.def_id),
-                SupertraitAsDerefTarget { t, target_principal, label },
+                SupertraitAsDerefTarget {
+                    self_ty,
+                    supertrait_principal: supertrait_principal.map_bound(|trait_ref| {
+                        ty::ExistentialTraitRef::erase_self_ty(tcx, trait_ref)
+                    }),
+                    target_principal,
+                    label,
+                },
             );
         }
     }

compiler/rustc_lint/src/lints.rs

@@ -556,8 +556,10 @@ pub enum BuiltinSpecialModuleNameUsed {
 // deref_into_dyn_supertrait.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_supertrait_as_deref_target)]
+#[note]
 pub struct SupertraitAsDerefTarget<'a> {
-    pub t: Ty<'a>,
+    pub self_ty: Ty<'a>,
+    pub supertrait_principal: PolyExistentialTraitRef<'a>,
     pub target_principal: PolyExistentialTraitRef<'a>,
     #[subdiagnostic]
     pub label: Option<SupertraitAsDerefTargetLabel>,

tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.rs

@@ -0,0 +1,35 @@
+#![deny(deref_into_dyn_supertrait)]
+#![feature(trait_upcasting)] // remove this and the test compiles
+use std::ops::Deref;
+
+trait Bar<T> {}
+impl<T, U> Bar<U> for T {}
+
+trait Foo: Bar<i32> {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a);
+}
+
+impl Foo for () {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a) {
+        self
+    }
+}
+
+impl<'a> Deref for dyn Foo + 'a {
+    type Target = dyn Bar<u32> + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_dyn_bar_u32()
+    }
+}
+
+fn take_dyn<T>(x: &dyn Bar<T>) -> T {
+    todo!()
+}
+
+fn main() {
+    let x: &dyn Foo = &();
+    let y = take_dyn(x);
+    let z: u32 = y;
+    //~^ ERROR mismatched types
+}

tests/ui/traits/trait-upcasting/deref-upcast-behavioral-change.stderr

@@ -0,0 +1,16 @@
+error[E0308]: mismatched types
+  --> $DIR/deref-upcast-behavioral-change.rs:33:18
+   |
+LL |     let z: u32 = y;
+   |            ---   ^ expected `u32`, found `i32`
+   |            |
+   |            expected due to this
+   |
+help: you can convert an `i32` to a `u32` and panic if the converted value doesn't fit
+   |
+LL |     let z: u32 = y.try_into().unwrap();
+   |                   ++++++++++++++++++++
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0308`.

tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.rs

@@ -6,7 +6,7 @@ trait Bar<'a> {}
 trait Foo<'a>: Bar<'a> {}
 
 impl<'a> Deref for dyn Foo<'a> {
-    //~^ ERROR dyn Foo<'_>` implements `Deref` with supertrait `Bar<'_>` as target
+    //~^ ERROR `dyn Foo<'_>` implements `Deref<Target = dyn Bar<'_>>` which conflicts with supertrait `Bar<'_>`
     //~| WARN this will change its meaning in a future release!
     type Target = dyn Bar<'a>;
 

tests/ui/traits/trait-upcasting/migrate-lint-deny-regions.stderr

@@ -1,4 +1,4 @@
-error: `dyn Foo<'_>` implements `Deref` with supertrait `Bar<'_>` as target
+error: `dyn Foo<'_>` implements `Deref<Target = dyn Bar<'_>>` which conflicts with supertrait `Bar<'_>`
   --> $DIR/migrate-lint-deny-regions.rs:8:1
    |
 LL | impl<'a> Deref for dyn Foo<'a> {
@@ -9,6 +9,7 @@ LL |     type Target = dyn Bar<'a>;
    |
    = warning: this will change its meaning in a future release!
    = note: for more information, see issue #89460 <https://github.com/rust-lang/rust/issues/89460>
+   = note: inference and runtime behavior may change after `#[feature(trait_upcasting)]` is enabled by default
 note: the lint level is defined here
   --> $DIR/migrate-lint-deny-regions.rs:1:9
    |

tests/ui/traits/trait-upcasting/migrate-lint-deny.rs

@@ -7,7 +7,7 @@ trait A {}
 trait B: A {}
 
 impl<'a> Deref for dyn 'a + B {
-    //~^ ERROR `dyn B` implements `Deref` with supertrait `A` as target
+    //~^ ERROR `dyn B` implements `Deref<Target = dyn A>` which conflicts with supertrait `A`
     //~| WARN this will change its meaning in a future release!
 
     type Target = dyn A;

tests/ui/traits/trait-upcasting/migrate-lint-deny.stderr

@@ -1,4 +1,4 @@
-error: `dyn B` implements `Deref` with supertrait `A` as target
+error: `dyn B` implements `Deref<Target = dyn A>` which conflicts with supertrait `A`
   --> $DIR/migrate-lint-deny.rs:9:1
    |
 LL | impl<'a> Deref for dyn 'a + B {
@@ -9,6 +9,7 @@ LL |     type Target = dyn A;
    |
    = warning: this will change its meaning in a future release!
    = note: for more information, see issue #89460 <https://github.com/rust-lang/rust/issues/89460>
+   = note: inference and runtime behavior may change after `#[feature(trait_upcasting)]` is enabled by default
 note: the lint level is defined here
   --> $DIR/migrate-lint-deny.rs:1:9
    |

tests/ui/traits/trait-upcasting/migrate-lint-different-substs.rs

@@ -0,0 +1,21 @@
+#![deny(deref_into_dyn_supertrait)]
+
+use std::ops::Deref;
+
+trait Bar<T> {}
+
+trait Foo: Bar<i32> {
+    fn as_dyn_bar_u32<'a>(&self) -> &(dyn Bar<u32> + 'a);
+}
+
+impl<'a> Deref for dyn Foo + 'a {
+    //~^ ERROR `dyn Foo` implements `Deref<Target = dyn Bar<u32>>` which conflicts with supertrait `Bar<i32>`
+    //~| WARN this will change its meaning in a future release!
+    type Target = dyn Bar<u32> + 'a;
+
+    fn deref(&self) -> &Self::Target {
+        self.as_dyn_bar_u32()
+    }
+}
+
+fn main() {}