Function calls_with_funcref_and_externref

tests/all/func.rs:1561–1676

(config: &mut Config)

#[wasmtime_test(wasm_features(reference_types, gc_types))]
#[cfg_attr(miri, ignore)]
fn calls_with_funcref_and_externref(config: &mut Config) -> wasmtime::Result<()> {
    let engine = Engine::new(&config)?;
    let mut store = Store::<()>::new(&engine, ());
    let module = Module::new(
        store.engine(),
        r#"
            (module
                (import "" "witness" (func $witness (param funcref externref)))
                (func (export "f") (param funcref externref) (result externref funcref)
                    local.get 0
                    local.get 1
                    call $witness
                    local.get 1
                    local.get 0
                )
            )

        "#,
    )?;
    let mut linker = Linker::new(store.engine());
    linker.func_wrap(
        "",
        "witness",
        |mut caller: Caller<'_, ()>, func: Option<Func>, externref: Option<Rooted<ExternRef>>| {
            if func.is_some() {
                assert_my_funcref(&mut caller, func.as_ref())?;
            }
            if externref.is_some() {
                assert_my_externref(&caller, externref);
            }
            Ok(())
        },
    )?;
    let instance = linker.instantiate(&mut store, &module)?;

    let typed = instance
        .get_typed_func::<(Option<Func>, Option<Rooted<ExternRef>>), (Option<Rooted<ExternRef>>, Option<Func>)>(
            &mut store, "f",
        )?;
    let untyped = typed.func();

    let my_funcref = Func::wrap(&mut store, || 100u32);
    let my_externref = ExternRef::new(&mut store, 99u32)?;
    let mut results = [Val::I32(0), Val::I32(0)];

    fn assert_my_funcref(mut store: impl AsContextMut, func: Option<&Func>) -> Result<()> {
        let mut store = store.as_context_mut();
        let func = func.unwrap();
        assert_eq!(func.typed::<(), u32>(&store)?.call(&mut store, ())?, 100);
        Ok(())
    }
    fn assert_my_externref(store: impl AsContext, externref: Option<Rooted<ExternRef>>) {
        assert_eq!(
            externref
                .unwrap()
                .data(&store)
                .unwrap()
                .unwrap()