Improve lifetime elision hint error

This also changes the tests introduced by the previous commits because of another rustc issue (#90258)

Author: Noratrieb

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -9,7 +9,7 @@ use crate::infer::SubregionOrigin;
 
 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported};
 use rustc_hir as hir;
-use rustc_hir::Ty;
+use rustc_hir::{GenericParamKind, Ty};
 use rustc_middle::ty::Region;
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
@@ -163,13 +163,13 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 }
             };
 
-        let mut e = struct_span_err!(self.tcx().sess, span, E0623, "lifetime mismatch");
+        let mut err = struct_span_err!(self.tcx().sess, span, E0623, "lifetime mismatch");
 
-        e.span_label(span_1, main_label);
-        e.span_label(span_2, String::new());
-        e.span_label(span, span_label);
+        err.span_label(span_1, main_label);
+        err.span_label(span_2, String::new());
+        err.span_label(span, span_label);
 
-        self.suggest_adding_lifetime_params(sub, ty_sup, ty_sub, &mut e);
+        self.suggest_adding_lifetime_params(sub, ty_sup, ty_sub, &mut err);
 
         if let Some(t) = future_return_type {
             let snip = self
@@ -185,12 +185,12 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                 })
                 .unwrap_or_else(|| "{unnamed_type}".to_string());
 
-            e.span_label(
+            err.span_label(
                 t.span,
                 &format!("this `async fn` implicitly returns an `impl Future<Output = {}>`", snip),
             );
         }
-        e.emit();
+        err.emit();
         Some(ErrorReported)
     }
 
@@ -199,7 +199,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         sub: Region<'tcx>,
         ty_sup: &Ty<'_>,
         ty_sub: &Ty<'_>,
-        e: &mut DiagnosticBuilder<'_>,
+        err: &mut DiagnosticBuilder<'_>,
     ) {
         if let (
             hir::Ty { kind: hir::TyKind::Rptr(lifetime_sub, _), .. },
@@ -214,29 +214,51 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                         ..
                     }) = self.tcx().hir().get(hir_id)
                     {
-                        let add_lifetime_param = match &generics.params {
-                            [] => (generics.span, "<'a>".to_string()),
-                            [first, ..] => (first.span.shrink_to_lo(), "'a, ".to_string()),
-                        };
-
-                        e.multipart_suggestion(
-                            "explicitly declare a lifetime and assign it to both",
-                            vec![
-                                add_lifetime_param,
-                                if let hir::LifetimeName::Underscore = lifetime_sub.name {
-                                    (lifetime_sub.span, "'a".to_string())
-                                } else {
-                                    (lifetime_sub.span.shrink_to_hi(), "'a ".to_string())
-                                },
-                                if let hir::LifetimeName::Underscore = lifetime_sup.name {
-                                    (lifetime_sup.span, "'a".to_string())
-                                } else {
-                                    (lifetime_sup.span.shrink_to_hi(), "'a ".to_string())
-                                },
-                            ],
+                        let (suggestion_param_name, introduce_new) = generics
+                            .params
+                            .iter()
+                            .find(|p| matches!(p.kind, GenericParamKind::Lifetime { .. }))
+                            .and_then(|p| self.tcx().sess.source_map().span_to_snippet(p.span).ok())
+                            .map(|name| (name, false))
+                            .unwrap_or_else(|| ("'a".to_string(), true));
+
+                        let mut suggestions = vec![
+                            if let hir::LifetimeName::Underscore = lifetime_sub.name {
+                                (lifetime_sub.span, suggestion_param_name.clone())
+                            } else {
+                                (
+                                    lifetime_sub.span.shrink_to_hi(),
+                                    suggestion_param_name.clone() + " ",
+                                )
+                            },
+                            if let hir::LifetimeName::Underscore = lifetime_sup.name {
+                                (lifetime_sup.span, suggestion_param_name.clone())
+                            } else {
+                                (
+                                    lifetime_sup.span.shrink_to_hi(),
+                                    suggestion_param_name.clone() + " ",
+                                )
+                            },
+                        ];
+
+                        if introduce_new {
+                            let new_param_suggestion = match &generics.params {
+                                [] => (generics.span, format!("<{}>", suggestion_param_name)),
+                                [first, ..] => (
+                                    first.span.shrink_to_lo(),
+                                    format!("{}, ", suggestion_param_name),
+                                ),
+                            };
+
+                            suggestions.push(new_param_suggestion);
+                        }
+
+                        err.multipart_suggestion(
+                            "consider introducing a named lifetime parameter",
+                            suggestions,
                             Applicability::MaybeIncorrect,
                         );
-                        e.note(
+                        err.note(
                             "each elided lifetime in input position becomes a distinct lifetime",
                         );
                     }

src/test/ui/lifetimes/issue-90170-elision-mismatch.fixed

@@ -0,0 +1,17 @@
+// run-rustfix
+
+fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); } //~ ERROR lifetime mismatch
+
+fn foo2<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); } //~ ERROR lifetime mismatch
+
+fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); } //~ ERROR lifetime mismatch
+
+fn ok<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
+    core::mem::swap(&mut slice_a, &mut slice_b);
+}
+
+fn main() {
+    let a = [1u8, 2, 3];
+    let b = [4u8, 5, 6];
+    foo(&mut a, &mut b);
+}

