Rollup merge of #103416 - compiler-errors:rpit-named, r=cjgillot

Dylan-DPC · web-flow · commit d6d6cb795ec0 · 2022-10-25T11:48:48.000+05:30
Name the `impl Trait` in region bound suggestions

Slightly more descriptive message
diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs
@@ -286,8 +286,8 @@ pub fn suggest_new_region_bound(
 ) {
     debug!("try_report_static_impl_trait: fn_return={:?}", fn_returns);
     // FIXME: account for the need of parens in `&(dyn Trait + '_)`
-    let consider = "consider changing the";
-    let declare = "to declare that the";
+    let consider = "consider changing";
+    let declare = "to declare that";
     let explicit = format!("you can add an explicit `{}` lifetime bound", lifetime_name);
     let explicit_static =
         arg.map(|arg| format!("explicit `'static` bound to the lifetime of {}", arg));
@@ -305,6 +305,10 @@ pub fn suggest_new_region_bound(
                     return;
                 };
 
+                // Get the identity type for this RPIT
+                let did = item_id.def_id.to_def_id();
+                let ty = tcx.mk_opaque(did, ty::InternalSubsts::identity_for_item(tcx, did));
+
                 if let Some(span) = opaque
                     .bounds
                     .iter()
@@ -321,7 +325,7 @@ pub fn suggest_new_region_bound(
                     if let Some(explicit_static) = &explicit_static {
                         err.span_suggestion_verbose(
                             span,
-                            &format!("{} `impl Trait`'s {}", consider, explicit_static),
+                            &format!("{consider} `{ty}`'s {explicit_static}"),
                             &lifetime_name,
                             Applicability::MaybeIncorrect,
                         );
@@ -351,12 +355,7 @@ pub fn suggest_new_region_bound(
                 } else {
                     err.span_suggestion_verbose(
                         fn_return.span.shrink_to_hi(),
-                        &format!(
-                            "{declare} `impl Trait` {captures}, {explicit}",
-                            declare = declare,
-                            captures = captures,
-                            explicit = explicit,
-                        ),
+                        &format!("{declare} `{ty}` {captures}, {explicit}",),
                         &plus_lt,
                         Applicability::MaybeIncorrect,
                     );
@@ -367,7 +366,7 @@ pub fn suggest_new_region_bound(
                     err.span_suggestion_verbose(
                         fn_return.span.shrink_to_hi(),
                         &format!(
-                            "{declare} trait object {captures}, {explicit}",
+                            "{declare} the trait object {captures}, {explicit}",
                             declare = declare,
                             captures = captures,
                             explicit = explicit,
@@ -384,7 +383,7 @@ pub fn suggest_new_region_bound(
                     if let Some(explicit_static) = &explicit_static {
                         err.span_suggestion_verbose(
                             lt.span,
-                            &format!("{} trait object's {}", consider, explicit_static),
+                            &format!("{} the trait object's {}", consider, explicit_static),
                             &lifetime_name,
                             Applicability::MaybeIncorrect,
                         );
diff --git a/src/test/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr b/src/test/ui/async-await/multiple-lifetimes/ret-impl-trait-one.stderr
@@ -25,7 +25,7 @@ LL | |     (a, b)
 LL | | }
    | |_^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Trait<'a>` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + 'b {
    |                                                                                ++++
diff --git a/src/test/ui/impl-trait/hidden-lifetimes.stderr b/src/test/ui/impl-trait/hidden-lifetimes.stderr
@@ -6,7 +6,7 @@ LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a {
 LL |     x
    |     ^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Swap` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + 'b {
    |                                                                     ++++
@@ -19,7 +19,7 @@ LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl S
 LL |     x
    |     ^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Swap` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {
    |                                                                                     ++++
diff --git a/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr b/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unrelated.stderr
@@ -7,7 +7,7 @@ LL | fn upper_bounds<'a, 'b, 'c, 'd, 'e>(a: Ordinary<'a>, b: Ordinary<'b>) -> im
 LL |     if condition() { a } else { b }
    |                                 ^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Trait<'d, 'e>` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | fn upper_bounds<'a, 'b, 'c, 'd, 'e>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'d, 'e> + 'b
    |                                                                                             ++++
diff --git a/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr b/src/test/ui/impl-trait/multiple-lifetimes/ordinary-bounds-unsuited.stderr
@@ -7,7 +7,7 @@ LL | fn upper_bounds<'a, 'b>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'a,
 LL |     if condition() { a } else { b }
    |                                 ^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Trait<'a, 'b>` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | fn upper_bounds<'a, 'b>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'a, 'b> + 'b
    |                                                                                 ++++
diff --git a/src/test/ui/impl-trait/must_outlive_least_region_or_bound.stderr b/src/test/ui/impl-trait/must_outlive_least_region_or_bound.stderr
@@ -6,7 +6,7 @@ LL | fn elided(x: &i32) -> impl Copy { x }
    |              |
    |              hidden type `&i32` captures the anonymous lifetime defined here
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Copy` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL | fn elided(x: &i32) -> impl Copy + '_ { x }
    |                                 ++++
@@ -19,7 +19,7 @@ LL | fn explicit<'a>(x: &'a i32) -> impl Copy { x }
    |             |
    |             hidden type `&'a i32` captures the lifetime `'a` as defined here
    |
-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
+help: to declare that `impl Copy` captures `'a`, you can add an explicit `'a` lifetime bound
    |
 LL | fn explicit<'a>(x: &'a i32) -> impl Copy + 'a { x }
    |                                          ++++
@@ -32,7 +32,7 @@ LL | fn elided2(x: &i32) -> impl Copy + 'static { x }
    |               |
    |               let's call the lifetime of this reference `'1`
    |
-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
+help: consider changing `impl Copy`'s explicit `'static` bound to the lifetime of argument `x`
    |
 LL | fn elided2(x: &i32) -> impl Copy + '_ { x }
    |                                    ~~
@@ -47,7 +47,7 @@ error: lifetime may not live long enough
 LL | fn explicit2<'a>(x: &'a i32) -> impl Copy + 'static { x }
    |              -- lifetime `'a` defined here            ^ returning this value requires that `'a` must outlive `'static`
    |
-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
+help: consider changing `impl Copy`'s explicit `'static` bound to the lifetime of argument `x`
    |
 LL | fn explicit2<'a>(x: &'a i32) -> impl Copy + 'a { x }
    |                                             ~~
@@ -76,7 +76,7 @@ help: to declare that the trait object captures data from argument `x`, you can
    |
 LL | fn elided5(x: &i32) -> (Box<dyn Debug + '_>, impl Debug) { (Box::new(x), x) }
    |                                       ++++
-help: to declare that the `impl Trait` captures data from argument `x`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Debug` captures data from argument `x`, you can add an explicit `'_` lifetime bound
    |
 LL | fn elided5(x: &i32) -> (Box<dyn Debug>, impl Debug + '_) { (Box::new(x), x) }
    |                                                    ++++
@@ -87,7 +87,7 @@ error: lifetime may not live long enough
 LL | fn with_bound<'a>(x: &'a i32) -> impl LifetimeTrait<'a> + 'static { x }
    |               -- lifetime `'a` defined here                         ^ returning this value requires that `'a` must outlive `'static`
    |
-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
+help: consider changing `impl LifetimeTrait<'a>`'s explicit `'static` bound to the lifetime of argument `x`
    |
 LL | fn with_bound<'a>(x: &'a i32) -> impl LifetimeTrait<'a> + 'a { x }
    |                                                           ~~
@@ -104,7 +104,7 @@ LL | fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32
 LL |     move |_| println!("{}", y)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
+help: to declare that `impl Fn(&'a u32)` captures `'b`, you can add an explicit `'b` lifetime bound
    |
 LL | fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32) + 'b {
    |                                                                              ++++
diff --git a/src/test/ui/impl-trait/region-escape-via-bound.stderr b/src/test/ui/impl-trait/region-escape-via-bound.stderr
@@ -7,7 +7,7 @@ LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y>
 LL |     x
    |     ^
    |
-help: to declare that the `impl Trait` captures `'x`, you can add an explicit `'x` lifetime bound
+help: to declare that `impl Trait<'y>` captures `'x`, you can add an explicit `'x` lifetime bound
    |
 LL | fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x
    |                                                    ++++
diff --git a/src/test/ui/impl-trait/static-return-lifetime-infered.stderr b/src/test/ui/impl-trait/static-return-lifetime-infered.stderr
@@ -6,7 +6,7 @@ LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Iterator<Item = u32>` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> + '_ {
    |                                                           ++++
@@ -19,7 +19,7 @@ LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Iterator<Item = u32>` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL |     fn iter_values_anon(&self) -> impl Iterator<Item=u32> + '_ {
    |                                                           ++++
@@ -32,7 +32,7 @@ LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
+help: to declare that `impl Iterator<Item = u32>` captures `'a`, you can add an explicit `'a` lifetime bound
    |
 LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + 'a {
    |                                                             ++++
@@ -45,7 +45,7 @@ LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {
 LL |         self.x.iter().map(|a| a.0)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
+help: to declare that `impl Iterator<Item = u32>` captures `'a`, you can add an explicit `'a` lifetime bound
    |
 LL |     fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + 'a {
    |                                                             ++++
diff --git a/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr b/src/test/ui/nll/ty-outlives/impl-trait-captures.stderr
@@ -6,7 +6,7 @@ LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> {
 LL |     x
    |     ^
    |
-help: to declare that the `impl Trait` captures `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))`, you can add an explicit `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))` lifetime bound
+help: to declare that `Opaque(DefId(0:13 ~ impl_trait_captures[1afc]::foo::{opaque#0}), [ReEarlyBound(0, 'a), T, ReEarlyBound(2, 'a)])` captures `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))`, you can add an explicit `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))` lifetime bound
    |
 LL | fn foo<'a, T>(x: &T) -> impl Foo<'a> + ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_)) {
    |                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
diff --git a/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr b/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait-async.stderr
@@ -6,7 +6,7 @@ LL |     async fn f(self: Pin<&Self>) -> impl Clone { self }
    |                          |
    |                          hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL |     async fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
    |                                                ++++
diff --git a/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr b/src/test/ui/self/arbitrary_self_types_pin_lifetime_impl_trait.stderr
@@ -6,7 +6,7 @@ LL |     fn f(self: Pin<&Self>) -> impl Clone { self }
    |                    |
    |                    hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL |     fn f(self: Pin<&Self>) -> impl Clone + '_ { self }
    |                                          ++++
diff --git a/src/test/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr b/src/test/ui/suggestions/lifetimes/missing-lifetimes-in-signature.stderr
@@ -18,7 +18,7 @@ LL | |         *dest = g.get();
 LL | |     }
    | |_____^
    |
-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl FnOnce()` captures `'_`, you can add an explicit `'_` lifetime bound
    |
 LL | fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_
    |                                                   ++++
diff --git a/src/test/ui/suggestions/lifetimes/trait-object-nested-in-impl-trait.stderr b/src/test/ui/suggestions/lifetimes/trait-object-nested-in-impl-trait.stderr
@@ -10,7 +10,7 @@ LL | |             remaining: self.0.iter(),
 LL | |         }
    | |_________^ returning this value requires that `'1` must outlive `'static`
    |
-help: to declare that the `impl Trait` captures data from argument `self`, you can add an explicit `'_` lifetime bound
+help: to declare that `impl Iterator<Item = Box<(dyn Foo + 'static)>>` captures data from argument `self`, you can add an explicit `'_` lifetime bound
    |
 LL |     fn iter(&self) -> impl Iterator<Item = Box<dyn Foo>> + '_ {
    |                                                          ++++
@@ -65,7 +65,7 @@ LL | |             remaining: self.0.iter(),
 LL | |         }
    | |_________^ returning this value requires that `'a` must outlive `'static`
    |
-help: to declare that the `impl Trait` captures data from argument `self`, you can add an explicit `'a` lifetime bound
+help: to declare that `impl Iterator<Item = Box<(dyn Foo + 'static)>>` captures data from argument `self`, you can add an explicit `'a` lifetime bound
    |
 LL |     fn iter<'a>(&'a self) -> impl Iterator<Item = Box<dyn Foo>> + 'a {
    |                                                                 ++++

Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ LL \| \| (a, b)`
`25`	`25`	`LL \| \| }`
`26`	`26`	`\| \|_^`
`27`	`27`	`\|`
`28`		-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
	`28`	+help: to declare that `impl Trait<'a>` captures `'b`, you can add an explicit `'b` lifetime bound
`29`	`29`	`\|`
`30`	`30`	`LL \| async fn async_ret_impl_trait1<'a, 'b>(a: &'a u8, b: &'b u8) -> impl Trait<'a> + 'b {`
`31`	`31`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a {`
`6`	`6`	`LL \| x`
`7`	`7`	`\| ^`
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
	`9`	+help: to declare that `impl Swap` captures `'b`, you can add an explicit `'b` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| fn hide_ref<'a, 'b, T: 'static>(x: &'a mut &'b T) -> impl Swap + 'a + 'b {`
`12`	`12`	`\| ++++`
`@@ -19,7 +19,7 @@ LL \| fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl S`
`19`	`19`	`LL \| x`
`20`	`20`	`\| ^`
`21`	`21`	`\|`
`22`		-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
	`22`	+help: to declare that `impl Swap` captures `'b`, you can add an explicit `'b` lifetime bound
`23`	`23`	`\|`
`24`	`24`	`LL \| fn hide_rc_refcell<'a, 'b: 'a, T: 'static>(x: Rc<RefCell<&'b T>>) -> impl Swap + 'a + 'b {`
`25`	`25`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ LL \| fn upper_bounds<'a, 'b, 'c, 'd, 'e>(a: Ordinary<'a>, b: Ordinary<'b>) -> im`
`7`	`7`	`LL \| if condition() { a } else { b }`
`8`	`8`	`\| ^`
`9`	`9`	`\|`
`10`		-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
	`10`	+help: to declare that `impl Trait<'d, 'e>` captures `'b`, you can add an explicit `'b` lifetime bound
`11`	`11`	`\|`
`12`	`12`	`LL \| fn upper_bounds<'a, 'b, 'c, 'd, 'e>(a: Ordinary<'a>, b: Ordinary<'b>) -> impl Trait<'d, 'e> + 'b`
`13`	`13`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| fn elided(x: &i32) -> impl Copy { x }`
`6`	`6`	`\| \|`
`7`	`7`	\| hidden type `&i32` captures the anonymous lifetime defined here
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`9`	+help: to declare that `impl Copy` captures `'_`, you can add an explicit `'_` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| fn elided(x: &i32) -> impl Copy + '_ { x }`
`12`	`12`	`\| ++++`
`@@ -19,7 +19,7 @@ LL \| fn explicit<'a>(x: &'a i32) -> impl Copy { x }`
`19`	`19`	`\| \|`
`20`	`20`	\| hidden type `&'a i32` captures the lifetime `'a` as defined here
`21`	`21`	`\|`
`22`		-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
	`22`	+help: to declare that `impl Copy` captures `'a`, you can add an explicit `'a` lifetime bound
`23`	`23`	`\|`
`24`	`24`	`LL \| fn explicit<'a>(x: &'a i32) -> impl Copy + 'a { x }`
`25`	`25`	`\| ++++`
`@@ -32,7 +32,7 @@ LL \| fn elided2(x: &i32) -> impl Copy + 'static { x }`
`32`	`32`	`\| \|`
`33`	`33`	\| let's call the lifetime of this reference `'1`
`34`	`34`	`\|`
`35`		-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
	`35`	+help: consider changing `impl Copy`'s explicit `'static` bound to the lifetime of argument `x`
`36`	`36`	`\|`
`37`	`37`	`LL \| fn elided2(x: &i32) -> impl Copy + '_ { x }`
`38`	`38`	`\| ~~`
`@@ -47,7 +47,7 @@ error: lifetime may not live long enough`
`47`	`47`	`LL \| fn explicit2<'a>(x: &'a i32) -> impl Copy + 'static { x }`
`48`	`48`	\| -- lifetime `'a` defined here ^ returning this value requires that `'a` must outlive `'static`
`49`	`49`	`\|`
`50`		-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
	`50`	+help: consider changing `impl Copy`'s explicit `'static` bound to the lifetime of argument `x`
`51`	`51`	`\|`
`52`	`52`	`LL \| fn explicit2<'a>(x: &'a i32) -> impl Copy + 'a { x }`
`53`	`53`	`\| ~~`
@@ -76,7 +76,7 @@ help: to declare that the trait object captures data from argument `x`, you can
`76`	`76`	`\|`
`77`	`77`	`LL \| fn elided5(x: &i32) -> (Box<dyn Debug + '_>, impl Debug) { (Box::new(x), x) }`
`78`	`78`	`\| ++++`
`79`		-help: to declare that the `impl Trait` captures data from argument `x`, you can add an explicit `'_` lifetime bound
	`79`	+help: to declare that `impl Debug` captures data from argument `x`, you can add an explicit `'_` lifetime bound
`80`	`80`	`\|`
`81`	`81`	`LL \| fn elided5(x: &i32) -> (Box<dyn Debug>, impl Debug + '_) { (Box::new(x), x) }`
`82`	`82`	`\| ++++`
`@@ -87,7 +87,7 @@ error: lifetime may not live long enough`
`87`	`87`	`LL \| fn with_bound<'a>(x: &'a i32) -> impl LifetimeTrait<'a> + 'static { x }`
`88`	`88`	\| -- lifetime `'a` defined here ^ returning this value requires that `'a` must outlive `'static`
`89`	`89`	`\|`
`90`		-help: consider changing the `impl Trait`'s explicit `'static` bound to the lifetime of argument `x`
	`90`	+help: consider changing `impl LifetimeTrait<'a>`'s explicit `'static` bound to the lifetime of argument `x`
`91`	`91`	`\|`
`92`	`92`	`LL \| fn with_bound<'a>(x: &'a i32) -> impl LifetimeTrait<'a> + 'a { x }`
`93`	`93`	`\| ~~`
`@@ -104,7 +104,7 @@ LL \| fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32`
`104`	`104`	`LL \| move \|_\| println!("{}", y)`
`105`	`105`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`106`	`106`	`\|`
`107`		-help: to declare that the `impl Trait` captures `'b`, you can add an explicit `'b` lifetime bound
	`107`	+help: to declare that `impl Fn(&'a u32)` captures `'b`, you can add an explicit `'b` lifetime bound
`108`	`108`	`\|`
`109`	`109`	`LL \| fn move_lifetime_into_fn<'a, 'b>(x: &'a u32, y: &'b u32) -> impl Fn(&'a u32) + 'b {`
`110`	`110`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ LL \| fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y>`
`7`	`7`	`LL \| x`
`8`	`8`	`\| ^`
`9`	`9`	`\|`
`10`		-help: to declare that the `impl Trait` captures `'x`, you can add an explicit `'x` lifetime bound
	`10`	+help: to declare that `impl Trait<'y>` captures `'x`, you can add an explicit `'x` lifetime bound
`11`	`11`	`\|`
`12`	`12`	`LL \| fn foo<'x, 'y>(x: Cell<&'x u32>) -> impl Trait<'y> + 'x`
`13`	`13`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| fn iter_values_anon(&self) -> impl Iterator<Item=u32> {`
`6`	`6`	`LL \| self.x.iter().map(\|a\| a.0)`
`7`	`7`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`9`	+help: to declare that `impl Iterator<Item = u32>` captures `'_`, you can add an explicit `'_` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| fn iter_values_anon(&self) -> impl Iterator<Item=u32> + '_ {`
`12`	`12`	`\| ++++`
`@@ -19,7 +19,7 @@ LL \| fn iter_values_anon(&self) -> impl Iterator<Item=u32> {`
`19`	`19`	`LL \| self.x.iter().map(\|a\| a.0)`
`20`	`20`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`21`	`21`	`\|`
`22`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`22`	+help: to declare that `impl Iterator<Item = u32>` captures `'_`, you can add an explicit `'_` lifetime bound
`23`	`23`	`\|`
`24`	`24`	`LL \| fn iter_values_anon(&self) -> impl Iterator<Item=u32> + '_ {`
`25`	`25`	`\| ++++`
`@@ -32,7 +32,7 @@ LL \| fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {`
`32`	`32`	`LL \| self.x.iter().map(\|a\| a.0)`
`33`	`33`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`34`	`34`	`\|`
`35`		-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
	`35`	+help: to declare that `impl Iterator<Item = u32>` captures `'a`, you can add an explicit `'a` lifetime bound
`36`	`36`	`\|`
`37`	`37`	`LL \| fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + 'a {`
`38`	`38`	`\| ++++`
`@@ -45,7 +45,7 @@ LL \| fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> {`
`45`	`45`	`LL \| self.x.iter().map(\|a\| a.0)`
`46`	`46`	`\| ^^^^^^^^^^^^^^^^^^^^^^^^^^`
`47`	`47`	`\|`
`48`		-help: to declare that the `impl Trait` captures `'a`, you can add an explicit `'a` lifetime bound
	`48`	+help: to declare that `impl Iterator<Item = u32>` captures `'a`, you can add an explicit `'a` lifetime bound
`49`	`49`	`\|`
`50`	`50`	`LL \| fn iter_values<'a>(&'a self) -> impl Iterator<Item=u32> + 'a {`
`51`	`51`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| fn foo<'a, T>(x: &T) -> impl Foo<'a> {`
`6`	`6`	`LL \| x`
`7`	`7`	`\| ^`
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))`, you can add an explicit `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))` lifetime bound
	`9`	+help: to declare that `Opaque(DefId(0:13 ~ impl_trait_captures[1afc]::foo::{opaque#0}), [ReEarlyBound(0, 'a), T, ReEarlyBound(2, 'a)])` captures `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))`, you can add an explicit `ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_))` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| fn foo<'a, T>(x: &T) -> impl Foo<'a> + ReFree(DefId(0:8 ~ impl_trait_captures[1afc]::foo), BrNamed(DefId(0:12 ~ impl_trait_captures[1afc]::foo::'_), '_)) {`
`12`	`12`	`\| ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| async fn f(self: Pin<&Self>) -> impl Clone { self }`
`6`	`6`	`\| \|`
`7`	`7`	\| hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`9`	+help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| async fn f(self: Pin<&Self>) -> impl Clone + '_ { self }`
`12`	`12`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ LL \| fn f(self: Pin<&Self>) -> impl Clone { self }`
`6`	`6`	`\| \|`
`7`	`7`	\| hidden type `Pin<&Foo>` captures the anonymous lifetime defined here
`8`	`8`	`\|`
`9`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`9`	+help: to declare that `impl Clone` captures `'_`, you can add an explicit `'_` lifetime bound
`10`	`10`	`\|`
`11`	`11`	`LL \| fn f(self: Pin<&Self>) -> impl Clone + '_ { self }`
`12`	`12`	`\| ++++`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ LL \| \| *dest = g.get();`
`18`	`18`	`LL \| \| }`
`19`	`19`	`\| \|_____^`
`20`	`20`	`\|`
`21`		-help: to declare that the `impl Trait` captures `'_`, you can add an explicit `'_` lifetime bound
	`21`	+help: to declare that `impl FnOnce()` captures `'_`, you can add an explicit `'_` lifetime bound
`22`	`22`	`\|`
`23`	`23`	`LL \| fn foo<G, T>(g: G, dest: &mut T) -> impl FnOnce() + '_`
`24`	`24`	`\| ++++`