feat: added call_coro to typed fucn handle, some code reorganization and qol functions

Author: WhaleKit

crates/tinywasm/src/coro.rs

@@ -116,7 +116,39 @@ impl<R, State> PotentialCoroCallResult<R, State> {
     }
 }
 
+impl<R, State, E> PotentialCoroCallResult<core::result::Result<R, E>, State> {
+    /// turns Self<Result<R>, S> into Resulf<Self<R>, S>
+    pub fn propagate_err_result(self) -> core::result::Result<PotentialCoroCallResult<R, State>, E> {
+        Ok(match self {
+            PotentialCoroCallResult::Return(res) => PotentialCoroCallResult::<R, State>::Return(res?),
+            PotentialCoroCallResult::Suspended(why, state) => {
+                PotentialCoroCallResult::<R, State>::Suspended(why, state)
+            }
+        })
+    }
+}
+impl<R, State, E> PotentialCoroCallResult<R, core::result::Result<State, E>> {
+    /// turns Self<R, Result<S>> into Resulf<R, Self<S>>
+    pub fn propagate_err_state(self) -> core::result::Result<PotentialCoroCallResult<R, State>, E> {
+        Ok(match self {
+            PotentialCoroCallResult::Return(res) => PotentialCoroCallResult::<R, State>::Return(res),
+            PotentialCoroCallResult::Suspended(why, state) => {
+                PotentialCoroCallResult::<R, State>::Suspended(why, state?)
+            }
+        })
+    }
+}
+
 impl<R> CoroStateResumeResult<R> {
+    /// in case you expect function only to return
+    /// you can make Suspend into [crate::Error::UnexpectedSuspend] error
+    pub fn suspend_to_err(self) -> Result<R> {
+        match self {
+            Self::Return(r) => Ok(r),
+            Self::Suspended(r) => Err(crate::Error::UnexpectedSuspend(r.into())),
+        }
+    }
+
     /// true if coro is finished
     pub fn finished(&self) -> bool {
         matches!(self, Self::Return(_))
@@ -142,6 +174,14 @@ impl<R> CoroStateResumeResult<R> {
     }
 }
 
+impl<R, E> CoroStateResumeResult<core::result::Result<R, E>> {
+    /// turns Self<Result<R>> into Resulf<Self<R>>
+    pub fn propagate_err(self) -> core::result::Result<CoroStateResumeResult<R>, E> {
+        Ok(PotentialCoroCallResult::<core::result::Result<R, E>, ()>::from(self).propagate_err_result()?.into())
+    }
+}
+
+// convert between PotentialCoroCallResult<SrcR, ()> and CoroStateResumeResult<SrcR>
 impl<DstR, SrcR> From<PotentialCoroCallResult<SrcR, ()>> for CoroStateResumeResult<DstR>
 where
     DstR: From<SrcR>,

crates/tinywasm/src/func.rs

@@ -18,50 +18,6 @@ pub struct FuncHandle {
     pub name: Option<String>,
 }
 
-pub(crate) type FuncHandleResumeOutcome = crate::coro::CoroStateResumeResult<Vec<WasmValue>>;
-
-#[derive(Debug)]
-struct SuspendedWasmFunc {
-    runtime: interpreter::SuspendedRuntime,
-    result_types: Box<[ValType]>,
-}
-impl SuspendedWasmFunc {
-    fn resume(&mut self, ctx: FuncContext<'_>, arg: ResumeArgument) -> Result<FuncHandleResumeOutcome> {
-        Ok(self.runtime.resume(ctx, arg)?.map_result(|mut stack| stack.values.pop_results(&self.result_types)))
-    }
-}
-
-#[derive(Debug)]
-#[allow(clippy::large_enum_variant)] // Wasm is bigger, but also much more common variant
-enum SuspendedFuncInner {
-    Wasm(SuspendedWasmFunc),
-    Host(SuspendedHostCoroState),
-}
-
-/// handle to function that was suspended and can be resumed
-#[derive(Debug)]
-pub struct SuspendedFunc {
-    func: SuspendedFuncInner,
-    module_addr: ModuleInstanceAddr,
-    store_id: usize,
-}
-
-impl crate::coro::CoroState<Vec<WasmValue>, &mut Store> for SuspendedFunc {
-    fn resume(&mut self, store: &mut Store, arg: ResumeArgument) -> Result<FuncHandleResumeOutcome> {
-        if store.id() != self.store_id {
-            return Err(Error::InvalidStore);
-        }
-
-        let ctx = FuncContext { store, module_addr: self.module_addr };
-        match &mut self.func {
-            SuspendedFuncInner::Wasm(wasm) => wasm.resume(ctx, arg),
-            SuspendedFuncInner::Host(host) => Ok(host.coro_state.resume(ctx, arg)?),
-        }
-    }
-}
-
-type FuncHandleCallOutcome = crate::coro::PotentialCoroCallResult<Vec<WasmValue>, SuspendedFunc>;
-
 impl FuncHandle {
     /// Call a function (Invocation)
     ///
@@ -130,7 +86,7 @@ impl FuncHandle {
         let runtime = store.runtime();
         let exec_outcome = runtime.exec(store, stack)?;
         Ok(exec_outcome
-            .map_result(|mut stack|->Vec<WasmValue> {
+            .map_result(|mut stack| -> Vec<WasmValue> {
                 // Once the function returns:
                 // let result_m = func_ty.results.len();
 
@@ -184,6 +140,92 @@ impl<P: IntoWasmValueTuple, R: FromWasmValueTuple> FuncHandleTyped<P, R> {
         // Convert the Vec<WasmValue> back to R
         R::from_wasm_value_tuple(&result)
     }
+
+    /// call a typed function, anticipating possible suspension of execution
+    pub fn call_coro(&self, store: &mut Store, params: P) -> Result<TypedFuncHandleCallOutcome<R>> {
+        // Convert params into Vec<WasmValue>
+        let wasm_values = params.into_wasm_value_tuple();
+
+        // Call the underlying WASM function
+        let result = self.func.call_coro(store, &wasm_values)?;
+
+        // Convert the Vec<WasmValue> back to R
+        result
+            .map_result(|vals| R::from_wasm_value_tuple(&vals))
+            .map_state(|state| SuspendedFuncTyped::<R> { func: state, _marker: core::marker::PhantomData {} })
+            .propagate_err_result()
+    }
+}
+
+pub(crate) type FuncHandleCallOutcome = crate::coro::PotentialCoroCallResult<Vec<WasmValue>, SuspendedFunc>;
+pub(crate) type TypedFuncHandleCallOutcome<R> = crate::coro::PotentialCoroCallResult<R, SuspendedFuncTyped<R>>;
+
+#[derive(Debug)]
+struct SuspendedWasmFunc {
+    runtime: interpreter::SuspendedRuntime,
+    result_types: Box<[ValType]>,
+}
+impl SuspendedWasmFunc {
+    fn resume(
+        &mut self,
+        ctx: FuncContext<'_>,
+        arg: ResumeArgument,
+    ) -> Result<crate::CoroStateResumeResult<Vec<WasmValue>>> {
+        Ok(self.runtime.resume(ctx, arg)?.map_result(|mut stack| stack.values.pop_results(&self.result_types)))
+    }
+}
+
+#[derive(Debug)]
+#[allow(clippy::large_enum_variant)] // Wasm is bigger, but also much more common variant
+enum SuspendedFuncInner {
+    Wasm(SuspendedWasmFunc),
+    Host(SuspendedHostCoroState),
+}
+
+/// handle to function that was suspended and can be resumed
+#[derive(Debug)]
+pub struct SuspendedFunc {
+    func: SuspendedFuncInner,
+    module_addr: ModuleInstanceAddr,
+    store_id: usize,
+}
+
+impl crate::coro::CoroState<Vec<WasmValue>, &mut Store> for SuspendedFunc {
+    fn resume(
+        &mut self,
+        store: &mut Store,
+        arg: ResumeArgument,
+    ) -> Result<crate::CoroStateResumeResult<Vec<WasmValue>>> {
+        if store.id() != self.store_id {
+            return Err(Error::InvalidStore);
+        }
+
+        let ctx = FuncContext { store, module_addr: self.module_addr };
+        match &mut self.func {
+            SuspendedFuncInner::Wasm(wasm) => wasm.resume(ctx, arg),
+            SuspendedFuncInner::Host(host) => Ok(host.coro_state.resume(ctx, arg)?),
+        }
+    }
+}
+
+pub struct SuspendedFuncTyped<R> {
+    pub func: SuspendedFunc,
+    pub(crate) _marker: core::marker::PhantomData<R>,
+}
+
+impl<R> core::fmt::Debug for SuspendedFuncTyped<R> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_struct("SuspendedFuncTyped").field("func", &self.func).finish()
+    }
+}
+
+impl<R> crate::coro::CoroState<R, &mut Store> for SuspendedFuncTyped<R>
+where
+    R: FromWasmValueTuple,
+{
+    fn resume(&mut self, ctx: &mut Store, arg: ResumeArgument) -> Result<crate::CoroStateResumeResult<R>> {
+        self.func.resume(ctx, arg)?.map_result(|vals| R::from_wasm_value_tuple(&vals)).propagate_err()
+    }
 }
 
 macro_rules! impl_into_wasm_value_tuple {

crates/tinywasm/tests/testsuite/util.rs

@@ -31,7 +31,6 @@ fn make_sometimes_breaking_cb(probability: f64) -> impl FnMut(&tinywasm::Store)
     }
 }
 
-
 #[cfg(not(feature = "test_async"))]
 pub fn exec_fn_instance(
     instance: Option<&ModuleInstanceAddr>,
@@ -51,7 +50,6 @@ pub fn exec_fn_instance(
     func.call(store, args)
 }
 
-
 #[cfg(feature = "test_async")]
 pub fn exec_fn_instance(
     instance: Option<&ModuleInstanceAddr>,
@@ -66,7 +64,7 @@ pub fn exec_fn_instance(
     let mut prev_reason = None;
     store.update_suspend_conditions(|old_cond| {
         prev_reason = Some(old_cond);
-        SuspendConditions { suspend_cb: Some(Box::new(make_sometimes_breaking_cb(2.0 / 3.0))), ..Default::default() }
+        SuspendConditions::new().with_suspend_callback(Box::new(make_sometimes_breaking_cb(2.0 / 3.0)))
     });
     let res = || -> Result<Vec<tinywasm_types::WasmValue>, tinywasm::Error> {
         let Some(instance) = store.get_module_instance(*instance) else {
@@ -124,10 +122,9 @@ pub fn exec_fn(
 
     let mut store = tinywasm::Store::new();
 
-    store.set_suspend_conditions(SuspendConditions {
-        suspend_cb: Some(Box::new(make_sometimes_breaking_cb(2.0 / 3.0))),
-        ..Default::default()
-    });
+    store.set_suspend_conditions(
+        SuspendConditions::new().with_suspend_callback(Box::new(make_sometimes_breaking_cb(2.0 / 3.0))),
+    );
 
     let module = tinywasm::Module::from(module);
     let instance = match module.instantiate_coro(&mut store, imports)? {
@@ -160,7 +157,6 @@ pub fn exec_fn(
     }
 }
 
-
 pub fn catch_unwind_silent<R>(f: impl FnOnce() -> R) -> std::thread::Result<R> {
     let prev_hook = panic::take_hook();
     panic::set_hook(Box::new(|_| {}));

examples/host_coro.rs

@@ -6,14 +6,21 @@ use tinywasm::{
 };
 use wat;
 
+fn main() -> eyre::Result<()> {
+    untyped()?;
+    typed()?;
+    Ok(())
+}
+
 const WASM: &str = r#"(module
     (import "host" "hello" (func $host_hello (param i32)))
     (import "host" "wait" (func $host_suspend (param i32)(result i32)))
     
-    (func (export "call_hello")
+    (func (export "call_hello") (result f32)
         (call $host_hello (i32.const -3))
         (call $host_suspend (i32.const 10))
         (call $host_hello)
+        (f32.const 6.28)
     )
 )
 "#;
@@ -38,7 +45,7 @@ impl<'a> CoroState<Vec<WasmValue>, FuncContext<'a>> for MySuspendedState {
     }
 }
 
-fn main() -> eyre::Result<()> {
+fn untyped() -> eyre::Result<()> {
     let wasm = wat::parse_str(WASM).expect("failed to parse wat");
     let module = Module::parse_bytes(&wasm)?;
     let mut store = Store::default();
@@ -47,9 +54,9 @@ fn main() -> eyre::Result<()> {
     imports.define(
         "host",
         "hello",
-        Extern::typed_func(|_: FuncContext<'_>, x: i32| {
-            println!("{x}");
-            Ok(())
+        Extern::func(&FuncType { params: Box::new([ValType::I32]), results: Box::new([]) }, |_: FuncContext<'_>, x| {
+            x.first().map(|x| println!("{:?}", x));
+            Ok(vec![])
         }),
     )?;
     let my_coro_starter = |_ctx: FuncContext<'_>,
@@ -76,7 +83,7 @@ fn main() -> eyre::Result<()> {
     let greeter = instance.exported_func_untyped(&store, "call_hello")?;
     let call_res = greeter.call_coro(&mut store, &[])?;
     let mut resumable = match call_res {
-        tinywasm::PotentialCoroCallResult::Return(..) => bail!("it's supposed to return"),
+        tinywasm::PotentialCoroCallResult::Return(..) => bail!("it's not supposed to return yet"),
         tinywasm::PotentialCoroCallResult::Suspended(SuspendReason::Yield(Some(val)), resumable) => {
             match val.downcast::<MyUserData>() {
                 Ok(val) => assert_eq!(val.magic, 42),
@@ -88,7 +95,62 @@ fn main() -> eyre::Result<()> {
     };
 
     let final_res = resumable.resume(&mut store, Some(Box::<i32>::new(7)))?;
-    assert!(final_res.finished());
+    if let CoroStateResumeResult::Return(vals) = final_res {
+        println!("{:?}", vals.first().unwrap());
+    } else {
+        panic!("should have finished");
+    }
+
+    Ok(())
+}
+
+fn typed() -> eyre::Result<()> {
+    let wasm = wat::parse_str(WASM).expect("failed to parse wat");
+    let module = Module::parse_bytes(&wasm)?;
+    let mut store = Store::default();
+
+    let mut imports = Imports::new();
+    imports.define(
+        "host",
+        "hello",
+        Extern::typed_func(|_: FuncContext<'_>, x: i32| {
+            println!("{x}");
+            Ok(())
+        }),
+    )?;
+    let my_coro_starter =
+        |_ctx: FuncContext<'_>, base: i32| -> tinywasm::Result<PotentialCoroCallResult<i32, Box<dyn HostCoroState>>> {
+            let coro = Box::new(MySuspendedState { base: base });
+            return Ok(PotentialCoroCallResult::Suspended(
+                SuspendReason::make_yield::<MyUserData>(MyUserData { magic: 42 }),
+                coro,
+            ));
+        };
+    imports.define("host", "wait", Extern::typed_func_coro(my_coro_starter))?;
+
+    let instance = module.instantiate(&mut store, Some(imports))?;
+
+    let greeter = instance.exported_func::<(), f32>(&store, "call_hello")?;
+    let call_res = greeter.call_coro(&mut store, ())?;
+    let mut resumable = match call_res {
+        tinywasm::PotentialCoroCallResult::Return(..) => bail!("it's not supposed to return yet"),
+        tinywasm::PotentialCoroCallResult::Suspended(SuspendReason::Yield(Some(val)), resumable) => {
+            match val.downcast::<MyUserData>() {
+                Ok(val) => assert_eq!(val.magic, 42),
+                Err(_) => bail!("invalid yielded val"),
+            }
+            resumable
+        }
+        tinywasm::PotentialCoroCallResult::Suspended(..) => bail!("wrong suspend"),
+    };
+
+    let final_res = resumable.resume(&mut store, Some(Box::<i32>::new(7)))?;
+
+    if let CoroStateResumeResult::Return(res) = final_res {
+        println!("{res}");
+    } else {
+        panic!("should have returned");
+    }
 
     Ok(())
 }