chore: simplify ToWasmTypes traits, general cleanup

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

Author: explodingcamera

CHANGELOG.md

@@ -44,6 +44,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `Parser::new` now takes `ParserOptions`. Use `Parser::default()` for default settings. `Parser::with_options` was removed.
 - Pluggable memory backends and `Config::with_trap_on_oom` were removed for performance reasons. Linear memory is always `Vec`-backed. Use `ResourceLimiter` to allow, reject, or trap memory allocation and growth requests.
 - `WasmTupleChain` was removed. Use direct tuples up to arity 20 or untyped functions for larger signatures.
+- `ToWasmTypes` was renamed to `WasmTypes`, and `ToWasmType` was renamed to `WasmValueType`. Conversion traits now include `WasmTypes`, and `FromWasmValues::from_wasm_values` rejects unconsumed values directly.
 - The `.twasm` format changed. Regenerate archives created by earlier TinyWasm versions.
 
 ## [0.10.0] - 2026-07-24

Cargo.lock

@@ -31,9 +31,9 @@ pretty_env_logger = "0.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 wasm-testsuite = { version = "0.7" }
-wasmparser = { version = "0.257", default-features = false }
-wast = "257"
-wat = "1.257"
+wasmparser = { version = "0.258", default-features = false }
+wast = "258"
+wat = "1.258"
 
 criterion = { version = "0.8", default-features = false, features = ["cargo_bench_support", "rayon"] }
 

Cargo.toml

@@ -9,7 +9,8 @@ use anyhow::{Context, Result, anyhow, bail};
 use log::{debug, error};
 use tinywasm::types::{MemoryType, RefType, RefValue, TableType, WasmType, WasmValue};
 use tinywasm::{ExecProgress, Global, HostFunction, Imports, Memory, Module, ModuleInstance, Store, Table};
-use wast::{QuoteWat, core::AbstractHeapType};
+use wast::QuoteWat;
+use wast::core::{AbstractHeapType, NanPattern};
 
 const TEST_TIME_SLICE: Duration = Duration::from_millis(20);
 const TEST_MAX_SUSPENSIONS: u32 = 1000;
@@ -18,6 +19,15 @@ const ACCEPTED_MALFORMED_MESSAGES: &[&str] =
     &["integer representation too long", "zero byte expected", "zero flag expected"];
 const ACCEPTED_INVALID_MESSAGES: &[&str] = &["multiple memories"];
 
