feat: add reusable host imports and simplify function calls

- make host definitions reusable across stores with gc-aware import linking
- reorganize function calls, resumable execution, and typed value handling
- expand typed tuples to arity 20 and update parser and store APIs

Signed-off-by: Henry <mail@henrygressmann.de>

Author: explodingcamera

CHANGELOG.md

@@ -17,6 +17,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- `HostFunction` is now a reusable definition, and module instantiation borrows `Imports` so host imports can be shared across stores.
+- Host function callbacks now require `Send + Sync` so the same definition can be used safely with multiple stores.
+- Typed function tuples now support up to 20 parameters or results. `WasmTupleChain` is deprecated. Use untyped functions for larger signatures.
 - Module types now use one dense recursive type space, while function types are resolved through `Function::ty(&Store)`.
 - Globals are stored in separate 32-bit, 64-bit, and 128-bit value lanes, avoiding tagged value conversion during guest execution.
 
@@ -27,7 +30,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Breaking Changes
 
-- Renamed `ModuleInstanceAddr` to `ModuleInstanceId` for consistency.
+- `HostFunction::from` and `HostFunction::from_untyped` no longer take a `Store` and now return reusable `HostFunction` definitions
+- `ModuleInstance::instantiate` and `instantiate_no_start` now borrow `Imports`.
+- `Store::id` now returns `u32` instead of `usize`.
+- `Parser::new` now takes `ParserOptions`, use `Parser::default()` for default settings. `Parser::with_options` was removed.
+- Renamed `ModuleInstanceAddr` to `ModuleInstanceId`.
 - Removed `HostFunction::ty` and `WasmFunction::ty`. Use `Function::ty(&Store)` for runtime function types.
 - Changed `TableType::element_type` and `Element::ty` from `WasmType` to `RefType`, and replaced module `table_types` with `TableDefinition { ty, init }`.
 

Cargo.lock

