Rename trait, get tests running

examples/wasi.rs

@@ -51,9 +51,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     let import_object = wasi_env.import_object(&module)?;
     let instance = Instance::new(&module, &import_object)?;
 
-    // WASI requires to explicitly set the memory for the `WasiEnv`
-    wasi_env.set_memory(instance.exports.get_memory("memory")?.clone());
-
     println!("Call WASI `_start` function...");
     // And we just call the `_start` function!
     let start = instance.exports.get_function("_start")?;

lib/api/src/externals/function.rs

@@ -126,7 +126,7 @@ impl Function {
     pub fn new_with_env<F, Env>(store: &Store, ty: &FunctionType, env: Env, func: F) -> Self
     where
         F: Fn(&mut Env, &[Val]) -> Result<Vec<Val>, RuntimeError> + 'static,
-        Env: Sized + crate::WasmerPostInstantiate + 'static,
+        Env: Sized + crate::WasmerEnv + 'static,
     {
         let dynamic_ctx = VMDynamicFunctionContext::from_context(VMDynamicFunctionWithEnv {
             env: RefCell::new(env),
@@ -230,7 +230,7 @@ impl Function {
         F: HostFunction<Args, Rets, WithEnv, Env>,
         Args: WasmTypeList,
         Rets: WasmTypeList,
-        Env: Sized + crate::WasmerPostInstantiate + 'static,
+        Env: Sized + crate::WasmerEnv + 'static,
     {
         let function = inner::Function::<Args, Rets>::new(func);
         let address = function.address();

lib/api/src/lib.rs

@@ -124,7 +124,7 @@ pub const VERSION: &str = env!("CARGO_PKG_VERSION");
 // TODO: rename everything, all names are throw-away names
 
 /// Prototype trait for finishing envs.
-pub trait WasmerPostInstantiate {
+pub trait WasmerEnv {
     /// The function that Wasmer will call on your type to let it finish
     /// instantiating.
     fn finish(&mut self, instance: &Instance);

lib/wasi/src/lib.rs

@@ -54,7 +54,7 @@ pub struct WasiEnv {
     memory: *mut Memory,
 }
 
-impl wasmer::WasmerPostInstantiate for WasiEnv {
+impl wasmer::WasmerEnv for WasiEnv {
     fn finish(&mut self, instance: &wasmer::Instance) {
         dbg!("in Wasi::Finish");
         let memory = instance.exports.get_memory("memory").unwrap();

tests/compilers/imports.rs

@@ -86,7 +86,22 @@ fn dynamic_function_with_env() -> Result<()> {
     let store = get_store(false);
     let module = get_module(&store)?;
 
-    let env: Arc<AtomicUsize> = Arc::new(AtomicUsize::new(0));
+    #[derive(Clone)]
+    struct Env(Arc<AtomicUsize>);
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<AtomicUsize>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl WasmerEnv for Env {
+        fn finish(&mut self, _instance: &Instance) {}
+        fn free(&mut self) {}
+    }
+
+    let env: Env = Env(Arc::new(AtomicUsize::new(0)));
     Instance::new(
         &module,
         &imports! {
@@ -203,25 +218,40 @@ fn static_function_with_env() -> Result<()> {
     let store = get_store(false);
     let module = get_module(&store)?;
 
-    let env: Arc<AtomicUsize> = Arc::new(AtomicUsize::new(0));
+    #[derive(Clone)]
+    struct Env(Arc<AtomicUsize>);
+
+    impl std::ops::Deref for Env {
+        type Target = Arc<AtomicUsize>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl WasmerEnv for Env {
+        fn finish(&mut self, _instance: &Instance) {}
+        fn free(&mut self) {}
+    }
+
+    let env: Env = Env(Arc::new(AtomicUsize::new(0)));
     Instance::new(
         &module,
         &imports! {
             "host" => {
-                "0" => Function::new_native_with_env(&store, env.clone(), |env: &mut Arc<AtomicUsize>| {
+                "0" => Function::new_native_with_env(&store, env.clone(), |env: &mut Env| {
                     assert_eq!(env.fetch_add(1, SeqCst), 0);
                 }),
-                "1" => Function::new_native_with_env(&store, env.clone(), |env: &mut Arc<AtomicUsize>, x: i32| -> i32 {
+                "1" => Function::new_native_with_env(&store, env.clone(), |env: &mut Env, x: i32| -> i32 {
                     assert_eq!(x, 0);
                     assert_eq!(env.fetch_add(1, SeqCst), 1);
                     1
                 }),
-                "2" => Function::new_native_with_env(&store, env.clone(), |env: &mut Arc<AtomicUsize>, x: i32, y: i64| {
+                "2" => Function::new_native_with_env(&store, env.clone(), |env: &mut Env, x: i32, y: i64| {
                     assert_eq!(x, 2);
                     assert_eq!(y, 3);
                     assert_eq!(env.fetch_add(1, SeqCst), 2);
                 }),
-                "3" => Function::new_native_with_env(&store, env.clone(), |env: &mut Arc<AtomicUsize>, a: i32, b: i64, c: i32, d: f32, e: f64| {
+                "3" => Function::new_native_with_env(&store, env.clone(), |env: &mut Env, a: i32, b: i64, c: i32, d: f32, e: f64| {
                     assert_eq!(a, 100);
                     assert_eq!(b, 200);
                     assert_eq!(c, 300);

tests/compilers/native_functions.rs

@@ -108,6 +108,18 @@ fn static_host_function_with_env() -> anyhow::Result<()> {
     #[derive(Clone)]
     struct Env(Rc<RefCell<i32>>);
 
+    impl std::ops::Deref for Env {
+        type Target = Rc<RefCell<i32>>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl WasmerEnv for Env {
+        fn finish(&mut self, _instance: &Instance) {}
+        fn free(&mut self) {}
+    }
+
     // Native static host function that returns a tuple.
     {
         let env = Env(Rc::new(RefCell::new(100)));
@@ -175,6 +187,18 @@ fn dynamic_host_function_with_env() -> anyhow::Result<()> {
     #[derive(Clone)]
     struct Env(Rc<RefCell<i32>>);
 
+    impl std::ops::Deref for Env {
+        type Target = Rc<RefCell<i32>>;
+        fn deref(&self) -> &Self::Target {
+            &self.0
+        }
+    }
+
+    impl WasmerEnv for Env {
+        fn finish(&mut self, _instance: &Instance) {}
+        fn free(&mut self) {}
+    }
+
     let env = Env(Rc::new(RefCell::new(100)));
     let f = Function::new_with_env(
         &store,