chore: use FromIterator for ValueCounts

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

Author: explodingcamera

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(&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/imports.rs

@@ -193,7 +193,8 @@ impl Extern {
             Ok(result.into_wasm_value_tuple())
         };
 
-        let ty = tinywasm_types::FuncType { params: P::val_types(), results: R::val_types() };
+        let results = R::val_types();
+        let ty = tinywasm_types::FuncType { params: P::val_types(), results };
         Self::Function(Function::Host(Rc::new(HostFunction { func: Box::new(inner_func), ty })))
     }
 

crates/tinywasm/src/interpreter/executor.rs

@@ -148,11 +148,8 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
                 JumpIfZero(ip) => if self.exec_jump_if_zero(*ip) { continue; },
                 JumpIfNonZero(ip) => if self.exec_jump_if_non_zero(*ip) { continue; },
                 DropKeepSmall { base32, keep32, base64, keep64, base128, keep128, base_ref, keep_ref } => {
-                    let stack_base = self.cf.stack_base();
-                    self.store.stack.values.stack_32.truncate_keep((stack_base.s32 + *base32 as u32) as usize, *keep32 as usize);
-                    self.store.stack.values.stack_64.truncate_keep((stack_base.s64 + *base64 as u32) as usize, *keep64 as usize);
-                    self.store.stack.values.stack_128.truncate_keep((stack_base.s128 + *base128 as u32) as usize, *keep128 as usize);
-                    self.store.stack.values.stack_ref.truncate_keep((stack_base.sref + *base_ref as u32) as usize, *keep_ref as usize);
+                    let mut base = self.cf.stack_base(); base.s32 += *base32 as u32; base.s64 += *base64 as u32; base.s128 += *base128 as u32; base.sref += *base_ref as u32;
+                    self.store.stack.values.truncate_keep_counts(base, ValueCounts { c32: *keep32 as u16, c64: *keep64 as u16, c128: *keep128 as u16, cref: *keep_ref as u16 });
                 }
                 DropKeep32(base, keep) => self.store.stack.values.stack_32.truncate_keep((self.cf.stack_base().s32 + *base as u32) as usize, *keep as usize),
                 DropKeep64(base, keep) => self.store.stack.values.stack_64.truncate_keep((self.cf.stack_base().s64 + *base as u32) as usize, *keep as usize),
@@ -822,9 +819,8 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
     }
 
     fn exec_return(&mut self) -> bool {
-        let result_counts = ValueCounts::from(self.func.ty.results.iter());
-        self.store.stack.values.truncate_keep_counts(self.cf.locals_base, result_counts);
-
+        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 };
 
         if cf.func_addr != self.cf.func_addr {

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

@@ -228,7 +228,7 @@ impl ValueStack {
     }
 
     pub(crate) fn truncate_keep_counts(&mut self, base: StackBase, keep: ValueCounts) {
-        if keep.c32 == 0 && keep.c64 == 0 && keep.c128 == 0 && keep.cref == 0 {
+        if keep.is_empty() {
             self.stack_32.len = base.s32 as usize;
             self.stack_64.len = base.s64 as usize;
             self.stack_128.len = base.s128 as usize;

crates/types/src/lib.rs

@@ -214,19 +214,25 @@ pub struct ValueCounts {
     pub cref: u16,
 }
 
-impl<'a, T: IntoIterator<Item = &'a ValType>> From<T> for ValueCounts {
+impl ValueCounts {
     #[inline]
-    fn from(types: T) -> Self {
-        let mut counts = Self::default();
-        for ty in types {
+    pub fn is_empty(&self) -> bool {
+        self.c32 == 0 && self.c64 == 0 && self.c128 == 0 && self.cref == 0
+    }
+}
+
+impl<'a> FromIterator<&'a ValType> for ValueCounts {
+    #[inline]
+    fn from_iter<I: IntoIterator<Item = &'a ValType>>(iter: I) -> Self {
+        iter.into_iter().fold(Self::default(), |mut counts, ty| {
             match ty {
                 ValType::I32 | ValType::F32 => counts.c32 += 1,
                 ValType::I64 | ValType::F64 => counts.c64 += 1,
                 ValType::V128 => counts.c128 += 1,
                 ValType::RefExtern | ValType::RefFunc => counts.cref += 1,
             }
-        }
-        counts
+            counts
+        })
     }
 }