Auto merge of #145640 - estebank:point-at-impl-e0277, r=nnethercote

When a trait isn't implemented, but another similar impl is found, point at it

```
error[E0277]: the trait bound `u32: Trait` is not satisfied
  --> $DIR/trait_objects_fail.rs:26:9
   |
LL |     foo(&10_u32);
   |         ^^^^^^^ the trait `Trait` is not implemented for `u32`
   |
help: the trait `Trait<12>` is not implemented for `u32`
      but trait `Trait<2>` is implemented for it
  --> $DIR/trait_objects_fail.rs:7:1
   |
LL | impl Trait<2> for u32 {}
   | ^^^^^^^^^^^^^^^^^^^^^
   = note: required for the cast from `&u32` to `&dyn Trait`
```

Pointing at the `impl` definition that *could* apply given a different self type is *particularly* useful when it has a blanket self type, as it might not be obvious and is not trivially greppable:

```
error[E0277]: the trait bound `RawImpl<_>: Raw<_>` is not satisfied
  --> $DIR/issue-62742.rs:4:5
   |
LL |     WrongImpl::foo(0i32);
   |     ^^^^^^^^^ unsatisfied trait bound
   |
help: the trait `Raw<_>` is not implemented for `RawImpl<_>`
      but trait `Raw<[_]>` is implemented for it
  --> $DIR/issue-62742.rs:29:1
   |
LL | impl<T> Raw<[T]> for RawImpl<T> {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
note: required by a bound in `SafeImpl`
  --> $DIR/issue-62742.rs:33:35
   |
LL | pub struct SafeImpl<T: ?Sized, A: Raw<T>>(PhantomData<(A, T)>);
   |                                   ^^^^^^ required by this bound in `SafeImpl`
```

Author: bors

compiler/rustc_errors/src/emitter.rs

@@ -1526,16 +1526,17 @@ impl HumanEmitter {
                 label_width += 2;
             }
             let mut line = 0;
