Unclear lifetime error in closure producing a future

[95th]

Code:

use std::future::Future;

pub async fn bar() {
    foo(|x| baz(x)).await;
}

pub async fn baz(x: &u8) -> bool {
    if *x == 1 {
        false
    } else {
        true
    }
}

pub async fn foo<F, T>(f: F) -> bool
where
    F: Fn(&u8) -> T,
    T: Future<Output = bool>,
{
    f(&32).await
}

produces following error:

error: lifetime may not live long enough
 --> src/lib.rs:4:13
  |
4 |     foo(|x| baz(x)).await;
  |          -- ^^^^^^ returning this value requires that `'1` must outlive `'2`
  |          ||
  |          |return type of closure is impl std::future::Future
  |          has type `&'1 u8`

Is this error correct? If yes, why?

following also doesn't work:

pub async fn bar() {
    foo(baz).await;
}

error (still not clear):

error[E0271]: type mismatch resolving `for<'r> <for<'_> fn(&u8) -> impl std::future::Future {baz} as std::ops::FnOnce<(&'r u8,)>>::Output == _`
  --> src/lib.rs:4:5
   |
4  |     foo(baz).await;
   |     ^^^ expected bound lifetime parameter, found concrete lifetime
...
15 | pub async fn foo<F, T>(f: F) -> bool
   |              --- required by a bound in this
16 | where
17 |     F: Fn(&u8) -> T,
   |                   - required by this bound in `foo`

meta:

$ rustc --version --verbose
rustc 1.45.0 (5c1f21c3b 2020-07-13)
binary: rustc
commit-hash: 5c1f21c3b82297671ad3ae1e8c942d2ca92e84f2
commit-date: 2020-07-13
host: x86_64-unknown-linux-gnu
release: 1.45.0
LLVM version: 10.0

[SNCPlay42]

This note

return type of closure is impl std::future::Future

Is supposed to define the lifetime '2 referred to by the error message by showing it as a parameter of the return type, but '2 doesn't appear in the type anywhere, possibly because of the opaque impl Future type.

cc #74072

[nikomatsakis]

This code is invalid. The closure is given a &u8, which is only valid during the closure execution. But baz(x) captures x and embeds it into a future that is returned -- this future, when awaited, will (or could) attempt to use x, even though the closure itself has returned, and hence x is no longer valid.

The error message here is obviously not great. We have specialized errors for these kinds of cases in closures normally, I'm not sure why it didn't trigger in this case.

[nikomatsakis]

There isn't a great workaround that uses stable syntax to make this compile, interestingly. We discussed it some on Zulip.

The error message for a comparable scenario without async isn't that great either, actually, I am somewhat surprised (playground):

error: lifetime may not live long enough
 --> src/lib.rs:4:13
  |
4 |     foo(|x| baz(x))
  |          -- ^^^^^^ returning this value requires that `'1` must outlive `'2`
  |          ||
  |          |return type of closure is &'2 u8
  |          has type `&'1 u8`

[nikomatsakis]

Returning a reference to a local variable is somewhat better (playground):

error[E0515]: cannot return value referencing local variable `p`
 --> src/lib.rs:4:26
  |
4 |     foo(|x| { let p = 3; baz(&p) })
  |                          ^^^^--^
  |                          |   |
  |                          |   `p` is borrowed here
  |                          returns a value referencing data owned by the current function