feat: all async/resume functionality is now feature-gated

Author: WhaleKit

Cargo.toml

@@ -30,6 +30,10 @@ rust-version.workspace=true
 name="wasm-rust"
 test=false
 
+[[example]]
+name="host_coro"
+required-features=["async"]
+
 [dev-dependencies]
 wat={workspace=true}
 eyre={workspace=true}

crates/tinywasm/Cargo.toml

@@ -37,7 +37,8 @@ logging=["log", "tinywasm-parser?/logging", "tinywasm-types/logging"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["dep:tinywasm-parser"]
 archive=["tinywasm-types/archive"]
-test_async=[] #feels weird putting it here
+async=[]
+test_async=["async"] #feels weird putting it here
 
 [[test]]
 name="test-wasm-1"

crates/tinywasm/src/coro.rs

@@ -6,7 +6,10 @@ use tinywasm_types::FuncType;
 #[cfg(feature = "parser")]
 pub use tinywasm_parser::ParseError;
 
-use crate::{coro::UnexpectedSuspendError, interpreter};
+#[cfg(feature = "async")]
+use crate::coro::UnexpectedSuspendError;
+
+use crate::interpreter;
 
 /// Errors that can occur for `TinyWasm` operations
 #[derive(Debug)]
@@ -45,6 +48,7 @@ pub enum Error {
 
     /// Function unexpectedly yielded instead of returning
     /// (for backwards compatibility with old api)
+    #[cfg(feature = "async")]
     UnexpectedSuspend(UnexpectedSuspendError),
 
     #[cfg(feature = "std")]
@@ -196,6 +200,9 @@ impl Display for Error {
             #[cfg(feature = "std")]
             Self::Io(err) => write!(f, "I/O error: {err}"),
 
+            #[cfg(feature = "async")]
+            Self::UnexpectedSuspend(_) => write!(f, "funtion yielded instead of returning"),
+
             Self::Trap(trap) => write!(f, "trap: {trap}"),
             Self::Linker(err) => write!(f, "linking error: {err}"),
             Self::InvalidLabelType => write!(f, "invalid label type"),
@@ -205,8 +212,6 @@ impl Display for Error {
                 write!(f, "invalid host function return: expected={expected:?}, actual={actual:?}")
             }
             Self::InvalidStore => write!(f, "invalid store"),
-
-            Self::UnexpectedSuspend(_) => write!(f, "funtion yielded instead of returning"),
             Self::InvalidResumeArgument => write!(f, "invalid resume argument supplied to suspended function"),
             Self::InvalidResume => write!(f, "attempt to resume coroutine that has already finished"),
         }

crates/tinywasm/src/error.rs

@@ -1,11 +1,13 @@
-use crate::coro::CoroState;
+#[cfg(feature = "async")]
+use {crate::coro::CoroState, tinywasm_types::ResumeArgument};
+
 use crate::interpreter;
 use crate::interpreter::executor::SuspendedHostCoroState;
 use crate::interpreter::stack::{CallFrame, Stack};
 use crate::{log, unlikely, Function};
 use crate::{Error, FuncContext, Result, Store};
 use alloc::{boxed::Box, format, string::String, string::ToString, vec, vec::Vec};
-use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ResumeArgument, ValType, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ValType, WasmValue};
 
 #[derive(Debug)]
 /// A function handle
@@ -152,7 +154,7 @@ impl<P: IntoWasmValueTuple, R: FromWasmValueTuple> FuncHandleTyped<P, R> {
         // 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 {} })
+            .map_state(|state| SuspendedFuncTyped::<R> { func: state, _marker: Default::default() })
             .propagate_err_result()
     }
 }
@@ -161,11 +163,13 @@ pub(crate) type FuncHandleCallOutcome = crate::coro::PotentialCoroCallResult<Vec
 pub(crate) type TypedFuncHandleCallOutcome<R> = crate::coro::PotentialCoroCallResult<R, SuspendedFuncTyped<R>>;
 
 #[derive(Debug)]
