chore: update deps, fix clippy warnings, add wast ModuleDefinition

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

4 files changed, 39 insertions, 14 deletions

diff --git a/crates/cli/src/engine_flags.rs b/crates/cli/src/engine_flags.rs
index 2965a3e..c8df1fe 100644
--- a/crates/cli/src/engine_flags.rs
+++ b/crates/cli/src/engine_flags.rs
@@ -91,7 +91,7 @@ impl EngineFlags {
                 MemoryBackendArg::Vec => tinywasm::MemoryBackend::vec(),
                 MemoryBackendArg::Paged => {
                     if self.memory_page_chunk_size == 0 {
-                        bail!("--memory-page-chunk-size must be greater than zero")
+                        bail!("--memory-page-chunk-size must be greater than zero");
                     }
                     tinywasm::MemoryBackend::paged(self.memory_page_chunk_size)
                 }
diff --git a/crates/cli/src/load.rs b/crates/cli/src/load.rs
index d16469b..7e6fc09 100644
--- a/crates/cli/src/load.rs
+++ b/crates/cli/src/load.rs
@@ -25,14 +25,14 @@ pub fn load_module(input: &str) -> Result<LoadedModule> {
 pub fn load_compilable_module(input: &str) -> Result<Module> {
     let loaded = load_module(input)?;
     if loaded.format == InputFormat::Twasm {
-        bail!("input is already a twasm archive; use `run`, `dump`, or `inspect` instead")
+        bail!("input is already a twasm archive; use `run`, `dump`, or `inspect` instead");
     }
     Ok(loaded.module)
 }
 
 pub fn default_twasm_output_path(input: &str) -> Result<String> {
     if input == "-" {
-        bail!("--output is required when compiling from stdin")
+        bail!("--output is required when compiling from stdin");
     }
 
     let path = Path::new(input);
@@ -50,7 +50,7 @@ pub fn write_output_bytes(output: &str, bytes: &[u8], force: bool) -> Result<()>
 
     let path = Path::new(output);
     if path.exists() && !force {
-        bail!("output file already exists: {output}; pass --force to overwrite")
+        bail!("output file already exists: {output}; pass --force to overwrite");
     }
 
     std::fs::write(path, bytes).with_context(|| format!("failed to write output file `{output}`"))?;
diff --git a/crates/cli/src/value_parse.rs b/crates/cli/src/value_parse.rs
index f9ffbbb..92c0363 100644
--- a/crates/cli/src/value_parse.rs
+++ b/crates/cli/src/value_parse.rs
@@ -5,7 +5,7 @@ use crate::output::format_wasm_type;
 
 pub fn parse_invocation_args(ty: &FuncType, args: &[String]) -> Result<Vec<WasmValue>> {
     if args.len() != ty.params().len() {
-        bail!("wrong number of arguments: expected {}, got {}", ty.params().len(), args.len())
+        bail!("wrong number of arguments: expected {}, got {}", ty.params().len(), args.len());
     }
 
     ty.params().iter().enumerate().map(|(idx, param_ty)| parse_arg(idx, *param_ty, &args[idx])).collect()
@@ -26,7 +26,7 @@ fn parse_arg(index: usize, ty: WasmType, value: &str) -> Result<WasmValue> {
                 "unsupported CLI argument type at position {}: {}; use the embedding API for reference values",
                 index + 1,
                 format_wasm_type(ty)
-            )
+            );
         }
     };
 
diff --git a/crates/cli/src/wast_runner.rs b/crates/cli/src/wast_runner.rs
index 3c0a1cd..99f1efe 100644
--- a/crates/cli/src/wast_runner.rs
+++ b/crates/cli/src/wast_runner.rs
@@ -219,7 +219,7 @@ impl WastRunner {
             let span = directive.span();
             use wast::WastDirective::{
                 AssertExhaustion, AssertInvalid, AssertMalformed, AssertReturn, AssertTrap, AssertUnlinkable, Invoke,
-                Module as Wat, Register,
+                Module as Wat, ModuleDefinition, Register,
             };
 
             match directive {
@@ -253,6 +253,17 @@ impl WastRunner {
 
                     test_group.add_result(&format!("Wat({i})"), span.linecol_in(wast_raw), result.map(|_| ()));
                 }
+                ModuleDefinition(module) => {
+                    let result = catch_unwind_silent(|| {
+                        let (_, bytes) = encode_quote_wat(module);
+                        parse_module_bytes(&bytes)
+                    })
+                    .map_err(|err| eyre!("failed to parse module definition: {}", try_downcast_panic(err)))
+                    .and_then(|result| result)
+                    .map(|_| ());
+
+                    test_group.add_result(&format!("ModuleDefinition({i})"), span.linecol_in(wast_raw), result);
+                }
                 AssertMalformed { span, mut module, message } => {
                     let Ok(encoded) = module.encode() else {
                         test_group.add_result(&format!("AssertMalformed({i})"), span.linecol_in(wast_raw), Ok(()));
@@ -742,7 +753,9 @@ fn convert_wastret<'a>(args: impl Iterator<Item = wast::WastRet<'a>>) -> Result<
 }
 
 fn wastarg2tinywasmvalue(arg: wast::WastArg) -> Result<WasmValue> {
-    let wast::WastArg::Core(arg) = arg else { bail!("unsupported arg type: Component") };
+    let wast::WastArg::Core(arg) = arg else {
+        bail!("unsupported arg type: Component");
+    };
     use wast::core::WastArgCore::*;
     Ok(match arg {
         F32(f) => WasmValue::F32(f32::from_bits(f.bits)),
@@ -758,9 +771,13 @@ fn wastarg2tinywasmvalue(arg: wast::WastArg) -> Result<WasmValue> {
             wast::core::HeapType::Abstract { shared: false, ty: AbstractHeapType::Extern } => {
                 WasmValue::RefExtern(ExternRef::null())
             }
-            _ => bail!("unsupported arg type: refnull: {:?}", t),
+            _ => {
+                bail!("unsupported arg type: refnull: {:?}", t);
+            }
         },
-        RefHost(_) => bail!("unsupported arg type: RefHost"),
+        RefHost(_) => {
+            bail!("unsupported arg type: RefHost");
+        }
     })
 }
 
@@ -781,7 +798,9 @@ fn wast_v128_to_bytes(i: wast::core::V128Pattern) -> [u8; 16] {
 }
 
 fn wastret2tinywasmvalues(ret: wast::WastRet) -> Result<Vec<WasmValue>> {
-    let wast::WastRet::Core(ret) = ret else { bail!("unsupported arg type") };
+    let wast::WastRet::Core(ret) = ret else {
+        bail!("unsupported arg type");
+    };
     match ret {
         wast::core::WastRetCore::Either(options) => {
             options.into_iter().map(wastretcore2tinywasmvalue).collect::<Result<Vec<_>>>()
@@ -805,14 +824,20 @@ fn wastretcore2tinywasmvalue(ret: wast::core::WastRetCore) -> Result<WasmValue>
             Some(wast::core::HeapType::Abstract { shared: false, ty: AbstractHeapType::Extern }) => {
                 WasmValue::RefExtern(ExternRef::null())
             }
-            _ => bail!("unsupported arg type: refnull: {:?}", t),
+            _ => {
+                bail!("unsupported arg type: refnull: {:?}", t);
+            }
         },
         RefExtern(v) => WasmValue::RefExtern(ExternRef::new(v)),
         RefFunc(v) => WasmValue::RefFunc(FuncRef::new(match v {
             Some(wast::token::Index::Num(n, _)) => Some(n),
-            _ => bail!("unsupported arg type: reffunc: {:?}", v),
+            _ => {
+                bail!("unsupported arg type: reffunc: {:?}", v);
+            }
         })),
-        a => bail!("unsupported arg type {:?}", a),
+        a => {
+            bail!("unsupported arg type {:?}", a);
+        }
     })
 }