self-review fixes

ValeryAntopol · ValeryAntopol · commit bf11145148e7 · 2023-11-30T15:21:37.000+04:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/core/Cargo.toml b/core/Cargo.toml
@@ -25,7 +25,6 @@ wasmer-it = { package = "wasmer-interface-types-fl", version = "0.27.0" }
 it-lilo = "0.6.0"
 it-memory-traits = "0.4.0"
 bytesize = "1.2.0"
-async-trait = "0.1.73"
 futures = "0.3.29"
 
 multimap = "0.8.3"
diff --git a/core/src/host_imports/lowering/lo_helper.rs b/core/src/host_imports/lowering/lo_helper.rs
@@ -15,7 +15,6 @@
  */
 
 use super::AllocateFunc;
-//use crate::call_wasm_func;
 
 use marine_wasm_backend_traits::DelayedContextLifetime;
 use marine_wasm_backend_traits::WasmBackend;
@@ -31,22 +30,20 @@ use futures::FutureExt;
 use std::marker::PhantomData;
 
 pub(crate) struct LoHelper<
-    'c,
     WB: WasmBackend,
     MV: MemoryView<DelayedContextLifetime<WB>>,
     M: Memory<MV, DelayedContextLifetime<WB>>,
 > {
     allocate_func: AllocateFunc<WB>,
     memory: M,
-    _memory_view_phantom: PhantomData<(MV, &'c i32)>,
+    _memory_view_phantom: PhantomData<MV>,
 }
 
 impl<
-        'c,
         WB: WasmBackend,
         MV: MemoryView<DelayedContextLifetime<WB>>,
         M: Memory<MV, DelayedContextLifetime<WB>>,
-    > LoHelper<'c, WB, MV, M>
+    > LoHelper<WB, MV, M>
 {
     pub(crate) fn new(allocate_func: AllocateFunc<WB>, memory: M) -> Self {
         Self {
@@ -58,11 +55,10 @@ impl<
 }
 
 impl<
-        's,
         WB: WasmBackend,
         MV: MemoryView<DelayedContextLifetime<WB>>,
         M: Memory<MV, DelayedContextLifetime<WB>>,
-    > Allocatable<MV, DelayedContextLifetime<WB>> for LoHelper<'s, WB, MV, M>
+    > Allocatable<MV, DelayedContextLifetime<WB>> for LoHelper<WB, MV, M>
 {
     fn allocate<'this, 'ctx1: 'this, 'ctx2: 'ctx1>(
         &'this mut self,
diff --git a/core/src/host_imports/mod.rs b/core/src/host_imports/mod.rs
@@ -29,9 +29,6 @@ use marine_wasm_backend_traits::WValue;
 use marine_wasm_backend_traits::WType;
 
 type HostImportResult<T> = std::result::Result<T, HostImportError>;
-/*type WasmModuleFunc<WB, Args, Rets> = Box<
-    dyn FnMut(&mut <WB as WasmBackend>::ContextMut<'_>, Args) -> RuntimeResult<Rets> + Sync + Send,
->;*/
 type AllocateFunc<WB> = TypedFunc<WB, (i32, i32), i32>;
 
 const ALLOCATE_FUNC_NAME: &str = "allocate";
diff --git a/core/src/module/marine_module.rs b/core/src/module/marine_module.rs
@@ -85,23 +85,6 @@ impl<WB: WasmBackend> Callable<WB> {
             .to_owned();
         Ok(result)
     }
-    /*
-    pub async fn call_async(
-        &mut self,
-        store: &mut <WB as WasmBackend>::ContextMut<'_>,
-        args: &[IValue],
-    ) -> MResult<Vec<IValue>> {
-        use wasmer_it::interpreter::stack::Stackable;
-
-        let result = self
-            .it_module_func
-            .interpreter
-            .run(args, Arc::make_mut(&mut self.it_instance), store).await?
-            .as_slice()
-            .to_owned();
-
-        Ok(result)
-    }*/
 }
 
 type ExportFunctions<WB> = HashMap<SharedString, Arc<Callable<WB>>>;
@@ -396,10 +379,6 @@ impl<WB: WasmBackend> MModule<WB> {
                 let wit_instance = wit_instance.clone();
                 let interpreter = interpreter.clone();
                 async move {
-                    /*                    let import_namespace = import_namespace.clone();
-                    let import_name = import_name.clone();
-                    let wit_instance = wit_instance.clone();
-                    let interpreter = interpreter.clone();*/
                     let mut ctx = ctx.as_context_mut();
 
                     use wasmer_it::interpreter::stack::Stackable;
diff --git a/crates/fluence-app-service/src/service.rs b/crates/fluence-app-service/src/service.rs
@@ -22,8 +22,8 @@ use super::AppServiceError;
 
 #[cfg(feature = "raw-module-api")]
 use marine_wasm_backend_traits::WasiState;
-use marine_wasm_backend_traits::{WasmBackend};
-use marine::{Marine};
+use marine_wasm_backend_traits::WasmBackend;
+use marine::Marine;
 use marine::MarineModuleConfig;
 use marine::IValue;
 
diff --git a/crates/js-backend/Cargo.toml b/crates/js-backend/Cargo.toml
@@ -22,5 +22,4 @@ log = "0.4.20"
 typed-index-collections = "3.1.0"
 derive_more = "0.99.17"
 wasmparser = "0.110.0"
-async-trait = "0.1.74"
-futures = "0.3.29"
+futures = "0.3.29"
diff --git a/crates/wasm-backend-traits/Cargo.toml b/crates/wasm-backend-traits/Cargo.toml
@@ -15,5 +15,4 @@ anyhow = "1.0.75"
 wasmparser = "0.101.1"
 paste = "1.0.14"
 multimap = "0.8.3"
-async-trait = "0.1.71"
-futures = "0.3.29"
+futures = "0.3.29"
diff --git a/crates/wasm-backend-traits/src/function.rs b/crates/wasm-backend-traits/src/function.rs
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-use std::future::Future;
 use crate::AsContextMut;
 use crate::FuncSig;
 use crate::impl_for_each_function_signature;
@@ -24,6 +23,8 @@ use crate::WValue;
 
 use futures::future::BoxFuture;
 
+use std::future::Future;
+
 /// 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 {
diff --git a/crates/wasm-backend-traits/src/imports.rs b/crates/wasm-backend-traits/src/imports.rs
@@ -20,11 +20,11 @@ use crate::AsContext;
 use crate::WasmBackend;
 use crate::WType;
 
+use futures::future::BoxFuture;
+
 use std::borrow::Cow;
 use std::fmt::Formatter;
-use std::future::Future;
 use std::sync::Arc;
-use futures::future::BoxFuture;
 
 /// A "Linker" object, that is used to match functions with module imports during instantiation.
 /// Cloning is a cheap operation for this object. All clones refer to the same data in store.
diff --git a/crates/wasmtime-backend/Cargo.toml b/crates/wasmtime-backend/Cargo.toml
@@ -19,4 +19,3 @@ paste = "1.0.14"
 anyhow = "1.0.75"
 log = "0.4.20"
 futures = "0.3.29"
-async-trait = "0.1.71"
diff --git a/crates/wasmtime-backend/src/caller.rs b/crates/wasmtime-backend/src/caller.rs
@@ -27,7 +27,6 @@ use wasmtime::AsContextMut as WasmtimeAsContextMut;
 use futures::future::BoxFuture;
 use futures::FutureExt;
 
-use std::future::Future;
 use std::sync::Arc;
 
 pub struct WasmtimeImportCallContext<'c> {
@@ -129,70 +128,9 @@ macro_rules! impl_func_getter {
 }
 
 // These signatures are sufficient for marine to work.
-//impl_func_getter!((i32, i32), i32);
+impl_func_getter!((i32, i32), i32);
 impl_func_getter!((i32, i32), ());
 impl_func_getter!(i32, i32);
 impl_func_getter!(i32, ());
 impl_func_getter!((), i32);
 impl_func_getter!((), ());
-
-impl<'c> FuncGetter<WasmtimeWasmBackend, (i32, i32), (i32)> for WasmtimeImportCallContext<'c> {
-    fn get_func(
-        &mut self,
-        name: &str,
-    ) -> Result<TypedFunc<WasmtimeWasmBackend, (i32, i32), (i32)>, ResolveError> {
-        fn create_func_getter_closure(
-            f: Arc<wasmtime::TypedFunc<(i32, i32), (i32)>>,
-        ) -> impl for<'args, 'ctx2> Fn(
-            &'args mut WasmtimeContextMut<'ctx2>,
-            (i32, i32),
-        ) -> TypedFuncFuture<'args, (i32)>
-               + 'static {
-            move |store: &mut WasmtimeContextMut<'_>,
-                  args: (i32, i32)|
-                  -> TypedFuncFuture<'_, (i32)> {
-                let f = f.clone();
-                call_typed_func(store, args, f).boxed()
-            }
-        }
-
-        async fn call_typed_func<'args, 'ctx2>(
-            store: &'args mut WasmtimeContextMut<'ctx2>,
-            args: (i32, i32),
-            f: Arc<wasmtime::TypedFunc<(i32, i32), (i32)>>,
-        ) -> RuntimeResult<(i32)> {
-            f.call_async(&mut store.inner, args).await.map_err(|e| {
-                if let Some(_) = e.downcast_ref::<wasmtime::Trap>() {
-                    RuntimeError::Trap(e)
-                } else {
-                    RuntimeError::Other(e)
-                }
-            })
-        }
-
-        let export = self
-            .inner
-            .get_export(name)
-            .ok_or(ResolveError::ExportNotFound(name.to_string()))?;
-
-        match export {
-            wasmtime::Extern::Func(f) => {
-                let f = f
-                    .typed(&mut self.inner)
-                    .map_err(|e| ResolveError::Other(e))?;
-                let f = Arc::new(f);
-                let closure = create_func_getter_closure(f);
-
-                Ok(Arc::new(closure))
-            }
-            wasmtime::Extern::Memory(_) => Err(ResolveError::ExportTypeMismatch {
-                expected: "function",
-                actual: "memory",
-            }),
-            _ => Err(ResolveError::ExportTypeMismatch {
-                expected: "function",
-                actual: "neither memory nor function",
-            }),
-        }
-    }
-}
diff --git a/crates/wasmtime-backend/src/function.rs b/crates/wasmtime-backend/src/function.rs
@@ -14,12 +14,9 @@
  * limitations under the License.
  */
 
-use std::future::Future;
-use std::pin::Pin;
-use std::task::Poll;
-use crate::WasmtimeContextMut;
 use crate::WasmtimeWasmBackend;
 use crate::WasmtimeImportCallContext;
+use crate::WasmtimeContextMut;
 use crate::val_to_wvalue;
 use crate::StoreState;
 use crate::sig_to_fn_ty;
@@ -35,6 +32,8 @@ use anyhow::anyhow;
 use futures::future::BoxFuture;
 use futures::FutureExt;
 
+use std::future::Future;
+
 #[derive(Clone)]
 pub struct WasmtimeFunction {
     pub(crate) inner: wasmtime::Func,
@@ -288,18 +287,3 @@ where
 {
     func
 }
-
-/*
-struct FuncCallFuture<'f, F> {
-    caller: wasmtime::Caller<'f, StoreState>,
-    args: Vec<WValue>,
-    func: &'f F,
-}
-
-impl<F> std::future::Future for FuncCallFuture<F> {
-    type Output = ();
-
-    fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
-        todo!()
-    }
-}*/