+macro_rules! float_value {
+    ($pattern:expr, $float:ty, $variant:ident) => {
+        match $pattern {
+            NanPattern::CanonicalNan | NanPattern::ArithmeticNan => WasmValue::$variant(<$float>::NAN),
+            NanPattern::Value(value) => WasmValue::$variant(<$float>::from_bits(value.bits)),
+        }
+    };
+}
+
 #[derive(Default)]
 struct ModuleRegistry {
     definitions: HashMap<String, Module>,
@@ -845,10 +855,10 @@ fn wastarg2tinywasmvalue(store: &mut Store, arg: wast::WastArg) -> Result<WasmVa
 fn wast_v128_to_bytes(i: wast::core::V128Pattern) -> [u8; 16] {
     let res: Vec<u8> = match i {
         wast::core::V128Pattern::F32x4(f) => {
-            f.iter().flat_map(|v| nanpattern2tinywasmvalue(*v).unwrap().as_f32().unwrap().to_le_bytes()).collect()
+            f.iter().flat_map(|v| float_value!(*v, f32, F32).as_f32().unwrap().to_le_bytes()).collect()
         }
         wast::core::V128Pattern::F64x2(f) => {
-            f.iter().flat_map(|v| nanpattern2tinywasmvalue(*v).unwrap().as_f64().unwrap().to_le_bytes()).collect()
+            f.iter().flat_map(|v| float_value!(*v, f64, F64).as_f64().unwrap().to_le_bytes()).collect()
         }
         wast::core::V128Pattern::I16x8(f) => f.iter().flat_map(|v| v.to_le_bytes()).collect(),
         wast::core::V128Pattern::I32x4(f) => f.iter().flat_map(|v| v.to_le_bytes()).collect(),
@@ -920,8 +930,8 @@ fn wastretcore2tinywasmvalue(ret: wast::core::WastRetCore) -> Result<ExpectedVal
         RefStruct, V128,
     };
     Ok(match ret {
-        F32(f) => ExpectedValue::Exact(nanpattern2tinywasmvalue(f)?),
-        F64(f) => ExpectedValue::Exact(nanpattern2tinywasmvalue(f)?),
+        F32(f) => ExpectedValue::Exact(float_value!(f, f32, F32)),
+        F64(f) => ExpectedValue::Exact(float_value!(f, f64, F64)),
         I32(i) => ExpectedValue::Exact(WasmValue::I32(i)),
         I64(i) => ExpectedValue::Exact(WasmValue::I64(i)),
         V128(i) => ExpectedValue::Exact(WasmValue::V128(wast_v128_to_bytes(i))),
@@ -945,63 +955,6 @@ fn wastretcore2tinywasmvalue(ret: wast::core::WastRetCore) -> Result<ExpectedVal
     })
 }
 
-enum Bits {
-    U32(u32),
-    U64(u64),
-}
-
-trait FloatToken {
-    fn bits(&self) -> Bits;
-    fn canonical_nan() -> WasmValue;
-    fn arithmetic_nan() -> WasmValue;
-    fn value(&self) -> WasmValue {
-        match self.bits() {
-            Bits::U32(v) => WasmValue::F32(f32::from_bits(v)),
-            Bits::U64(v) => WasmValue::F64(f64::from_bits(v)),
-        }
-    }
-}
-
-impl FloatToken for wast::token::F32 {
-    fn bits(&self) -> Bits {
-        Bits::U32(self.bits)
-    }
-
-    fn canonical_nan() -> WasmValue {
-        WasmValue::F32(f32::NAN)
-    }
-
-    fn arithmetic_nan() -> WasmValue {
-        WasmValue::F32(f32::NAN)
-    }
-}
-
-impl FloatToken for wast::token::F64 {
-    fn bits(&self) -> Bits {
-        Bits::U64(self.bits)
-    }
-
-    fn canonical_nan() -> WasmValue {
-        WasmValue::F64(f64::NAN)
-    }
-
-    fn arithmetic_nan() -> WasmValue {
-        WasmValue::F64(f64::NAN)
-    }
-}
-
-fn nanpattern2tinywasmvalue<T>(arg: wast::core::NanPattern<T>) -> Result<WasmValue>
-where
-    T: FloatToken,
-{
-    use wast::core::NanPattern::{ArithmeticNan, CanonicalNan, Value};
-    Ok(match arg {
-        CanonicalNan => T::canonical_nan(),
-        ArithmeticNan => T::arithmetic_nan(),
-        Value(v) => v.value(),
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/cli/src/wast_runner.rs

@@ -51,16 +51,16 @@ pub enum FuelPolicy {
 }
 
 /// Default size for the 32-bit value stack (i32, f32, ref values).
-pub const DEFAULT_VALUE_STACK_32_SIZE: usize = 36 * 1024; // 36k slots
+const DEFAULT_VALUE_STACK_32_SIZE: usize = 36 * 1024; // 36k slots
 
 /// Default size for the 64-bit value stack (i64, f64 values).
-pub const DEFAULT_VALUE_STACK_64_SIZE: usize = 32 * 1024; // 32k slots
+const DEFAULT_VALUE_STACK_64_SIZE: usize = 32 * 1024; // 32k slots
 
 /// Default size for the 128-bit value stack (v128 values).
-pub const DEFAULT_VALUE_STACK_128_SIZE: usize = 4 * 1024; // 4k slots
+const DEFAULT_VALUE_STACK_128_SIZE: usize = 4 * 1024; // 4k slots
 
 /// Default maximum size for the call stack (function frames).
-pub const DEFAULT_MAX_CALL_STACK_SIZE: usize = 1024; // 1024 frames
+const DEFAULT_MAX_CALL_STACK_SIZE: usize = 1024; // 1024 frames
 
 /// Stack allocation policy.
 #[derive(Clone, Copy, PartialEq, Eq)]

crates/tinywasm/src/engine.rs

@@ -21,12 +21,11 @@ impl FuncContext<'_> {
     }
 
     /// Get the module instance.
-    pub fn module(&self) -> crate::ModuleInstance {
+    pub fn module(&self) -> &crate::ModuleInstance {
         unwrap_or_unreachable!(
             self.store.get_module_instance(self.module_id),
             "invalid module instance id in host function context"
         )
-        .clone()
     }
 
     /// Get a memory export.
@@ -46,7 +45,7 @@ impl FuncContext<'_> {
 
     /// Get the value of a global export.
     pub fn global_get(&mut self, name: &str) -> Result<WasmValue> {
-        self.module().global_get(self.store, name)
+        self.module().clone().global_get(self.store, name)
     }
 
     /// Get a global export.
@@ -56,7 +55,7 @@ impl FuncContext<'_> {
 
     /// Set the value of a mutable global export.
     pub fn global_set(&mut self, name: &str, value: WasmValue) -> Result<()> {
-        self.module().global_set(self.store, name, value)
+        self.module().clone().global_set(self.store, name, value)
     }
 
     /// Charge additional fuel from the currently running resumable invocation.
@@ -98,11 +97,11 @@ impl FuncContext<'_> {
 
     /// Calls a Store-aware function reference in the current module context.
     pub fn call_ref(&mut self, func: FuncRef, args: &[WasmValue], results: &mut [WasmValue]) -> Result<()> {
-        let addr = func.addr(self.store.store_id()).ok_or(crate::Trap::InvalidStore)?;
+        let addr = func.addr(self.store.id()).ok_or(crate::Trap::InvalidStore)?;
         if self.store.state.funcs.get(addr as usize).is_none() {
             return Err(crate::Trap::InvalidReference.into());
         }
-        let function = Function { item: crate::StoreItem::new(self.store.store_id(), addr), module_id: self.module_id };
+        let function = Function { item: crate::StoreItem::new(self.store.id(), addr), module_id: self.module_id };
         self.call_untyped(&function, args, results)
     }
 
@@ -132,7 +131,7 @@ impl FuncContext<'_> {
                 let value_stack_base = store.value_stack.base();
                 func.func.call_untyped(store, params, results, call_stack_base, value_stack_base)?;
                 values.drain(..param_count);
-                R::from_wasm_values_exact(&mut values.drain(..))
+                R::from_wasm_values(&mut values.drain(..))
             })
         } else {
             let call_stack_base = self.store.call_stack.len();

crates/tinywasm/src/func/context.rs

@@ -1,7 +1,7 @@
 use alloc::{boxed::Box, vec::Vec};
 use tinywasm_types::{FuncType, ModuleInstanceId, TypeAddr, WasmType};
 
-use super::{FromWasmValues, FuncContext, IntoWasmValues, ToWasmTypes};
+use super::{FromWasmValues, FuncContext, IntoWasmValues};
 use crate::shared::StoreShared;
 use crate::store::FuncValueTypes;
 use crate::{Function, FunctionInstance, Result, Store, WasmValue};
@@ -33,7 +33,7 @@ impl HostFunction {
     pub(crate) fn instantiate_registered(&self, store: &mut Store, type_addr: TypeAddr) -> Function {
         let addr = store
             .add_func(FunctionInstance { type_addr, inner: crate::store::FunctionInstanceInner::Host(self.clone()) });
-        Function { item: crate::StoreItem::new(store.store_id(), addr), module_id: 0 }
+        Function { item: crate::StoreItem::new(store.id(), addr), module_id: 0 }
     }
 
     /// Resolves the importing module's types without allocating a function instance.
@@ -213,10 +213,10 @@ impl HostFunction {
     pub fn from<F, P, R>(func: F) -> Self
     where
         F: Fn(FuncContext<'_>, P) -> Result<R> + HostFunctionCallback + 'static,
-        P: FromWasmValues + ToWasmTypes + 'static,
-        R: IntoWasmValues + ToWasmTypes + 'static,
+        P: FromWasmValues + 'static,
+        R: IntoWasmValues + 'static,
     {
-        let ty = FuncType::new(&P::wasm_types(), &R::wasm_types());
+        let ty = FuncType::new(P::WASM_TYPES, R::WASM_TYPES);
         let func = TypedHostCallbackImpl { func, marker: core::marker::PhantomData };
         Self(StoreShared::new(HostFunctionInner { ty, callback: HostCallback::Typed(Box::new(func)) }))
     }
@@ -261,7 +261,7 @@ where
 {
     fn call(&self, ctx: FuncContext<'_>, args: &[WasmValue], results: &mut [WasmValue]) -> Result<()> {
         let mut values = args.iter().cloned();
-        let params = cold_err!(P::from_wasm_values_exact(&mut values))?;
+        let params = cold_err!(P::from_wasm_values(&mut values))?;
         let mut values = (self.func)(ctx, params)?.into_wasm_values();
         for result in results {
             *result = cold_err!(values.next().ok_or_else(|| crate::Error::other("not enough typed function results")))?;
@@ -279,7 +279,7 @@ where
         };
         let params = {
             let mut values = store.stack_value_iter(type_addr, FuncValueTypes::Params, base)?;
-            cold_err!(P::from_wasm_values_exact(&mut values))
+            cold_err!(P::from_wasm_values(&mut values))
         };
         store.value_stack.truncate_to_base(base);
         let result = cold_err!((self.func)(FuncContext { store, module_id }, params?))?;

crates/tinywasm/src/func/host.rs

@@ -16,7 +16,7 @@ pub use host::HostFunction;
 #[doc(hidden)]
 pub use host::HostFunctionCallback;
 pub use resume::{ExecProgress, FuncExecution, FuncExecutionTyped};
-pub use values::{FromWasmValues, IntoWasmValues, ToWasmType, ToWasmTypes};
+pub use values::{FromWasmValues, IntoWasmValues, WasmTypes, WasmValueType};
 
 fn write_typed_params(params: &mut [WasmValue], mut values: impl Iterator<Item = WasmValue>) -> Result<()> {
     for param in params {
@@ -42,7 +42,7 @@ impl Function {
     /// Returns this function as a Store-aware WebAssembly function reference.
     pub fn as_func_ref(&self, store: &Store) -> Result<FuncRef> {
         self.item.validate_store(store)?;
-        Ok(FuncRef::new(store.store_id(), self.addr()))
+        Ok(FuncRef::new(store.id(), self.addr()))
     }
 
     #[inline]
@@ -219,7 +219,7 @@ impl<P: IntoWasmValues, R: FromWasmValues> FunctionTyped<P, R> {
                 let (params, results) = values.split_at_mut(param_count);
                 self.func.call(store, params, results)?;
                 values.drain(..param_count);
-                R::from_wasm_values_exact(&mut values.drain(..))
+                R::from_wasm_values(&mut values.drain(..))
             })
         } else {
             store.enter_execution()?;