Queue::exec_async can be mis-used with just safe code

[jesdazrez]

If the closure passed to exec_async contains a reference, it might be executed even if the referenced value is gone / has changed. It's also possible to end up with +1 &mut T.

Wonder if there's something that could be done, like a 'static bound or something similar?

Example:

use core_foundation::runloop::CFRunLoopRun;
use dispatch2::Queue;
use std::thread;

struct X {
    y: u8,
}

impl Drop for X {
    fn drop(&mut self) {
        println!("dropping X {{ {} }}", self.y);
    }
}

fn mutate(x: &mut X) {
    let th = thread::current();
    let th = th.name();
    println!("mutating x ({}) from {th:?}", x.y);
    x.y += 1;
    println!(
        "x mutated (to ({})) from {th:?}, releasing exclusive access",
        x.y
    );
}

fn main() {
    thread::spawn(|| {
        let mut x = X { y: 1 };
        let queue = Queue::main();
        queue.exec_async(|| {
            mutate(&mut x);
        });
        mutate(&mut x);
    });
    unsafe { CFRunLoopRun() };
}

Output example (it might segfault instead):

[madsmtm]

Indeed, we need a + 'static bound on the closure.

(I haven't really gotten around to fully reviewing dispatch2 (tracked in #77), so that's why this issue exists)

[jesdazrez]

thanks for the quick answer!, let me know if you want some help with a PR

[madsmtm]

I'm somewhat busy with finishing a long overdue release, so a PR would be nice.