chore: cleanup

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

Author: explodingcamera

crates/cli/src/cli.rs

@@ -1,10 +1,6 @@
-use clap::{
-    Args, Parser, Subcommand, ValueEnum,
-    builder::{
-        Styles,
-        styling::{AnsiColor, Effects},
-    },
-};
+use clap::builder::Styles;
+use clap::builder::styling::{AnsiColor, Effects};
+use clap::{Args, Parser, Subcommand, ValueEnum};
 use clap_complete::Shell;
 
 use crate::engine_flags::EngineFlags;

crates/cli/src/wast_runner.rs

@@ -1,11 +1,9 @@
 use std::collections::{BTreeMap, HashMap};
 use std::fmt::{Display, Formatter};
 use std::fs::canonicalize;
+use std::panic::{self, AssertUnwindSafe};
 use std::path::PathBuf;
-use std::{
-    panic::{self, AssertUnwindSafe},
-    time::Duration,
-};
+use std::time::Duration;
 
 use eyre::{Context, Result, bail, eyre};
 use log::{debug, error};
@@ -833,9 +831,11 @@ 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)
     }
@@ -845,9 +845,11 @@ 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)
     }

crates/parser/src/module.rs

@@ -1,7 +1,6 @@
 use crate::log::debug;
 use crate::{ParseError, ParserOptions, Result, conversion::*, optimize};
-use alloc::sync::Arc;
-use alloc::{boxed::Box, format, string::ToString, vec::Vec};
+use alloc::{boxed::Box, format, string::ToString, sync::Arc, vec::Vec};
 use core::marker::PhantomData;
 use core::ops::Range;
 use tinywasm_types::*;

crates/parser/src/visit.rs

