move from async_trait to BoxFuture

Author: ValeryAntopol

core/src/host_imports/lowering/lo_helper.rs

@@ -25,6 +25,9 @@ use it_lilo::traits::AllocatableError;
 use it_memory_traits::MemoryView;
 use it_memory_traits::Memory;
 
+use futures::future::BoxFuture;
+use futures::FutureExt;
+
 use std::marker::PhantomData;
 
 pub(crate) struct LoHelper<
@@ -54,23 +57,25 @@ impl<
     }
 }
 
-#[async_trait::async_trait]
 impl<
         's,
         WB: WasmBackend,
         MV: MemoryView<DelayedContextLifetime<WB>>,
         M: Memory<MV, DelayedContextLifetime<WB>>,
     > Allocatable<MV, DelayedContextLifetime<WB>> for LoHelper<'s, WB, MV, M>
 {
-    async fn allocate<'ctx1, 'ctx2: 'ctx1>(
-        &mut self,
+    fn allocate<'this, 'ctx1: 'this, 'ctx2: 'ctx1>(
+        &'this mut self,
         store: &'ctx1 mut <WB as WasmBackend>::ContextMut<'ctx2>,
         size: u32,
         type_tag: u32,
-    ) -> Result<(u32, MV), AllocatableError> {
-        let offset = (self.allocate_func)(store, (size as _, type_tag as _))
-            .await
-            .unwrap();
-        Ok((offset as u32, self.memory.view()))
+    ) -> BoxFuture<'this, Result<(u32, MV), AllocatableError>> {
+        async move {
+            let offset = (self.allocate_func)(store, (size as _, type_tag as _))
+                .await
+                .unwrap();
+            Ok((offset as u32, self.memory.view()))
+        }
+        .boxed()
     }
 }

core/src/module/exports.rs

@@ -19,6 +19,9 @@ use super::IType;
 use super::IFunctionArg;
 use wasmer_it::interpreter::wasm;
 
+use futures::future::BoxFuture;
+use futures::FutureExt;
+
 // In current implementation export simply does nothing, because there is no more
 // explicit instruction call-export in this version of wasmer-interface-types,
 // but explicit Exports is still required by wasmer-interface-types::Interpreter.
@@ -42,7 +45,6 @@ impl ITExport {
     }
 }
 
-#[async_trait::async_trait]
 impl wasm::structures::Export for ITExport {
     fn name(&self) -> &str {
         self.name.as_str()
@@ -64,7 +66,10 @@ impl wasm::structures::Export for ITExport {
         &self.outputs
     }
 
-    async fn call_async(&self, arguments: &[IValue]) -> Result<Vec<IValue>, anyhow::Error> {
-        (self.function)(arguments)
+    fn call_async<'args>(
+        &'args self,
+        arguments: &'args [IValue],
+    ) -> BoxFuture<'args, Result<Vec<IValue>, anyhow::Error>> {
+        async move { (self.function)(arguments) }.boxed()
     }
 }

core/src/module/wit_function.rs

@@ -29,6 +29,8 @@ use marine_wasm_backend_traits::ExportFunction;
 use wasmer_it::interpreter::wasm;
 
 use anyhow::anyhow;
+use futures::future::BoxFuture;
+use futures::FutureExt;
 
 use std::sync::Arc;
 
@@ -114,7 +116,6 @@ impl<WB: WasmBackend> WITFunction<WB> {
     }
 }
 
-#[async_trait::async_trait]
 impl<WB: WasmBackend> wasm::structures::LocalImport<DelayedContextLifetime<WB>>
     for WITFunction<WB>
 {
@@ -138,31 +139,34 @@ impl<WB: WasmBackend> wasm::structures::LocalImport<DelayedContextLifetime<WB>>
         &self.outputs
     }
 
-    async fn call_async(
-        &self,
-        store: &mut <WB as WasmBackend>::ContextMut<'_>,
-        arguments: &[IValue],
-    ) -> std::result::Result<Vec<IValue>, anyhow::Error> {
-        use super::type_converters::wval_to_ival;
-        use super::type_converters::ival_to_wval;
-        match &self.inner {
-            WITFunctionInner::Export { func, .. } => func
-                .as_ref()
-                .call(
-                    store,
-                    arguments
-                        .iter()
-                        .map(ival_to_wval)
-                        .collect::<Vec<WValue>>()
-                        .as_slice(),
-                )
-                .await
-                .map_err(|e| anyhow!(e))
-                .map(|results| results.iter().map(wval_to_ival).collect()),
-            WITFunctionInner::Import { callable, .. } => Arc::make_mut(&mut callable.clone())
-                .call(store, arguments)
-                .await
-                .map_err(|e| anyhow!(e)),
+    fn call_async<'args>(
+        &'args self,
+        store: &'args mut <WB as WasmBackend>::ContextMut<'_>,
+        arguments: &'args [IValue],
+    ) -> BoxFuture<'args, anyhow::Result<Vec<IValue>>> {
+        async move {
+            use super::type_converters::wval_to_ival;
+            use super::type_converters::ival_to_wval;
+            match &self.inner {
+                WITFunctionInner::Export { func, .. } => func
+                    .as_ref()
+                    .call(
+                        store,
+                        arguments
+                            .iter()
+                            .map(ival_to_wval)
+                            .collect::<Vec<WValue>>()
+                            .as_slice(),
+                    )
+                    .await
+                    .map_err(|e| anyhow!(e))
+                    .map(|results| results.iter().map(wval_to_ival).collect()),
+                WITFunctionInner::Import { callable, .. } => Arc::make_mut(&mut callable.clone())
+                    .call(store, arguments)
+                    .await
+                    .map_err(|e| anyhow!(e)),
+            }
         }
+        .boxed()
     }
 }

