Poor error message when spawning a future returned by an async fn that takes an owned value as reference

[LukeMathWalker]

Let's consider this snippet:

async fn test(a: &str) {
    println!("{}", a)
}

#[tokio::main]
async fn main() {
    let owned = "Hello!".to_string();
    tokio::spawn(test(&owned));
}

If we try to compile it, we'll get the following error:

error[E0597]: `owned` does not live long enough
 --> src/main.rs:8:23
  |
8 |     tokio::spawn(test(&owned));
  |                  -----^^^^^^-
  |                  |    |
  |                  |    borrowed value does not live long enough
  |                  argument requires that `owned` is borrowed for `'static`
9 | }
  | - `owned` dropped here while still borrowed

error: aborting due to previous error

For more information about this error, try `rustc --explain E0597`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

The intent here is quite clear: I have ownership of owned, I want to pass it to test and then call tokio::spawn on the resulting future. The error message, though, does not point the user in the right direction.
The issue is indeed about lifetimes, but owned is never used again - therefore it'd make sense for the compiler to push the user into creating an async block that takes ownership of owned and gives back a 'static future. E.g.

async fn test(a: &str) {
    println!("{}", a)
}

#[tokio::main]
async fn main() {
    let owned = "Hello!".to_string();
    let fut = async move {
        test(&owned).await;
    };
    tokio::spawn(fut);
}

[sgrif]

I would also like to add that if the value was not 'static to begin with, the compiler should additionally suggest to_owned. For example:

async fn test(a: &str) {}

fn test2(a: &str) {
    tokio::spawn(async move {
        test(a).await
    });
}

fn main() {
    let owned = "Hello!".to_string();
    test2(&owned);
}

Even if the compiler suggested async move, the diagnostic would recommend requiring 'static on a, which would ultimately lead to the same error in main if followed. The code should recommend calling .to_owned() or similar on a. The code the user would want to write is:

async fn test(a: &str) {}

fn test2(a: &str) {
    let a = a.to_owned();
    tokio::spawn(async move {
        test(&a).await
    });
}

#[tokio::main]
async fn main() {
    let owned = "Hello!".to_string();
    test2(&owned);
}

[osa1]

Repro without dependencies:

use std::future::Future;

async fn test(a: &str) {}

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

async fn main_async() {
    let owned = "Hello!".to_string();
    spawn(test(&owned));
}

fn main() {}

[traviscross]

@rustbot labels +AsyncAwait-Triaged

We reviewed this today in WG-async triage.

The fact that it gives an error is correct here, but the diagnostic could definitely be improved.