Add beginner friendly lifetime elision hint to E0623

Suggest adding a new lifetime parameter when two elided lifetimes should match up but don't

Issue #90170

Author: Noratrieb

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

@@ -7,7 +7,10 @@ use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use crate::infer::lexical_region_resolve::RegionResolutionError;
 use crate::infer::SubregionOrigin;
 
-use rustc_errors::{struct_span_err, ErrorReported};
+use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported};
+use rustc_hir as hir;
+use rustc_hir::Ty;
+use rustc_middle::ty::Region;
 
 impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
     /// Print the error message for lifetime errors when both the concerned regions are anonymous.
@@ -166,6 +169,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         e.span_label(span_2, String::new());
         e.span_label(span, span_label);
 
+        self.suggest_adding_lifetime_params(sub, ty_sup, ty_sub, &mut e);
+
         if let Some(t) = future_return_type {
             let snip = self
                 .tcx()
@@ -178,7 +183,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
                     (_, "") => None,
                     _ => Some(s),
                 })
-                .unwrap_or("{unnamed_type}".to_string());
+                .unwrap_or_else(|| "{unnamed_type}".to_string());
 
             e.span_label(
                 t.span,
@@ -188,4 +193,53 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
         e.emit();
         Some(ErrorReported)
     }
+
+    fn suggest_adding_lifetime_params(
+        &self,
+        sub: Region<'tcx>,
+        ty_sup: &Ty<'_>,
+        ty_sub: &Ty<'_>,
+        e: &mut DiagnosticBuilder<'_>,
+    ) {
+        if let (
+            hir::Ty { kind: hir::TyKind::Rptr(lifetime_sub, _), .. },
+            hir::Ty { kind: hir::TyKind::Rptr(lifetime_sup, _), .. },
+        ) = (ty_sub, ty_sup)
+        {
+            if lifetime_sub.name.is_elided() && lifetime_sup.name.is_elided() {
+                if let Some(anon_reg) = self.tcx().is_suitable_region(sub) {
+                    let hir_id = self.tcx().hir().local_def_id_to_hir_id(anon_reg.def_id);
+                    if let hir::Node::Item(&hir::Item {
+                        kind: hir::ItemKind::Fn(_, ref generics, ..),
+                        ..
+                    }) = 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())
+                                },
+                            ],
+                            Applicability::MaybeIncorrect,
+                        );
+                        e.note("Each elided lifetime in input position becomes a distinct lifetime.");
+                    }
+                }
+            }
+        }
+    }
 }

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

@@ -0,0 +1,19 @@
+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
+}
+
+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 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.stderr

@@ -0,0 +1,63 @@
+error[E0623]: lifetime mismatch
+  --> $DIR/issue-90170-elision-mismatch.rs:2:35
+   |
+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
+   |
+   = note: Each elided lifetime in input position becomes a distinct lifetime.
+help: Explicitly declare a lifetime and assign it to both
+   |
+LL | fn foo<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
+   |       ++++           ++                     ++
+
+error[E0623]: lifetime mismatch
+  --> $DIR/issue-90170-elision-mismatch.rs:2:35
+   |
+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
+   |
+   = note: Each elided lifetime in input position becomes a distinct lifetime.
+help: Explicitly declare a lifetime and assign it to both
+   |
+LL | fn foo<'a>(slice_a: &'a mut [u8], slice_b: &'a mut [u8]) {
+   |       ++++           ++                     ++
+
+error[E0623]: lifetime mismatch
+  --> $DIR/issue-90170-elision-mismatch.rs:7:35
+   |
+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
+   |
+   = note: Each elided lifetime in input position becomes a distinct lifetime.
+help: Explicitly declare a lifetime and assign it to both
+   |
+LL | fn foo2<'a, U, W, O>(slice_a: &'a mut [u8], slice_b: &'a mut [u8], _: U, _: W, _: O) {
+   |         +++                    ++                     ++
+
+error[E0623]: lifetime mismatch
+  --> $DIR/issue-90170-elision-mismatch.rs:7:35
+   |
+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
+   |
+   = note: Each elided lifetime in input position becomes a distinct lifetime.
+help: Explicitly declare a lifetime and assign it to both
+   |
+LL | fn foo2<'a, U, W, O>(slice_a: &'a mut [u8], slice_b: &'a mut [u8], _: U, _: W, _: O) {
+   |         +++                    ++                     ++
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0623`.

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

@@ -5,6 +5,12 @@ LL | fn foo(&mut (ref mut v, w): &mut (&u8, &u8), x: &u8) {
    |                                   ---           --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(&mut (ref mut v, w): &mut (&'a u8, &u8), x: &'a u8) {
+   |       ++++                             ++               ++
 
 error: aborting due to previous error
 

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

@@ -5,6 +5,12 @@ LL | fn foo(z: &mut Vec<(&u8,&u8)>, (x, y): (&u8, &u8)) {
    |                     ---                 --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(z: &mut Vec<(&'a u8,&u8)>, (x, y): (&'a u8, &u8)) {
+   |       ++++               ++                     ++
 
 error[E0623]: lifetime mismatch
   --> $DIR/ex3-both-anon-regions-3.rs:2:15
@@ -13,6 +19,12 @@ LL | fn foo(z: &mut Vec<(&u8,&u8)>, (x, y): (&u8, &u8)) {
    |                         ---                  --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(z: &mut Vec<(&u8,&'a u8)>, (x, y): (&u8, &'a u8)) {
+   |       ++++                   ++                      ++
 
 error: aborting due to 2 previous errors
 

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

@@ -5,6 +5,12 @@ LL | fn foo(x:fn(&u8, &u8), y: Vec<&u8>, z: &u8) {
    |                               ---      --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(x:fn(&u8, &u8), y: Vec<&'a u8>, z: &'a u8) {
+   |       ++++                         ++          ++
 
 error: aborting due to previous error
 

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

@@ -5,6 +5,12 @@ LL | fn foo(x:Box<dyn Fn(&u8, &u8)> , y: Vec<&u8>, z: &u8) {
    |                     ---  --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(x:Box<dyn Fn(&'a u8, &'a u8)> , y: Vec<&u8>, z: &u8) {
+   |       ++++               ++      ++
 
 error: aborting due to previous error
 

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

@@ -5,6 +5,12 @@ LL | fn foo(x: &mut Vec<&u8>, y: &u8) {
    |                    ---      --- these two types are declared with different lifetimes...
 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
+   |
+LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) {
+   |       ++++              ++          ++
 
 error: aborting due to previous error
 

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

@@ -5,6 +5,12 @@ 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
+   |
+LL | fn foo<'a>(x: &mut Vec<&'a u8>, y: &'a u8) { x.push(y); }
+   |       ++++              ~~          ~~
 
 error: aborting due to previous error