Additional let bindings needed to avoid Sync

[crepererum]

I tried this code:

use std::future::Future;

fn spawn<T>(_: T)
where
    T: Future + Send + 'static,
    T::Output: Send + 'static,
{
}

async fn f<T>(_: T) {}

async fn g<T>(x: T)
where
    T: Clone + Send + 'static,
{
    spawn(async move {
        f(x.clone()).await;
    });
}

fn main() {}

(playground)

I expected to see this happen:
It should compile.

Instead, this happened:

Compiling playground v0.0.1 (/playground)
error: future cannot be sent between threads safely
  [--> src/main.rs:16:5
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
16 |     spawn(async move {
   |     ^^^^^ future created by async block is not `Send`
   |
note: future is not `Send` as this value is used across an await
  [--> src/main.rs:17:21
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
17 |         f(x.clone()).await;
   |           -         ^^^^^^ await occurs here, with `x` maybe used later
   |           |
   |           has type `&T` which is not `Send`
note: `x` is later dropped here
  [--> src/main.rs:17:27
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
17 |         f(x.clone()).await;
   |                           ^
help: consider moving this into a `let` binding to create a shorter lived borrow
  [--> src/main.rs:17:11
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
17 |         f(x.clone()).await;
   |           ^^^^^^^^^
note: required by a bound in `spawn`
  [--> src/main.rs:5:17
](https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021#)   |
3  | fn spawn<T>(_: T)
   |    ----- required by a bound in this
4  | where
5  |     T: Future + Send + 'static,
   |                 ^^^^ required by this bound in `spawn`
help: consider further restricting this bound
   |
14 |     T: Clone + Send + 'static + std::marker::Sync,
   |                               +++++++++++++++++++

error: could not compile `playground` due to previous error

Note that following the suggestion using an additional let binding fixes the issue:

async fn g<T>(x: T)
where
    T: Clone + Send + 'static,
{
    spawn(async move {
        let x = x.clone();
        f(x).await;
    });
}

What is kinda weird (from my PoV) is the explanation: adding an additional let binding doesn't really shorted the borrowing of x, we're still just calling .clone() and then call f.

You might wonder why someone would clone x here, but let's assume we need x after calling f and I didn't want to make the example more complicated.

The spawn function above was chosen because it is similar to tokio::spawn, for which this issue was observed originally.

I think this might be another instance of #69663 but I'm not sure.

Meta

rustc --version --verbose:

rustc 1.59.0 (9d1b2106e 2022-02-23)
binary: rustc
commit-hash: 9d1b2106e23b1abd32fce1f17267604a5102f57a
commit-date: 2022-02-23
host: x86_64-unknown-linux-gnu
release: 1.59.0
LLVM version: 13.0.0

Bug is also reproducible on nightly.

[fmease]

This now successfully compiles. Closing as fixed.