newtype ExecutionResult

Author: axic

bindings/rust/src/lib.rs

@@ -135,7 +135,29 @@ impl From<f64> for Value {
 }
 
 /// The result of an exection.
-pub type ExecutionResult = sys::FizzyExecutionResult;
+pub struct ExecutionResult(sys::FizzyExecutionResult);
+
+impl ExecutionResult {
+    /// True if execution has resulted in a trap.
+    pub fn trapped(&self) -> bool {
+        self.0.trapped
+    }
+
+    /// The optional return value. Only a single return value is allowed in WebAssembly 1.0.
+    pub fn value(&self) -> Option<Value> {
+        if !self.0.trapped && self.0.has_value {
+            Some(self.0.value)
+        } else {
+            None
+        }
+    }
+}
+
+impl From<ExecutionResult> for sys::FizzyExecutionResult {
+    fn from(v: ExecutionResult) -> Self {
+        v.0
+    }
+}
 
 impl Instance {
     /// Unsafe execution of a given function index with the given values.
@@ -145,7 +167,9 @@ impl Instance {
         args: &[Value],
         depth: i32,
     ) -> ExecutionResult {
-        sys::fizzy_execute(self.ptr.as_ptr(), func_idx, args.as_ptr(), depth)
+        ExecutionResult {
+            0: sys::fizzy_execute(self.ptr.as_ptr(), func_idx, args.as_ptr(), depth),
+        }
     }
 }
 
@@ -203,29 +227,29 @@ mod tests {
         let mut instance = instance.unwrap();
 
         let result = unsafe { instance.unsafe_execute(0, &[], 0) };
-        assert!(!result.trapped);
-        assert!(!result.has_value);
+        assert!(!result.trapped());
+        assert!(!result.value().is_some());
 
         let result = unsafe { instance.unsafe_execute(1, &[], 0) };
-        assert!(!result.trapped);
-        assert!(result.has_value);
-        assert_eq!(result.value.as_i32(), 42);
+        assert!(!result.trapped());
+        assert!(result.value().is_some());
+        assert_eq!(result.value().unwrap().as_i32(), 42);
 
         // Explicit type specification
         let result =
             unsafe { instance.unsafe_execute(2, &[(42 as i32).into(), (2 as i32).into()], 0) };
-        assert!(!result.trapped);
-        assert!(result.has_value);
-        assert_eq!(result.value.as_i32(), 21);
+        assert!(!result.trapped());
+        assert!(result.value().is_some());
+        assert_eq!(result.value().unwrap().as_i32(), 21);
 
         // Implicit i64 types (even though the code expects i32)
         let result = unsafe { instance.unsafe_execute(2, &[42.into(), 2.into()], 0) };
-        assert!(!result.trapped);
-        assert!(result.has_value);
-        assert_eq!(result.value.as_i32(), 21);
+        assert!(!result.trapped());
+        assert!(result.value().is_some());
+        assert_eq!(result.value().unwrap().as_i32(), 21);
 
         let result = unsafe { instance.unsafe_execute(3, &[], 0) };
-        assert!(result.trapped);
-        assert!(!result.has_value);
+        assert!(result.trapped());
+        assert!(!result.value().is_some());
     }
 }