Function recursive_call

tests/all/async_functions.rs:142–186

()

#[tokio::test]
#[cfg_attr(miri, ignore)]
async fn recursive_call() {
    let mut store = async_store();
    let func_ty = FuncType::new(store.engine(), None, None);
    let async_wasm_func = Func::new_async(&mut store, func_ty, |_caller, _params, _results| {
        Box::new(async {
            tokio::task::yield_now().await;
            Ok(())
        })
    });

    // Create an imported function which recursively invokes another wasm
    // function asynchronously, although this one is just our own host function
    // which suffices for this test.
    let func_ty = FuncType::new(store.engine(), None, None);
    let func2 = Func::new_async(&mut store, func_ty, move |mut caller, _params, _results| {
        Box::new(async move {
            async_wasm_func
                .call_async(&mut caller, &[], &mut [])
                .await?;
            Ok(())
        })
    });

    // Create an instance which calls an async import twice.
    let module = Module::new(
        store.engine(),
        "
            (module
                (import \"\" \"\" (func))
                (func (export \"\")
                    ;; call imported function which recursively does an async
                    ;; call
                    call 0
                    ;; do it again, and our various pointers all better align
                    call 0))
        ",
    )
    .unwrap();

    let instance = Instance::new_async(&mut store, &module, &[func2.into()])
        .await
        .unwrap();
    let func = instance.get_func(&mut store, "").unwrap();
    func.call_async(&mut store, &[], &mut []).await.unwrap();
}

#[tokio::test]
#[cfg_attr(miri, ignore)]