nested impl trait in return position (ITRP) forces argument lifetimes to be 'static

[ajwerner]

I tried this code (playground):

trait Goal {}

impl Goal for () {}

struct Holder<'a, T: ?Sized> {
    r: &'a T,
}

struct StaticHolder<T> {
    t: T,
}

fn make_goal<'a, T: 'a>(_s: &'a StaticHolder<T>) -> impl Goal + 'static {
    ()
}

fn outer() -> impl Goal {
    let s = String::from("hello world");
    let h = Holder { r: s.as_str() };
    let s = StaticHolder { t: h };
    make_goal(&s)
}

fn main() {
    outer();
}

I expected it to work. The value returned from make_goal is impl Goal + 'static, so i should be able to return it from outer.

Instead, this happened:

error[[E0597]](https://doc.rust-lang.org/stable/error_codes/E0597.html): `s` does not live long enough
  --> src/main.rs:19:25
   |
18 |     let s = String::from("hello world");
   |         - binding `s` declared here
19 |     let h = Holder { r: s.as_str() };
   |                         ^^^^^^^^^^ borrowed value does not live long enough
20 |     let s = StaticHolder { t: h };
21 |     make_goal(&s)
   |     ------------- argument requires that `s` is borrowed for `'static`
22 | }
   | - `s` dropped here while still borrowed

For more information about this error, try `rustc --explain E0597`.

Meta

I compiled in the playground using 1.72.0 and 1.74.0.

[traviscross]

Here's a minimized version:

struct Ref<'a>(&'a ());

fn capture<'o, T>(_x: T) -> impl Send + 'o {}

fn outlives<'o, T: 'o>(_t: T) {}
fn test<'o>(x: ()) -> impl Send + 'o {
    outlives::<'o, _>(capture::<'o, Ref<'_>>(Ref(&x))); // OK.
    capture::<'o, Ref<'_>>(Ref(&x))
//                             ^^
// ERROR: borrowed value does not live long enough.
}

Playground link

This is another manifestation of #42940.

As it applies here, it's not that the argument lifetimes need to be 'static, it's that they have to be able to be named in a way that's valid outside of the function. Consider, e.g., that this is accepted:

trait Captures<T> {}
impl<T, U: ?Sized> Captures<T> for U {}

struct Ref<'a>(&'a ());

fn capture<'o, T>(_x: T) -> impl Send + 'o {}

fn outlives<'o, T: 'o>(_t: T) {}
fn test<'o, 'b>(x: &'b ()) -> impl Send + Captures<&'b ()> + 'o {
    outlives::<'o, _>(capture::<'o, Ref<'b>>(Ref(x))); // OK.
    capture::<'o, Ref<'b>>(Ref(x)) // OK.
}

Playground link

A full analysis of this issue is available here.

[aliemjay]

This is another manifestation of #42940.

Agree. Closing as a duplicate of #42940. Thanks for reporting!