Account for owning item lifetimes in suggestion and annotate tests as run-rustfix

```
error: lifetime may not live long enough
  --> $DIR/lt-ref-self.rs:12:9
   |
LL |     fn ref_self(&self, f: &u32) -> &u32 {
   |                 -         - let's call the lifetime of this reference `'1`
   |                 |
   |                 let's call the lifetime of this reference `'2`
LL |         f
   |         ^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
   |
help: consider introducing a named lifetime parameter and update trait if needed
   |
LL |     fn ref_self<'b>(&'b self, f: &'b u32) -> &'b u32 {
   |                ++++  ++           ++          ++
```

Author: estebank

compiler/rustc_infer/src/errors/mod.rs

@@ -1,4 +1,5 @@
 use hir::GenericParamKind;
+use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::{
     codes::*, Applicability, Diag, DiagMessage, DiagStyledString, EmissionGuarantee, IntoDiagArg,
     MultiSpan, SubdiagMessageOp, Subdiagnostic,
@@ -362,13 +363,27 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
 
             let node = self.tcx.hir_node_by_def_id(anon_reg.def_id);
             let is_impl = matches!(&node, hir::Node::ImplItem(_));
-            let generics = match node {
+            let (generics, parent_generics) = match node {
                 hir::Node::Item(&hir::Item {
                     kind: hir::ItemKind::Fn(_, ref generics, ..),
                     ..
                 })
                 | hir::Node::TraitItem(&hir::TraitItem { ref generics, .. })
-                | hir::Node::ImplItem(&hir::ImplItem { ref generics, .. }) => generics,
+                | hir::Node::ImplItem(&hir::ImplItem { ref generics, .. }) => (
+                    generics,
+                    match self.tcx.parent_hir_node(self.tcx.local_def_id_to_hir_id(anon_reg.def_id))
+                    {
+                        hir::Node::Item(hir::Item {
+                            kind: hir::ItemKind::Trait(_, _, ref generics, ..),
+                            ..
+                        })
+                        | hir::Node::Item(hir::Item {
+                            kind: hir::ItemKind::Impl(hir::Impl { ref generics, .. }),
+                            ..
+                        }) => Some(generics),
+                        _ => None,
+                    },
+                ),
                 _ => return false,
             };
 
@@ -379,8 +394,29 @@ impl Subdiagnostic for AddLifetimeParamsSuggestion<'_> {
                 .map(|p| p.name.ident().name)
                 .find(|i| *i != kw::UnderscoreLifetime);
             let introduce_new = suggestion_param_name.is_none();
+
+            let mut default = "'a".to_string();
+            if let Some(parent_generics) = parent_generics {
+                let used: FxHashSet<_> = parent_generics
+                    .params
+                    .iter()
+                    .filter(|p| matches!(p.kind, GenericParamKind::Lifetime { .. }))
+                    .map(|p| p.name.ident().name)
+                    .filter(|i| *i != kw::UnderscoreLifetime)
+                    .map(|l| l.to_string())
+                    .collect();
+                if let Some(lt) =
+                    ('a'..='z').map(|it| format!("'{it}")).find(|it| !used.contains(it))
+                {
+                    // We want a lifetime that *isn't* present in the `trait` or `impl` that assoc
+                    // `fn` belongs to. We could suggest reusing one of their lifetimes, but it is
+                    // likely to be an over-constraining lifetime requirement, so we always add a
+                    // lifetime to the `fn`.
+                    default = lt;
+                }
+            }
             let suggestion_param_name =
-                suggestion_param_name.map(|n| n.to_string()).unwrap_or_else(|| "'a".to_owned());
+                suggestion_param_name.map(|n| n.to_string()).unwrap_or_else(|| default);
 
             struct ImplicitLifetimeFinder {
                 suggestions: Vec<(Span, String)>,

tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.fixed

@@ -0,0 +1,17 @@
+//@ run-rustfix
+#![allow(dead_code)]
+struct Foo {
+    field: i32,
+}
+
+impl Foo {
+  fn foo<'a>(&'a self, x: &'a i32) -> &'a i32 {
+
+    x
+    //~^ ERROR lifetime may not live long enough
+
+  }
+
+}
+
+fn main() {}

tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.rs

@@ -1,5 +1,7 @@
+//@ run-rustfix
+#![allow(dead_code)]
 struct Foo {
-  field: i32
+    field: i32,
 }
 
 impl Foo {
@@ -12,4 +14,4 @@ impl Foo {
 
 }
 
-fn main() { }
+fn main() {}

tests/ui/lifetimes/lifetime-errors/ex1-return-one-existing-name-return-type-is-anon.stderr

@@ -1,5 +1,5 @@
 error: lifetime may not live long enough
-  --> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:8:5
+  --> $DIR/ex1-return-one-existing-name-return-type-is-anon.rs:10:5
    |
 LL |   fn foo<'a>(&self, x: &'a i32) -> &i32 {
    |          --  - let's call the lifetime of this reference `'1`

tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.fixed

@@ -0,0 +1,14 @@
+//@ run-rustfix
+#![allow(dead_code)]
+struct Foo {
+  field: i32,
+}
+
+impl Foo {
+  fn foo<'a>(&'a self, x: &'a i32) -> &'a i32 {
+    x
+    //~^ ERROR lifetime may not live long enough
+  }
+}
+
+fn main() { }

tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.rs

@@ -1,5 +1,7 @@
+//@ run-rustfix
+#![allow(dead_code)]
 struct Foo {
-  field: i32
+  field: i32,
 }
 
 impl Foo {

tests/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-return-type-is-anon.stderr

@@ -1,5 +1,5 @@
 error: lifetime may not live long enough
-  --> $DIR/ex3-both-anon-regions-return-type-is-anon.rs:7:5
+  --> $DIR/ex3-both-anon-regions-return-type-is-anon.rs:9:5
    |
 LL |   fn foo<'a>(&self, x: &i32) -> &i32 {
    |              -         - let's call the lifetime of this reference `'1`

tests/ui/self/arbitrary_self_types_pin_lifetime_mismatch.rs

@@ -6,6 +6,9 @@ impl Foo {
     fn a(self: Pin<&Foo>, f: &Foo) -> &Foo { f }
     //~^ lifetime may not live long enough
 
+    // For this suggestion to be right, we'd need to also suggest `self: Pin<&'a Self>`, which we
+    // don't, but we provide a follow up suggestion to do so, so I condider that good at least for
+    // now.
     fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) { (self, f) }
     //~^ lifetime may not live long enough
 }

tests/ui/self/arbitrary_self_types_pin_lifetime_mismatch.stderr

@@ -13,7 +13,7 @@ LL |     fn a<'a>(self: Pin<&'a Foo>, f: &'a Foo) -> &'a Foo { f }
    |         ++++            ++           ++          ++
 
 error: lifetime may not live long enough
-  --> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:9:69
+  --> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:12:69
    |
 LL |     fn c(self: Pin<&Self>, f: &Foo, g: &Foo) -> (Pin<&Foo>, &Foo) { (self, f) }
    |                    -          -                                     ^^^^^^^^^ method was supposed to return data with lifetime `'2` but it is returning data with lifetime `'1`
@@ -27,7 +27,7 @@ LL |     fn c<'a>(self: Pin<&'a Self>, f: &'a Foo, g: &Foo) -> (Pin<&'a Foo>, &'
    |         ++++            ++            ++                        ++        ++
 
 error: lifetime may not live long enough
-  --> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:15:58
+  --> $DIR/arbitrary_self_types_pin_lifetime_mismatch.rs:18:58
    |
 LL |     fn bar<'a>(self: Alias<&Self>, arg: &'a ()) -> &() { arg }
    |            --  ---- has type `Pin<&'1 Foo>`              ^^^ method was supposed to return data with lifetime `'1` but it is returning data with lifetime `'a`

tests/ui/self/elision/lt-ref-self-async.fixed

@@ -0,0 +1,45 @@
+//@ edition:2018
+//@ run-rustfix
+#![allow(non_snake_case, dead_code)]
+
+use std::pin::Pin;
+
+struct Struct<'a> { data: &'a u32 }
+
+impl<'a> Struct<'a> {
+    // Test using `&self` sugar:
+
+    async fn ref_self<'b>(&'b self, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+
+    // Test using `&Self` explicitly:
+
+    async fn ref_Self<'b>(self: &'b Self, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+
+    async fn box_ref_Self<'b>(self: Box<&'b Self>, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+
+    async fn pin_ref_Self<'b>(self: Pin<&'b Self>, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+
+    async fn box_box_ref_Self<'b>(self: Box<Box<&'b Self>>, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+
+    async fn box_pin_Self<'b>(self: Box<Pin<&'b Self>>, f: &'b u32) -> &u32 {
+        f
+        //~^ ERROR lifetime may not live long enough
+    }
+}
+
+fn main() { }