crates/js-backend/src/function.rs

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-use std::future::Future;
 use crate::JsInstance;
 use crate::JsWasmBackend;
 use crate::JsImportCallContext;
@@ -33,9 +32,12 @@ use marine_wasm_backend_traits::replace_with;
 use marine_wasm_backend_traits::prelude::*;
 
 use anyhow::anyhow;
+use futures::future::BoxFuture;
+use futures::FutureExt;
 use js_sys::Array;
 use wasm_bindgen::prelude::*;
-use futures::future::BoxFuture;
+
+use std::future::Future;
 
 // Safety: this is safe because its intended to run in single thread
 unsafe impl Send for HostImportFunction {}
@@ -239,7 +241,11 @@ impl HostFunction<JsWasmBackend> for HostImportFunction {
 }
 
 impl AsyncFunction<JsWasmBackend> for HostImportFunction {
-    async fn call_async<CTX>(&self, store: &mut CTX, args: &[WValue]) -> RuntimeResult<Vec<WValue>>
+    fn call_async<CTX>(
+        &self,
+        store: &mut CTX,
+        args: &[WValue],
+    ) -> BoxFuture<RuntimeResult<Vec<WValue>>>
     where
         CTX: AsContextMut<JsWasmBackend> + Send,
     {
@@ -331,28 +337,31 @@ fn prepare_js_closure(func: Box<dyn FnMut(&Array) -> Array>) -> js_sys::Function
 
     wrapper.bind1(&JsValue::UNDEFINED, &closure)
 }
-#[async_trait::async_trait]
+
 impl ExportFunction<JsWasmBackend> for WasmExportFunction {
     fn signature(&self, store: &mut impl AsContextMut<JsWasmBackend>) -> FuncSig {
         self.stored_mut(store.as_context_mut()).signature.clone()
     }
 
-    async fn call(
-        &self,
-        store: &mut impl AsContextMut<JsWasmBackend>,
-        args: &[WValue],
-    ) -> RuntimeResult<Vec<WValue>> {
-        store
-            .as_context_mut()
-            .inner
-            .wasm_call_stack
-            .push(self.bound_instance.clone());
+    fn call<'args>(
+        &'args self,
+        store: &'args mut impl AsContextMut<JsWasmBackend>,
+        args: &'args [WValue],
+    ) -> BoxFuture<'args, RuntimeResult<Vec<WValue>>> {
+        async move {
+            store
+                .as_context_mut()
+                .inner
+                .wasm_call_stack
+                .push(self.bound_instance.clone());
 
-        let result = self.call_inner(store, args);
+            let result = self.call_inner(store, args);
 
-        store.as_context_mut().inner.wasm_call_stack.pop();
+            store.as_context_mut().inner.wasm_call_stack.pop();
 
-        result
+            result
+        }
+        .boxed()
     }
 }
 

crates/js-backend/src/module.rs

@@ -23,6 +23,8 @@ use crate::module_info::ModuleInfo;
 use marine_wasm_backend_traits::prelude::*;
 
 use anyhow::anyhow;
+use futures::future::BoxFuture;
+use futures::FutureExt;
 use js_sys::WebAssembly;
 use js_sys::Uint8Array;
 use wasm_bindgen::JsValue;
