Fix spectests

lib/runtime/src/error.rs

@@ -9,14 +9,24 @@ pub type CallResult<T> = std::result::Result<T, Box<CallError>>;
 /// This is returned when the chosen compiler is unable to
 /// successfully compile the provided webassembly module into
 /// a `Module`.
+///
+/// Comparing two `CompileError`s always evaluates to false.
 #[derive(Debug, Clone)]
 pub enum CompileError {
     ValidationError { msg: String },
     InternalError { msg: String },
 }
 
+impl PartialEq for CompileError {
+    fn eq(&self, _other: &CompileError) -> bool {
+        false
+    }
+}
+
 /// This is returned when the runtime is unable to
 /// correctly link the module with the provided imports.
+///
+/// Comparing two `LinkError`s always evaluates to false.
 #[derive(Debug, Clone)]
 pub enum LinkError {
     IncorrectImportType {
@@ -55,10 +65,18 @@ pub enum LinkError {
     },
 }
 
+impl PartialEq for LinkError {
+    fn eq(&self, _other: &LinkError) -> bool {
+        false
+    }
+}
+
 /// This is the error type returned when calling
 /// a webassembly function.
 ///
 /// The main way to do this is `Instance.call`.
+///
+/// Comparing two `RuntimeError`s always evaluates to false.
 #[derive(Debug, Clone)]
 pub enum RuntimeError {
     OutOfBoundsAccess { memory: MemoryIndex, addr: u32 },
@@ -67,50 +85,78 @@ pub enum RuntimeError {
     Unknown { msg: String },
 }
 
+impl PartialEq for RuntimeError {
+    fn eq(&self, _other: &RuntimeError) -> bool {
+        false
+    }
+}
+
 /// This error type is produced by calling a wasm function
 /// exported from a module.
 ///
 /// If the module traps in some way while running, this will
 /// be the `CallError::Runtime(RuntimeError)` variant.
+///
+/// Comparing two `CallError`s always evaluates to false.
 #[derive(Debug, Clone)]
 pub enum CallError {
     Signature { expected: FuncSig, found: Vec<Type> },
     NoSuchExport { name: String },
     ExportNotFunc { name: String },
-    Runtime(Box<RuntimeError>),
+    Runtime(RuntimeError),
+}
+
+impl PartialEq for CallError {
+    fn eq(&self, _other: &CallError) -> bool {
+        false
+    }
 }
 
 /// The amalgamation of all errors that can occur
 /// during the compilation, instantiation, or execution
 /// of a webassembly module.
+///
+/// Comparing two `Error`s always evaluates to false.
 #[derive(Debug, Clone)]
 pub enum Error {
-    CompileError(Box<CompileError>),
-    LinkError(Box<LinkError>),
-    RuntimeError(Box<RuntimeError>),
-    CallError(Box<CallError>),
+    CompileError(CompileError),
+    LinkError(LinkError),
+    RuntimeError(RuntimeError),
+    CallError(CallError),
+}
+
+impl PartialEq for Error {
+    fn eq(&self, _other: &Error) -> bool {
+        false
+    }
 }
 
 impl From<Box<CompileError>> for Box<Error> {
     fn from(compile_err: Box<CompileError>) -> Self {
-        Box::new(Error::CompileError(compile_err))
+        Box::new(Error::CompileError(*compile_err))
     }
 }
 
 impl From<Box<LinkError>> for Box<Error> {
     fn from(link_err: Box<LinkError>) -> Self {
-        Box::new(Error::LinkError(link_err))
+        Box::new(Error::LinkError(*link_err))
     }
 }
 
 impl From<Box<RuntimeError>> for Box<Error> {
     fn from(runtime_err: Box<RuntimeError>) -> Self {
-        Box::new(Error::RuntimeError(runtime_err))
+        Box::new(Error::RuntimeError(*runtime_err))
     }
 }
 
 impl From<Box<CallError>> for Box<Error> {
     fn from(call_err: Box<CallError>) -> Self {
-        Box::new(Error::CallError(call_err))
+        Box::new(Error::CallError(*call_err))
+    }
+}
+
+impl From<Box<RuntimeError>> for Box<CallError> {
+    fn from(runtime_err: Box<RuntimeError>) -> Self {
+        Box::new(CallError::Runtime(*runtime_err))
     }
 }

lib/runtime/src/instance.rs

@@ -138,7 +138,7 @@ impl Instance {
             .chain(iter::once(libffi_arg(&vmctx_ptr)))
             .collect();
 
-        call_protected(|| {
+        Ok(call_protected(|| {
             signature
                 .returns
                 .first()
@@ -155,8 +155,7 @@ impl Instance {
                     }
                     None
                 })
-        })
-        .map_err(|e| CallError::Runtime(e).into())
+        })?)
     }
 }