On object safety errors, point at specific object unsafe trait in path

We use the new HIR node tracking for well-formedness obligations to
point at the specific trait object in a path/type (`dyn T` instead of a
whole `Box<dyn T>`, for example).

```
error[E0038]: the trait `MapLike` cannot be made into an object
  --> $DIR/file.rs:47:16
   |
LL |         as Box<dyn Trait>;
   |                ^^^^^^^^^ `Trait` cannot be made into an object
```

We also provide a structured suggestion for `<dyn Trait>::assoc`:

```
   = help: when writing `<dyn Trait>::function` you are requiring `Trait` be "object safe", which it isn't
help: you might have meant to access the associated function of a specific `impl` to avoid requiring "object safety" from `Trait`, either with some explicit type...
   |
LL |     </* Type */ as Trait>::function();
   |      ~~~~~~~~~~~~~
help: ...or rely on inference if the compiler has enough context to identify the desired type on its own...
   |
LL -     <dyn Trait>::function();
LL +     Trait::function();
   |
help: ...which is equivalent to
   |
LL |     <_ as Trait>::function();
   |      ~~~~
```

Author: estebank

Cargo.lock

@@ -3997,6 +3997,7 @@ dependencies = [
 name = "rustc_infer"
 version = "0.0.0"
 dependencies = [
+ "rustc_ast",
  "rustc_ast_ir",
  "rustc_data_structures",
  "rustc_errors",

compiler/rustc_infer/Cargo.toml

@@ -8,6 +8,7 @@ doctest = false
 
 [dependencies]
 # tidy-alphabetical-start
+rustc_ast = { path = "../rustc_ast" }
 rustc_ast_ir = { path = "../rustc_ast_ir" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }

compiler/rustc_infer/src/traits/error_reporting/mod.rs

@@ -1,10 +1,12 @@
 use super::ObjectSafetyViolation;
 
 use crate::infer::InferCtxt;
+use rustc_ast::TraitObjectSyntax;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{codes::*, struct_span_code_err, Applicability, Diag, MultiSpan};
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::intravisit::Visitor;
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::Span;
@@ -39,6 +41,23 @@ impl<'tcx> InferCtxt<'tcx> {
     }
 }
 
+struct TraitObjectFinder<'tcx> {
+    trait_def_id: DefId,
+    result: Vec<&'tcx hir::Ty<'tcx>>,
+}
+
+impl<'v> Visitor<'v> for TraitObjectFinder<'v> {
+    fn visit_ty(&mut self, ty: &'v hir::Ty<'v>) {
+        if let hir::TyKind::TraitObject(traits, _, _) = ty.kind
+            && traits.iter().any(|t| t.trait_ref.trait_def_id() == Some(self.trait_def_id))
+        {
+            self.result.push(ty);
+        }
+        hir::intravisit::walk_ty(self, ty);
+    }
+}
+
+#[tracing::instrument(level = "debug", skip(tcx))]
 pub fn report_object_safety_error<'tcx>(
     tcx: TyCtxt<'tcx>,
     span: Span,
@@ -51,33 +70,79 @@ pub fn report_object_safety_error<'tcx>(
         hir::Node::Item(item) => Some(item.ident.span),
         _ => None,
     });