src/test/ui/lifetimes/issue-90170-elision-mismatch.rs

@@ -1,12 +1,10 @@
-fn foo(slice_a: &mut [u8], slice_b: &mut [u8]) {
-    core::mem::swap(&mut slice_a, &mut slice_b); //~ ERROR lifetime mismatch
-    //~^ ERROR lifetime mismatch
-}
+// run-rustfix
 
-fn foo2<U, W, O>(slice_a: &mut [u8], slice_b: &mut [u8], _: U, _: W, _: O) {
-    core::mem::swap(&mut slice_a, &mut slice_b); //~ ERROR lifetime mismatch
-    //~^ ERROR lifetime mismatch
-}
+fn foo(x: &mut Vec<&u8>, y: &u8) { x.push(y); } //~ ERROR lifetime mismatch
+
+fn foo2(x: &mut Vec<&'_ u8>, y: &u8) { x.push(y); } //~ ERROR lifetime mismatch
+
+fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&u8>, y: &u8) { x.push(y); } //~ ERROR lifetime mismatch
 
 fn ok<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
     core::mem::swap(&mut slice_a, &mut slice_b);

src/test/ui/lifetimes/issue-90170-elision-mismatch.stderr

@@ -1,63 +1,64 @@
 error[E0623]: lifetime mismatch
-  --> $DIR/issue-90170-elision-mismatch.rs:2:35
+  --> $DIR/issue-90170-elision-mismatch.rs:3:43
    |
