chore: clean up code

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

Author: explodingcamera

Cargo.lock

@@ -5,7 +5,7 @@ use tinywasm::types::WasmValue;
 pub struct WasmArg(WasmValue);
 
 pub fn to_wasm_args(args: Vec<WasmArg>) -> Vec<WasmValue> {
-    args.into_iter().map(|a| a.into()).collect()
+    args.into_iter().map(Into::into).collect()
 }
 
 impl From<WasmArg> for WasmValue {
@@ -18,14 +18,14 @@ impl FromStr for WasmArg {
     type Err = String;
     fn from_str(s: &str) -> std::prelude::v1::Result<Self, Self::Err> {
         let [ty, val]: [&str; 2] =
-            s.split(':').collect::<Vec<_>>().try_into().map_err(|e| format!("invalid arguments: {:?}", e))?;
+            s.split(':').collect::<Vec<_>>().try_into().map_err(|e| format!("invalid arguments: {e:?}"))?;
 
         let arg: WasmValue = match ty {
             "i32" => val.parse::<i32>().map_err(|e| format!("invalid argument value for i32: {e:?}"))?.into(),
             "i64" => val.parse::<i64>().map_err(|e| format!("invalid argument value for i64: {e:?}"))?.into(),
             "f32" => val.parse::<f32>().map_err(|e| format!("invalid argument value for f32: {e:?}"))?.into(),
             "f64" => val.parse::<f64>().map_err(|e| format!("invalid argument value for f64: {e:?}"))?.into(),
-            t => return Err(format!("Invalid arg type: {}", t)),
+            t => return Err(format!("Invalid arg type: {t}")),
         };
 
         Ok(WasmArg(arg))

crates/cli/src/args.rs

@@ -14,7 +14,7 @@ mod util;
 mod wat;
 
 #[derive(FromArgs)]
-/// TinyWasm CLI
+/// `TinyWasm` CLI
 struct TinyWasmCli {
     #[argh(subcommand)]
     nested: TinyWasmSubcommand,
@@ -40,7 +40,7 @@ impl FromStr for Engine {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "main" => Ok(Self::Main),
-            _ => Err(format!("unknown engine: {}", s)),
+            _ => Err(format!("unknown engine: {s}")),
         }
     }
 }
@@ -98,19 +98,19 @@ fn main() -> Result<()> {
             };
 
             match engine {
-                Engine::Main => run(module, func, to_wasm_args(args)),
+                Engine::Main => run(module, func, &to_wasm_args(args)),
             }
         }
     }
 }
 
-fn run(module: Module, func: Option<String>, args: Vec<WasmValue>) -> Result<()> {
+fn run(module: Module, func: Option<String>, args: &[WasmValue]) -> Result<()> {
     let mut store = tinywasm::Store::default();
     let instance = module.instantiate(&mut store, None)?;
 
     if let Some(func) = func {
         let func = instance.exported_func_untyped(&store, &func)?;
-        let res = func.call(&mut store, &args)?;
+        let res = func.call(&mut store, args)?;
         info!("{res:?}");
     }
 

crates/cli/src/bin.rs

@@ -38,7 +38,7 @@ pub(crate) fn convert_module_element(element: wasmparser::Element<'_>) -> Result
                 .collect::<Result<Vec<_>>>()?
                 .into_boxed_slice();
 
-            Ok(tinywasm_types::Element { kind, items, ty: convert_reftype(&ty), range: element.range })
+            Ok(tinywasm_types::Element { kind, items, ty: convert_reftype(ty), range: element.range })
         }
     }
 }
@@ -76,23 +76,23 @@ pub(crate) fn convert_module_import(import: wasmparser::Import<'_>) -> Result<Im
         kind: match import.ty {
             wasmparser::TypeRef::Func(ty) => ImportKind::Function(ty),
             wasmparser::TypeRef::Table(ty) => ImportKind::Table(TableType {
-                element_type: convert_reftype(&ty.element_type),
+                element_type: convert_reftype(ty.element_type),
                 size_initial: ty.initial.try_into().map_err(|_| {
                     crate::ParseError::UnsupportedOperator(format!("Table size initial is too large: {}", ty.initial))
                 })?,
                 size_max: match ty.maximum {
                     Some(max) => Some(max.try_into().map_err(|_| {
-                        crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {}", max))
+                        crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {max}"))
                     })?),
                     None => None,
                 },
             }),
-            wasmparser::TypeRef::Memory(ty) => ImportKind::Memory(convert_module_memory(ty)?),
+            wasmparser::TypeRef::Memory(ty) => ImportKind::Memory(convert_module_memory(ty)),
             wasmparser::TypeRef::Global(ty) => {
                 ImportKind::Global(GlobalType { mutable: ty.mutable, ty: convert_valtype(&ty.content_type) })
             }
             wasmparser::TypeRef::Tag(ty) => {
-                return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {:?}", ty)))
+                return Err(crate::ParseError::UnsupportedOperator(format!("Unsupported import kind: {ty:?}")))
             }
         },
     })