+    let mut visitor = TraitObjectFinder { trait_def_id, result: vec![] };
+    if let Some(hir_id) = hir_id {
+        match tcx.hir_node(hir_id) {
+            hir::Node::Expr(expr) => {
+                visitor.visit_expr(&expr);
+                if visitor.result.is_empty() {
+                    match tcx.parent_hir_node(hir_id) {
+                        hir::Node::Expr(expr) if let hir::ExprKind::Cast(_, ty) = expr.kind => {
+                            // Special case for `<expr> as <ty>`, as we're given the `expr` instead
+                            // of the whole cast expression. This will let us point at `dyn Trait`
+                            // instead of `x` in `x as Box<dyn Trait>`.
+                            visitor.visit_ty(ty);
+                        }
+                        hir::Node::LetStmt(stmt) if let Some(ty) = stmt.ty => {
+                            // Special case for `let <pat>: <ty> = <expr>;`, as we're given the
+                            // `expr` instead of the whole cast expression. This will let us point
+                            // at `dyn Trait` instead of `x` in `let y: Box<dyn Trait> = x;`.
+                            visitor.visit_ty(ty);
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            hir::Node::Ty(ty) => {
+                visitor.visit_ty(&ty);
+            }
+            _ => {}
+        }
+    }
+    let mut label_span = span;
+    let mut dyn_trait_spans = vec![];
+    let mut trait_spans = vec![];
+    let spans: MultiSpan = if visitor.result.is_empty() {
+        span.into()
+    } else {
+        for ty in &visitor.result {
+            let hir::TyKind::TraitObject(traits, ..) = ty.kind else { continue };
+            dyn_trait_spans.push(ty.span);
+            trait_spans.extend(
+                traits
+                    .iter()
+                    .filter(|t| t.trait_ref.trait_def_id() == Some(trait_def_id))
+                    .map(|t| t.trait_ref.path.span),
+            );
+        }
+        match (&dyn_trait_spans[..], &trait_spans[..]) {
+            ([], []) => span.into(),
+            ([only], [_]) => {
+                // There is a single `dyn Trait` for the expression or type that was stored in the
+                // `WellFormedLoc`. We point at the whole `dyn Trait`.
+                label_span = *only;
+                (*only).into()
+            }
+            (_, [.., last]) => {
+                // There are more than one trait in `dyn A + A` in the expression or type that was
+                // stored in the `WellFormedLoc` that points at the relevant trait, or there are
+                // more than one `dyn A`. We apply the primary span label to the last one of these.
+                label_span = *last;
+                trait_spans.into()
+            }
+            // Should be unreachable, as if one is empty, the other must be too.
+            _ => span.into(),
+        }
+    };
     let mut err = struct_span_code_err!(
         tcx.dcx(),
-        span,
+        spans,
         E0038,
         "the trait `{}` cannot be made into an object",
         trait_str
     );
-    err.span_label(span, format!("`{trait_str}` cannot be made into an object"));
+    err.span_label(label_span, format!("`{trait_str}` cannot be made into an object"));
 
-    if let Some(hir_id) = hir_id
-        && let hir::Node::Ty(ty) = tcx.hir_node(hir_id)
-        && let hir::TyKind::TraitObject([trait_ref, ..], ..) = ty.kind
-    {
-        let mut hir_id = hir_id;
-        while let hir::Node::Ty(ty) = tcx.parent_hir_node(hir_id) {
-            hir_id = ty.hir_id;
-        }
-        if tcx.parent_hir_node(hir_id).fn_sig().is_some() {
-            // Do not suggest `impl Trait` when dealing with things like super-traits.
-            err.span_suggestion_verbose(
-                ty.span.until(trait_ref.span),
-                "consider using an opaque type instead",
-                "impl ",
-                Applicability::MaybeIncorrect,
-            );
-        }
-    }
     let mut reported_violations = FxIndexSet::default();
     let mut multi_span = vec![];
     let mut messages = vec![];
@@ -160,7 +225,106 @@ pub fn report_object_safety_error<'tcx>(
     } else {
         false
     };
+    let mut has_suggested = false;
+    if let Some(hir_id) = hir_id {
+        let node = tcx.hir_node(hir_id);
+        if let hir::Node::Ty(ty) = node
+            && let hir::TyKind::TraitObject([trait_ref, ..], ..) = ty.kind
+        {
+            let mut hir_id = hir_id;
+            while let hir::Node::Ty(ty) = tcx.parent_hir_node(hir_id) {
+                hir_id = ty.hir_id;
+            }
+            if tcx.parent_hir_node(hir_id).fn_sig().is_some() {
+                // Do not suggest `impl Trait` when dealing with things like super-traits.
+                err.span_suggestion_verbose(
+                    ty.span.until(trait_ref.span),
+                    "consider using an opaque type instead",
+                    "impl ",
+                    Applicability::MaybeIncorrect,
+                );
+                has_suggested = true;
+            }
+        }
+        if let hir::Node::Expr(expr) = node
+            && let hir::ExprKind::Path(hir::QPath::TypeRelative(ty, path_segment)) = expr.kind
+            && let hir::TyKind::TraitObject([trait_ref, ..], _, trait_object_syntax) = ty.kind
+        {
+            if let TraitObjectSyntax::None = trait_object_syntax
+                && !expr.span.edition().at_least_rust_2021()
+            {
+                err.span_note(
+                    trait_ref.trait_ref.path.span,
+                    format!(
+                        "`{trait_str}` is the type for the trait in editions 2015 and 2018 and is \
+                         equivalent to writing `dyn {trait_str}`",
+                    ),
+                );
+            }
+            let segment = path_segment.ident;
+            err.help(format!(
+                "when writing `<dyn {trait_str}>::{segment}` you are requiring `{trait_str}` be \
+                 \"object safe\", which it isn't",
+            ));
+            let (only, msg, sugg, appl) = if let [only] = &impls[..] {
+                // We know there's a single implementation for this trait, so we can be explicit on
+                // the type they should have used.
+                let ty = tcx.type_of(*only).instantiate_identity();
+                (
+                    true,
+                    format!(
+                        "specify the specific `impl` for type `{ty}` to avoid requiring \"object \
+                         safety\" from `{trait_str}`",
+                    ),
+                    with_no_trimmed_paths!(format!("{ty} as ")),
+                    Applicability::MachineApplicable,
+                )
+            } else {
+                (
+                    false,
+                    format!(
+                        "you might have meant to access the associated function of a specific \
+                         `impl` to avoid requiring \"object safety\" from `{trait_str}`, either \
+                         with some explicit type...",
+                    ),
+                    "/* Type */ as ".to_string(),
+                    Applicability::HasPlaceholders,
+                )
+            };
+            // `<dyn Trait>::segment()` or `<Trait>::segment()` to `<Type as Trait>::segment()`
+            let sp = ty.span.until(trait_ref.trait_ref.path.span);
+            err.span_suggestion_verbose(sp, msg, sugg, appl);
+            if !only {
+                // `<dyn Trait>::segment()` or `<Trait>::segment()` to `Trait::segment()`
+                err.multipart_suggestion_verbose(
+                    "...or rely on inference if the compiler has enough context to identify the \
+                     desired type on its own...",
+                    vec![
+                        (expr.span.until(trait_ref.trait_ref.path.span), String::new()),
+                        (
+                            path_segment
+                                .ident
+                                .span
+                                .shrink_to_lo()
+                                .with_lo(trait_ref.trait_ref.path.span.hi()),
+                            "::".to_string(),
+                        ),
+                    ],
+                    Applicability::MaybeIncorrect,
+                );
+                // `<dyn Trait>::segment()` or `<Trait>::segment()` to `<_ as Trait>::segment()`
+                err.span_suggestion_verbose(
+                    ty.span.until(trait_ref.trait_ref.path.span),
+                    "...which is equivalent to",
+                    format!("_ as "),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+            has_suggested = true;
+        }
+    }
     match &impls[..] {
+        _ if has_suggested => {}
         [] => {}
         _ if impls.len() > 9 => {}
         [only] if externally_visible => {

tests/ui/async-await/in-trait/object-safety.stderr

@@ -1,8 +1,8 @@
 error[E0038]: the trait `Foo` cannot be made into an object
-  --> $DIR/object-safety.rs:9:12
+  --> $DIR/object-safety.rs:9:13
    |
 LL |     let x: &dyn Foo = todo!();
-   |            ^^^^^^^^ `Foo` cannot be made into an object
+   |             ^^^^^^^ `Foo` cannot be made into an object
    |
 note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/object-safety.rs:5:14

tests/ui/did_you_mean/trait-object-reference-without-parens-suggestion.stderr

@@ -11,10 +11,10 @@ LL |     let _: &'static Copy + 'static;
    |            ^^^^^^^^^^^^^^^^^^^^^^^ help: try adding parentheses: `&'static (Copy + 'static)`
 
 error[E0038]: the trait `Copy` cannot be made into an object
-  --> $DIR/trait-object-reference-without-parens-suggestion.rs:4:12
+  --> $DIR/trait-object-reference-without-parens-suggestion.rs:4:13
    |
 LL |     let _: &Copy + 'static;
-   |            ^^^^^ `Copy` cannot be made into an object
+   |             ^^^^ `Copy` cannot be made into an object
    |
    = note: the trait cannot be made into an object because it requires `Self: Sized`
    = note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>

tests/ui/dyn-keyword/trait-dyn-in-qualified-path-for-object-safe-function-with-one-impl.stderr

@@ -11,7 +11,7 @@ LL | trait Trait {
    |       ----- this trait cannot be made into an object...
 LL |     fn function() {}
    |        ^^^^^^^^ ...because associated function `function` has no `self` parameter
-   = help: only type `()` implements the trait, consider using it directly instead
+   = help: when writing `<dyn Trait>::function` you are requiring `Trait` be "object safe", which it isn't
 help: consider turning `function` into a method by giving it a `&self` argument
    |
 LL |     fn function(&self) {}
@@ -20,6 +20,10 @@ help: alternatively, consider constraining `function` so it does not apply to tr
    |
 LL |     fn function() where Self: Sized {}
    |                   +++++++++++++++++
+help: specify the specific `impl` for type `()` to avoid requiring "object safety" from `Trait`
+   |
+LL |     <() as Trait>::function();
+   |      ~~~~~
 
 error: aborting due to 1 previous error
 

tests/ui/dyn-keyword/trait-dyn-in-qualified-path-for-object-unsafe-trait.stderr

@@ -57,7 +57,11 @@ LL | trait Trait: Sized {}
    |       -----  ^^^^^ ...because it requires `Self: Sized`
    |       |
    |       this trait cannot be made into an object...
-   = help: only type `()` implements the trait, consider using it directly instead
+   = help: when writing `<dyn Trait>::function` you are requiring `Trait` be "object safe", which it isn't
+help: specify the specific `impl` for type `()` to avoid requiring "object safety" from `Trait`
+   |
+LL |     <() as Trait>::function(&());
+   |      ~~~~~
 
 error: aborting due to 4 previous errors
 

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

@@ -11,6 +11,20 @@ LL | trait Trait: Sized {
    |       -----  ^^^^^ ...because it requires `Self: Sized`
    |       |
    |       this trait cannot be made into an object...
+   = help: when writing `<dyn Trait>::function` you are requiring `Trait` be "object safe", which it isn't
+help: you might have meant to access the associated function of a specific `impl` to avoid requiring "object safety" from `Trait`, either with some explicit type...
+   |
+LL |     </* Type */ as Trait>::function();
+   |      ~~~~~~~~~~~~~
+help: ...or rely on inference if the compiler has enough context to identify the desired type on its own...
+   |
+LL -     <dyn Trait>::function();
+LL +     Trait::function();
+   |
+help: ...which is equivalent to
+   |
+LL |     <_ as Trait>::function();
+   |      ~~~~
 
 error[E0277]: the size for values of type `dyn Trait` cannot be known at compilation time
   --> $DIR/trait-dyn-in-qualified-path.rs:5:6

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

@@ -20,6 +20,25 @@ LL |     let x: u32 = <Default>::default();
    |
    = note: the trait cannot be made into an object because it requires `Self: Sized`
    = note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+note: `Default` is the type for the trait in editions 2015 and 2018 and is equivalent to writing `dyn Default`
+  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
+   |
+LL |     let x: u32 = <Default>::default();
+   |                   ^^^^^^^
+   = help: when writing `<dyn Default>::default` you are requiring `Default` be "object safe", which it isn't
+help: you might have meant to access the associated function of a specific `impl` to avoid requiring "object safety" from `Default`, either with some explicit type...
+   |
+LL |     let x: u32 = </* Type */ as Default>::default();
+   |                   +++++++++++++
+help: ...or rely on inference if the compiler has enough context to identify the desired type on its own...
+   |
+LL -     let x: u32 = <Default>::default();
+LL +     let x: u32 = Default::default();
+   |
+help: ...which is equivalent to
+   |
+LL |     let x: u32 = <_ as Default>::default();
+   |                   ++++
 
 error[E0277]: the size for values of type `dyn Default` cannot be known at compilation time
   --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
@@ -44,10 +63,10 @@ LL |     let x: u32 = <Default>::default();
    = help: `u32` implements `Default` so you could change the expected type to `Box<dyn Default>`
 
 error[E0038]: the trait `Default` cannot be made into an object
-  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:18
+  --> $DIR/trait-missing-dyn-in-qualified-path.rs:5:19
    |
 LL |     let x: u32 = <Default>::default();
-   |                  ^^^^^^^^^^^^^^^^^^^^ `Default` cannot be made into an object
+   |                   ^^^^^^^ `Default` cannot be made into an object
    |
    = note: the trait cannot be made into an object because it requires `Self: Sized`
    = note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>

tests/ui/feature-gates/feature-gate-dispatch-from-dyn-missing-impl.stderr

@@ -1,11 +1,11 @@
 error[E0038]: the trait `Trait` cannot be made into an object
-  --> $DIR/feature-gate-dispatch-from-dyn-missing-impl.rs:32:25
+  --> $DIR/feature-gate-dispatch-from-dyn-missing-impl.rs:32:29
    |
 LL |     fn ptr(self: Ptr<Self>);
    |                  --------- help: consider changing method `ptr`'s `self` parameter to be `&self`: `&Self`
 ...
 LL |     Ptr(Box::new(4)) as Ptr<dyn Trait>;
-   |                         ^^^^^^^^^^^^^^ `Trait` cannot be made into an object
+   |                             ^^^^^^^^^ `Trait` cannot be made into an object
    |
 note: for a trait to be "object safe" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
   --> $DIR/feature-gate-dispatch-from-dyn-missing-impl.rs:25:18