"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.

[Dylan-DPC]

Current output:

error[E0308]: mismatched types
  --> src/main.rs:4:13
   |
4  |     let _ = wrapper(hello);
   |             ^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected opaque type `impl for<'a> Future<Output = ()>`
              found opaque type `impl Future<Output = ()>`
   = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
  --> src/main.rs:11:20
   |
11 |     F: Fn(&i32) -> FutResp,
   |                    ^^^^^^^

error: implementation of `Fn` is not general enough
  --> src/main.rs:4:13
   |
4  |       let _ = wrapper(hello);
   |               ^^^^^^^^^^^^^^
...
9  | / async fn wrapper<F, FutResp>(f: F)
10 | | where
11 | |     F: Fn(&i32) -> FutResp,
   | |        ------------------- doesn't satisfy where-clause
12 | |     FutResp: Future<Output = ()>,
   | |_________________________________- due to a where-clause on `wrapper`...
   |
   = note: ...`for<'a> fn(&'a i32) -> impl Future<Output = ()> {hello}` must implement `Fn<(&i32,)>`
   = note: ...but it actually implements `Fn<(&'0 i32,)>`, for some specific lifetime `'0`

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