`ScopedCoroutine` is unsound

[zetanumbers]

use std::{mem::forget, sync::mpsc};

use corosensei::ScopedCoroutine;

fn main() {
    let mut s = "Happy".to_owned();
    let (tx1, rx1) = mpsc::sync_channel(1);
    let (tx2, rx2) = mpsc::sync_channel(1);
    {
        let s = s.as_str();
        let mut coroutine = Box::pin(ScopedCoroutine::new(|yielder, ()| {
            std::thread::scope(move |scope| {
                let _thrd = scope.spawn(move || {
                    rx1.recv().unwrap();
                    tx2.send(s.to_owned()).unwrap();
                });
                let () = yielder.suspend(());
            });
        }));
        coroutine.as_mut().resume(());
        forget(coroutine);
    }
    s.clear();
    s.push_str("Sad");
    tx1.send(()).unwrap();
    let data_race_s = rx2.recv().unwrap();
    dbg!(&s, &data_race_s);
}

Prints out:

[src/main.rs:27:5] &s = "Sad"
[src/main.rs:27:5] &data_race_s = "Sadpy"

[zetanumbers]

In other words issue #27 was reintroduced in #58

It's rewind time

[zetanumbers]

Let me give you an advice about borrowing coroutines:

First, you can relax closure's F: 'static and Return: 'static requirements by using std::thread::scope-like API. It's simple.

Second, you can kinda relax Input: 'static and Yield: 'static, but then those types have to be borrowed with some methods like:

• for ScopedCoroutine::resume<'a>(&'a mut self, &'a mut Input)
  you get Yielder::borrow_input<'a>(&'a mut self) -> &'a mut Input and
• for Yielder::suspend<'a>(&'a mut self, &'a mut Yield)
  you get ScopedCoroutine::borrow_yield<'a>(&'a mut self) -> &'a mut Yield respectively.

But that would only be enough to only pass mutable borrows of those types and would still require 'static. Generally you have to parametrize those types' lifetimes to match &mut self, aka Input<'a> and Yield<'a>. This is exactly the problem yoke::Yokeable have partially solved, so you would have to use that trait to design new API.

You can also toy around with my scope-lock library, and see what's possible, which is how I think of it from time to time.

[Amanieu]

I think #60 is sound, but I would like you to double-check. The combination of Pin and scope ensures that it is impossible to "forget" a ScopedCoroutine which I think makes lifetimes on F, Return and Stack sound. I also think lifetimes on Input and Yield are now also sound, but I'm less sure.