Added custom error test

lib/js-api/src/native.rs

@@ -80,7 +80,7 @@ macro_rules! impl_native_traits {
                 let results = self.exported.function.apply(
                     &JsValue::UNDEFINED,
                     &Array::from_iter(params_list.iter())
-                ).unwrap();
+                )?;
                 let mut rets_list_array = Rets::empty_array();
                 let mut_rets = rets_list_array.as_mut() as *mut [i128] as *mut i128;
                 match Rets::size() {

lib/js-api/src/trap.rs

@@ -2,8 +2,10 @@
 use std::error::Error;
 use std::fmt;
 use std::sync::Arc;
+use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
+use wasm_bindgen::JsCast;
 
 /// A struct representing an aborted instruction execution, with a message
 /// indicating the cause.
@@ -57,8 +59,13 @@ impl RuntimeError {
 
     /// Raises a custom user Error
     pub fn raise(error: Box<dyn Error + Send + Sync>) -> ! {
-        let error = RuntimeError {
+        let error = if error.is::<RuntimeError>() {
+            *error.downcast::<RuntimeError>().unwrap()
+        }
+        else {
+            RuntimeError {
                 inner: Arc::new(RuntimeErrorSource::User(error)),
+            }
         };
         let js_error: JsValue = error.into();
         wasm_bindgen::throw_val(js_error)
@@ -119,11 +126,18 @@ impl From<JsValue> for RuntimeError {
         RuntimeError {
             inner: Arc::new(RuntimeErrorSource::Js(original)),
         }
-    }
+        // let into_runtime: Result<RuntimeError, _> = original.clone().try_into();
-}
+        // match into_runtime {
-
+        //     Ok(rt) => rt,
-// impl Into<JsValue> for RuntimeError {
+        //     Err(_) =>         RuntimeError {
-//     fn into(self) -> JsValue {
+        //         inner: Arc::new(RuntimeErrorSource::Js(original)),
-
         //     }    
         // }
+        // match original.dyn_into::<RuntimeError>() {
+        //     Ok(rt) => rt,
+        //     Err(original) =>         RuntimeError {
+        //         inner: Arc::new(RuntimeErrorSource::Js(original)),
+        //     }    
+        // }
+    }
+}

lib/js-api/tests/instance.rs

@@ -585,3 +585,69 @@ fn test_native_function() {
     let add_one: NativeFunc<i32, i32> = instance.exports.get_native_function("add_one").unwrap();
     assert_eq!(add_one.call(1), Ok(2));
 }
+
+#[wasm_bindgen_test]
+fn test_custom_error() {
+    let store = Store::default();
+    let module = Module::new(
+        &store,
+        br#"
+(module
+  (type $run_t (func (param i32 i32) (result i32)))
+  (type $early_exit_t (func (param) (result)))
+  (import "env" "early_exit" (func $early_exit (type $early_exit_t)))
+  (func $run (type $run_t) (param $x i32) (param $y i32) (result i32)
+    (call $early_exit)
+    (i32.add
+        local.get $x
+        local.get $y))
+  (export "run" (func $run)))
+"#,
+    ).unwrap();
+
+    use std::fmt;
+
+    #[derive(Debug, Clone, Copy)]
+    struct ExitCode(u32);
+    
+    impl fmt::Display for ExitCode {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "{}", self.0)
+        }
+    }
+    
+    impl std::error::Error for ExitCode {}
+
+    fn early_exit() {
+        RuntimeError::raise(Box::new(ExitCode(1)));
+    }
+
+    let import_object = imports! {
+        "env" => {
+            "early_exit" => Function::new_native(&store, early_exit),
+        }
+    };
+    let instance = Instance::new(&module, &import_object).unwrap();
+
+    let run_func: NativeFunc<(i32, i32), i32> = instance.exports.get_native_function("run").unwrap();
+
+    match run_func.call(1, 7) {
+        Ok(result) => {
+            assert!(false,
+                "Expected early termination with `ExitCode`, found: {}",
+                result
+            );
+        }
+        Err(e) => {
+            assert!(false, "Unknown error `{:?}`", e);
+            match e.downcast::<ExitCode>() {
+            // We found the exit code used to terminate execution.
+            Ok(exit_code) => {
+                assert_eq!(exit_code.0, 1);
+            }
+            Err(e) => {
+                assert!(false, "Unknown error `{:?}` found. expected `ErrorCode`", e);
+            }
+        }},
+    }
+}