Tweak wording and only suggest dyn Trait if Trait is object safe

Author: estebank

compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs

@@ -20,9 +20,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     ) -> Option<ErrorGuaranteed> {
         let tcx = self.tcx();
 
-        let hir::TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
-            self_ty.kind
-        else {
+        let hir::TyKind::TraitObject(traits, _, TraitObjectSyntax::None) = self_ty.kind else {
+            return None;
+        };
+        let [poly_trait_ref, ..] = traits else {
             return None;
         };
 
@@ -36,6 +37,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let is_global = poly_trait_ref.trait_ref.path.is_global();
 
+        let object_safe = traits.iter().all(|ptr| match ptr.trait_ref.path.res {
+            Res::Def(DefKind::Trait, def_id) => tcx.object_safety_violations(def_id).is_empty(),
+            _ => false,
+        });
+
         let mut sugg = vec![(
             self_ty.span.shrink_to_lo(),
             format!(
@@ -63,10 +69,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 rustc_errors::struct_span_code_err!(tcx.dcx(), self_ty.span, E0782, "{}", msg);
             let mut downgrade = false;
             if self_ty.span.can_be_used_for_suggestions() {
-                let (non_object_safe, should_downgrade) =
-                    self.maybe_suggest_impl_trait(self_ty, &mut diag);
+                let should_downgrade = self.maybe_suggest_impl_trait(self_ty, &mut diag);
                 downgrade = should_downgrade;
-                if !non_object_safe {
+                if object_safe {
                     // Only emit this suggestion if the trait is object safe.
                     diag.multipart_suggestion_verbose(
                         label,
@@ -89,12 +94,27 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         } else {
             tcx.node_span_lint(BARE_TRAIT_OBJECTS, self_ty.hir_id, self_ty.span, |lint| {
                 lint.primary_message("trait objects without an explicit `dyn` are deprecated");
-                if self_ty.span.can_be_used_for_suggestions() {
-                    lint.multipart_suggestion_verbose(
-                        "if this is an object-safe trait, use `dyn`",
-                        sugg,
-                        Applicability::MachineApplicable,
-                    );
+                match (object_safe, self_ty.span.can_be_used_for_suggestions()) {
+                    (true, true) => {
+                        lint.multipart_suggestion_verbose(
+                            "as this is an \"object safe\" trait, write `dyn` in front of the \
+                             trait",
+                            sugg,
+                            Applicability::MachineApplicable,
+                        );
+                    }
+                    (true, false) => {
+                        lint.note(
+                            "as this is an \"object safe\" trait, you can write `dyn` in front of \
+                             the trait",
+                        );
+                    }
+                    (false, _) => {
+                        lint.note(
+                            "you can't use write a trait object here because the trait isn't \
+                             \"object safe\"",
+                        );
+                    }
                 }
                 self.maybe_suggest_blanket_trait_impl(self_ty, lint);
             });
@@ -170,7 +190,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     /// Make sure that we are in the condition to suggest `impl Trait`.
     ///
     /// Returns whether a suggestion was provided and whether the error itself should not be emitted
-    fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> (bool, bool) {
+    fn maybe_suggest_impl_trait(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) -> bool {
         let tcx = self.tcx();
         let parent_id = tcx.hir().get_parent_item(self_ty.hir_id).def_id;
         // FIXME: If `type_alias_impl_trait` is enabled, also look for `Trait0<Ty = Trait1>`
@@ -185,10 +205,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 owner_id,
                 ..
             }) => (sig, generics, Some(tcx.parent(owner_id.to_def_id()))),
-            _ => return (false, false),
+            _ => return false,
         };
         let Ok(trait_name) = tcx.sess.source_map().span_to_snippet(self_ty.span) else {
-            return (false, false);
+            return false;
         };
         let impl_sugg = vec![(self_ty.span.shrink_to_lo(), "impl ".to_string())];
         let mut is_downgradable = true;
@@ -201,7 +221,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                             // For recursive traits, don't downgrade the error. (#119652)
                             is_downgradable = false;
                         }
-                        tcx.check_is_object_safe(id)
+                        tcx.object_safety_violations(id).is_empty()
                     }
                     _ => false,
                 })
@@ -234,7 +254,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                 // We'll emit the object safety error already, with a structured suggestion.
                 downgrade = true;
             }
-            return (true, downgrade);
+            return downgrade;
         }
         for ty in sig.decl.inputs {
             if ty.hir_id != self_ty.hir_id {
@@ -279,9 +299,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     Applicability::MachineApplicable,
                 );
             }
-            return (true, downgrade);
+            return downgrade;
         }
-        (false, downgrade)
+        downgrade
     }
 
     fn maybe_suggest_assoc_ty_bound(&self, self_ty: &hir::Ty<'_>, diag: &mut Diag<'_>) {

tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.rs

@@ -3,12 +3,10 @@
 
 fn f(_: impl Trait<T = Copy>) {}
 //~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
 //~| HELP you might have meant to write a bound here
 
 fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
 //~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
 //~| HELP you might have meant to write a bound here
 
 fn h(_: impl Trait<T<> = 'static + for<'a> Fn(&'a ())>) {}
@@ -19,7 +17,6 @@ fn h(_: impl Trait<T<> = 'static + for<'a> Fn(&'a ())>) {}
 // Don't suggest assoc ty bound in trait object types, that's not valid:
 type Obj = dyn Trait<T = Clone>;
 //~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
 
 trait Trait { type T; }
 

tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.stderr

@@ -4,32 +4,24 @@ error[E0782]: trait objects must include the `dyn` keyword
 LL | fn f(_: impl Trait<T = Copy>) {}
    |                        ^^^^
    |
-help: add `dyn` keyword before this trait
-   |
-LL | fn f(_: impl Trait<T = dyn Copy>) {}
-   |                        +++
 help: you might have meant to write a bound here
    |
 LL | fn f(_: impl Trait<T: Copy>) {}
    |                     ~
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:9:24
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:8:24
    |
 LL | fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
    |                        ^^^^^^^^^^^^^^^^^^^^
    |
-help: add `dyn` keyword before this trait
-   |
-LL | fn g(_: impl Trait<T = dyn std::fmt::Debug + Eq>) {}
-   |                        +++
 help: you might have meant to write a bound here
    |
 LL | fn g(_: impl Trait<T: std::fmt::Debug + Eq>) {}
    |                     ~
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:14:26
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:12:26
    |
 LL | fn h(_: impl Trait<T<> = 'static + for<'a> Fn(&'a ())>) {}
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,15 +36,10 @@ LL | fn h(_: impl Trait<T<>: 'static + for<'a> Fn(&'a ())>) {}
    |                       ~
 
 error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:20:26
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:18:26
    |
 LL | type Obj = dyn Trait<T = Clone>;
    |                          ^^^^^
-   |
-help: add `dyn` keyword before this trait
-   |
-LL | type Obj = dyn Trait<T = dyn Clone>;
-   |                          +++
 
 error: aborting due to 4 previous errors
 

tests/ui/consts/const_refs_to_static-ice-121413.stderr

@@ -18,7 +18,7 @@ LL |     static FOO: Sync = AtomicUsize::new(0);
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
    = note: `#[warn(bare_trait_objects)]` on by default
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL |     static FOO: dyn Sync = AtomicUsize::new(0);
    |                 +++
@@ -32,7 +32,7 @@ LL |     static FOO: Sync = AtomicUsize::new(0);
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL |     static FOO: dyn Sync = AtomicUsize::new(0);
    |                 +++

tests/ui/did_you_mean/bad-assoc-ty.stderr

@@ -182,7 +182,7 @@ LL | type H = Fn(u8) -> (u8)::Output;
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
    = note: `#[warn(bare_trait_objects)]` on by default
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL | type H = <dyn Fn(u8) -> (u8)>::Output;
    |          ++++               +

tests/ui/dyn-keyword/dyn-2018-edition-lint.stderr

@@ -11,7 +11,7 @@ note: the lint level is defined here
    |
 LL | #[deny(bare_trait_objects)]
    |        ^^^^^^^^^^^^^^^^^^
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL | fn function(x: &dyn SomeTrait, y: Box<SomeTrait>) {
    |                 +++
@@ -24,7 +24,7 @@ LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
    |
    = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL | fn function(x: &SomeTrait, y: Box<dyn SomeTrait>) {
    |                                   +++
@@ -37,7 +37,7 @@ LL |     let _x: &SomeTrait = todo!();
    |
    = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL |     let _x: &dyn SomeTrait = todo!();
    |              +++

tests/ui/dyn-keyword/dyn-angle-brackets.stderr

@@ -11,7 +11,7 @@ note: the lint level is defined here
    |
 LL | #![deny(bare_trait_objects)]
    |         ^^^^^^^^^^^^^^^^^^
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL |         <dyn fmt::Debug>::fmt(self, f)
    |          +++

tests/ui/dyn-keyword/trait-missing-dyn-in-qualified-path.edition2018.stderr

@@ -6,11 +6,8 @@ LL |     let x: u32 = <Default>::default();
    |
    = warning: this is accepted in the current edition (Rust 2018) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: you can't use write a trait object here because the trait isn't "object safe"
    = note: `#[warn(bare_trait_objects)]` on by default
-help: if this is an object-safe trait, use `dyn`
-   |
-LL |     let x: u32 = <dyn Default>::default();
-   |                   +++
 
 error[E0038]: the trait `Default` cannot be made into an object
   --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19

tests/ui/dyn-keyword/trait-missing-dyn-in-qualified-path.edition2021.stderr

@@ -3,11 +3,6 @@ error[E0782]: trait objects must include the `dyn` keyword
    |
 LL |     let x: u32 = <Default>::default();
    |                   ^^^^^^^
-   |
-help: add `dyn` keyword before this trait
-   |
-LL |     let x: u32 = <dyn Default>::default();
-   |                   +++
 
 error: aborting due to 1 previous error
 

tests/ui/impl-trait/fresh-lifetime-from-bare-trait-obj-114664.stderr

@@ -7,7 +7,7 @@ LL | fn ice() -> impl AsRef<Fn(&())> {
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
    = note: `#[warn(bare_trait_objects)]` on by default
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL | fn ice() -> impl AsRef<dyn Fn(&())> {
    |                        +++
@@ -21,7 +21,7 @@ LL | fn ice() -> impl AsRef<Fn(&())> {
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: if this is an object-safe trait, use `dyn`
+help: as this is an "object safe" trait, write `dyn` in front of the trait
    |
 LL | fn ice() -> impl AsRef<dyn Fn(&())> {
    |                        +++