generalize async fiber abstraction

benches/call.rs

@@ -135,7 +135,7 @@ fn bench_host_to_wasm<Params, Results>(
     typed_results: Results,
 ) where
     Params: WasmParams + ToVals + Copy,
-    Results: WasmResults + ToVals + Copy + PartialEq + Debug,
+    Results: WasmResults + ToVals + Copy + PartialEq + Debug + 'static,
 {
     // Benchmark the "typed" version, which should be faster than the versions
     // below.
@@ -628,7 +628,8 @@ mod component {
             + PartialEq
             + Debug
             + Send
-            + Sync,
+            + Sync
+            + 'static,
     {
         // Benchmark the "typed" version.
         c.bench_function(&format!("component - host-to-wasm - typed - {name}"), |b| {

crates/wasmtime/Cargo.toml

@@ -194,6 +194,7 @@ async = [
   "dep:wasmtime-fiber",
   "dep:async-trait",
   "dep:trait-variant",
+  "dep:futures",
   "wasmtime-component-macro?/async",
   "runtime",
 ]

crates/wasmtime/src/runtime.rs

@@ -34,6 +34,8 @@ pub(crate) mod code_memory;
 #[cfg(feature = "debug-builtins")]
 pub(crate) mod debug;
 pub(crate) mod externals;
+#[cfg(feature = "async")]
+pub(crate) mod fiber;
 pub(crate) mod gc;
 pub(crate) mod instance;
 pub(crate) mod instantiate;

crates/wasmtime/src/runtime/component/func.rs

@@ -547,7 +547,7 @@ impl Func {
         let mut store = store.as_context_mut();
         assert!(
             store.0.async_support(),
-            "cannot use `call_async` without enabling async support in the config"
+            "cannot use `post_return_async` without enabling async support in the config"
         );
         // Future optimization opportunity: conditionally use a fiber here since
         // some func's post_return will not need the async context (i.e. end up

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -179,7 +179,7 @@ where
     ) -> Result<Return>
     where
         Params: Send + Sync,
-        Return: Send + Sync,
+        Return: Sync,
     {
         let mut store = store.as_context_mut();
         assert!(

crates/wasmtime/src/runtime/component/linker.rs

@@ -7,6 +7,8 @@ use crate::component::types;
 use crate::component::{
     Component, ComponentNamedList, Instance, InstancePre, Lift, Lower, ResourceType, Val,
 };
+#[cfg(feature = "async")]
+use crate::fiber::AsyncCx;
 use crate::hash_map::HashMap;
 use crate::prelude::*;
 use crate::{AsContextMut, Engine, Module, StoreContextMut};
@@ -442,9 +444,9 @@ impl<T: 'static> LinkerInstance<'_, T> {
             "cannot use `func_wrap_async` without enabling async support in the config"
         );
         let ff = move |mut store: StoreContextMut<'_, T>, params: Params| -> Result<Return> {
-            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
-            let future = f(store.as_context_mut(), params);
-            unsafe { async_cx.block_on(Pin::from(future)) }?
+            let async_cx = AsyncCx::new(&mut store.0);
+            let mut future = Pin::from(f(store.as_context_mut(), params));
+            async_cx.block_on(future.as_mut())?
         };
         self.func_wrap(name, ff)
     }
@@ -604,9 +606,9 @@ impl<T: 'static> LinkerInstance<'_, T> {
             "cannot use `func_new_async` without enabling async support in the config"
         );
         let ff = move |mut store: StoreContextMut<'_, T>, params: &[Val], results: &mut [Val]| {
-            let async_cx = store.as_context_mut().0.async_cx().expect("async cx");
-            let future = f(store.as_context_mut(), params, results);
-            unsafe { async_cx.block_on(Pin::from(future)) }?
+            let async_cx = AsyncCx::new(&mut store.0);
+            let mut future = Pin::from(f(store.as_context_mut(), params, results));
+            async_cx.block_on(future.as_mut())?
         };
         self.func_new(name, ff)
     }
@@ -676,9 +678,9 @@ impl<T: 'static> LinkerInstance<'_, T> {
         let dtor = Arc::new(crate::func::HostFunc::wrap_inner(
             &self.engine,
             move |mut cx: crate::Caller<'_, T>, (param,): (u32,)| {
-                let async_cx = cx.as_context_mut().0.async_cx().expect("async cx");
-                let future = dtor(cx.as_context_mut(), param);
-                match unsafe { async_cx.block_on(Pin::from(future)) } {
+                let async_cx = AsyncCx::new(&mut cx.as_context_mut().0);
+                let mut future = Pin::from(dtor(cx.as_context_mut(), param));
+                match async_cx.block_on(future.as_mut()) {
                     Ok(Ok(())) => Ok(()),
                     Ok(Err(trap)) | Err(trap) => Err(trap),
                 }