How to pass JS types as params when embedding wasmi

[huntc]

Howdy. I'm attempting to embed wasmi and then call an AssemblyScript-written function. All is well, until I try and pass a more complex structure. Without further ado:

    #[wasm_bindgen]
    #[allow(dead_code)]
    struct SomeStruct {
        afield: i32,
    }
    let add =
        instance.get_typed_func::<(<SomeStruct as IntoWasmAbi>::Abi, i32), i32>(&store, "add")?;

    let some_struct = SomeStruct { afield: 10 };
    let result = add.call(&mut store, (some_struct.into_abi(), 10))?;
    println!("result: {}", result);

On executing call, the following is yielded:

Error: out of bounds memory access

So, I'm clearly doing something wrong, or I've made an assumption that wasm bindgen is passing JS types in exactly the same way as JS in the browser would when calling out to the same file (which works).

Here's the AssemblyScript being called:

class SomeStruct {
  afield!: i32;
}

export function add(a: SomeStruct, b: i32): i32 {
  return a.afield + b;
}

...and here's the JS when calling from the browser:

add({ "afield": 10 }, 2)

Any pointers on how JS types like this can be passed around? Thanks.

[Robbepop]

I am clearly not an expert in this area of use cases or in AssemblyScript but given that you want to use Wasm interprocessing with complex custom types you probably want to take a look into this fork of wit_bindgen by @flavio: https://github.com/bytecodealliance/wit-bindgen

WIT is the format for the interface types Wasm proposal which was made exactly for the purpose of exchanging interface information between different languages, e.g. JS and AssemblyScript via Wasm.

[huntc]

Well, I spent quite a bit of this week learning how to pass complex types around between a WASMI host written in Rust, and a Rust based WASM program using the component model.

I won.

The approach I took:

1. Create a project using wit-bindgen as documented. Quite straightforward, and I ended up declaring two worlds in my wit file - one for exporting by the wasm, and one for importing elsewhere.
2. Create a Rust project for importing the wit.
3. In my Rust/wasmi host, I import the project from (2) and I'm then free to use the wit-bindgen-generated types.
4. Expand the macro generated code from the project (2) and transpose it to my host program for the purposes of modifying it. wit-bindgen isn't ready for use within host programs.
5. Copy structures like strings directly into an instance's memory and pass their offset in that memory as a pointer.

So, given some WIT like this:

package edge-ems:edge-ems

interface load-manager {
  record some-struct {
    afield: s32,
    bfield: s32,
    cfield: string,
  }

  add: func(a: some-struct, b: s32) -> s32
}

world edge-ems {
  export load-manager
}

world edge-ems-host {
  import load-manager
}

... my host code looks like this:

    let Some(memory) = instance.get_memory(&store, "memory") else {
        return Err(Error::CannotLocateWasmMemory.into())
    };

    let add = instance.get_typed_func::<(i32, i32, i32, i32, i32), i32>(
        &store,
        "edge-ems:edge-ems/load-manager#add",
    )?;

    // Set up the call params

    let a = edge_ems::edge_ems::load_manager::SomeStruct {
        afield: 10,
        bfield: 1,
        cfield: "hi".to_string(),
    };
    let b = 5;

    // Make the call by converting to the component model conventions for param passing

    let edge_ems::edge_ems::load_manager::SomeStruct {
        afield: afield0,
        bfield: bfield0,
        cfield: cfield0,
    } = a;
    let vec1 = cfield0;
    let ptr1 = 0i32;
    memory
        .write(&mut store, ptr1 as usize, vec1.as_str().as_bytes())
        .unwrap();
    let len1 = vec1.len() as i32;

    let result = add
        .call(
            &mut store,
            (
                wit_bindgen::rt::as_i32(afield0),
                wit_bindgen::rt::as_i32(bfield0),
                ptr1,
                len1,
                wit_bindgen::rt::as_i32(b),
            ),
        )
        .unwrap();

    // Call completed

    println!("result: {}", result);

There's plenty of opportunity to tidy that up, but hopefully, it demonstrates the approach.

If @flavio's work is merged into wit-bindgen in future then this should all become much simpler of course.

[Robbepop]

Thanks a lot for the write down of how you won this battle! 🚀 Really great attitude there to document for the people to face this issue in the future - and maybe also for your future self. :)

Also I learned quite a bit about wasm-bindgen usage through this write down, so thanks again. :)