@@ -101,18 +101,15 @@ pub(crate) fn convert_module_import(import: wasmparser::Import<'_>) -> Result<Im
 pub(crate) fn convert_module_memories<T: IntoIterator<Item = wasmparser::Result<wasmparser::MemoryType>>>(
     memory_types: T,
 ) -> Result<Vec<MemoryType>> {
-    memory_types.into_iter().map(|memory| convert_module_memory(memory?)).collect::<Result<Vec<_>>>()
+    memory_types.into_iter().map(|memory| Ok(convert_module_memory(memory?))).collect::<Result<Vec<_>>>()
 }
 
-pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> Result<MemoryType> {
-    Ok(MemoryType {
-        arch: match memory.memory64 {
-            true => MemoryArch::I64,
-            false => MemoryArch::I32,
-        },
+pub(crate) fn convert_module_memory(memory: wasmparser::MemoryType) -> MemoryType {
+    MemoryType {
+        arch: if memory.memory64 { MemoryArch::I64 } else { MemoryArch::I32 },
         page_count_initial: memory.initial,
         page_count_max: memory.maximum,
-    })
+    }
 }
 
 pub(crate) fn convert_module_tables<'a, T: IntoIterator<Item = wasmparser::Result<wasmparser::Table<'a>>>>(
@@ -129,12 +126,12 @@ pub(crate) fn convert_module_table(table: wasmparser::Table<'_>) -> Result<Table
     let size_max = match table.ty.maximum {
         Some(max) => Some(
             max.try_into()
-                .map_err(|_| crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {}", max)))?,
+                .map_err(|_| crate::ParseError::UnsupportedOperator(format!("Table size max is too large: {max}")))?,
         ),
         None => None,
     };
 
-    Ok(TableType { element_type: convert_reftype(&table.ty.element_type), size_initial, size_max })
+    Ok(TableType { element_type: convert_reftype(table.ty.element_type), size_initial, size_max })
 }
 
 pub(crate) fn convert_module_globals(
@@ -185,11 +182,11 @@ pub(crate) fn convert_module_code(
 
     for i in 0..validator.len_locals() {
         match validator.get_local_type(i) {
-            Some(wasmparser::ValType::I32) | Some(wasmparser::ValType::F32) => {
+            Some(wasmparser::ValType::I32 | wasmparser::ValType::F32) => {
                 local_addr_map.push(local_counts.c32);
                 local_counts.c32 += 1;
             }
-            Some(wasmparser::ValType::I64) | Some(wasmparser::ValType::F64) => {
+            Some(wasmparser::ValType::I64 | wasmparser::ValType::F64) => {
                 local_addr_map.push(local_counts.c64);
                 local_counts.c64 += 1;
             }
@@ -225,7 +222,7 @@ pub(crate) fn convert_module_type(ty: wasmparser::RecGroup) -> Result<FuncType>
     Ok(FuncType { params, results })
 }
 
-pub(crate) fn convert_reftype(reftype: &wasmparser::RefType) -> ValType {
+pub(crate) fn convert_reftype(reftype: wasmparser::RefType) -> ValType {
     match reftype {
         _ if reftype.is_func_ref() => ValType::RefFunc,
         _ if reftype.is_extern_ref() => ValType::RefExtern,
@@ -240,7 +237,7 @@ pub(crate) fn convert_valtype(valtype: &wasmparser::ValType) -> ValType {
         wasmparser::ValType::F32 => ValType::F32,
         wasmparser::ValType::F64 => ValType::F64,
         wasmparser::ValType::V128 => ValType::V128,
-        wasmparser::ValType::Ref(r) => convert_reftype(r),
+        wasmparser::ValType::Ref(r) => convert_reftype(*r),
     }
 }
 
@@ -260,7 +257,7 @@ pub(crate) fn process_const_operators(ops: OperatorsReader<'_>) -> Result<ConstI
         wasmparser::Operator::F32Const { value } => Ok(ConstInstruction::F32Const(f32::from_bits(value.bits()))),
         wasmparser::Operator::F64Const { value } => Ok(ConstInstruction::F64Const(f64::from_bits(value.bits()))),
         wasmparser::Operator::GlobalGet { global_index } => Ok(ConstInstruction::GlobalGet(*global_index)),
-        op => Err(crate::ParseError::UnsupportedOperator(format!("Unsupported const instruction: {:?}", op))),
+        op => Err(crate::ParseError::UnsupportedOperator(format!("Unsupported const instruction: {op:?}"))),
     }
 }
 

crates/parser/src/conversion.rs

@@ -42,19 +42,19 @@ impl Display for ParseError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::InvalidType => write!(f, "invalid type"),
-            Self::UnsupportedSection(section) => write!(f, "unsupported section: {}", section),
-            Self::DuplicateSection(section) => write!(f, "duplicate section: {}", section),
-            Self::EmptySection(section) => write!(f, "empty section: {}", section),
-            Self::UnsupportedOperator(operator) => write!(f, "unsupported operator: {}", operator),
+            Self::UnsupportedSection(section) => write!(f, "unsupported section: {section}"),
+            Self::DuplicateSection(section) => write!(f, "duplicate section: {section}"),
+            Self::EmptySection(section) => write!(f, "empty section: {section}"),
+            Self::UnsupportedOperator(operator) => write!(f, "unsupported operator: {operator}"),
             Self::ParseError { message, offset } => {
-                write!(f, "error parsing module: {} at offset {}", message, offset)
+                write!(f, "error parsing module: {message} at offset {offset}")
             }
-            Self::InvalidEncoding(encoding) => write!(f, "invalid encoding: {:?}", encoding),
+            Self::InvalidEncoding(encoding) => write!(f, "invalid encoding: {encoding:?}"),
             Self::InvalidLocalCount { expected, actual } => {
-                write!(f, "invalid local count: expected {}, actual {}", expected, actual)
+                write!(f, "invalid local count: expected {expected}, actual {actual}")
             }
             Self::EndNotReached => write!(f, "end of module not reached"),
-            Self::Other(message) => write!(f, "unknown error: {}", message),
+            Self::Other(message) => write!(f, "unknown error: {message}"),
         }
     }
 }