Function non_stacky_async_activations

tests/all/async_functions.rs:835–968

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn non_stacky_async_activations() -> Result<()> {
    let engine = Engine::default();
    let mut store1: Store<Option<Pin<Box<dyn Future<Output = Result<()>> + Send>>>> =
        Store::new(&engine, None);
    let mut linker1 = Linker::new(&engine);

    let module1 = Module::new(
        &engine,
        r#"
            (module $m1
                (import "" "host_capture_stack" (func $host_capture_stack))
                (import "" "start_async_instance" (func $start_async_instance))
                (func $capture_stack (export "capture_stack")
                    call $host_capture_stack
                )
                (func $run_sync (export "run_sync")
                    call $start_async_instance
                )
            )
        "#,
    )?;

    let module2 = Module::new(
        &engine,
        r#"
            (module $m2
                (import "" "yield" (func $yield))

                (func $run_async (export "run_async")
                    call $yield
                )
            )
        "#,
    )?;

    let stacks = Arc::new(Mutex::new(vec![]));
    fn capture_stack(stacks: &Arc<Mutex<Vec<WasmBacktrace>>>, store: impl AsContext) {
        let mut stacks = stacks.lock().unwrap();
        stacks.push(wasmtime::WasmBacktrace::force_capture(store));
    }

    linker1.func_wrap_async("", "host_capture_stack", {
        let stacks = stacks.clone();
        move |caller, _: ()| {
            capture_stack(&stacks, &caller);
            Box::new(async { Ok(()) })
        }
    })?;

    linker1.func_wrap_async("", "start_async_instance", {
        let stacks = stacks.clone();
        move |mut caller, _: ()| {
            let stacks = stacks.clone();
            capture_stack(&stacks, &caller);

            let module2 = module2.clone();
            let mut store2 = Store::new(caller.engine(), ());
            let mut linker2 = Linker::<()>::new(caller.engine());