@@ -35,7 +37,6 @@ pub struct JsModule {
 unsafe impl Send for JsModule {}
 unsafe impl Sync for JsModule {}
 
-//#[async_trait::async_trait]
 impl Module<JsWasmBackend> for JsModule {
     fn new(_store: &mut JsStore, wasm: &[u8]) -> ModuleCreationResult<Self> {
         let data = Uint8Array::new_with_length(wasm.len() as u32);
@@ -68,23 +69,28 @@ impl Module<JsWasmBackend> for JsModule {
         }
     }
 
-    async fn instantiate(
-        &self,
-        store: &mut JsStore,
-        imports: &JsImports,
-    ) -> InstantiationResult<<JsWasmBackend as WasmBackend>::Instance> {
-        let imports_object = imports.build_import_object(store.as_context(), &self.inner);
-        let instance = WebAssembly::Instance::new(&self.inner, &imports_object)
-            .map_err(|e| InstantiationError::Other(anyhow!("failed to instantiate: {:?}", e)))?;
+    fn instantiate<'args>(
+        &'args self,
+        store: &'args mut JsStore,
+        imports: &'args JsImports,
+    ) -> BoxFuture<'args, InstantiationResult<<JsWasmBackend as WasmBackend>::Instance>> {
+        async move {
+            let imports_object = imports.build_import_object(store.as_context(), &self.inner);
+            let instance =
+                WebAssembly::Instance::new(&self.inner, &imports_object).map_err(|e| {
+                    InstantiationError::Other(anyhow!("failed to instantiate: {:?}", e))
+                })?;
 
-        // adds memory to @wasmer/wasi object
-        imports.bind_to_instance(store.as_context(), &instance);
+            // adds memory to @wasmer/wasi object
+            imports.bind_to_instance(store.as_context(), &instance);
 
-        let stored_instance = JsInstance::new(
-            &mut store.as_context_mut(),
-            instance,
-            self.module_info.clone(),
-        );
-        Ok(stored_instance)
+            let stored_instance = JsInstance::new(
+                &mut store.as_context_mut(),
+                instance,
+                self.module_info.clone(),
+            );
+            Ok(stored_instance)
+        }
+        .boxed()
     }
 }

crates/wasm-backend-traits/src/function.rs

@@ -24,8 +24,6 @@ use crate::WValue;
 
 use futures::future::BoxFuture;
 
-//use async_trait::async_trait;
-
 /// A host function ready to be used as an import for instantiating a module.
 /// As it is only a handle to an object in `Store`, cloning is cheap.
 pub trait HostFunction<WB: WasmBackend>: AsyncFunction<WB> + Send + Sync + Clone {
@@ -80,7 +78,6 @@ pub trait HostFunction<WB: WasmBackend>: AsyncFunction<WB> + Send + Sync + Clone
 
 /// A Wasm function handle, it can be either a function from a host or an export from an `Instance`.
 /// As it is only a handle to an object in `Store`, cloning is cheap
-//#[async_trait]
 pub trait ExportFunction<WB: WasmBackend>: Send + Sync + Clone {
     /// Returns the signature of the function.
     /// The signature is constructed each time this function is called, so
@@ -92,16 +89,19 @@ pub trait ExportFunction<WB: WasmBackend>: Send + Sync + Clone {
     ///     If given a store different from the one that stores the function.
     /// # Errors:
     ///     See `RuntimeError` documentation.
-    fn call<'store>(
-        &self,
-        store: &'store mut impl AsContextMut<WB>,
-        args: &[WValue],
-    ) -> impl Future<Output = RuntimeResult<Vec<WValue>>> + Send + 'store;
+    fn call<'args>(
+        &'args self,
+        store: &'args mut impl AsContextMut<WB>,
+        args: &'args [WValue],
+    ) -> BoxFuture<'args, RuntimeResult<Vec<WValue>>>;
 }
 
-//#[async_trait]
 pub trait AsyncFunction<WB: WasmBackend> {
-    async fn call_async<CTX>(&self, store: &mut CTX, args: &[WValue]) -> RuntimeResult<Vec<WValue>>
+    fn call_async<'args, CTX>(
+        &'args self,
+        store: &'args mut CTX,
+        args: &'args [WValue],
+    ) -> BoxFuture<'args, RuntimeResult<Vec<WValue>>>
     where
         CTX: AsContextMut<WB> + Send;
 }

crates/wasm-backend-traits/src/lib.rs

@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-#![feature(async_fn_in_trait)]
-#![feature(return_position_impl_trait_in_trait)]
-
 pub mod errors;
 pub mod exports;
 pub mod imports;

crates/wasm-backend-traits/src/module.rs

@@ -18,10 +18,9 @@ use crate::ModuleCreationResult;
 use crate::InstantiationResult;
 use crate::WasmBackend;
 
-use async_trait::async_trait;
+use futures::future::BoxFuture;
 
 /// A handle to compiled wasm module.
-//#[async_trait]
 pub trait Module<WB: WasmBackend>: Sized {
     /// Compiles a wasm bytes into a module and extracts custom sections.
     fn new(store: &mut <WB as WasmBackend>::Store, wasm: &[u8]) -> ModuleCreationResult<Self>;
@@ -35,9 +34,9 @@ pub trait Module<WB: WasmBackend>: Sized {
     /// # Panics:
     ///
     ///     If the `Store` given is not the same with `Store` used to create `Imports` and this object.
-    async fn instantiate(
-        &self,
-        store: &mut <WB as WasmBackend>::Store,
-        imports: &<WB as WasmBackend>::Imports,
-    ) -> InstantiationResult<<WB as WasmBackend>::Instance>;
+    fn instantiate<'args>(
+        &'args self,
+        store: &'args mut <WB as WasmBackend>::Store,
+        imports: &'args <WB as WasmBackend>::Imports,
+    ) -> BoxFuture<'args, InstantiationResult<<WB as WasmBackend>::Instance>>;
 }