Migrate from failure to thiserror and anyhow (#436)

* Migrate from failure to thiserror and anyhow

The failure crate invents its own traits that don't use
std::error::Error (because failure predates certain features added to
Error); this prevents using ? on an error from failure in a function
using Error. The thiserror and anyhow crates integrate with the standard
Error trait instead.

This change does not attempt to semantically change or refactor the
approach to error-handling in any portion of the code, to ensure that
the change remains straightforward to review. Modules using specific
differentiated error types move from failure_derive and derive(Fail) to
thiserror and derive(Error). Modules boxing all errors opaquely move
from failure::Error to anyhow. Modules using String as an error type
continue to do so. Code using unwrap or expect continues to do so.

Drop Display implementations when thiserror can easily derive an
identical instance.

Drop manual traversal of iter_causes; anyhow's Debug instance prints the
chain of causes by default.

Use anyhow's type alias anyhow::Result<T> in place of
std::result::Result<T, anyhow::Error> whenever possible.

* wasm2obj: Simplify error handling using existing messages

handle_module in wasm2obj manually maps
cranelift_codegen::isa::LookupError values to strings, but LookupError
values already have strings that say almost exactly the same thing.
Rely on the strings from cranelift.

* wasmtime: Rely on question-mark-in-main

The main() wrapper around rmain() completely matches the behavior of
question-mark-in-main (print error to stderr and return 1), so switch to
question-mark-in-main.

* Update to walrus 0.13 and wasm-webidl-bindings 0.6

Both crates switched from failure to anyhow; updating lets us avoid a
translation from failure to anyhow within wasmtime-interface-types.

wasmtime-api/src/instance.rs

@@ -9,8 +9,8 @@ use alloc::boxed::Box;
 use alloc::rc::Rc;
 use alloc::string::{String, ToString};
 use alloc::vec::Vec;
+use anyhow::Result;
 use core::cell::RefCell;
-use failure::Error;
 
 use wasmtime_jit::{instantiate, Resolver};
 use wasmtime_runtime::{Export, InstanceHandle};
@@ -34,7 +34,7 @@ pub fn instantiate_in_context(
     imports: Vec<(String, String, Extern)>,
     mut context: Context,
     exports: Rc<RefCell<HashMap<String, Option<wasmtime_runtime::Export>>>>,
-) -> Result<(InstanceHandle, HashSet<Context>), Error> {
+) -> Result<(InstanceHandle, HashSet<Context>)> {
     let mut contexts = HashSet::new();
     let debug_info = context.debug_info();
     let mut resolver = SimpleResolver { imports };
@@ -64,7 +64,7 @@ impl Instance {
         store: HostRef<Store>,
         module: HostRef<Module>,
         externs: &[Extern],
-    ) -> Result<Instance, Error> {
+    ) -> Result<Instance> {
         let context = store.borrow_mut().context().clone();
         let exports = store.borrow_mut().global_exports().clone();
         let imports = module
@@ -105,7 +105,7 @@ impl Instance {
     pub fn from_handle(
         store: HostRef<Store>,
         instance_handle: InstanceHandle,
-    ) -> Result<(Instance, HashMap<String, usize>), Error> {
+    ) -> Result<(Instance, HashMap<String, usize>)> {
         let contexts = HashSet::new();
 
         let mut exports = Vec::new();

wasmtime-api/src/lib.rs

@@ -17,8 +17,6 @@ mod values;
 #[cfg(feature = "wasm-c-api")]
 pub mod wasm;
 
-#[macro_use]
-extern crate failure_derive;
 #[macro_use]
 extern crate alloc;
 

wasmtime-api/src/module.rs

@@ -7,7 +7,7 @@ use crate::types::{
 use alloc::boxed::Box;
 use alloc::string::String;
 use alloc::vec::Vec;
-use failure::Error;
+use anyhow::Result;
 
 use wasmparser::{validate, ExternalKind, ImportSectionEntryType, ModuleReader, SectionCode};
 
@@ -61,9 +61,7 @@ fn into_table_type(tt: wasmparser::TableType) -> TableType {
     TableType::new(ty, limits)
 }
 
-fn read_imports_and_exports(
-    binary: &[u8],
-) -> Result<(Box<[ImportType]>, Box<[ExportType]>), Error> {
+fn read_imports_and_exports(binary: &[u8]) -> Result<(Box<[ImportType]>, Box<[ExportType]>)> {
     let mut reader = ModuleReader::new(binary)?;
     let mut imports = Vec::new();
     let mut exports = Vec::new();
@@ -184,7 +182,7 @@ pub struct Module {
 }
 
 impl Module {
-    pub fn new(store: HostRef<Store>, binary: &[u8]) -> Result<Module, Error> {
+    pub fn new(store: HostRef<Store>, binary: &[u8]) -> Result<Module> {
         let (imports, exports) = read_imports_and_exports(binary)?;
         Ok(Module {
             store,

wasmtime-api/src/trampoline/create_handle.rs

@@ -1,9 +1,9 @@
 //! Support for a calling of an imported function.
 
+use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use cranelift_wasm::DefinedFuncIndex;
 //use target_lexicon::HOST;
-use failure::Error;
 use wasmtime_environ::Module;
 use wasmtime_runtime::{Imports, InstanceHandle, VMFunctionBody};
 
@@ -22,7 +22,7 @@ pub(crate) fn create_handle(
     signature_registry: Option<RefMut<Store>>,
     finished_functions: PrimaryMap<DefinedFuncIndex, *const VMFunctionBody>,
     state: Box<dyn Any>,
-) -> Result<InstanceHandle, Error> {
+) -> Result<InstanceHandle> {
     let global_exports: Rc<RefCell<HashMap<String, Option<wasmtime_runtime::Export>>>> =
         Rc::new(RefCell::new(HashMap::new()));
 

wasmtime-api/src/trampoline/func.rs

@@ -1,6 +1,7 @@
 //! Support for a calling of an imported function.
 
 use crate::r#ref::HostRef;
+use anyhow::Result;
 use cranelift_codegen::ir::types;
 use cranelift_codegen::ir::{InstBuilder, StackSlotData, StackSlotKind, TrapCode};
 use cranelift_codegen::Context;
@@ -9,7 +10,6 @@ use cranelift_entity::{EntityRef, PrimaryMap};
 use cranelift_frontend::{FunctionBuilder, FunctionBuilderContext};
 use cranelift_wasm::{DefinedFuncIndex, FuncIndex};
 //use target_lexicon::HOST;
-use failure::Error;
 use wasmtime_environ::{Export, Module};
 use wasmtime_jit::CodeMemory;
 use wasmtime_runtime::{InstanceHandle, VMContext, VMFunctionBody};
@@ -195,7 +195,7 @@ pub fn create_handle_with_function(
     ft: &FuncType,
     func: &Rc<dyn Callable + 'static>,
     store: &HostRef<Store>,
-) -> Result<InstanceHandle, Error> {
+) -> Result<InstanceHandle> {
     let sig = ft.get_cranelift_signature().clone();
 
     let isa = {

wasmtime-api/src/trampoline/global.rs

@@ -1,6 +1,6 @@
 use alloc::boxed::Box;
+use anyhow::Result;
 use cranelift_entity::PrimaryMap;
-use failure::Error;
 use wasmtime_environ::Module;
 use wasmtime_runtime::{InstanceHandle, VMGlobalDefinition};
 
@@ -13,10 +13,7 @@ pub struct GlobalState {
     handle: InstanceHandle,
 }
 
-pub fn create_global(
-    gt: &GlobalType,
-    val: Val,
-) -> Result<(wasmtime_runtime::Export, GlobalState), Error> {
+pub fn create_global(gt: &GlobalType, val: Val) -> Result<(wasmtime_runtime::Export, GlobalState)> {
     let mut definition = Box::new(VMGlobalDefinition::new());
     unsafe {
         match val {

wasmtime-api/src/trampoline/memory.rs

@@ -1,7 +1,7 @@
 use alloc::boxed::Box;
 use alloc::string::ToString;
+use anyhow::Result;
 use cranelift_entity::PrimaryMap;
-use failure::Error;
 use wasmtime_environ::Module;
 use wasmtime_runtime::InstanceHandle;
 
@@ -10,7 +10,7 @@ use crate::MemoryType;
 
 #[allow(dead_code)]
 
-pub fn create_handle_with_memory(memory: &MemoryType) -> Result<InstanceHandle, Error> {
+pub fn create_handle_with_memory(memory: &MemoryType) -> Result<InstanceHandle> {
     let mut module = Module::new();
 
     let memory = cranelift_wasm::Memory {

wasmtime-api/src/trampoline/mod.rs

@@ -8,7 +8,7 @@ mod table;
 
 use crate::r#ref::HostRef;
 use alloc::rc::Rc;
-use failure::Error;
+use anyhow::Result;
 
 use self::func::create_handle_with_function;
 use self::global::create_global;
@@ -22,7 +22,7 @@ pub fn generate_func_export(
     ft: &FuncType,
     func: &Rc<dyn Callable + 'static>,
     store: &HostRef<Store>,
-) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export), Error> {
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
     let mut instance = create_handle_with_function(ft, func, store)?;
     let export = instance.lookup("trampoline").expect("trampoline export");
     Ok((instance, export))
@@ -31,13 +31,13 @@ pub fn generate_func_export(
 pub fn generate_global_export(
     gt: &GlobalType,
     val: Val,
-) -> Result<(wasmtime_runtime::Export, GlobalState), Error> {
+) -> Result<(wasmtime_runtime::Export, GlobalState)> {
     create_global(gt, val)
 }
 
 pub fn generate_memory_export(
     m: &MemoryType,
-) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export), Error> {
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
     let mut instance = create_handle_with_memory(m)?;
     let export = instance.lookup("memory").expect("memory export");
     Ok((instance, export))
@@ -45,7 +45,7 @@ pub fn generate_memory_export(
 
 pub fn generate_table_export(
     t: &TableType,
-) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export), Error> {
+) -> Result<(wasmtime_runtime::InstanceHandle, wasmtime_runtime::Export)> {
     let mut instance = create_handle_with_table(t)?;
     let export = instance.lookup("table").expect("table export");
     Ok((instance, export))

wasmtime-api/src/trampoline/table.rs

@@ -1,15 +1,15 @@
 use alloc::boxed::Box;
 use alloc::string::ToString;
+use anyhow::Result;
 use cranelift_entity::PrimaryMap;
 use cranelift_wasm::TableElementType;
-use failure::Error;
 use wasmtime_environ::Module;
 use wasmtime_runtime::InstanceHandle;
 
 use super::create_handle::create_handle;
 use crate::{TableType, ValType};
 
-pub fn create_handle_with_table(table: &TableType) -> Result<InstanceHandle, Error> {
+pub fn create_handle_with_table(table: &TableType) -> Result<InstanceHandle> {
     let mut module = Module::new();
 
     let table = cranelift_wasm::Table {

wasmtime-api/src/trap.rs

@@ -1,7 +1,8 @@
 use alloc::string::{String, ToString};
+use thiserror::Error;
 
-#[derive(Fail, Debug)]
-#[fail(display = "Wasm trap")]
+#[derive(Error, Debug)]
+#[error("Wasm trap: {message}")]
 pub struct Trap {
     message: String,
 }

wasmtime-api/src/wasm.rs

@@ -682,7 +682,7 @@ pub unsafe extern "C" fn wasm_instance_new(
         }
         Err(_) => {
             if !result.is_null() {
-                // TODO Unwrap trap from failure::Error
+                // TODO Unwrap trap from error
                 let trap = Box::new(wasm_trap_t {
                     trap: HostRef::new(Trap::new("trap during instantiation".to_string())),
                 });