Migrate wasmtime-cli to wasmtime::error

Author: fitzgen

Cargo.lock

@@ -62,7 +62,6 @@ wasmtime-unwinder = { workspace = true }
 wasmtime-wizer = { workspace = true, optional = true, features = ['clap', 'wasmtime'] }
 clap = { workspace = true }
 clap_complete = { workspace = true, optional = true }
-anyhow = { workspace = true, features = ['std'] }
 target-lexicon = { workspace = true }
 listenfd = { version = "1.0.0", optional = true }
 wat = { workspace = true, optional = true }
@@ -139,9 +138,6 @@ windows-sys = { workspace = true, features = ["Win32_System_Memory"] }
 [target.'cfg(unix)'.dev-dependencies]
 rustix = { workspace = true, features = ["param"] }
 
-[build-dependencies]
-anyhow = { workspace = true, features = ['std'] }
-
 [profile.release.build-override]
 opt-level = 0
 

Cargo.toml

@@ -1,9 +1,8 @@
-use anyhow::Context;
 use std::{fs, path::Path};
-
 use wasmtime::{
     Config, Engine, Result, Store,
     component::{Component, HasSelf, Linker, bindgen},
+    error::Context as _,
 };
 
 // Generate bindings of the guest and host components.

examples/component/main.rs

@@ -3,8 +3,8 @@
 //! an example of setup for asynchronous usage, see
 //! `tests/all/epoch_interruption.rs`
 
-use anyhow::Error;
 use std::sync::Arc;
+use wasmtime::Error;
 use wasmtime::{Config, Engine, Instance, Module, Store};
 
 fn main() -> Result<(), Error> {

examples/epochs.rs

@@ -1,6 +1,6 @@
 //! Tuning Wasmtime for fast instantiation.
 
-use anyhow::anyhow;
+use wasmtime::format_err;
 use wasmtime::{
     Config, Engine, InstanceAllocationStrategy, Linker, Module, PoolingAllocationConfig, Result,
     Store,
@@ -85,7 +85,7 @@ fn main() -> Result<()> {
 
     // Wait for the threads to finish.
     for h in handles.into_iter() {
-        h.join().map_err(|_| anyhow!("thread panicked!"))??;
+        h.join().map_err(|_| format_err!("thread panicked!"))??;
     }
 
     Ok(())

examples/fast_instantiation.rs

@@ -18,7 +18,7 @@ fn main() -> Result<()> {
     // load_fn up our exports from the instance
     let memory = instance
         .get_memory(&mut store, "memory")
-        .ok_or(anyhow::format_err!("failed to find `memory` export"))?;
+        .ok_or(wasmtime::format_err!("failed to find `memory` export"))?;
     let size = instance.get_typed_func::<(), i32>(&mut store, "size")?;
     let load_fn = instance.get_typed_func::<i32, i32>(&mut store, "load")?;
     let store_fn = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store")?;

examples/memory.rs

@@ -31,11 +31,11 @@
 //! $ sysctl vm.max_map_count=$LARGER_LIMIT
 //! ```
 
-use anyhow::anyhow;
 use bytesize::ByteSize;
 use clap::Parser;
 use log::{info, warn};
 use std::str::FromStr;
+use wasmtime::format_err;
 use wasmtime::*;
 
 fn main() -> Result<()> {
@@ -84,7 +84,7 @@ struct Args {
 /// Parse a human-readable byte size--e.g., "512 MiB"--into the correct number
 /// of bytes.
 fn parse_byte_size(value: &str) -> Result<u64> {
-    let size = ByteSize::from_str(value).map_err(|e| anyhow!(e))?;
+    let size = ByteSize::from_str(value).map_err(|e| format_err!(e))?;
     Ok(size.as_u64())
 }
 
@@ -239,15 +239,15 @@ fn num_bytes_mapped() -> Result<usize> {
         let range = line
             .split_whitespace()
             .next()
-            .ok_or(anyhow!("parse failure: expected whitespace"))?;
+            .ok_or(format_err!("parse failure: expected whitespace"))?;
         let mut addresses = range.split("-");
-        let start = addresses
-            .next()
-            .ok_or(anyhow!("parse failure: expected dash-separated address"))?;
+        let start = addresses.next().ok_or(format_err!(
+            "parse failure: expected dash-separated address"
+        ))?;
         let start = usize::from_str_radix(start, 16)?;
-        let end = addresses
-            .next()
-            .ok_or(anyhow!("parse failure: expected dash-separated address"))?;
+        let end = addresses.next().ok_or(format_err!(
+            "parse failure: expected dash-separated address"
+        ))?;
         let end = usize::from_str_radix(end, 16)?;
 
         total += end - start;
@@ -257,5 +257,5 @@ fn num_bytes_mapped() -> Result<usize> {
 
 #[cfg(not(target_os = "linux"))]
 fn num_bytes_mapped() -> Result<usize> {
-    anyhow::bail!("this example can only read virtual memory maps on Linux")
+    wasmtime::bail!("this example can only read virtual memory maps on Linux")
 }

examples/mpk.rs

@@ -7,7 +7,7 @@
 
 // You can execute this example with `cargo run --example multi`
 
-use anyhow::Result;
+use wasmtime::Result;
 
 fn main() -> Result<()> {
     use wasmtime::*;

examples/multi.rs

@@ -23,14 +23,14 @@ fn main() -> Result<()> {
 
     let memory0 = instance
         .get_memory(&mut store, "memory0")
-        .ok_or(anyhow::format_err!("failed to find `memory0` export"))?;
+        .ok_or(wasmtime::format_err!("failed to find `memory0` export"))?;
     let size0 = instance.get_typed_func::<(), i32>(&mut store, "size0")?;
     let load0 = instance.get_typed_func::<i32, i32>(&mut store, "load0")?;
     let store0 = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store0")?;
 
     let memory1 = instance
         .get_memory(&mut store, "memory1")
-        .ok_or(anyhow::format_err!("failed to find `memory1` export"))?;
+        .ok_or(wasmtime::format_err!("failed to find `memory1` export"))?;
     let size1 = instance.get_typed_func::<(), i32>(&mut store, "size1")?;
     let load1 = instance.get_typed_func::<i32, i32>(&mut store, "load1")?;
     let store1 = instance.get_typed_func::<(i32, i32), ()>(&mut store, "store1")?;

examples/multimemory.rs

@@ -1,6 +1,6 @@
-use anyhow::Error;
 use std::sync::Arc;
 use tokio::time::Duration;
+use wasmtime::Error;
 use wasmtime::{Config, Engine, Linker, Module, Store};
 use wasmtime_wasi::{WasiCtx, p1::WasiP1Ctx};