"expected bound lifetime parameter, found concrete lifetime" when passing a 'static reference to a closure that returns a future

[shepmaster]

use std::future::Future;

fn main() {
    let _ = wrapper(hello);
}

static GLOBAL: i32 = 42;

async fn wrapper<F, FutResp>(f: F)
where
    F: Fn(&i32) -> FutResp,
    FutResp: Future<Output = ()>,
{
    f(&GLOBAL).await
}

async fn hello(_: &i32) {
    println!("Hello");
}

(Playground)

Errors:

error[E0271]: type mismatch resolving `for<'r> <for<'_> fn(&i32) -> impl std::future::Future {hello} as std::ops::FnOnce<(&'r i32,)>>::Output == _`
  --> src/main.rs:4:13
   |
4  |     let _ = wrapper(hello);
   |             ^^^^^^^ expected bound lifetime parameter, found concrete lifetime
...
9  | async fn wrapper<F, FutResp>(f: F)
   |          -------
10 | where
11 |     F: Fn(&i32) -> FutResp,
   |                    ------- required by this bound in `wrapper`

I can make the code work by restricting the closure to only accept 'static references:

async fn wrapper<F, FutResp>(f: F)
where
    F: Fn(&'static i32) -> FutResp,
    //     ^^^^^^^
    FutResp: Future<Output = ()>,

I did try to add 'static bounds to the response future (and the closure, for good measure), but this did not help:

async fn wrapper<F, FutResp>(f: F)
where
    F: Fn(&i32) -> FutResp + 'static,
    FutResp: Future<Output = ()> + 'static,

The equivalent(?) synchronous code works as I'd expect:

fn main() {
    let _ = wrapper(hello);
}

static GLOBAL: i32 = 42;

fn wrapper<F>(f: F)
where
    F: Fn(&i32) -> (),
{
    f(&GLOBAL)
}

fn hello(_: &i32) {
    println!("Hello");
}

[Aaron1011]

Adding an explicit lifetime 'a allows this to compile:

use std::future::Future;

fn main() {
    let _ = wrapper(hello);
}

static GLOBAL: i32 = 42;

async fn wrapper<'a, F, FutResp>(f: F)
where
    F: Fn(&'a i32) -> FutResp + 'a,
    FutResp: Future<Output = ()>,
{
    f(&GLOBAL).await
}

async fn hello(_: &i32) {
    println!("Hello");
}

I think the issue is that F: Fn(&i32) -> FutResp requires FutResp to be 'static (or at least, not dependent on the lifetime of the &i32. However, the future returned by async fn hello(_: &i32) does depend on the lifetime of the &i32, since the &i32 can be used within the generator.

However, the error message is almost completely opaque. We should probably add some special-casing around lifetime-related errors when async functions are involved.