Migrate fuzzing to wasmtime::error (#12263)

* Migrate fuzzing to `wasmtime::error`

* fix

Author: fitzgen

Cargo.lock

@@ -15,7 +15,6 @@ workspace = true
 wasmtime-test-util = { workspace = true, features = ['wast'] }
 
 [dependencies]
-anyhow = { workspace = true }
 backtrace = { workspace = true }
 arbitrary = { workspace = true, features = ["derive"] }
 env_logger = { workspace = true }

crates/fuzzing/Cargo.toml

@@ -2,9 +2,9 @@
 
 use super::{AsyncConfig, CodegenSettings, InstanceAllocationStrategy, MemoryConfig, ModuleConfig};
 use crate::oracles::{StoreLimits, Timeout};
-use anyhow::Result;
 use arbitrary::{Arbitrary, Unstructured};
 use std::time::Duration;
+use wasmtime::Result;
 use wasmtime::{Enabled, Engine, Module, Store};
 use wasmtime_test_util::wast::{WastConfig, WastTest, limits};
 

crates/fuzzing/src/generators/config.rs

@@ -90,7 +90,7 @@ mod test {
     use rand::prelude::*;
 
     pub fn gen_until_pass<T: for<'a> Arbitrary<'a>>(
-        mut f: impl FnMut(T, &mut Unstructured<'_>) -> anyhow::Result<bool>,
+        mut f: impl FnMut(T, &mut Unstructured<'_>) -> wasmtime::Result<bool>,
     ) -> bool {
         let mut rng = SmallRng::seed_from_u64(0);
         let mut buf = vec![0; 2048];

crates/fuzzing/src/lib.rs

@@ -321,7 +321,7 @@ fn compile_module(
 ) -> Option<Module> {
     log_wasm(bytes);
 
-    fn is_pcc_error(e: &anyhow::Error) -> bool {
+    fn is_pcc_error(e: &wasmtime::Error) -> bool {
         // NOTE: please keep this predicate in sync with the display format of CodegenError,
         // defined in `wasmtime/cranelift/codegen/src/result.rs`
         e.to_string().to_lowercase().contains("proof-carrying-code")
@@ -400,7 +400,7 @@ pub fn instantiate_with_dummy(store: &mut Store<StoreLimits>, module: &Module) -
 
 fn unwrap_instance(
     store: &Store<StoreLimits>,
-    instance: anyhow::Result<Instance>,
+    instance: wasmtime::Result<Instance>,
 ) -> Option<Instance> {
     let e = match instance {
         Ok(i) => return Some(i),
@@ -460,7 +460,7 @@ pub fn differential(
     name: &str,
     args: &[DiffValue],
     result_tys: &[DiffValueType],
-) -> anyhow::Result<bool> {
+) -> wasmtime::Result<bool> {
     log::debug!("Evaluating: `{name}` with {args:?}");
     let lhs_results = match lhs.evaluate(name, args, result_tys) {
         Ok(Some(results)) => Ok(results),
@@ -1324,7 +1324,7 @@ mod tests {
                 let ok =
                     Validator::new_with_features(WasmFeatures::all() ^ feature).validate_all(&wasm);
                 if ok.is_err() {
-                    anyhow::bail!("generated a module with {feature:?} but that wasn't expected");
+                    wasmtime::bail!("generated a module with {feature:?} but that wasn't expected");
                 }
             }
 

crates/fuzzing/src/oracles.rs

@@ -226,7 +226,7 @@ where
     fn host_function<P, R>(
         cx: StoreContextMut<'_, Box<dyn Any + Send>>,
         params: P,
-    ) -> anyhow::Result<R>
+    ) -> wasmtime::Result<R>
     where
         P: Debug + PartialEq + 'static,
         R: Debug + Clone + 'static,

crates/fuzzing/src/oracles/component_api.rs

@@ -3,9 +3,8 @@
 
 use crate::generators::{Config, DiffValue, DiffValueType};
 use crate::oracles::engine::{DiffEngine, DiffInstance};
-use anyhow::{Error, Result, anyhow};
 use wasm_spec_interpreter::SpecValue;
-use wasmtime::Trap;
+use wasmtime::{Error, Result, Trap, format_err};
 
 /// A wrapper for `wasm-spec-interpreter` as a [`DiffEngine`].
 pub struct SpecInterpreter;
@@ -41,7 +40,7 @@ impl DiffEngine for SpecInterpreter {
 
     fn instantiate(&mut self, wasm: &[u8]) -> Result<Box<dyn DiffInstance>> {
         let instance = wasm_spec_interpreter::instantiate(wasm)
-            .map_err(|e| anyhow!("failed to instantiate in spec interpreter: {e}"))?;
+            .map_err(|e| format_err!("failed to instantiate in spec interpreter: {e}"))?;
         Ok(Box::new(SpecInstance { instance }))
     }
 
@@ -73,7 +72,7 @@ impl DiffInstance for SpecInstance {
         let arguments = arguments.iter().map(SpecValue::from).collect();
         match wasm_spec_interpreter::interpret(&self.instance, function_name, Some(arguments)) {
             Ok(results) => Ok(Some(results.into_iter().map(SpecValue::into).collect())),
-            Err(err) => Err(anyhow!(err)),
+            Err(err) => Err(format_err!(err)),
         }
     }
 

crates/fuzzing/src/oracles/diff_spec.rs

@@ -1,10 +1,9 @@
 use crate::generators::{Config, DiffValue, DiffValueType};
 use crate::oracles::engine::{DiffEngine, DiffInstance};
-use anyhow::{Error, Result, bail};
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::sync::Once;
-use wasmtime::Trap;
+use wasmtime::{Error, Result, Trap, bail};
 
 pub struct V8Engine {
     isolate: Rc<RefCell<v8::OwnedIsolate>>,

crates/fuzzing/src/oracles/diff_v8.rs

@@ -2,8 +2,7 @@
 
 use crate::generators::{Config, DiffValue, DiffValueType};
 use crate::oracles::engine::{DiffEngine, DiffInstance};
-use anyhow::{Context, Error, Result};
-use wasmtime::Trap;
+use wasmtime::{Error, Result, Trap, error::Context as _};
 
 /// A wrapper for `wasmi` as a [`DiffEngine`].
 pub struct WasmiEngine {

crates/fuzzing/src/oracles/diff_wasmi.rs

@@ -5,9 +5,10 @@ use crate::oracles::dummy;
 use crate::oracles::engine::DiffInstance;
 use crate::oracles::{StoreLimits, compile_module, engine::DiffEngine};
 use crate::single_module_fuzzer::KnownValid;
-use anyhow::{Context, Error, Result};
 use arbitrary::Unstructured;
-use wasmtime::{Extern, FuncType, Instance, Module, Store, Trap, Val};
+use wasmtime::{
+    Error, Extern, FuncType, Instance, Module, Result, Store, Trap, Val, error::Context as _,
+};
 
 /// A wrapper for using Wasmtime as a [`DiffEngine`].
 pub struct WasmtimeEngine {