+#[cfg_attr(not(feature = "async"), allow(unused))]
 struct SuspendedWasmFunc {
     runtime: interpreter::SuspendedRuntime,
     result_types: Box<[ValType]>,
 }
 impl SuspendedWasmFunc {
+    #[cfg(feature = "async")]
     fn resume(
         &mut self,
         ctx: FuncContext<'_>,
@@ -176,6 +180,7 @@ impl SuspendedWasmFunc {
 }
 
 #[derive(Debug)]
+#[cfg_attr(not(feature = "async"), allow(unused))]
 #[allow(clippy::large_enum_variant)] // Wasm is bigger, but also much more common variant
 enum SuspendedFuncInner {
     Wasm(SuspendedWasmFunc),
@@ -184,13 +189,15 @@ enum SuspendedFuncInner {
 
 /// handle to function that was suspended and can be resumed
 #[derive(Debug)]
+#[cfg_attr(not(feature = "async"), allow(unused))]
 pub struct SuspendedFunc {
     func: SuspendedFuncInner,
     module_addr: ModuleInstanceAddr,
     store_id: usize,
 }
 
 impl crate::coro::CoroState<Vec<WasmValue>, &mut Store> for SuspendedFunc {
+    #[cfg(feature = "async")]
     fn resume(
         &mut self,
         store: &mut Store,
@@ -208,6 +215,7 @@ impl crate::coro::CoroState<Vec<WasmValue>, &mut Store> for SuspendedFunc {
     }
 }
 
+#[cfg_attr(not(feature = "async"), allow(unused))]
 pub struct SuspendedFuncTyped<R> {
     pub func: SuspendedFunc,
     pub(crate) _marker: core::marker::PhantomData<R>,
@@ -223,6 +231,7 @@ impl<R> crate::coro::CoroState<R, &mut Store> for SuspendedFuncTyped<R>
 where
     R: FromWasmValueTuple,
 {
+    #[cfg(feature = "async")]
     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()
     }

crates/tinywasm/src/func.rs

@@ -2,10 +2,9 @@ use alloc::{boxed::Box, format, rc::Rc, string::ToString};
 use tinywasm_types::*;
 
 use crate::func::{FromWasmValueTuple, IntoWasmValueTuple};
-use crate::{
-    Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, MemoryRefMut, Module, PotentialCoroCallResult, Result,
-    Store, SuspendedFunc,
-};
+use crate::{Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, MemoryRefMut, Module, Result, Store};
+#[cfg(feature = "async")]
+use crate::{PotentialCoroCallResult, SuspendedFunc};
 
 /// An instanciated WebAssembly module
 ///
@@ -270,8 +269,9 @@ impl ModuleInstance {
     /// Invoke the start function of the module
     ///
     /// Returns None if the module has no start function
-    /// If start function suspends, returns SuspededFunc.
+    /// If start function suspends, returns SuspendedFunc.
     /// Only when it finishes can this module instance be considered instantiated
+    #[cfg(feature = "async")]
     pub fn start_coro(&self, store: &mut Store) -> Result<Option<PotentialCoroCallResult<(), SuspendedFunc>>> {
         let Some(func) = self.start_func(store)? else {
             return Ok(None);

crates/tinywasm/src/instance.rs

@@ -5,18 +5,21 @@ use super::no_std_floats::NoStdFloatExt;
 use alloc::boxed::Box;
 use alloc::{format, rc::Rc, string::ToString};
 use core::ops::ControlFlow;
-use coro::SuspendReason;
 use interpreter::simd::exec_next_simd;
 use interpreter::stack::CallFrame;
 use tinywasm_types::*;
 
+#[cfg(feature = "async")]
+use coro::SuspendReason;
+
 use super::num_helpers::*;
 use super::stack::{BlockFrame, BlockType, Stack};
 use super::values::*;
 use crate::*;
 
 pub(crate) enum ReasonToBreak {
     Errored(Error),
+    #[cfg_attr(not(feature = "async"), allow(unused))]
     Suspended(SuspendReason),
     Finished,
 }
@@ -28,18 +31,20 @@ impl From<ReasonToBreak> for ControlFlow<ReasonToBreak> {
 }
 
 #[derive(Debug)]
+#[cfg_attr(not(feature = "async"), allow(unused))]
 pub(crate) struct SuspendedHostCoroState {
     pub(crate) coro_state: Box<dyn HostCoroState>,
     // plug into used in store.get_func to get original function
     // can be used for checking returned types
-    #[allow(dead_code)] // not implemented yet, but knowing context is useful
+    #[allow(dead_code)] // knowing context is useful for debug and other possible future uses
     pub(crate) coro_orig_function: u32,
 }
 
 #[derive(Debug)]
 pub(crate) struct Executor<'store, 'stack> {
     pub(crate) cf: CallFrame,
     pub(crate) module: ModuleInstance,
+    #[cfg(feature = "async")]
     pub(crate) suspended_host_coro: Option<SuspendedHostCoroState>,
     pub(crate) store: &'store mut Store,
     pub(crate) stack: &'stack mut Stack,
@@ -51,7 +56,14 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     pub(crate) fn new(store: &'store mut Store, stack: &'stack mut Stack) -> Result<Self> {
         let current_frame = stack.call_stack.pop().expect("no call frame, this is a bug");
         let current_module = store.get_module_instance_raw(current_frame.module_addr());
-        Ok(Self { cf: current_frame, module: current_module, suspended_host_coro: None, stack, store })
+        Ok(Self {
+            cf: current_frame,
+            module: current_module,
+            #[cfg(feature = "async")]
+            suspended_host_coro: None,
+            stack,
+            store,
+        })
     }
 
     #[inline(always)]
@@ -67,6 +79,7 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         }
     }
 
+    #[cfg(feature = "async")]
     #[inline(always)]
     pub(crate) fn resume(&mut self, res_arg: ResumeArgument) -> Result<ExecOutcome> {
         if let Some(coro_state) = self.suspended_host_coro.as_mut() {
@@ -105,6 +118,7 @@ impl<'store, 'stack> Executor<'store, 'stack> {
     /// execution may not be suspended in the middle of execution the funcion:
     /// so only do it as the last thing or first thing in the intsruction execution
     #[must_use = "If this returns ControlFlow::Break, the caller should propagate it"]
+    #[cfg(feature = "async")]
     fn check_should_suspend(&mut self) -> ControlFlow<ReasonToBreak> {
         if let Some(flag) = &self.store.suspend_cond.suspend_flag {
             if flag.load(core::sync::atomic::Ordering::Acquire) {
@@ -130,6 +144,11 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         ControlFlow::Continue(())
     }
 
+    #[cfg(not(feature = "async"))]
+    fn check_should_suspend(&mut self) -> ControlFlow<ReasonToBreak> {
+        ControlFlow::Continue(())
+    }
+
     #[inline(always)]
     fn exec_next(&mut self) -> ControlFlow<ReasonToBreak> {
         use tinywasm_types::Instruction::*;
@@ -414,7 +433,7 @@ impl<'store, 'stack> Executor<'store, 'stack> {
         self.module.swap_with(self.cf.module_addr(), self.store);
         ControlFlow::Continue(())
     }
-    fn exec_call_host(&mut self, host_func: Rc<HostFunction>, func_ref: u32) -> ControlFlow<ReasonToBreak> {
+    fn exec_call_host(&mut self, host_func: Rc<HostFunction>, _func_ref: u32) -> ControlFlow<ReasonToBreak> {
         let params = self.stack.values.pop_params(&host_func.ty.params);
         let res = host_func.call(FuncContext { store: self.store, module_addr: self.module.id() }, &params).to_cf()?;
         match res {
@@ -424,9 +443,10 @@ impl<'store, 'stack> Executor<'store, 'stack> {
                 self.check_should_suspend()?; // who knows how long we've spent in host function
                 ControlFlow::Continue(())
             }
+            #[cfg(feature = "async")]
             PotentialCoroCallResult::Suspended(suspend_reason, state) => {
                 self.suspended_host_coro =
-                    Some(SuspendedHostCoroState { coro_state: state, coro_orig_function: func_ref });
+                    Some(SuspendedHostCoroState { coro_state: state, coro_orig_function: _func_ref });
                 self.cf.incr_instr_ptr();
                 ReasonToBreak::Suspended(suspend_reason).into()
             }

crates/tinywasm/src/interpreter/executor.rs

@@ -6,12 +6,13 @@ mod values;
 
 #[cfg(not(feature = "std"))]
 mod no_std_floats;
+#[cfg(feature = "async")]
+use {executor::Executor, tinywasm_types::ResumeArgument};
 
 use crate::coro;
 use crate::{FuncContext, ModuleInstance, Result, Store};
-use executor::{Executor, SuspendedHostCoroState};
+use executor::SuspendedHostCoroState;
 use stack::{CallFrame, Stack};
-use tinywasm_types::ResumeArgument;
 pub use values::*;
 
 /// The main `TinyWasm` runtime.
@@ -21,6 +22,7 @@ pub use values::*;
 pub struct InterpreterRuntime {}
 
 #[derive(Debug)]
+#[cfg_attr(not(feature = "async"), allow(unused))]
 pub(crate) struct SuspendedRuntimeBody {
     pub(crate) suspended_host_coro: Option<SuspendedHostCoroState>,
     pub(crate) module: ModuleInstance,
@@ -29,8 +31,10 @@ pub(crate) struct SuspendedRuntimeBody {
 
 #[derive(Debug)]
 pub(crate) struct SuspendedRuntime {
+    #[cfg_attr(not(feature = "async"), allow(unused))]
     pub(crate) body: Option<(SuspendedRuntimeBody, Stack)>,
 }
+#[cfg(feature = "async")]
 impl SuspendedRuntime {
     fn make_exec<'store, 'stack>(
         body: SuspendedRuntimeBody,
@@ -44,10 +48,11 @@ impl SuspendedRuntime {
     }
 }
 
-impl<'a> coro::CoroState<stack::Stack, FuncContext<'a>> for SuspendedRuntime {
+impl coro::CoroState<stack::Stack, FuncContext<'_>> for SuspendedRuntime {
+    #[cfg(feature = "async")]
     fn resume(
         &mut self,
-        ctx: FuncContext<'a>,
+        ctx: FuncContext<'_>,
         arg: ResumeArgument,
     ) -> Result<coro::CoroStateResumeResult<stack::Stack>> {
         // should be put back into self.body unless we're finished
@@ -83,6 +88,7 @@ impl InterpreterRuntime {
         let mut executor = executor::Executor::new(store, &mut stack)?;
         match executor.run_to_suspension()? {
             coro::CoroStateResumeResult::Return(()) => Ok(RuntimeExecOutcome::Return(stack)),
+            #[cfg(feature = "async")]
             coro::CoroStateResumeResult::Suspended(suspend) => Ok(RuntimeExecOutcome::Suspended(
                 suspend,
                 SuspendedRuntime { body: Some((SuspendedRuntime::unmake_exec(executor), stack)) },

crates/tinywasm/src/interpreter/mod.rs

@@ -91,12 +91,20 @@ pub(crate) mod log {
 }
 
 mod error;
-pub use coro::{CoroState, CoroStateResumeResult, PotentialCoroCallResult, SuspendReason};
+#[cfg(not(feature = "async"))]
+#[allow(unused)]
+use coro::{CoroState, CoroStateResumeResult, PotentialCoroCallResult, SuspendReason};
+#[cfg(feature = "async")]
+pub use {
+    coro::{CoroState, CoroStateResumeResult, PotentialCoroCallResult, SuspendReason},
+    module::IncompleteModule,
+};
+
 pub use error::*;
 pub use func::{FuncHandle, FuncHandleTyped, SuspendedFunc};
 pub use imports::*;
 pub use instance::ModuleInstance;
-pub use module::{IncompleteModule, Module};
+pub use module::Module;
 pub use reference::*;
 pub use store::*;
 

crates/tinywasm/src/lib.rs

@@ -1,5 +1,10 @@
-use crate::{CoroState, Imports, ModuleInstance, PotentialCoroCallResult, Result, Store, SuspendedFunc};
-use tinywasm_types::{ResumeArgument, TinyWasmModule};
+#[cfg(feature = "async")]
+use crate::{CoroState, PotentialCoroCallResult, SuspendedFunc};
+#[cfg(feature = "async")]
+use tinywasm_types::ResumeArgument;
+
+use crate::{Imports, ModuleInstance, Result, Store};
+use tinywasm_types::TinyWasmModule;
 
 /// A WebAssembly Module
 ///
@@ -59,6 +64,7 @@ impl Module {
 
     /// same as [Self::instantiate] but accounts for possibility of start function suspending, in which case it returns
     /// [PotentialCoroCallResult::Suspended]. You can call [CoroState::resume] on it at any time to resume instantiation
+    #[cfg(feature = "async")]
     pub fn instantiate_coro(
         self,
         store: &mut Store,
@@ -80,11 +86,14 @@ impl Module {
 
 /// a corostate that results in [ModuleInstance] when finished
 #[derive(Debug)]
+#[cfg(feature = "async")]
 pub struct IncompleteModule(Option<HitTheFloor>);
 
 #[derive(Debug)]
+#[cfg(feature = "async")]
 struct HitTheFloor(ModuleInstance, SuspendedFunc);
 
+#[cfg(feature = "async")]
 impl CoroState<ModuleInstance, &mut Store> for IncompleteModule {
     fn resume(&mut self, ctx: &mut Store, arg: ResumeArgument) -> Result<crate::CoroStateResumeResult<ModuleInstance>> {
         let mut body: HitTheFloor = match self.0.take() {