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

This reverts commit 450881e.

Author: WhaleKit

Cargo.toml

@@ -30,10 +30,6 @@ 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,8 +37,7 @@ logging=["log", "tinywasm-parser?/logging", "tinywasm-types/logging"]
 std=["tinywasm-parser?/std", "tinywasm-types/std"]
 parser=["dep:tinywasm-parser"]
 archive=["tinywasm-types/archive"]
-async=[]
-test_async=["async"] #feels weird putting it here
+test_async=[] #feels weird putting it here
 
 [[test]]
 name="test-wasm-1"

crates/tinywasm/src/coro.rs

@@ -6,10 +6,7 @@ use tinywasm_types::FuncType;
 #[cfg(feature = "parser")]
 pub use tinywasm_parser::ParseError;
 
-#[cfg(feature = "async")]
-use crate::coro::UnexpectedSuspendError;
-
-use crate::interpreter;
+use crate::{coro::UnexpectedSuspendError, interpreter};
 
 /// Errors that can occur for `TinyWasm` operations
 #[derive(Debug)]
@@ -48,7 +45,6 @@ pub enum Error {
 
     /// Function unexpectedly yielded instead of returning
     /// (for backwards compatibility with old api)
-    #[cfg(feature = "async")]
     UnexpectedSuspend(UnexpectedSuspendError),
 
     #[cfg(feature = "std")]
@@ -200,9 +196,6 @@ 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"),
@@ -212,6 +205,8 @@ 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,13 +1,11 @@
-#[cfg(feature = "async")]
-use {crate::coro::CoroState, tinywasm_types::ResumeArgument};
-
+use crate::coro::CoroState;
 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, ValType, WasmValue};
+use tinywasm_types::{ExternRef, FuncRef, FuncType, ModuleInstanceAddr, ResumeArgument, ValType, WasmValue};
 
 #[derive(Debug)]
 /// A function handle
@@ -154,7 +152,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: Default::default() })
+            .map_state(|state| SuspendedFuncTyped::<R> { func: state, _marker: core::marker::PhantomData {} })
             .propagate_err_result()
     }
 }
@@ -163,13 +161,11 @@ 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<'_>,
@@ -180,7 +176,6 @@ 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),
@@ -189,15 +184,13 @@ 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,
@@ -215,7 +208,6 @@ 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>,
@@ -231,7 +223,6 @@ 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,9 +2,10 @@ 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, Result, Store};
-#[cfg(feature = "async")]
-use crate::{PotentialCoroCallResult, SuspendedFunc};
+use crate::{
+    Error, FuncHandle, FuncHandleTyped, Imports, MemoryRef, MemoryRefMut, Module, PotentialCoroCallResult, Result,
+    Store, SuspendedFunc,
+};
 
 /// An instanciated WebAssembly module
 ///
@@ -269,9 +270,8 @@ impl ModuleInstance {
     /// Invoke the start function of the module
     ///
     /// Returns None if the module has no start function
-    /// If start function suspends, returns SuspendedFunc.
+    /// If start function suspends, returns SuspededFunc.
     /// 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,21 +5,18 @@ 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,
 }
@@ -31,20 +28,18 @@ 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)] // knowing context is useful for debug and other possible future uses
+    #[allow(dead_code)] // not implemented yet, but knowing context is useful
     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,
@@ -56,14 +51,7 @@ 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,
-            #[cfg(feature = "async")]
-            suspended_host_coro: None,
-            stack,
-            store,
-        })
+        Ok(Self { cf: current_frame, module: current_module, suspended_host_coro: None, stack, store })
     }
 
     #[inline(always)]
@@ -79,7 +67,6 @@ 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() {
@@ -118,7 +105,6 @@ 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) {
@@ -144,11 +130,6 @@ 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::*;
@@ -433,7 +414,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 {
@@ -443,10 +424,9 @@ 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,13 +6,12 @@ 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::SuspendedHostCoroState;
+use executor::{Executor, SuspendedHostCoroState};
 use stack::{CallFrame, Stack};
+use tinywasm_types::ResumeArgument;
 pub use values::*;
 
 /// The main `TinyWasm` runtime.
@@ -22,7 +21,6 @@ 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,
@@ -31,10 +29,8 @@ 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,
@@ -48,11 +44,10 @@ impl SuspendedRuntime {
     }
 }
 
-impl coro::CoroState<stack::Stack, FuncContext<'_>> for SuspendedRuntime {
-    #[cfg(feature = "async")]
+impl<'a> coro::CoroState<stack::Stack, FuncContext<'a>> for SuspendedRuntime {
     fn resume(
         &mut self,
-        ctx: FuncContext<'_>,
+        ctx: FuncContext<'a>,
         arg: ResumeArgument,
     ) -> Result<coro::CoroStateResumeResult<stack::Stack>> {
         // should be put back into self.body unless we're finished
@@ -88,7 +83,6 @@ 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,20 +91,12 @@ pub(crate) mod log {
 }
 
 mod error;
-#[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 coro::{CoroState, CoroStateResumeResult, PotentialCoroCallResult, SuspendReason};
 pub use error::*;
 pub use func::{FuncHandle, FuncHandleTyped, SuspendedFunc};
 pub use imports::*;
 pub use instance::ModuleInstance;
-pub use module::Module;
+pub use module::{IncompleteModule, Module};
 pub use reference::*;
 pub use store::*;
 

crates/tinywasm/src/lib.rs

@@ -1,10 +1,5 @@
-#[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;
+use crate::{CoroState, Imports, ModuleInstance, PotentialCoroCallResult, Result, Store, SuspendedFunc};
+use tinywasm_types::{ResumeArgument, TinyWasmModule};
 
 /// A WebAssembly Module
 ///
@@ -64,7 +59,6 @@ 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,
@@ -86,14 +80,11 @@ 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() {