Unexpected "the parameter type X may not live long enough" error in asynchronous functions

[wvwwvwwv]

When a Future is wrapped in an async block or an async function, some of its traits are lost, e.g., Send, thus causing various issues.

I tried this code:

#![feature(impl_trait_in_assoc_type)]

use std::future::Future;

pub trait Get: Send + Sync {
    type Ret<'a>: Future<Output = usize> + Send + 'a
    where
        Self: 'a;
    fn get<'a>(&'a self) -> Self::Ret<'a>
    where
        Self: 'a;
}

impl Get for usize {
    type Ret<'a> = impl Future<Output = usize> + Send + 'a
    where
        Self: 'a;

    fn get<'a>(&'a self) -> Self::Ret<'a>
    where
        Self: 'a,
    {
        async move { *self }
    }
}

fn is_send<R, F: Future<Output = R> + Send>(_f: &F) -> bool {
    true
}

async fn wrap<G: Get>(g: &G) -> usize {
    let fut = g.get();
    assert!(is_send(&fut));
    fut.await
}

async fn wrap_wrap<G: Get>(g: &G) -> usize {
    let fut = wrap(g);
    assert!(is_send(&fut)); //~ ERROR the parameter type `G` may not live long enough
    fut.await
}

I expected to see no compiler errors: the returned Future from async fn wrap should be Send, because g.get() is Send and async fn wrap only wraps the code in an asynchronous code block.

Instead, this happened: the returned Future from async fn wrap is not anymore Send. Note that the error manifests differently if another lifetime bounds are involved in the trait - lifetime bound not satisfied when asserting is_send(&fut). It's even strange to see lifetime bounds or may not live long enough errors when checking the Send bound.

Meta

rustc --version --verbose:

rustc 1.59.0 (9d1b2106e 2022-02-23)
binary: rustc
commit-hash: 9d1b2106e23b1abd32fce1f17267604a5102f57a
commit-date: 2022-02-23
host: aarch64-apple-darwin
release: 1.59.0
LLVM version: 13.0.0

Error

error[E0311]: the parameter type `G` may not live long enough
   --> tests/test.rs:687:17
    |
684 |     async fn wrap_wrap<G: Get>(g: &G) -> usize {
    |                        -- help: consider adding an explicit lifetime bound...: `G: 'a +`
...
687 |         assert!(is_send(&fut));
    |                 ^^^^^^^ ...so that the type `G` will meet its required lifetime bounds...
    |
note: ...that is required by this bound
   --> tests/test.rs:674:43
    |
674 |     fn is_send<R, F: Future<Output = R> + Send>(_f: &F) -> bool {
    |                                           ^^^^

error: could not compile `async-trait` due to previous error

[wvwwvwwv]

Now, I understand that the code should not compile since g.get() borrows data from the stack of wrap, thus the returned impl Future is not Send. However, the error message is still weird...

[wvwwvwwv]

Also, wouldn't it be weird?

async move {
    let fut = g.get();
    assert!(is_send(&fut));
    fut.await
}

I understand that the above code block is !Send because the closure captures &self reference which is local to the stack, but since the code block is asynchronous, it is guaranteed that the value of &self is only evaluated once the async move block is pinned, and therefore the code block can actually be sent!

[ivan770]

This issue is probably related to #90696, since I was able to run your code by adding for<'a> <G as Get>::Ret<'a>: Send + Sync bound: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6827058de35474e1afc64733741d95f7

[traviscross]

@rustbot labels +AsyncAwait-Triaged +WG-async

We reviewed this today in WG-async triage.

We believe this is a manifestation of what's being worked on and tracked in #110338.