+            let mut pad = false;
             for (text, style) in msgs.iter() {
                 let text =
                     self.translator.translate_message(text, args).map_err(Report::new).unwrap();
                 // Account for newlines to align output to its label.
-                for text in normalize_whitespace(&text).lines() {
+                for text in normalize_whitespace(&text).split('\n') {
                     buffer.append(
                         line,
                         &format!(
                             "{}{}",
-                            if line == 0 { String::new() } else { " ".repeat(label_width) },
+                            if pad { " ".repeat(label_width) } else { String::new() },
                             text
                         ),
                         match style {
@@ -1544,7 +1545,9 @@ impl HumanEmitter {
                         },
                     );
                     line += 1;
+                    pad = true;
                 }
+                pad = false;
                 // We add lines above, but if the last line has no explicit newline (which would
                 // yield an empty line), then we revert one line up to continue with the next
                 // styled text chunk on the same line as the last one from the prior one. Otherwise

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -1904,13 +1904,13 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 // ignore `do_not_recommend` items
                 .filter(|def_id| !self.tcx.do_not_recommend_impl(*def_id))
                 // Ignore automatically derived impls and `!Trait` impls.
-                .filter_map(|def_id| self.tcx.impl_trait_header(def_id))
-                .filter_map(|header| {
-                    (header.polarity != ty::ImplPolarity::Negative
+                .filter_map(|def_id| self.tcx.impl_trait_header(def_id).map(|h| (h, def_id)))
+                .filter_map(|(header, def_id)| {
+                    (header.polarity == ty::ImplPolarity::Positive
                         || self.tcx.is_automatically_derived(def_id))
-                    .then(|| header.trait_ref.instantiate_identity())
+                    .then(|| (header.trait_ref.instantiate_identity(), def_id))
                 })
-                .filter(|trait_ref| {
+                .filter(|(trait_ref, _)| {
                     let self_ty = trait_ref.self_ty();
                     // Avoid mentioning type parameters.
                     if let ty::Param(_) = self_ty.kind() {
@@ -1928,7 +1928,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 })
                 .collect();
 
-            impl_candidates.sort_by_key(|tr| tr.to_string());
+            impl_candidates.sort_by_key(|(tr, _)| tr.to_string());
             impl_candidates.dedup();
             impl_candidates
         };
@@ -1956,7 +1956,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let candidates = if impl_candidates.is_empty() {
                 alternative_candidates(trait_def_id)
             } else {
-                impl_candidates.into_iter().map(|cand| cand.trait_ref).collect()
+                impl_candidates.into_iter().map(|cand| (cand.trait_ref, cand.impl_def_id)).collect()
             };
             let mut span: MultiSpan = self.tcx.def_span(trait_def_id).into();
             span.push_span_label(self.tcx.def_span(trait_def_id), "this is the required trait");
@@ -1988,7 +1988,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     self.tcx.def_span(found_type),
                     "this type doesn't implement the required trait",
                 );
-                for trait_ref in candidates {
+                for (trait_ref, _) in candidates {
                     if let ty::Adt(def, _) = trait_ref.self_ty().peel_refs().kind()
                         && let candidate_def_id = def.did()
                         && let Some(name) = self.tcx.opt_item_name(candidate_def_id)
@@ -2175,7 +2175,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                         msg.extend(types.1.0);
                         msg.push(StringPart::normal("`"));
                     }
-                    err.highlighted_help(msg);
+                    err.highlighted_span_help(self.tcx.def_span(single.impl_def_id), msg);
 
                     if let [TypeError::Sorts(exp_found)] = &terrs[..] {
                         let exp_found = self.resolve_vars_if_possible(*exp_found);
@@ -2201,12 +2201,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         }
 
         let other = if other { "other " } else { "" };
-        let report = |mut candidates: Vec<TraitRef<'tcx>>, err: &mut Diag<'_>| {
-            candidates.retain(|tr| !tr.references_error());
+        let report = |mut candidates: Vec<(TraitRef<'tcx>, DefId)>, err: &mut Diag<'_>| {
+            candidates.retain(|(tr, _)| !tr.references_error());
             if candidates.is_empty() {
                 return false;
             }
-            if let &[cand] = &candidates[..] {
+            if let &[(cand, def_id)] = &candidates[..] {
                 if self.tcx.is_diagnostic_item(sym::FromResidual, cand.def_id)
                     && !self.tcx.features().enabled(sym::try_trait_v2)
                 {
@@ -2222,56 +2222,87 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                     };
                 let trait_ = self.tcx.short_string(cand.print_trait_sugared(), err.long_ty_path());
                 let self_ty = self.tcx.short_string(cand.self_ty(), err.long_ty_path());
-                err.highlighted_help(vec![
-                    StringPart::normal(format!("the trait `{trait_}` ",)),
-                    StringPart::highlighted("is"),
-                    StringPart::normal(desc),
-                    StringPart::highlighted(self_ty),
-                    StringPart::normal("`"),
-                    StringPart::normal(mention_castable),
-                ]);
+                err.highlighted_span_help(
+                    self.tcx.def_span(def_id),
+                    vec![
+                        StringPart::normal(format!("the trait `{trait_}` ",)),
+                        StringPart::highlighted("is"),
+                        StringPart::normal(desc),
+                        StringPart::highlighted(self_ty),
+                        StringPart::normal("`"),
+                        StringPart::normal(mention_castable),
+                    ],
+                );
                 return true;
             }
-            let trait_ref = TraitRef::identity(self.tcx, candidates[0].def_id);
+            let trait_ref = TraitRef::identity(self.tcx, candidates[0].0.def_id);
             // Check if the trait is the same in all cases. If so, we'll only show the type.
             let mut traits: Vec<_> =
-                candidates.iter().map(|c| c.print_only_trait_path().to_string()).collect();
+                candidates.iter().map(|(c, _)| c.print_only_trait_path().to_string()).collect();
             traits.sort();
             traits.dedup();
             // FIXME: this could use a better heuristic, like just checking
             // that args[1..] is the same.
             let all_traits_equal = traits.len() == 1;
 
-            let candidates: Vec<String> = candidates
-                .into_iter()
-                .map(|c| {
-                    if all_traits_equal {
-                        format!("\n  {}", self.tcx.short_string(c.self_ty(), err.long_ty_path()))
-                    } else {
-                        format!(
-                            "\n  `{}` implements `{}`",
-                            self.tcx.short_string(c.self_ty(), err.long_ty_path()),
-                            self.tcx.short_string(c.print_only_trait_path(), err.long_ty_path()),
-                        )
-                    }
-                })
-                .collect();
-
             let end = if candidates.len() <= 9 || self.tcx.sess.opts.verbose {
                 candidates.len()
             } else {
                 8
             };
-            err.help(format!(
-                "the following {other}types implement trait `{}`:{}{}",
-                trait_ref.print_trait_sugared(),
-                candidates[..end].join(""),
-                if candidates.len() > 9 && !self.tcx.sess.opts.verbose {
-                    format!("\nand {} others", candidates.len() - 8)
-                } else {
-                    String::new()
+            if candidates.len() < 5 {
+                let spans: Vec<_> =
+                    candidates.iter().map(|(_, def_id)| self.tcx.def_span(def_id)).collect();
+                let mut span: MultiSpan = spans.into();
+                for (c, def_id) in &candidates {
+                    let msg = if all_traits_equal {
+                        format!("`{}`", self.tcx.short_string(c.self_ty(), err.long_ty_path()))
+                    } else {
+                        format!(
+                            "`{}` implements `{}`",
+                            self.tcx.short_string(c.self_ty(), err.long_ty_path()),
+                            self.tcx.short_string(c.print_only_trait_path(), err.long_ty_path()),
+                        )
+                    };
+                    span.push_span_label(self.tcx.def_span(def_id), msg);
                 }
-            ));
+                err.span_help(
+                    span,
+                    format!(
+                        "the following {other}types implement trait `{}`",
+                        trait_ref.print_trait_sugared(),
+                    ),
+                );
+            } else {
+                let candidate_names: Vec<String> = candidates
+                    .iter()
+                    .map(|(c, _)| {
+                        if all_traits_equal {
+                            format!(
+                                "\n  {}",
+                                self.tcx.short_string(c.self_ty(), err.long_ty_path())
+                            )
+                        } else {
+                            format!(
+                                "\n  `{}` implements `{}`",
+                                self.tcx.short_string(c.self_ty(), err.long_ty_path()),
+                                self.tcx
+                                    .short_string(c.print_only_trait_path(), err.long_ty_path()),
+                            )
+                        }
+                    })
+                    .collect();
+                err.help(format!(
+                    "the following {other}types implement trait `{}`:{}{}",
+                    trait_ref.print_trait_sugared(),
+                    candidate_names[..end].join(""),
+                    if candidates.len() > 9 && !self.tcx.sess.opts.verbose {
+                        format!("\nand {} others", candidates.len() - 8)
+                    } else {
+                        String::new()
+                    }
+                ));
+            }
             true
         };
 
@@ -2333,7 +2364,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             (cand.similarity, len, cand.trait_ref.to_string())
         });
         let mut impl_candidates: Vec<_> =
-            impl_candidates.into_iter().map(|cand| cand.trait_ref).collect();
+            impl_candidates.into_iter().map(|cand| (cand.trait_ref, cand.impl_def_id)).collect();
         impl_candidates.dedup();
 
         report(impl_candidates, err)

tests/ui-fulldeps/rustc-dev-remap.only-remap.stderr

@@ -9,9 +9,13 @@ help: the trait `VisitorResult` is not implemented for `NotAValidResultType`
    |
 LL | struct NotAValidResultType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: the following other types implement trait `VisitorResult`:
-             ()
-             ControlFlow<T>
+help: the following other types implement trait `VisitorResult`
+  --> /rustc-dev/xyz/compiler/rustc_ast_ir/src/visit.rs:LL:COL
+   |
+   = note: `()`
+  ::: /rustc-dev/xyz/compiler/rustc_ast_ir/src/visit.rs:LL:COL
+   |
+   = note: `ControlFlow<T>`
 note: required by a bound in `rustc_ast::visit::Visitor::Result`
   --> /rustc-dev/xyz/compiler/rustc_ast/src/visit.rs:LL:COL
    = note: this error originates in the macro `common_visitor_and_walkers` (in Nightly builds, run with -Z macro-backtrace for more info)

tests/ui-fulldeps/rustc-dev-remap.remap-unremap.stderr

@@ -9,9 +9,14 @@ help: the trait `VisitorResult` is not implemented for `NotAValidResultType`
    |
 LL | struct NotAValidResultType;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = help: the following other types implement trait `VisitorResult`:
-             ()
-             ControlFlow<T>
+help: the following other types implement trait `VisitorResult`
+  --> $COMPILER_DIR_REAL/rustc_ast_ir/src/visit.rs:LL:COL
+   |
+LL | impl VisitorResult for () {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^ `()`
+...
+LL | impl<T> VisitorResult for ControlFlow<T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ControlFlow<T>`
 note: required by a bound in `rustc_ast::visit::Visitor::Result`
   --> $COMPILER_DIR_REAL/rustc_ast/src/visit.rs:LL:COL
    |

tests/ui/allocator/not-an-allocator.rs

@@ -1,3 +1,6 @@
+//@ revisions: u w
+//@[u] only-unix
+//@[w] only-windows
 #[global_allocator]
 static A: usize = 0;
 //~^ ERROR E0277

tests/ui/allocator/not-an-allocator.stderr renamed to tests/ui/allocator/not-an-allocator.u.stderr

@@ -1,44 +1,48 @@
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
-  --> $DIR/not-an-allocator.rs:2:11
+  --> $DIR/not-an-allocator.rs:5:11
    |
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
    |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
    |
-   = help: the trait `GlobalAlloc` is implemented for `System`
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
-  --> $DIR/not-an-allocator.rs:2:11
+  --> $DIR/not-an-allocator.rs:5:11
    |
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
    |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
    |
-   = help: the trait `GlobalAlloc` is implemented for `System`
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
-  --> $DIR/not-an-allocator.rs:2:11
+  --> $DIR/not-an-allocator.rs:5:11
    |
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
    |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
    |
-   = help: the trait `GlobalAlloc` is implemented for `System`
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
-  --> $DIR/not-an-allocator.rs:2:11
+  --> $DIR/not-an-allocator.rs:5:11
    |
 LL | #[global_allocator]
    | ------------------- in this attribute macro expansion
 LL | static A: usize = 0;
    |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
    |
-   = help: the trait `GlobalAlloc` is implemented for `System`
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/unix.rs:LL:COL
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: aborting due to 4 previous errors

tests/ui/allocator/not-an-allocator.w.stderr

@@ -0,0 +1,50 @@
+error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
+  --> $DIR/not-an-allocator.rs:5:11
+   |
+LL | #[global_allocator]
+   | ------------------- in this attribute macro expansion
+LL | static A: usize = 0;
+   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/windows.rs:LL:COL
+
+error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
+  --> $DIR/not-an-allocator.rs:5:11
+   |
+LL | #[global_allocator]
+   | ------------------- in this attribute macro expansion
+LL | static A: usize = 0;
+   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/windows.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
+  --> $DIR/not-an-allocator.rs:5:11
+   |
+LL | #[global_allocator]
+   | ------------------- in this attribute macro expansion
+LL | static A: usize = 0;
+   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/windows.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error[E0277]: the trait bound `usize: GlobalAlloc` is not satisfied
+  --> $DIR/not-an-allocator.rs:5:11
+   |
+LL | #[global_allocator]
+   | ------------------- in this attribute macro expansion
+LL | static A: usize = 0;
+   |           ^^^^^ the trait `GlobalAlloc` is not implemented for `usize`
+   |
+help: the trait `GlobalAlloc` is implemented for `System`
+  --> $SRC_DIR/std/src/sys/alloc/windows.rs:LL:COL
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0277`.