chore(deps): update upstream wasmtime dependencies (#142)

* chore(deps)!: update upstream wasmtime dependencies

This commit updates the wasmtime dependencies in use, in preparation
for the next release, as git dependencies cannot be used in a release.

This change is breaking because the API to upstream `Wizer` has
changed, and is now `async`. Since `wasmtime-wizer`'s `Wizer::run()`
is re-exposed here we must introduce a breaking change here too.

* refactor: use wasmtime::error::Context pervasively

* chore: fix clippy lints

* refactor: update regex test to use OnceLock, refresh binary

Author: vados-cosmonic

Cargo.lock

@@ -19,12 +19,13 @@ name = "wizer"
 required-features = ["cli"]
 
 [dependencies]
-anyhow = { version = "1.0.97", optional = true }
-env_logger = { version = "0.11.8", optional = true }
-clap = { version = "4.5", optional = true, features = ['derive'] }
-wasmtime = { workspace = true }
-wasmtime-wizer = { workspace = true }
+anyhow = { workspace = true, optional = true }
+clap = { workspace = true, optional = true, features = ['derive'] }
+env_logger = { workspace = true, optional = true }
+tokio = { workspace = true, features = ["macros"] }
+wasmtime = { workspace = true, features = ["async", "anyhow"] }
 wasmtime-wasi = { workspace = true, features = ["p1"] }
+wasmtime-wizer = { workspace = true, features = ["wasmtime"] }
 
 [features]
 # Enable this dependency to get messages with WAT disassemblies when certain
@@ -34,25 +35,39 @@ wasmprinter = ['wasmtime-wizer/wasmprinter']
 cli = ['dep:clap', 'dep:env_logger', 'dep:anyhow', 'wasmtime-wizer/clap']
 
 [workspace.dependencies]
-wasmprinter = "0.238.0"
-wasmtime = { git = 'https://github.com/bytecodealliance/wasmtime' }
-wasmtime-wasi = { git = 'https://github.com/bytecodealliance/wasmtime' }
-wasmtime-wizer = { git = 'https://github.com/bytecodealliance/wasmtime' }
+anyhow = { version = "1.0.97" }
+clap = { version = "4.5" }
+criterion = { version = "0.5.1" }
+env_logger = { version = "0.11.8" }
+log = { version = "0.4.27" }
+wasm-encoder = { version = "0.244.0" }
+wasmparser = { version = "0.244.0" }
+wasmprinter = { version = "0.244.0" }
+
+# TODO: remove once wasmtime releases 42.0.0
+#wasmtime = { version = "42.0.0" }
+#wasmtime-wasi = { version = "42.0.0" }
+#wasmtime-wizer = { version = "42.0.0" }
+
+wasmtime = { git = "https://github.com/bytecodealliance/wasmtime" }
+wasmtime-wasi = { git = "https://github.com/bytecodealliance/wasmtime" }
+wasmtime-wizer = { git = "https://github.com/bytecodealliance/wasmtime" }
+
+wat = { version = "1.244.0" }
+tokio = { version = "1.49.0" }
 
 [dev-dependencies]
-log = "0.4.27"
-anyhow = "1.0.97"
-criterion = "0.5.1"
-env_logger = "0.11.8"
+anyhow = { workspace = true }
+criterion = { workspace = true }
+env_logger = { workspace = true }
+log = { workspace = true }
+wasm-encoder = { workspace = true }
+wasmparser = { workspace = true }
 wasmprinter = { workspace = true }
-wat = "1.238.0"
-wasm-encoder = "0.238.0"
-wasmparser = "0.238.0"
+wat = { workspace = true }
 
 [workspace]
-members = [
-    "tests/regex-test",
-]
+members = ["tests/regex-test"]
 
 [profile.bench]
 debug = true

Cargo.toml

@@ -0,0 +1 @@
+edition = "2024"

rustfmt.toml

@@ -1,9 +1,10 @@
-use anyhow::Context;
-use anyhow::Result;
-use clap::Parser;
 use std::fs;
 use std::io::{self, BufRead, Write};
 use std::path::PathBuf;
+
+use anyhow::Result;
+use clap::Parser;
+use wasmtime::error::Context;
 use wizer::Wizer;
 
 #[derive(Parser)]
@@ -168,7 +169,8 @@ fn optional_flag_with_default(flag: Option<Option<bool>>, default: bool) -> bool
     }
 }
 