@@ -63,6 +63,7 @@ fn operand_size(ty: wasmparser::ValType) -> OperandSize {
 
 impl<'a, R: WasmModuleResources> VisitOperator<'a> for ValidateThenVisit<'_, R> {
     type Output = ();
+
     wasmparser::for_each_visit_operator!(validate_then_visit);
 
     fn simd_visitor(&mut self) -> Option<&mut dyn VisitSimdOperator<'a, Output = Self::Output>> {
@@ -113,12 +114,13 @@ pub(crate) struct FunctionBuilder<R> {
 
 impl<'a, R: WasmModuleResources> wasmparser::VisitOperator<'a> for FunctionBuilder<R> {
     type Output = ();
-    wasmparser::for_each_visit_operator!(impl_visit_operator);
 
     fn simd_visitor(&mut self) -> Option<&mut dyn VisitSimdOperator<'a, Output = Self::Output>> {
         Some(self)
     }
 
+    wasmparser::for_each_visit_operator!(impl_visit_operator);
+
     define_mem_operands! {
         visit_i32_load(I32Load), visit_i64_load(I64Load), visit_f32_load(F32Load), visit_f64_load(F64Load),
         visit_i32_load8_s(I32Load8S), visit_i32_load8_u(I32Load8U), visit_i32_load16_s(I32Load16S),
@@ -467,10 +469,12 @@ impl<R: WasmModuleResources> wasmparser::VisitSimdOperator<'_> for FunctionBuild
     define_mem_operands_simd! {
         visit_v128_load(V128Load), visit_v128_load8x8_s(V128Load8x8S), visit_v128_load8x8_u(V128Load8x8U), visit_v128_load16x4_s(V128Load16x4S), visit_v128_load16x4_u(V128Load16x4U), visit_v128_load32x2_s(V128Load32x2S), visit_v128_load32x2_u(V128Load32x2U), visit_v128_load8_splat(V128Load8Splat), visit_v128_load16_splat(V128Load16Splat), visit_v128_load32_splat(V128Load32Splat), visit_v128_load64_splat(V128Load64Splat), visit_v128_load32_zero(V128Load32Zero), visit_v128_load64_zero(V128Load64Zero), visit_v128_store(V128Store)
     }
+
     define_mem_operands_simd_lane! {
         visit_v128_load8_lane(V128Load8Lane), visit_v128_load16_lane(V128Load16Lane), visit_v128_load32_lane(V128Load32Lane), visit_v128_load64_lane(V128Load64Lane),
         visit_v128_store8_lane(V128Store8Lane), visit_v128_store16_lane(V128Store16Lane), visit_v128_store32_lane(V128Store32Lane), visit_v128_store64_lane(V128Store64Lane)
     }
+
     define_operands! {
         visit_v128_not(V128Not), visit_v128_and(V128And), visit_v128_andnot(V128AndNot), visit_v128_or(V128Or), visit_v128_xor(V128Xor), visit_v128_bitselect(V128Bitselect), visit_v128_any_true(V128AnyTrue),
         visit_i8x16_splat(I8x16Splat), visit_i8x16_swizzle(I8x16Swizzle), visit_i8x16_eq(I8x16Eq), visit_i8x16_ne(I8x16Ne), visit_i8x16_lt_s(I8x16LtS), visit_i8x16_lt_u(I8x16LtU), visit_i8x16_gt_s(I8x16GtS), visit_i8x16_gt_u(I8x16GtU), visit_i8x16_le_s(I8x16LeS), visit_i8x16_le_u(I8x16LeU), visit_i8x16_ge_s(I8x16GeS), visit_i8x16_ge_u(I8x16GeU),
@@ -554,7 +558,9 @@ impl<R: WasmModuleResources> FunctionBuilder<R> {
     }
 
     fn stack_base_at_frame(&self, depth: usize) -> StackBase {
-        let Some(frame) = self.validator.get_control_frame(depth) else { return StackBase::default() };
+        let Some(frame) = self.validator.get_control_frame(depth) else {
+            return StackBase::default();
+        };
         let mut base = StackBase::default();
         let stack_height = self.validator.operand_stack_height() as usize;
         for i in 0..frame.height {

crates/tinywasm/benches/tinywasm.rs

@@ -1,8 +1,7 @@
 use criterion::{Criterion, criterion_group, criterion_main};
 use eyre::Result;
-use tinywasm::{
-    Engine, FuncContext, HostFunction, Imports, MemoryBackend, ModuleInstance, Store, engine::Config, types,
-};
+use tinywasm::engine::Config;
+use tinywasm::{Engine, FuncContext, HostFunction, Imports, MemoryBackend, ModuleInstance, Store, types};
 use types::Module;
 
 const WASM: &[u8] = include_bytes!("../../../examples/rust/out/tinywasm.wasm");

crates/tinywasm/src/error.rs

@@ -2,8 +2,7 @@ use alloc::boxed::Box;
 use alloc::string::{String, ToString};
 use alloc::sync::Arc;
 use alloc::vec::Vec;
-use core::fmt::Debug;
-use core::fmt::Display;
+use core::fmt::{Debug, Display};
 use tinywasm_types::FuncType;
 use tinywasm_types::archive::TwasmError;
 

crates/tinywasm/src/instance.rs

@@ -1,8 +1,5 @@
+use alloc::{boxed::Box, format, rc::Rc, sync::Arc};
 use core::hint::cold_path;
-
-use alloc::boxed::Box;
-use alloc::sync::Arc;
-use alloc::{format, rc::Rc};
 use tinywasm_types::*;
 
 use crate::func::{FromWasmValues, IntoWasmValues, ToWasmTypes};

crates/tinywasm/src/interpreter/executor.rs

@@ -1243,6 +1243,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
     fn exec_const<T: InternalValue>(&mut self, val: T) -> Result<(), Trap> {
         self.store.value_stack.push(val)
     }
+
     fn exec_ref_is_null(&mut self) -> Result<(), Trap> {
         let is_null = i32::from(<ValueRef>::stack_pop(&mut self.store.value_stack).is_null());
         self.store.value_stack.push::<i32>(is_null)
@@ -1255,6 +1256,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
             false => self.store.value_stack.push::<i32>(mem.page_count as i32),
         }
     }
+
     fn exec_memory_grow(&mut self, addr: u32) -> Result<(), Trap> {
         let mem = self.store.state.get_mem_mut(self.module.resolve_mem_addr(addr));
         let is_64bit = mem.is_64bit();
@@ -1290,6 +1292,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         }
         Ok(())
     }
+
     fn exec_memory_fill(&mut self, addr: u32) -> Result<(), Trap> {
         let size = i32::stack_pop(&mut self.store.value_stack);
         let val = i32::stack_pop(&mut self.store.value_stack);
@@ -1351,6 +1354,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         }
         Ok(())
     }
+
     fn exec_table_copy(&mut self, dst_table: u32, src_table: u32) -> Result<(), Trap> {
         let size = i32::stack_pop(&mut self.store.value_stack);
         let src = i32::stack_pop(&mut self.store.value_stack);
@@ -1473,16 +1477,19 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
         let v = table.get_wasm_val(idx as u32)?;
         self.store.value_stack.push_dyn(v.into())
     }
+
     fn exec_table_set(&mut self, table_index: u32) -> Result<(), Trap> {
         let val = <ValueRef>::stack_pop(&mut self.store.value_stack);
         let idx = <i32>::stack_pop(&mut self.store.value_stack) as u32;
         let table = self.store.state.get_table_mut(self.module.resolve_table_addr(table_index));
         table.set(idx, val.addr().into())
     }
+
     fn exec_table_size(&mut self, table_index: u32) -> Result<(), Trap> {
         let table = self.store.state.get_table(self.module.resolve_table_addr(table_index));
         self.store.value_stack.push(table.size())
     }
+
     fn exec_table_init(&mut self, elem_index: u32, table_index: u32) -> Result<(), Trap> {
         let size = i32::stack_pop(&mut self.store.value_stack); // n
         let offset = i32::stack_pop(&mut self.store.value_stack); // s
@@ -1517,6 +1524,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
 
         table.init(i64::from(dst), &items[offset as usize..(offset + size) as usize])
     }
+
     fn exec_table_grow(&mut self, table_index: u32) -> Result<(), Trap> {
         let table = self.store.state.get_table_mut(self.module.resolve_table_addr(table_index));
         let sz = table.size();
@@ -1527,6 +1535,7 @@ impl<'store, const BUDGETED: bool> Executor<'store, BUDGETED> {
             Err(_) => self.store.value_stack.push(-1_i32),
         }
     }
+
     fn exec_table_fill(&mut self, table_index: u32) -> Result<(), Trap> {
         let table = self.store.state.get_table_mut(self.module.resolve_table_addr(table_index));
 

crates/tinywasm/src/interpreter/num_helpers.rs

@@ -1,7 +1,4 @@
-pub(crate) trait TinywasmIntExt
-where
-    Self: Sized,
-{
+pub(crate) trait TinywasmIntExt: Sized {
     fn checked_wrapping_rem(self, rhs: Self) -> Result<Self, Trap>;
     fn wasm_checked_div(self, rhs: Self) -> Result<Self, Trap>;
 }