-LL | fn foo(slice_a: &mut [u8], slice_b: &mut [u8]) {
-   |                 ---------           --------- these two types are declared with different lifetimes...
-LL |     core::mem::swap(&mut slice_a, &mut slice_b);
-   |                                   ^^^^^^^^^^^^ ...but data from `slice_b` flows into `slice_a` here
+LL | fn foo(x: &mut Vec<&u8>, y: &u8) { x.push(y); }
+   |                    ---      ---           ^ ...but data from `y` flows into `x` here
+   |                             |
+   |                             these two types are declared with different lifetimes...
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
-LL | fn foo<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
-   |       ++++           ++                     ++
+LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
+   |       ++++              ++          ++
 
 error[E0623]: lifetime mismatch
-  --> $DIR/issue-90170-elision-mismatch.rs:2:35
+  --> $DIR/issue-90170-elision-mismatch.rs:5:47
    |
-LL | fn foo(slice_a: &mut [u8], slice_b: &mut [u8]) {
-   |                 ---------           ---------
-   |                 |
-   |                 these two types are declared with different lifetimes...
-LL |     core::mem::swap(&mut slice_a, &mut slice_b);
-   |                                   ^^^^^^^^^^^^ ...but data from `slice_a` flows into `slice_b` here
+LL | fn foo2(x: &mut Vec<&'_ u8>, y: &u8) { x.push(y); }
+   |                     ------      ---           ^ ...but data from `y` flows into `x` here
+   |                                 |
+   |                                 these two types are declared with different lifetimes...
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
-LL | fn foo<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
-   |       ++++           ++                     ++
+LL | fn foo2<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
+   |        ++++              ~~          ++
 
 error[E0623]: lifetime mismatch
-  --> $DIR/issue-90170-elision-mismatch.rs:7:35
+  --> $DIR/issue-90170-elision-mismatch.rs:7:66
    |
-LL | fn foo2<U, W, O>(slice_a: &mut [u8], slice_b: &mut [u8], _: U, _: W, _: O) {
-   |                           ---------           --------- these two types are declared with different lifetimes...
-LL |     core::mem::swap(&mut slice_a, &mut slice_b);
-   |                                   ^^^^^^^^^^^^ ...but data from `slice_b` flows into `slice_a` here
+LL | fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&u8>, y: &u8) { x.push(y); }
+   |                                           ---      ---           ^ ...but data from `y` flows into `x` here
+   |                                                    |
+   |                                                    these two types are declared with different lifetimes...
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
-LL | fn foo2<'a, U, W, O>(slice_a: &'a mut [u8], slice_b: &'a mut [u8], _: U, _: W, _: O) {
-   |         +++                    ++                     ++
+LL | fn foo3<'a>(_other: &'a [u8], x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
+   |                                            ++          ++
 
-error[E0623]: lifetime mismatch
-  --> $DIR/issue-90170-elision-mismatch.rs:7:35
+error[E0308]: mismatched types
+  --> $DIR/issue-90170-elision-mismatch.rs:16:9
    |
-LL | fn foo2<U, W, O>(slice_a: &mut [u8], slice_b: &mut [u8], _: U, _: W, _: O) {
-   |                           ---------           ---------
-   |                           |
-   |                           these two types are declared with different lifetimes...
-LL |     core::mem::swap(&mut slice_a, &mut slice_b);
-   |                                   ^^^^^^^^^^^^ ...but data from `slice_a` flows into `slice_b` here
+LL |     foo(&mut a, &mut b);
+   |         ^^^^^^ expected struct `Vec`, found array `[u8; 3]`
    |
-   = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+   = note: expected mutable reference `&mut Vec<&u8>`
+              found mutable reference `&mut [u8; 3]`
+
+error[E0308]: mismatched types
+  --> $DIR/issue-90170-elision-mismatch.rs:16:17
+   |
+LL |     foo(&mut a, &mut b);
+   |                 ^^^^^^ expected `u8`, found array `[u8; 3]`
    |
-LL | fn foo2<'a, U, W, O>(slice_a: &'a mut [u8], slice_b: &'a mut [u8], _: U, _: W, _: O) {
-   |         +++                    ++                     ++
+   = note:      expected reference `&u8`
+           found mutable reference `&mut [u8; 3]`
 
-error: aborting due to 4 previous errors
+error: aborting due to 5 previous errors
 
-For more information about this error, try `rustc --explain E0623`.
+Some errors have detailed explanations: E0308, E0623.
+For more information about an error, try `rustc --explain E0308`.

src/test/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-2.stderr

@@ -7,7 +7,7 @@ LL |     *v = x;
    |          ^ ...but data from `x` flows here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(&mut (ref mut v, w): &mut (&'a u8, &u8), x: &'a u8) {
    |       ++++                             ++               ++

src/test/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-3.stderr

@@ -7,7 +7,7 @@ LL |     z.push((x,y));
    |             ^ ...but data flows into `z` here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(z: &mut Vec<(&'a u8,&u8)>, (x, y): (&'a u8, &u8)) {
    |       ++++               ++                     ++
@@ -21,7 +21,7 @@ LL |     z.push((x,y));
    |               ^ ...but data flows into `z` here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(z: &mut Vec<(&u8,&'a u8)>, (x, y): (&u8, &'a u8)) {
    |       ++++                   ++                      ++

src/test/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-fn-items.stderr

@@ -7,7 +7,7 @@ LL |   y.push(z);
    |          ^ ...but data from `z` flows into `y` here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(x:fn(&u8, &u8), y: Vec<&'a u8>, z: &'a u8) {
    |       ++++                         ++          ++

src/test/ui/lifetimes/lifetime-errors/ex3-both-anon-regions-using-trait-objects.stderr

@@ -7,7 +7,7 @@ LL |   y.push(z);
    |          ^ ...but data from `z` flows into `y` here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(x:Box<dyn Fn(&'a u8, &'a u8)> , y: Vec<&u8>, z: &u8) {
    |       ++++               ++      ++

src/test/ui/lifetimes/lifetime-errors/ex3-both-anon-regions.stderr

@@ -7,7 +7,7 @@ LL |     x.push(y);
    |            ^ ...but data from `y` flows into `x` here
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) {
    |       ++++              ++          ++

src/test/ui/underscore-lifetime/underscore-lifetime-elison-mismatch.stderr

@@ -7,7 +7,7 @@ LL | fn foo(x: &mut Vec<&'_ u8>, y: &'_ u8) { x.push(y); }
    |                                these two types are declared with different lifetimes...
    |
    = note: each elided lifetime in input position becomes a distinct lifetime
-help: explicitly declare a lifetime and assign it to both
+help: consider introducing a named lifetime parameter
    |
 LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
    |       ++++              ~~          ~~