-fn main() -> anyhow::Result<()> {
+#[tokio::main]
+async fn main() -> Result<()> {
     env_logger::init();
     let options = Options::parse();
 
@@ -262,10 +264,11 @@ fn main() -> anyhow::Result<()> {
 
     let output_wasm = options
         .wizer
-        .run(&mut store, &input_wasm, |store, module| {
+        .run(&mut store, &input_wasm, async |store, module| {
             linker.define_unknown_imports_as_traps(module)?;
             linker.instantiate(store, module)
-        })?;
+        })
+        .await?;
 
     output
         .write_all(&output_wasm)

src/bin/wizer.rs

@@ -1,13 +1,16 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
+use wasmtime::error::Context as _;
 use wasmtime_wasi::WasiCtxBuilder;
 use wat::parse_str as wat_to_wasm;
 use wizer::Wizer;
 
 fn get_wizer() -> Wizer {
-    Wizer::new()
+    let mut wizer = Wizer::new();
+    wizer.init_func("wizer.initialize");
+    wizer
 }
 
-fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
+async fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
     let _ = env_logger::try_init();
 
     let mut config = wasmtime::Config::new();
@@ -21,11 +24,15 @@ fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
     let wasi_ctx = WasiCtxBuilder::new().build_p1();
     let mut store = wasmtime::Store::new(&engine, wasi_ctx);
 
-    let wasm = get_wizer().run(&mut store, &wasm, |store, module| {
-        let mut linker = wasmtime::Linker::new(store.engine());
-        linker.func_wrap("foo", "bar", |x: i32| x + 1)?;
-        linker.instantiate(store, module)
-    })?;
+    let wasm = get_wizer()
+        .run(&mut store, wasm, async |store, module| {
+            let mut linker = wasmtime::Linker::new(store.engine());
+            linker.func_wrap("foo", "bar", |x: i32| x + 1)?;
+            linker.instantiate(store, module)
+        })
+        .await
+        .map_err(|e| anyhow!(e))?;
+
     log::debug!(
         "=== Wizened Wasm ==========================================================\n\
        {}\n\
@@ -40,8 +47,8 @@ fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
         wasmtime::Module::new(store.engine(), wasm).context("Wasm test case failed to compile")?;
 
     let mut linker = wasmtime::Linker::new(&engine);
-    linker.func_wrap("foo", "bar", |_: i32| -> Result<i32> {
-        Err(anyhow!("shouldn't be called"))
+    linker.func_wrap("foo", "bar", |_: i32| -> wasmtime::error::Result<i32> {
+        wasmtime::error::bail!("shouldn't be called")
     })?;
 
     let instance = linker.instantiate(&mut store, &module)?;
@@ -51,7 +58,8 @@ fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
         .ok_or_else(|| anyhow::anyhow!("the test Wasm module does not export a `run` function"))?;
 
     let mut actual = vec![wasmtime::Val::I32(0)];
-    run.call(&mut store, args, &mut actual)?;
+    run.call(&mut store, args, &mut actual)
+        .context("failed to call wasm run fn")?;
     anyhow::ensure!(actual.len() == 1, "expected one result");
     let actual = match actual[0] {
         wasmtime::Val::I32(x) => x,
@@ -67,14 +75,14 @@ fn run_wasm(args: &[wasmtime::Val], expected: i32, wasm: &[u8]) -> Result<()> {
     Ok(())
 }
 
-fn run_wat(args: &[wasmtime::Val], expected: i32, wat: &str) -> Result<()> {
+async fn run_wat(args: &[wasmtime::Val], expected: i32, wat: &str) -> Result<()> {
     let _ = env_logger::try_init();
     let wasm = wat_to_wasm(wat)?;
-    run_wasm(args, expected, &wasm)
+    run_wasm(args, expected, &wasm).await
 }
 
-#[test]
-fn custom_linker() -> Result<()> {
+#[tokio::test]
+async fn custom_linker() -> Result<()> {
     run_wat(
         &[],
         1,
@@ -93,4 +101,5 @@ fn custom_linker() -> Result<()> {
   )
 )"#,
     )
+    .await
 }

tests/make_linker.rs

@@ -1,39 +1,44 @@
 use anyhow::Result;
+use wasmtime::error::Context as _;
 use wasmtime::{Instance, Linker, Module};
 use wasmtime_wizer::Wizer;
 use wat::parse_str as wat_to_wasm;
 
-const PRELOAD1: &'static str = r#"
+const PRELOAD1: &str = r#"
 (module
  (func (export "f") (param i32) (result i32)
   local.get 0
   i32.const 1
   i32.add))
   "#;
 
-const PRELOAD2: &'static str = r#"
+const PRELOAD2: &str = r#"
 (module
  (func (export "f") (param i32) (result i32)
   local.get 0
   i32.const 2
   i32.add))
   "#;
 
-fn run_with_preloads(args: &[wasmtime::Val], wat: &str) -> Result<wasmtime::Val> {
+async fn run_with_preloads(args: &[wasmtime::Val], wat: &str) -> Result<wasmtime::Val> {
     let wasm = wat_to_wasm(wat)?;
     let engine = wasmtime::Engine::default();
     let mut store = wasmtime::Store::new(&engine, ());
     let mod1 = Module::new(store.engine(), PRELOAD1)?;
     let mod2 = Module::new(store.engine(), PRELOAD2)?;
 
-    let processed = Wizer::new().run(&mut store, &wasm, |store, module| {
-        let i1 = Instance::new(&mut *store, &mod1, &[])?;
-        let i2 = Instance::new(&mut *store, &mod2, &[])?;
-        let mut linker = Linker::new(store.engine());
-        linker.instance(&mut *store, "mod1", i1)?;
-        linker.instance(&mut *store, "mod2", i2)?;
-        linker.instantiate(store, module)
-    })?;
+    let mut wizer = Wizer::new();
+    wizer.init_func("wizer.initialize");
+    let processed = wizer
+        .run(&mut store, &wasm, async |mut store, module| {
+            let i1 = Instance::new(&mut store, &mod1, &[]).context("failed to create instance")?;
+            let i2 = Instance::new(&mut store, &mod2, &[]).context("failed to create instance")?;
+            let mut linker = Linker::new(store.engine());
+            linker.instance(&mut store, "mod1", i1)?;
+            linker.instance(&mut store, "mod2", i2)?;
+            linker.instantiate(store, module)
+        })
+        .await?;
 
     let testmod = wasmtime::Module::new(&engine, &processed[..])?;
 
@@ -48,13 +53,14 @@ fn run_with_preloads(args: &[wasmtime::Val], wat: &str) -> Result<wasmtime::Val>
         .get_func(&mut store, "run")
         .ok_or_else(|| anyhow::anyhow!("no `run` function on test module"))?;
     let mut returned = vec![wasmtime::Val::I32(0)];
-    run.call(&mut store, args, &mut returned)?;
+    run.call(&mut store, args, &mut returned)
+        .context("call failed")?;
     Ok(returned[0])
 }
 
-#[test]
-fn test_preloads() {
-    const WAT: &'static str = r#"
+#[tokio::test]
+async fn test_preloads() -> Result<()> {
+    const WAT: &str = r#"
     (module
      (import "mod1" "f" (func $mod1f (param i32) (result i32)))
      (import "mod2" "f" (func $mod2f (param i32) (result i32)))
@@ -80,6 +86,7 @@ fn test_preloads() {
     "#;
 
     let result =
-        run_with_preloads(&[wasmtime::Val::I32(200), wasmtime::Val::I32(201)], WAT).unwrap();
+        run_with_preloads(&[wasmtime::Val::I32(200), wasmtime::Val::I32(201)], WAT).await?;
     assert!(matches!(result, wasmtime::Val::I32(607)));
+    Ok(())
 }

tests/preloads.rs

@@ -2,7 +2,7 @@ Source code used to create `/wizer/tests/regex_test.wasm`.
 
 Rebuild with:
 
-```
-$ cargo build --release --target wasm32-wasi -p regex-test
-$ cp target/wasm32-wasi/release/regex_test.wasm tests/regex_test.wasm
+```console
+cargo build --release --target wasm32-wasip1 -p regex-test
+cp target/wasm32-wasip1/release/regex_test.wasm tests/regex_test.wasm
 ```

tests/regex-test/README.md

@@ -1,19 +1,20 @@
 use regex::Regex;
+use std::sync::OnceLock;
 
 /// A regex that matches numbers that start with "1".
-static mut REGEX: Option<Regex> = None;
+static REGEX: OnceLock<Regex> = OnceLock::new();
 
 #[export_name = "wizer.initialize"]
 pub fn init() {
-    unsafe {
-        REGEX = Some(Regex::new(r"^1\d*$").unwrap());
-    }
+    REGEX.get_or_init(|| Regex::new(r"^1\d*$").expect("failed to compile regex"));
 }
 
 #[no_mangle]
 pub fn run(n: i32) -> i32 {
     let s = format!("{}", n);
-    let regex = unsafe { REGEX.as_ref().unwrap() };
+    let regex = REGEX
+        .get()
+        .expect("regex should have been initialized at wizering");
     if regex.is_match(&s) {
         42
     } else {