Rely on core::error::Error

With Wasmtime's new MSRV at 1.81 this means that `core::error::Error` is
available which means that in `no_std` mode the `Error` trait can be
used. This has been integrated into `anyhow::Error` already upstream and
means that we can remove our own local hacks such as the `Err2Anyhow` trait.

This commit removes the `Err2Anyhow` trait and all usage, going back to
idiomatic Rust error propagation and conversion even in the `no_std`
world. This should make code more portable by default and remove some
weird idioms we had for supporting this.

prtest:full

Cargo.toml

@@ -291,10 +291,10 @@ wasm-wave = "0.221.2"
 # Non-Bytecode Alliance maintained dependencies:
 # --------------------------
 cc = "1.0"
-object = { version = "0.36", default-features = false, features = ['read_core', 'elf'] }
+object = { version = "0.36.5", default-features = false, features = ['read_core', 'elf'] }
 gimli = { version = "0.31.0", default-features = false, features = ['read'] }
 addr2line = { version = "0.24.1", default-features = false }
-anyhow = { version = "1.0.22", default-features = false }
+anyhow = { version = "1.0.93", default-features = false }
 windows-sys = "0.59.0"
 env_logger = "0.11.5"
 log = { version = "0.4.8", default-features = false }
@@ -317,7 +317,7 @@ proptest = "1.0.0"
 rand = { version = "0.8.3", features = ["small_rng"] }
 sptr = "0.3.2"
 # serde and serde_derive must have the same version
-serde = { version = "1.0.188", default-features = false, features = ['alloc'] }
+serde = { version = "1.0.215", default-features = false, features = ['alloc'] }
 serde_derive = "1.0.188"
 serde_json = "1.0.80"
 glob = "0.3.0"

crates/environ/src/compile/mod.rs

@@ -59,8 +59,7 @@ impl From<WasmError> for CompileError {
     }
 }
 
-#[cfg(feature = "std")]
-impl std::error::Error for CompileError {
+impl core::error::Error for CompileError {
     fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
         match self {
             CompileError::Wasm(e) => Some(e),

crates/environ/src/obj.rs

@@ -1,6 +1,8 @@
 //! Utilities for working with object files that operate as Wasmtime's
 //! serialization and intermediate format for compiled modules.
 
+use core::fmt;
+
 /// Filler for the `os_abi` field of the ELF header.
 ///
 /// This is just a constant that seems reasonable in the sense it's unlikely to
@@ -177,3 +179,21 @@ libcalls! {
     FmaF64 = "libcall_fmaf64"
     X86Pshufb = "libcall_x86_pshufb"
 }
+
+/// Workaround to implement `core::error::Error` until
+/// gimli-rs/object#747 is settled.
+pub struct ObjectCrateErrorWrapper(pub object::Error);
+
+impl fmt::Debug for ObjectCrateErrorWrapper {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl fmt::Display for ObjectCrateErrorWrapper {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl core::error::Error for ObjectCrateErrorWrapper {}

crates/environ/src/prelude.rs

@@ -26,61 +26,3 @@ pub use alloc::string::{String, ToString};
 pub use alloc::vec;
 pub use alloc::vec::Vec;
 pub use wasmparser::collections::{IndexMap, IndexSet};
-
-/// Convenience trait for converting `Result<T, E>` into `anyhow::Result<T>`
-///
-/// Typically this is automatically done with the `?` operator in Rust and
-/// by default this trait isn't necessary. With the `anyhow` crate's `std`
-/// feature disabled, however, the `?` operator won't work because the `Error`
-/// trait is not defined. This trait helps to bridge this gap.
-///
-/// This does the same thing as `?` when the `std` feature is enabled, and when
-/// `std` is disabled it'll use different trait bounds to create an
-/// `anyhow::Error`.
-///
-/// This trait is not suitable as a public interface because features change
-/// what implements the trait. It's good enough for a wasmtime internal
-/// implementation detail, however.
-pub trait Err2Anyhow<T> {
-    /// Convert `self` to `anyhow::Result<T>`.
-    fn err2anyhow(self) -> anyhow::Result<T>;
-}
-
-impl<T, E: IntoAnyhow> Err2Anyhow<T> for Result<T, E> {
-    fn err2anyhow(self) -> anyhow::Result<T> {
-        match self {
-            Ok(e) => Ok(e),
-            Err(e) => Err(e.into_anyhow()),
-        }
-    }
-}
-
-/// Convenience trait to convert a value into `anyhow::Error`
-///
-/// This trait is not a suitable public interface of Wasmtime so it's just an
-/// internal implementation detail for now. This trait is conditionally
-/// implemented on the `std` feature with different bounds.
-pub trait IntoAnyhow {
-    /// Converts `self` into an `anyhow::Error`.
-    fn into_anyhow(self) -> anyhow::Error;
-}
-
-#[cfg(feature = "std")]
-impl<T> IntoAnyhow for T
-where
-    T: Into<anyhow::Error>,
-{
-    fn into_anyhow(self) -> anyhow::Error {
-        self.into()
-    }
-}
-
-#[cfg(not(feature = "std"))]
-impl<T> IntoAnyhow for T
-where
-    T: core::fmt::Display + core::fmt::Debug + Send + Sync + 'static,
-{
-    fn into_anyhow(self) -> anyhow::Error {
-        anyhow::Error::msg(self)
-    }
-}