Tweak output of missing lifetime on associated type

compiler/rustc_resolve/src/late.rs

@@ -20,7 +20,8 @@ use rustc_ast::*;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::codes::*;
 use rustc_errors::{
-    Applicability, DiagArgValue, ErrorGuaranteed, IntoDiagArg, StashKey, Suggestions,
+    Applicability, Diag, DiagArgValue, ErrorGuaranteed, IntoDiagArg, StashKey, Suggestions,
+    pluralize,
 };
 use rustc_hir::def::Namespace::{self, *};
 use rustc_hir::def::{self, CtorKind, DefKind, LifetimeRes, NonMacroAttrKind, PartialRes, PerNS};
@@ -1870,9 +1871,13 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                                     ty: ty.span,
                                 });
                             } else {
-                                self.r.dcx().emit_err(errors::AnonymousLivetimeNonGatReportError {
-                                    lifetime: lifetime.ident.span,
-                                });
+                                let mut err = self.r.dcx().create_err(
+                                    errors::AnonymousLivetimeNonGatReportError {
+                                        lifetime: lifetime.ident.span,
+                                    },
+                                );
+                                self.point_at_impl_lifetimes(&mut err, i, lifetime.ident.span);
+                                err.emit();
                             }
                         } else {
                             self.r.dcx().emit_err(errors::ElidedAnonymousLivetimeReportError {
@@ -1909,6 +1914,47 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
         self.report_missing_lifetime_specifiers(vec![missing_lifetime], None);
     }
 
+    fn point_at_impl_lifetimes(&mut self, err: &mut Diag<'_>, i: usize, lifetime: Span) {
+        let Some((rib, span)) = self.lifetime_ribs[..i]
+            .iter()
+            .rev()
+            .skip(1)
+            .filter_map(|rib| match rib.kind {
+                LifetimeRibKind::Generics { span, kind: LifetimeBinderKind::ImplBlock, .. } => {
+                    Some((rib, span))
+                }
+                _ => None,
+            })
+            .next()
+        else {
+            return;
+        };
+        if !rib.bindings.is_empty() {
+            err.span_label(
+                span,
+                format!(
+                    "there {} named lifetime{} specified on the impl block you could use",
+                    if rib.bindings.len() == 1 { "is a" } else { "are" },
+                    pluralize!(rib.bindings.len()),
+                ),
+            );
+            if rib.bindings.len() == 1 {
+                err.span_suggestion_verbose(
+                    lifetime.shrink_to_hi(),
+                    "consider using the lifetime from the impl block",
+                    format!("{} ", rib.bindings.keys().next().unwrap()),
+                    Applicability::MaybeIncorrect,
+                );
+            }
+        } else {
+            err.span_label(
+                span,
+                "you could add a lifetime on the impl block, if the trait or the self type can \
+                 have one",
+            );
+        }
+    }
+
     #[instrument(level = "debug", skip(self))]
     fn resolve_elided_lifetime(&mut self, anchor_id: NodeId, span: Span) {
         let id = self.r.next_node_id();

tests/ui/impl-header-lifetime-elision/assoc-type.stderr

@@ -1,6 +1,8 @@
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
   --> $DIR/assoc-type.rs:11:19
    |
+LL | impl MyTrait for &i32 {
+   |     - you could add a lifetime on the impl block, if the trait or the self type can have one
 LL |     type Output = &i32;
    |                   ^ this lifetime must come from the implemented type
 

tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.rs

@@ -3,9 +3,11 @@ struct T;
 
 impl<'a> IntoIterator for &S {
     //~^ ERROR E0207
+    //~| NOTE there is a named lifetime specified on the impl block you could use
     //~| NOTE unconstrained lifetime parameter
     type Item = &T;
     //~^ ERROR in the trait associated type
+    //~| HELP consider using the lifetime from the impl block
     //~| NOTE this lifetime must come from the implemented type
     type IntoIter = std::collections::btree_map::Values<'a, i32, T>;
 

tests/ui/lifetimes/missing-lifetime-in-assoc-type-1.stderr

@@ -1,8 +1,16 @@
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
-  --> $DIR/missing-lifetime-in-assoc-type-1.rs:7:17
+  --> $DIR/missing-lifetime-in-assoc-type-1.rs:8:17
    |
+LL | impl<'a> IntoIterator for &S {
+   |     ---- there is a named lifetime specified on the impl block you could use
+...
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
+   |
+help: consider using the lifetime from the impl block
+   |
+LL |     type Item = &'a T;
+   |                  ++
 
 error[E0207]: the lifetime parameter `'a` is not constrained by the impl trait, self type, or predicates
   --> $DIR/missing-lifetime-in-assoc-type-1.rs:4:6

tests/ui/lifetimes/missing-lifetime-in-assoc-type-2.stderr

@@ -1,6 +1,8 @@
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
   --> $DIR/missing-lifetime-in-assoc-type-2.rs:5:17
    |
+LL | impl IntoIterator for &S {
+   |     - you could add a lifetime on the impl block, if the trait or the self type can have one
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
 

tests/ui/lifetimes/missing-lifetime-in-assoc-type-3.stderr

@@ -1,6 +1,8 @@
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
   --> $DIR/missing-lifetime-in-assoc-type-3.rs:5:17
    |
+LL | impl IntoIterator for &S {
+   |     - you could add a lifetime on the impl block, if the trait or the self type can have one
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
 

tests/ui/lifetimes/missing-lifetime-in-assoc-type-4.stderr

@@ -1,6 +1,8 @@
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
   --> $DIR/missing-lifetime-in-assoc-type-4.rs:5:17
    |
+LL | impl IntoIterator for &S {
+   |     - you could add a lifetime on the impl block, if the trait or the self type can have one
 LL |     type Item = &T;
    |                 ^ this lifetime must come from the implemented type
 

tests/ui/lifetimes/no_lending_iterators.stderr

@@ -13,6 +13,8 @@ LL | impl Iterator for Data {
 error: in the trait associated type is declared without lifetime parameters, so using a borrowed type for them requires that lifetime to come from the implemented type
   --> $DIR/no_lending_iterators.rs:18:17
    |
+LL | impl Bar for usize {
+   |     - you could add a lifetime on the impl block, if the trait or the self type can have one
 LL |     type Item = &usize;
    |                 ^ this lifetime must come from the implemented type