chore: cleanup

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

Author: explodingcamera

crates/parser/README.md

@@ -1,7 +1,6 @@
 # `tinywasm-parser`
 
-This crate provides a parser that can parse WebAssembly modules into a TinyWasm module.
-It uses [my fork](https://crates.io/crates/tinywasm-wasmparser) of the [`wasmparser`](https://crates.io/crates/wasmparser) crate that has been modified to be compatible with `no_std` environments.
+This crate provides a compiler that can convert WebAssembly modules into a `tinywasm` modules.
 
 ## Features
 
@@ -16,6 +15,6 @@ let bytes = include_bytes!("./file.wasm");
 
 let parser = Parser::new();
 let module = parser.parse_module_bytes(bytes).unwrap();
-let mudule = parser.parse_module_file("path/to/file.wasm").unwrap();
+let module = parser.parse_module_file("path/to/file.wasm").unwrap();
 let module = parser.parse_module_stream(&mut stream).unwrap();
 ```

crates/parser/src/conversion.rs

@@ -28,7 +28,7 @@ pub(crate) fn convert_module_element(element: wasmparser::Element<'_>) -> Result
                 .collect::<Result<Vec<_>>>()?
                 .into_boxed_slice();
 
-            Ok(tinywasm_types::Element { kind, items, ty: ValType::RefFunc, range: element.range })
+            Ok(tinywasm_types::Element { kind, items, ty: WasmType::RefFunc, range: element.range })
         }
 
         wasmparser::ElementItems::Expressions(ty, exprs) => {
@@ -211,26 +211,26 @@ pub(crate) fn convert_module_type(ty: wasmparser::RecGroup) -> Result<FuncType>
     }
 
     let ty = types.next().unwrap().unwrap_func();
-    let params = ty.params().iter().map(convert_valtype).collect::<Vec<ValType>>().into_boxed_slice();
-    let results = ty.results().iter().map(convert_valtype).collect::<Vec<ValType>>().into_boxed_slice();
-    Ok(FuncType { params, results })
+    let params: Vec<_> = ty.params().iter().map(convert_valtype).collect();
+    let results: Vec<_> = ty.results().iter().map(convert_valtype).collect();
+    Ok(FuncType::new(&params, &results))
 }
 
-pub(crate) fn convert_reftype(reftype: wasmparser::RefType) -> ValType {
+pub(crate) fn convert_reftype(reftype: wasmparser::RefType) -> WasmType {
     match reftype {
-        _ if reftype.is_func_ref() => ValType::RefFunc,
-        _ if reftype.is_extern_ref() => ValType::RefExtern,
+        _ if reftype.is_func_ref() => WasmType::RefFunc,
+        _ if reftype.is_extern_ref() => WasmType::RefExtern,
         _ => unimplemented!("Unsupported reference type: {:?}, {:?}", reftype, reftype.heap_type()),
     }
 }
 
-pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> ValType {
+pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> WasmType {
     match valtype {
-        wasmparser::ValType::I32 => ValType::I32,
-        wasmparser::ValType::I64 => ValType::I64,
-        wasmparser::ValType::F32 => ValType::F32,
-        wasmparser::ValType::F64 => ValType::F64,
-        wasmparser::ValType::V128 => ValType::V128,
+        wasmparser::ValType::I32 => WasmType::I32,
+        wasmparser::ValType::I64 => WasmType::I64,
+        wasmparser::ValType::F32 => WasmType::F32,
+        wasmparser::ValType::F64 => WasmType::F64,
+        wasmparser::ValType::V128 => WasmType::V128,
         wasmparser::ValType::Ref(r) => convert_reftype(*r),
     }
 }
@@ -247,8 +247,8 @@ pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<Box<[C
     for op in ops.iter().take(ops.len() - 1) {
         let instr = match op {
             wasmparser::Operator::RefNull { hty } => match convert_heaptype(*hty) {
-                ValType::RefFunc => ConstInstruction::RefFunc(None),
-                ValType::RefExtern => ConstInstruction::RefExtern(None),
+                WasmType::RefFunc => ConstInstruction::RefFunc(None),
+                WasmType::RefExtern => ConstInstruction::RefExtern(None),
                 _ => unimplemented!("Unsupported heap type: {:?}", hty),
             },
             wasmparser::Operator::RefFunc { function_index } => ConstInstruction::RefFunc(Some(*function_index)),
@@ -276,11 +276,11 @@ pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<Box<[C
     Ok(out.into_boxed_slice())
 }
 
-pub(crate) fn convert_heaptype(heap: wasmparser::HeapType) -> ValType {
+pub(crate) fn convert_heaptype(heap: wasmparser::HeapType) -> WasmType {
     match heap {
-        wasmparser::HeapType::Abstract { shared: false, ty: wasmparser::AbstractHeapType::Func } => ValType::RefFunc,
+        wasmparser::HeapType::Abstract { shared: false, ty: wasmparser::AbstractHeapType::Func } => WasmType::RefFunc,
         wasmparser::HeapType::Abstract { shared: false, ty: wasmparser::AbstractHeapType::Extern } => {
-            ValType::RefExtern
+            WasmType::RefExtern
         }
         _ => unimplemented!("Unsupported heap type: {:?}", heap),
     }

crates/parser/src/module.rs

@@ -181,7 +181,7 @@ impl ModuleReader {
         let funcs = self.code.into_iter().zip(self.code_type_addrs).enumerate().map(
             |(func_idx, ((instructions, mut data, locals), ty_idx))| {
                 let ty = self.func_types.get(ty_idx as usize).expect("No func type for func, this is a bug").clone();
-                let params = ValueCounts::from_iter(&ty.params);
+                let params = ValueCounts::from_iter(ty.params());
                 let self_func = (imported_func_count + func_idx) as u32;
                 let instructions = optimize::optimize_instructions(instructions, &mut data, self_func, options);
                 WasmFunction { instructions: ArcSlice::from(instructions), data, locals, params, ty }

crates/tinywasm/src/func.rs

@@ -3,7 +3,7 @@ use crate::reference::StoreItem;
 use crate::{Error, FunctionInstance, InterpreterRuntime, Result, Store, unlikely};
 use alloc::rc::Rc;
 use alloc::{boxed::Box, format, string::ToString, vec, vec::Vec};
-use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ValType, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, WasmType, WasmValue};
 
 impl Function {
     /// Call a function (Invocation)
@@ -132,12 +132,12 @@ impl HostFunction {
             let ty = ty_inner.clone();
             let result = func(ctx, args)?;
 
-            if result.len() != ty.results.len() {
+            if result.len() != ty.results().len() {
                 return Err(crate::Error::InvalidHostFnReturn { expected: ty.clone(), actual: result });
             };
 
-            result.iter().zip(ty.results.iter()).try_for_each(|(val, res_ty)| {
-                if val.val_type() != *res_ty {
+            result.iter().zip(ty.results().iter()).try_for_each(|(val, res_ty)| {
+                if WasmType::from(val) != *res_ty {
                     return Err(crate::Error::InvalidHostFnReturn { expected: ty.clone(), actual: result.clone() });
                 }
                 Ok(())
@@ -153,17 +153,16 @@ impl HostFunction {
     /// Create a new typed host function import.
     pub fn from<P, R>(store: &mut Store, func: impl Fn(FuncContext<'_>, P) -> Result<R> + 'static) -> Function
     where
-        P: FromWasmValueTuple + ValTypesFromTuple,
-        R: IntoWasmValueTuple + ValTypesFromTuple,
+        P: FromWasmValueTuple + WasmTypesFromTuple,
+        R: IntoWasmValueTuple + WasmTypesFromTuple,
     {
         let inner_func = move |ctx: FuncContext<'_>, args: &[WasmValue]| -> Result<Vec<WasmValue>> {
             let args = P::from_wasm_value_tuple(args)?;
             let result = func(ctx, args)?;
             Ok(result.into_wasm_value_tuple())
         };
 
-        let results = R::val_types();
-        let ty = tinywasm_types::FuncType { params: P::val_types(), results };
+        let ty = tinywasm_types::FuncType::new(&P::wasm_types(), &R::wasm_types());
         let addr = store.add_func(FunctionInstance::Host(Rc::new(Self { func: Box::new(inner_func), ty: ty.clone() })));
         Function { item: crate::StoreItem::new(store.id(), addr), module_addr: 0, addr, ty }
     }
@@ -363,24 +362,24 @@ impl<'store> FuncExecution<'store> {
 }
 
 fn validate_call_params(func_ty: &FuncType, params: &[WasmValue]) -> Result<()> {
-    if unlikely(func_ty.params.len() != params.len()) {
+    if unlikely(func_ty.params().len() != params.len()) {
         return Err(Error::Other(format!(
             "param count mismatch: expected {}, got {}",
-            func_ty.params.len(),
+            func_ty.params().len(),
             params.len()
         )));
     }
 
-    if !(func_ty.params.iter().zip(params).all(|(ty, param)| ty == &param.val_type())) {
+    if !(func_ty.params().iter().zip(params).all(|(ty, param)| ty == &param.into())) {
         return Err(Error::Other("Type mismatch".into()));
     }
 
     Ok(())
 }
 
 fn collect_call_results(store: &mut Store, func_ty: &FuncType) -> Result<Vec<WasmValue>> {
-    debug_assert!(store.stack.values.len() >= func_ty.results.len()); // m values are on the top of the stack (Ensured by validation)
-    let mut res: Vec<_> = store.stack.values.pop_types(func_ty.results.iter().rev()).collect(); // pop in reverse order since the stack is LIFO
+    debug_assert!(store.stack.values.len() >= func_ty.results().len()); // m values are on the top of the stack (Ensured by validation)
+    let mut res: Vec<_> = store.stack.values.pop_types(func_ty.results().iter().rev()).collect(); // pop in reverse order since the stack is LIFO
     res.reverse(); // reverse to get the original order
     Ok(res)
 }
@@ -443,28 +442,28 @@ impl<'store, R: FromWasmValueTuple> FuncExecutionTyped<'store, R> {
     }
 }
 
-pub trait ValTypesFromTuple {
-    fn val_types() -> Box<[ValType]>;
+pub trait WasmTypesFromTuple {
+    fn wasm_types() -> Box<[WasmType]>;
 }
 
-pub trait ToValType {
-    fn to_val_type() -> ValType;
+pub trait ToWasmType {
+    fn to_wasm_type() -> WasmType;
 }
 
 macro_rules! impl_scalar_wasm_traits {
     ($($T:ty => $val_ty:ident),+ $(,)?) => {
         $(
-            impl ToValType for $T {
+            impl ToWasmType for $T {
                 #[inline]
-                fn to_val_type() -> ValType {
-                    ValType::$val_ty
+                fn to_wasm_type() -> WasmType {
+                    WasmType::$val_ty
                 }
             }
 
-            impl ValTypesFromTuple for $T {
+            impl WasmTypesFromTuple for $T {
                 #[inline]
-                fn val_types() -> Box<[ValType]> {
-                    Box::new([ValType::$val_ty])
+                fn wasm_types() -> Box<[WasmType]> {
+                    Box::new([WasmType::$val_ty])
                 }
             }
 
@@ -495,13 +494,13 @@ macro_rules! impl_scalar_wasm_traits {
 
 macro_rules! impl_tuple_traits {
     ($($T:ident),+) => {
-        impl<$($T),+> ValTypesFromTuple for ($($T,)+)
+        impl<$($T),+> WasmTypesFromTuple for ($($T,)+)
         where
-            $($T: ToValType,)+
+            $($T: ToWasmType,)+
         {
             #[inline]
-            fn val_types() -> Box<[ValType]> {
-                Box::new([$($T::to_val_type(),)+])
+            fn wasm_types() -> Box<[WasmType]> {
+                Box::new([$($T::to_wasm_type(),)+])
             }
         }
 
@@ -569,9 +568,9 @@ impl_scalar_wasm_traits!(
 );
 impl_tuple!(impl_tuple_traits);
 
-impl ValTypesFromTuple for () {
+impl WasmTypesFromTuple for () {
     #[inline]
-    fn val_types() -> Box<[ValType]> {
+    fn wasm_types() -> Box<[WasmType]> {
         Box::new([])
     }
 }

crates/tinywasm/src/imports.rs

@@ -67,7 +67,7 @@ impl From<&Import> for ExternName {
 /// # use log;
 /// # fn main() -> tinywasm::Result<()> {
 /// use tinywasm::{Global, HostFunction, Imports, Memory, Module, Store, Table};
-/// use tinywasm::types::{ValType, TableType, MemoryType, WasmValue};
+/// use tinywasm::types::{WasmType, TableType, MemoryType, WasmValue};
 /// # let wasm = wat::parse_str("(module)").expect("valid wat");
 /// # let module = Module::parse_bytes(&wasm)?;
 /// # let mut store = Store::default();
@@ -81,9 +81,9 @@ impl From<&Import> for ExternName {
 ///     Ok(())
 /// });
 ///
-/// let table = Table::new(&mut store, TableType::new(ValType::RefFunc, 10, Some(20)), WasmValue::default_for(ValType::RefFunc))?;
+/// let table = Table::new(&mut store, TableType::new(WasmType::RefFunc, 10, Some(20)), WasmValue::default_for(WasmType::RefFunc))?;
 /// let memory = Memory::new(&mut store, MemoryType::default().with_page_count_initial(1).with_page_count_max(Some(2)))?;
-/// let global_i32 = Global::new(&mut store, tinywasm::types::GlobalType::default().with_ty(ValType::I32), WasmValue::I32(666))?;
+/// let global_i32 = Global::new(&mut store, tinywasm::types::GlobalType::default().with_ty(WasmType::I32), WasmValue::I32(666))?;
 ///
 /// imports
 ///     .define("my_module", "print_i32", print_i32)

crates/tinywasm/src/instance.rs

@@ -2,7 +2,7 @@ use alloc::boxed::Box;
 use alloc::{format, rc::Rc};
 use tinywasm_types::*;
 
-use crate::func::{FromWasmValueTuple, IntoWasmValueTuple, ValTypesFromTuple};
+use crate::func::{FromWasmValueTuple, IntoWasmValueTuple, WasmTypesFromTuple};
 use crate::{Error, Function, FunctionTyped, Global, Imports, Memory, Module, Result, Store, Table};
 
 /// A typed view over an exported extern value.
@@ -304,7 +304,7 @@ impl ModuleInstance {
     }
 
     /// Get a typed function export by name.
-    pub fn func<P: IntoWasmValueTuple + ValTypesFromTuple, R: FromWasmValueTuple + ValTypesFromTuple>(
+    pub fn func<P: IntoWasmValueTuple + WasmTypesFromTuple, R: FromWasmValueTuple + WasmTypesFromTuple>(
         &self,
         store: &Store,
         name: &str,
@@ -317,7 +317,10 @@ impl ModuleInstance {
     /// Get a typed function by its module-local index.
     #[cfg_attr(docsrs, doc(cfg(feature = "guest_debug")))]
     #[cfg(feature = "guest_debug")]
-    pub fn func_typed_by_index<P: IntoWasmValueTuple + ValTypesFromTuple, R: FromWasmValueTuple + ValTypesFromTuple>(
+    pub fn func_typed_by_index<
+        P: IntoWasmValueTuple + WasmTypesFromTuple,
+        R: FromWasmValueTuple + WasmTypesFromTuple,
+    >(
         &self,
         store: &Store,
         func_index: FuncAddr,
@@ -327,8 +330,11 @@ impl ModuleInstance {
         Ok(FunctionTyped { func, marker: core::marker::PhantomData })
     }
 
-    fn validate_typed_func<P: ValTypesFromTuple, R: ValTypesFromTuple>(func: &Function, func_name: &str) -> Result<()> {
-        let expected = FuncType { params: P::val_types(), results: R::val_types() };
+    fn validate_typed_func<P: WasmTypesFromTuple, R: WasmTypesFromTuple>(
+        func: &Function,
+        func_name: &str,
+    ) -> Result<()> {
+        let expected = FuncType::new(&P::wasm_types(), &R::wasm_types());
         if func.ty != expected {
             #[cfg(feature = "debug")]
             return Err(Error::Other(format!(

crates/tinywasm/src/interpreter/executor.rs

@@ -738,7 +738,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         Ok(())
     }
     fn exec_call_host(&mut self, host_func: Rc<HostFunction>) -> Result<()> {
-        let params = self.store.stack.values.pop_types(&host_func.ty.params).collect::<Box<_>>();
+        let params = self.store.stack.values.pop_types(host_func.ty.params()).collect::<Box<_>>();
         let res = host_func.call(FuncContext { store: self.store, module_addr: self.module.idx }, &params)?;
         self.store.stack.values.extend_from_wasmvalues(&res)?;
         self.cf.incr_instr_ptr();
@@ -780,7 +780,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         let func_ref = {
             let table_idx: u32 = self.store.stack.values.pop::<i32>() as u32;
             let table = self.store.state.get_table(self.module.resolve_table_addr(table_addr));
-            assert!(table.kind.element_type == ValType::RefFunc, "table is not of type funcref");
+            assert!(table.kind.element_type == WasmType::RefFunc, "table is not of type funcref");
             let table =
                 table.get(table_idx).map_err(|_| Error::from(Trap::UndefinedElement { index: table_idx as usize }))?;
             table.addr().ok_or_else(|| Error::from(Trap::UninitializedElement { index: table_idx as usize }))?
@@ -814,7 +814,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
     }
 
     fn exec_return(&mut self) -> bool {
-        let results = ValueCounts::from_iter(&self.func.ty.results);
+        let results = ValueCounts::from_iter(self.func.ty.results());
         self.store.stack.values.truncate_keep_counts(self.cf.locals_base, results);
         let Some(cf) = self.store.stack.call_stack.pop() else { return true };
 

crates/tinywasm/src/interpreter/stack/value_stack.rs

@@ -1,6 +1,6 @@
 use alloc::boxed::Box;
 use alloc::vec::Vec;
-use tinywasm_types::{ExternRef, FuncRef, LocalAddr, ValType, ValueCounts, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, LocalAddr, ValueCounts, WasmType, WasmValue};
 
 use crate::{Result, Trap, engine::Config, interpreter::*, unlikely};
 
@@ -197,7 +197,7 @@ impl ValueStack {
 
     pub(crate) fn pop_types<'a>(
         &'a mut self,
-        val_types: impl IntoIterator<Item = &'a ValType>,
+        val_types: impl IntoIterator<Item = &'a WasmType>,
     ) -> impl core::iter::Iterator<Item = WasmValue> {
         val_types.into_iter().map(|val_type| self.pop_wasmvalue(*val_type))
     }
@@ -272,15 +272,15 @@ impl ValueStack {
         Ok(())
     }
 
-    pub(crate) fn pop_wasmvalue(&mut self, val_type: ValType) -> WasmValue {
+    pub(crate) fn pop_wasmvalue(&mut self, val_type: WasmType) -> WasmValue {
         match val_type {
-            ValType::I32 => WasmValue::I32(self.pop()),
-            ValType::I64 => WasmValue::I64(self.pop()),
-            ValType::F32 => WasmValue::F32(self.pop()),
-            ValType::F64 => WasmValue::F64(self.pop()),
-            ValType::RefExtern => WasmValue::RefExtern(ExternRef::new(self.pop())),
-            ValType::RefFunc => WasmValue::RefFunc(FuncRef::new(self.pop())),
-            ValType::V128 => WasmValue::V128(self.pop::<Value128>().into()),
+            WasmType::I32 => WasmValue::I32(self.pop()),
+            WasmType::I64 => WasmValue::I64(self.pop()),
+            WasmType::F32 => WasmValue::F32(self.pop()),
+            WasmType::F64 => WasmValue::F64(self.pop()),
+            WasmType::RefExtern => WasmValue::RefExtern(ExternRef::new(self.pop())),
+            WasmType::RefFunc => WasmValue::RefFunc(FuncRef::new(self.pop())),
+            WasmType::V128 => WasmValue::V128(self.pop::<Value128>().into()),
         }
     }