Look at the current impl before suggesting adding a lifetime

Given an associated item that needs a named lifetime, look at the enclosing `impl` item for one. If there is none, look at the self type and the implemented trait to see if either of those has an anonimous lifetime. If so, suggest adding a named lifetime.

```
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 |     type Item = &T;
   |                 ^ this lifetime must come from the implemented type
   |
help: add a lifetime to the impl block and use it in the self type and associated type
   |
LL ~ impl<'a> IntoIterator for &'a S {
LL ~     type Item = &'a T;
   |
```

Author: estebank

compiler/rustc_resolve/src/late.rs

@@ -10,6 +10,7 @@ use std::assert_matches::debug_assert_matches;
 use std::borrow::Cow;
 use std::collections::hash_map::Entry;
 use std::mem::{replace, swap, take};
+use std::ops::ControlFlow;
 
 use rustc_ast::visit::{
     AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor, try_visit, visit_opt, walk_list,
@@ -1953,11 +1954,63 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                 );
             }
         } else {
-            err.span_label(
-                span,
-                "you could add a lifetime on the impl block, if the trait or the self type can \
-                 have one",
-            );
+            struct AnonRefFinder;
+            impl<'ast> Visitor<'ast> for AnonRefFinder {
+                type Result = ControlFlow<Span>;
+
+                fn visit_ty(&mut self, ty: &'ast ast::Ty) -> Self::Result {
+                    if let ast::TyKind::Ref(None, mut_ty) = &ty.kind {
+                        return ControlFlow::Break(mut_ty.ty.span.shrink_to_lo());
+                    }
+                    visit::walk_ty(self, ty)
+                }
+
+                fn visit_lifetime(
+                    &mut self,
+                    lt: &'ast ast::Lifetime,
+                    _cx: visit::LifetimeCtxt,
+                ) -> Self::Result {
+                    if lt.ident.name == kw::UnderscoreLifetime {
+                        return ControlFlow::Break(lt.ident.span);
+                    }
+                    visit::walk_lifetime(self, lt)
+                }
+            }
+
+            if let Some(ty) = &self.diag_metadata.current_self_type
+                && let ControlFlow::Break(sp) = AnonRefFinder.visit_ty(ty)
+            {
+                err.multipart_suggestion_verbose(
+                    "add a lifetime to the impl block and use it in the self type and associated \
+                     type",
+                    vec![
+                        (span, "<'a>".to_string()),
+                        (sp, "'a ".to_string()),
+                        (lifetime.shrink_to_hi(), "'a ".to_string()),
+                    ],
+                    Applicability::MaybeIncorrect,
+                );
+            } else if let Some(item) = &self.diag_metadata.current_item
+                && let ItemKind::Impl(impl_) = &item.kind
+                && let Some(of_trait) = &impl_.of_trait
+                && let ControlFlow::Break(sp) = AnonRefFinder.visit_trait_ref(of_trait)
+            {
+                err.multipart_suggestion_verbose(
+                    "add a lifetime to the impl block and use it in the trait and associated type",
+                    vec![
+                        (span, "<'a>".to_string()),
+                        (sp, "'a".to_string()),
+                        (lifetime.shrink_to_hi(), "'a ".to_string()),
+                    ],
+                    Applicability::MaybeIncorrect,
+                );
+            } else {
+                err.span_label(
+                    span,
+                    "you could add a lifetime on the impl block, if the trait or the self type \
+                     could have one",
+                );
+            }
         }
     }
 

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

@@ -17,6 +17,19 @@ impl MyTrait for &u32 {
     //~^ ERROR `'_` cannot be used here
 }
 
+impl<'a> MyTrait for &f64 {
+    type Output = &f64;
+    //~^ 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
+}
+
+trait OtherTrait<'a> {
+    type Output;
+}
+impl OtherTrait<'_> for f64 {
+    type Output = &f64;
+    //~^ 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
+}
+
 // This is what you have to do:
 impl<'a> MyTrait for &'a f32 {
     type Output = &'a f32;

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

@@ -1,17 +1,46 @@
 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
+   |
+help: add a lifetime to the impl block and use it in the self type and associated type
+   |
+LL ~ impl<'a> MyTrait for &'a i32 {
+LL ~     type Output = &'a i32;
+   |
 
 error[E0637]: `'_` cannot be used here
   --> $DIR/assoc-type.rs:16:20
    |
 LL |     type Output = &'_ i32;
    |                    ^^ `'_` is a reserved lifetime name
 
-error: aborting due to 2 previous errors
+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:21:19
+   |
+LL | impl<'a> MyTrait for &f64 {
+   |     ---- there is a named lifetime specified on the impl block you could use
+LL |     type Output = &f64;
+   |                   ^ this lifetime must come from the implemented type
+   |
+help: consider using the lifetime from the impl block
+   |
+LL |     type Output = &'a f64;
+   |                    ++
+
+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:29:19
+   |
+LL |     type Output = &f64;
+   |                   ^ this lifetime must come from the implemented type
+   |
+help: add a lifetime to the impl block and use it in the trait and associated type
+   |
+LL ~ impl<'a> OtherTrait<'a> for f64 {
+LL ~     type Output = &'a f64;
+   |
+
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0637`.

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

@@ -1,10 +1,14 @@
 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
+   |
+help: add a lifetime to the impl block and use it in the self type and associated type
+   |
+LL ~ impl<'a> IntoIterator for &'a S {
+LL ~     type Item = &'a T;
+   |
 
 error[E0261]: use of undeclared lifetime name `'a`
   --> $DIR/missing-lifetime-in-assoc-type-2.rs:7:57

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

@@ -1,10 +1,14 @@
 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
+   |
+help: add a lifetime to the impl block and use it in the self type and associated type
+   |
+LL ~ impl<'a> IntoIterator for &'a S {
+LL ~     type Item = &'a T;
+   |
 
 error[E0106]: missing lifetime specifier
   --> $DIR/missing-lifetime-in-assoc-type-3.rs:7:56

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

@@ -1,10 +1,14 @@
 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
+   |
+help: add a lifetime to the impl block and use it in the self type and associated type
+   |
+LL ~ impl<'a> IntoIterator for &'a S {
+LL ~     type Item = &'a T;
+   |
 
 error[E0195]: lifetime parameters or bounds on associated type `IntoIter` do not match the trait declaration
   --> $DIR/missing-lifetime-in-assoc-type-4.rs:7:18

tests/ui/lifetimes/no_lending_iterators.stderr

@@ -14,7 +14,7 @@ error: in the trait associated type is declared without lifetime parameters, so
   --> $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
+   |     - you could add a lifetime on the impl block, if the trait or the self type could have one
 LL |     type Item = &usize;
    |                 ^ this lifetime must come from the implemented type