@@ -177,20 +177,20 @@ impl WastRunner {
             .define("spectest", "global_i64", global_i64)
             .define("spectest", "global_f32", global_f32)
             .define("spectest", "global_f64", global_f64)
-            .define("spectest", "print", HostFunction::from(store, |_ctx: tinywasm::FuncContext, (): ()| Ok(())))
-            .define("spectest", "print_i32", HostFunction::from(store, |_ctx: tinywasm::FuncContext, _arg: i32| Ok(())))
-            .define("spectest", "print_i64", HostFunction::from(store, |_ctx: tinywasm::FuncContext, _arg: i64| Ok(())))
-            .define("spectest", "print_f32", HostFunction::from(store, |_ctx: tinywasm::FuncContext, _arg: f32| Ok(())))
-            .define("spectest", "print_f64", HostFunction::from(store, |_ctx: tinywasm::FuncContext, _arg: f64| Ok(())))
+            .define("spectest", "print", HostFunction::from(|_ctx: tinywasm::FuncContext, (): ()| Ok(())))
+            .define("spectest", "print_i32", HostFunction::from(|_ctx: tinywasm::FuncContext, _arg: i32| Ok(())))
+            .define("spectest", "print_i64", HostFunction::from(|_ctx: tinywasm::FuncContext, _arg: i64| Ok(())))
+            .define("spectest", "print_f32", HostFunction::from(|_ctx: tinywasm::FuncContext, _arg: f32| Ok(())))
+            .define("spectest", "print_f64", HostFunction::from(|_ctx: tinywasm::FuncContext, _arg: f64| Ok(())))
             .define(
                 "spectest",
                 "print_i32_f32",
-                HostFunction::from(store, |_ctx: tinywasm::FuncContext, _args: (i32, f32)| Ok(())),
+                HostFunction::from(|_ctx: tinywasm::FuncContext, _args: (i32, f32)| Ok(())),
             )
             .define(
                 "spectest",
                 "print_f64_f64",
-                HostFunction::from(store, |_ctx: tinywasm::FuncContext, _args: (f64, f64)| Ok(())),
+                HostFunction::from(|_ctx: tinywasm::FuncContext, _args: (f64, f64)| Ok(())),
             );
 
         for (name, module) in modules {
@@ -235,7 +235,7 @@ impl WastRunner {
                         let (name, bytes) = encode_quote_wat(module);
                         let module = parse_module_bytes(&bytes).expect("failed to parse module bytes");
                         let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
-                        let module_instance = ModuleInstance::instantiate(&mut store, &module, Some(imports))
+                        let module_instance = ModuleInstance::instantiate(&mut store, &module, Some(&imports))
                             .expect("failed to instantiate module");
                         (name, module_instance)
                     })
@@ -331,7 +331,7 @@ impl WastRunner {
                                 let module = parse_module_bytes(&wat.encode().expect("failed to encode module"))
                                     .expect("failed to parse module");
                                 let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
-                                ModuleInstance::instantiate(&mut store, &module, Some(imports))?;
+                                ModuleInstance::instantiate(&mut store, &module, Some(&imports))?;
                                 return Ok(());
                             }
                             wast::WastExecute::Get { .. } => panic!("get not supported"),
@@ -376,7 +376,7 @@ impl WastRunner {
                         let module = parse_module_bytes(&module.encode().expect("failed to encode module"))
                             .expect("failed to parse module");
                         let imports = Self::imports(&mut store, module_registry.modules()).unwrap();
-                        ModuleInstance::instantiate(&mut store, &module, Some(imports))
+                        ModuleInstance::instantiate(&mut store, &module, Some(&imports))
                     });
                     match res {
                         Err(err) => test_group.add_result(

crates/cli/src/wast_runner.rs

@@ -16,15 +16,15 @@ use tinywasm_parser::{Parser, ParserOptions};
 
 let bytes = include_bytes!("./file.wasm");
 
-let parser = Parser::new();
+let parser = Parser::default();
 let module = parser.parse_module_bytes(bytes)?;
 
-let parser = Parser::with_options(ParserOptions::default().with_rewrite_optimization(false));
+let parser = Parser::new(ParserOptions::default().with_rewrite_optimization(false));
 let module = parser.parse_module_bytes(bytes)?;
 
 let module = parser.parse_module_file("path/to/file.wasm")?;
 let mut stream = std::fs::File::open("path/to/file.wasm")?;
 let module = parser.parse_module_stream(&mut stream)?;
 ```
 
-If you just want the default configuration, the top-level `parse_bytes`, `parse_file`, and `parse_stream` helpers are thin wrappers around `Parser::new()`.
+If you just want the default configuration, the top-level `parse_bytes`, `parse_file`, and `parse_stream` helpers are thin wrappers around `Parser::default()`.

crates/parser/README.md

@@ -90,6 +90,11 @@ impl Default for ParserOptions {
 }
 
 impl ParserOptions {
+    /// Create parser options with default settings.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     /// Enable or disable WebAssembly validation.
     ///
     /// Requires the `validate` feature to have any effect.
@@ -152,13 +157,8 @@ pub struct Parser {
 }
 
 impl Parser {
-    /// Create a new parser instance
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Create a new parser with explicit options.
-    pub fn with_options(options: ParserOptions) -> Self {
+    /// Create a parser with the given options.
+    pub const fn new(options: ParserOptions) -> Self {
         Self { options }
     }
 
@@ -352,17 +352,17 @@ impl TryFrom<ModuleReader<'_>> for Module {
 
 /// Parse a module from bytes
 pub fn parse_bytes(wasm: &[u8]) -> Result<Module> {
-    Parser::new().parse_module_bytes(wasm)
+    Parser::default().parse_module_bytes(wasm)
 }
 
 #[cfg(feature = "std")]
 /// Parse a module from a file. Requires the `std` feature.
 pub fn parse_file(path: impl AsRef<crate::std::path::Path> + Clone) -> Result<Module> {
-    Parser::new().parse_module_file(path)
+    Parser::default().parse_module_file(path)
 }
 
 #[cfg(feature = "std")]
 /// Parse a module from a stream. Requires the `std` feature.
 pub fn parse_stream(stream: impl crate::std::io::Read) -> Result<Module> {
-    Parser::new().parse_module_stream(stream)
+    Parser::default().parse_module_stream(stream)
 }

crates/parser/src/lib.rs

@@ -6,7 +6,7 @@ use types::Module;
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/argon2id.wasm");
 
 fn argon2id_parse() -> Result<Module> {
-    let parser = tinywasm_parser::Parser::new();
+    let parser = tinywasm_parser::Parser::default();
     let data = parser.parse_module_bytes(WASM)?;
     Ok(data)
 }

crates/tinywasm/benches/argon2id.rs

@@ -6,7 +6,7 @@ use types::Module;
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/fibonacci.wasm");
 
 fn fibonacci_parse() -> Result<Module> {
-    let parser = tinywasm_parser::Parser::new();
+    let parser = tinywasm_parser::Parser::default();
     let data = parser.parse_module_bytes(WASM)?;
     Ok(data)
 }

crates/tinywasm/benches/fibonacci.rs

@@ -1,13 +1,13 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use eyre::Result;
 use tinywasm::engine::Config;
-use tinywasm::{Engine, FuncContext, HostFunction, Imports, MemoryBackend, ModuleInstance, Store, types};
+use tinywasm::{Engine, FuncContext, HostFunction, Imports, ModuleInstance, Store, types};
 use types::Module;
 
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm");
 
 fn tinywasm_parse() -> Result<Module> {
-    let parser = tinywasm_parser::Parser::new();
+    let parser = tinywasm_parser::Parser::default();
     let data = parser.parse_module_bytes(WASM)?;
     Ok(data)
 }
@@ -26,8 +26,8 @@ fn tinywasm_run(module: &Module) -> Result<()> {
     let engine = Engine::new(Config::default());
     let mut store = Store::new(engine);
     let mut imports = Imports::default();
-    imports.define("env", "printi32", HostFunction::from(&mut store, |_: FuncContext<'_>, _: i32| Ok(())));
-    let instance = ModuleInstance::instantiate(&mut store, module, Some(imports)).expect("instantiate");
+    imports.define("env", "printi32", HostFunction::from(|_: FuncContext<'_>, _: i32| Ok(())));
+    let instance = ModuleInstance::instantiate(&mut store, module, Some(&imports)).expect("instantiate");
     let hello = instance.func::<(), ()>(&store, "hello").expect("func_typed");
     hello.call(&mut store, ()).expect("call");
     Ok(())

crates/tinywasm/benches/tinywasm.rs

@@ -10,7 +10,7 @@ const TIME_BUDGET_PER_ROUND: core::time::Duration = core::time::Duration::from_m
 const BENCH_MEASUREMENT_TIME: core::time::Duration = core::time::Duration::from_secs(10);
 
 fn tinywasm_parse() -> Result<Module> {
-    let parser = tinywasm_parser::Parser::new();
+    let parser = tinywasm_parser::Parser::default();
     Ok(parser.parse_module_bytes(WASM)?)
 }
 
@@ -21,9 +21,9 @@ fn setup_typed_func(module: &Module, engine: Option<Engine>) -> Result<(Store, F
     };
 
     let mut imports = Imports::default();
-    imports.define("env", "printi32", HostFunction::from(&mut store, |_: FuncContext<'_>, _: i32| Ok(())));
+    imports.define("env", "printi32", HostFunction::from(|_: FuncContext<'_>, _: i32| Ok(())));
 
-    let instance = ModuleInstance::instantiate(&mut store, module, Some(imports))?;
+    let instance = ModuleInstance::instantiate(&mut store, module, Some(&imports))?;
     let func = instance.func::<(), ()>(&store, "hello")?;
     Ok((store, func))
 }