Function suspend_while_suspending

tests/all/async_functions.rs:190–248

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn suspend_while_suspending() {
    let mut store = async_store();

    // Create a synchronous function which calls our asynchronous function and
    // runs it locally. This shouldn't generally happen but we know everything
    // is synchronous in this test so it's fine for us to do this.
    //
    // The purpose of this test is intended to stress various cases in how
    // we manage pointers in ways that are not necessarily common but are still
    // possible in safe code.
    let func_ty = FuncType::new(store.engine(), None, None);
    let async_thunk = Func::new_async(&mut store, func_ty, |_caller, _params, _results| {
        Box::new(async { Ok(()) })
    });
    let func_ty = FuncType::new(store.engine(), None, None);
    let sync_call_async_thunk =
        Func::new(&mut store, func_ty, move |mut caller, _params, _results| {
            let mut future = Box::pin(async_thunk.call_async(&mut caller, &[], &mut []));
            let poll = future
                .as_mut()
                .poll(&mut Context::from_waker(Waker::noop()));
            assert!(poll.is_ready());
            Ok(())
        });

    // A small async function that simply awaits once to pump the loops and
    // then finishes.
    let func_ty = FuncType::new(store.engine(), None, None);
    let async_import = Func::new_async(&mut store, func_ty, move |_caller, _params, _results| {
        Box::new(async move {
            tokio::task::yield_now().await;
            Ok(())
        })
    });

    let module = Module::new(
        store.engine(),
        "
            (module
                (import \"\" \"\" (func $sync_call_async_thunk))
                (import \"\" \"\" (func $async_import))
                (func (export \"\")
                    ;; Set some store-local state and pointers
                    call $sync_call_async_thunk
                    ;; .. and hopefully it's all still configured correctly
                    call $async_import))
        ",
    )
    .unwrap();
    let instance = Instance::new_async(
        &mut store,
        &module,
        &[sync_call_async_thunk.into(), async_import.into()],
    )
    .await
    .unwrap();
    let func = instance.get_func(&mut store, "").unwrap();
    func.call_async(&mut store, &[], &mut []).await.unwrap();