Remove deprecated Magnus call in trap (#533)

Author: jeffcharles

ext/src/ruby_api/component/func.rs

@@ -107,7 +107,7 @@ impl Func {
         )?;
 
         func.call(store.context_mut(), &params, &mut results)
-            .map_err(|e| store_context_value.handle_wasm_error(e))?;
+            .map_err(|e| store_context_value.handle_wasm_error(ruby, e))?;
 
         let result = match results_ty.len() {
             0 => Ok(ruby.qnil().as_value()),
@@ -127,7 +127,7 @@ impl Func {
         };
 
         func.post_return(store.context_mut())
-            .map_err(|e| store_context_value.handle_wasm_error(e))?;
+            .map_err(|e| store_context_value.handle_wasm_error(ruby, e))?;
 
         result
     }

ext/src/ruby_api/func.rs

@@ -219,7 +219,7 @@ impl<'a> Func<'a> {
         let mut results = vec![Val::null_func_ref(); func_ty.results().len()];
 
         func.call(context, &params, &mut results)
-            .map_err(|e| store.handle_wasm_error(e))?;
+            .map_err(|e| store.handle_wasm_error(ruby, e))?;
 
         match results.as_slice() {
             [] => Ok(().into_value_with(ruby)),

ext/src/ruby_api/instance.rs

@@ -64,7 +64,7 @@ impl Instance {
 
         let module = module.get();
         let inner = InstanceImpl::new(context, module, &imports)
-            .map_err(|e| StoreContextValue::from(wrapped_store).handle_wasm_error(e))?;
+            .map_err(|e| StoreContextValue::from(wrapped_store).handle_wasm_error(ruby, e))?;
 
         Ok(Self {
             inner,

ext/src/ruby_api/linker.rs

@@ -266,17 +266,27 @@ impl Linker {
     /// @param store [Store]
     /// @param mod [Module]
     /// @return [Instance]
-    pub fn instantiate(&self, store: Obj<Store>, module: &Module) -> Result<Instance, Error> {
-        if *self.has_wasi.borrow() && !store.context().data().has_wasi_p1_ctx() {
+    pub fn instantiate(
+        ruby: &Ruby,
+        rb_self: Obj<Self>,
+        store: Obj<Store>,
+        module: &Module,
+    ) -> Result<Instance, Error> {
+        if *rb_self.has_wasi.borrow() && !store.context().data().has_wasi_p1_ctx() {
             return err!("{}", errors::missing_wasi_p1_ctx_error());
         }
 
-        self.inner
+        rb_self
+            .inner
             .borrow_mut()
             .instantiate(store.context_mut(), module.get())
-            .map_err(|e| StoreContextValue::from(store).handle_wasm_error(e))
+            .map_err(|e| StoreContextValue::from(store).handle_wasm_error(ruby, e))
             .map(|instance| {
-                self.refs.borrow().iter().for_each(|val| store.retain(*val));
+                rb_self
+                    .refs
+                    .borrow()
+                    .iter()
+                    .for_each(|val| store.retain(*val));
                 Instance::from_inner(store, instance)
             })
     }

ext/src/ruby_api/store.rs

@@ -346,14 +346,14 @@ impl StoreContextValue<'_> {
         };
     }
 
-    pub fn handle_wasm_error(&self, error: wasmtime::Error) -> Error {
+    pub fn handle_wasm_error(&self, ruby: &Ruby, error: wasmtime::Error) -> Error {
         if let Ok(Some(error)) = self.take_last_error() {
             error
         } else if let Some(exit) = error.downcast_ref::<I32Exit>() {
             wasi_exit_error().new_instance((exit.0,)).unwrap().into()
         } else {
             Trap::try_from(error)
-                .map(|trap| trap.into())
+                .map(|trap| trap.into_error(ruby))
                 .unwrap_or_else(|e| error!("{}", e))
         }
     }

ext/src/ruby_api/trap.rs

@@ -86,11 +86,9 @@ impl Trap {
             rb_self.code()?.into_value_with(ruby).inspect()
         ))
     }
-}
 
-impl From<Trap> for Error {
-    fn from(trap: Trap) -> Self {
-        magnus::Exception::from_value(Obj::wrap(trap).as_value())
+    pub fn into_error(self, ruby: &Ruby) -> Error {
+        magnus::Exception::from_value(ruby.obj_wrap(self).as_value())
             .unwrap() // Can't fail: Wasmtime::Trap is an Exception
             .into()
     }