Explain why borrows can't be held across yield point in async blocks/functions

[jyn514]

Consider the following code:

use std::sync::Arc;
use tokio::runtime::Runtime; // 0.3.1

async fn f() {
    let room_ref = Arc::new(Vec::new());

    let gameloop_handle = Runtime::new().unwrap().spawn(async {
        game_loop(Arc::clone(&room_ref))
    });
    gameloop_handle.await;
}

fn game_loop(v: Arc<Vec<usize>>) {}

The error message has a helpful hint:

help: to force the async block to take ownership of `room_ref` (and any other referenced variables), use the `move` keyword
  |
7 |     let gameloop_handle = Runtime::new().unwrap().spawn(async move {
8 |         game_loop(Arc::clone(&room_ref))
9 |     });

But it doesn't explain very well why move is necessary:

error[E0373]: async block may outlive the current function, but it borrows `room_ref`, which is owned by the current function
 --> src/lib.rs:7:63
  |
7 |       let gameloop_handle = Runtime::new().unwrap().spawn(async {
  |  _______________________________________________________________^
8 | |         game_loop(Arc::clone(&room_ref))
  | |                               -------- `room_ref` is borrowed here
9 | |     });
  | |_____^ may outlive borrowed value `room_ref`
  |
note: function requires argument type to outlive `'static`
 --> src/lib.rs:7:57
  |
7 |       let gameloop_handle = Runtime::new().unwrap().spawn(async {
  |  _________________________________________________________^
8 | |         game_loop(Arc::clone(&room_ref))
9 | |     });
  | |_____^

In particular, 'async block may outlive the current function' makes no sense without a very good mental model of async: the future is awaited within the current function, so of course it can't outlive it. The thing to realize here is that even though it's written as one function, it's actually two: one executed before the yield point, and one after, and the stack space for the first function goes away when you call await.

It would be nice to instead say something like

note: borrows cannot be held across a yield point, because the stack space of the current function is not preserved
help: see https://rust-lang.github.io/async-book/03_async_await/01_chapter.html#awaiting-on-a-multithreaded-executor for more information

[jyn514]

cc @estebank

[jyn514]

Hmm, reading that link, it looks like this issue is specific to multi-threaded executors and this would be fine without a 'static bound on spawn? I'm not sure how much help the compiler can be then ...

[SkiFire13]

This isn't specific to async, it also happens with std::thread::spawn requiring the closure to be 'static even if we later call JoinHandle::join in the same function.

[tmandry]

What about something like

note: async blocks are not executed immediately and either must take a reference or ownership of outside variables they use
help: to force ...

We could substitute "closures" in the non-async case as well, if it'd be helpful.

[tmandry]

Happy to help anyone who wants to implement this.

[sledgehammervampire]

Hi, I want to start contributing to Rust. Would this be a good first issue?