refactor concurrent_imports support in wasmtime-wit-bindgen (#6)

I had a few goals with this PR:

  1. Improve the ergonomics of concurrent import bindings by supporting
  `async`/`await` sugar and allowing store access to be arbitrarily interspersed
  between `await` points -- while still preventing references to the store
  across `await` points.

  2. Get rid of the `Data` associated types for `Host` traits and support
  `add_to_linker_get_host` where the `Host` impl is not the same as the `T` in
  `Store<T>`.

  3. Allow creating, reading from, writing to, etc. streams and futures without
  exposing `StoreContextMut` directly.

Unfortunately, after a day of intense type tetris I failed to achieve items 2 or
3, so this only covers item 1.

Regarding item 1: I've introduced a new `Accessor` type which wraps a `*mut dyn
VMStore` and provides access to it only via a `with` method that accepts a
synchronous closure which takes a `StoreContextMut<T>` parameter.  The closure
can do what it likes and return an arbitrary value as long as that result has a
`'static` lifetime (i.e. does not borrow from the store).  This ensures that the
host function is able to access the store only between `await`s and not across
them; we prohibit the latter because it would prevent other async-lowered
imports from running concurrently.  Finally, since host function takes a `&mut
Accessor<T>`, it is not possible for the reference to outlive the future
returned by the host function, and since the `with` method takes `&mut self` it
cannot be used recursively.

Regarding items 2 and 3: In order to read from or write to streams/futures, we
need to be able to efficiently lift and lower their payload types, which
requires that both the payload type (of which there could be several for a given
world) and the `T` in `Store<T>` be in scope.  I was unable to find a way to
thread those types through the various layers of closures, futures, and
generated code without adding unwanted `'static` bounds and/or breaking the
blanket `impl`s used for forwarding calls from `&mut X` to `X`.  Also, the usual
tricks of using dyn objects or vtables could only be used ergonomically to erase
one of the two types but not both.  I'd love to revisit this later with the help
of a Rust type wizard to see if there's a strategy I missed.

Signed-off-by: Joel Dice <joel.dice@fermyon.com>

Author: dicej

crates/misc/component-async-tests/http/src/lib.rs

@@ -29,9 +29,9 @@ use {
     wasi::http::types::{ErrorCode, HeaderError, Method, RequestOptionsError, Scheme},
     wasmtime::{
         component::{
-            self, ErrorContext, FutureReader, Linker, Resource, ResourceTable, StreamReader,
+            Accessor, ErrorContext, FutureReader, Linker, Resource, ResourceTable, StreamReader,
         },
-        AsContextMut, StoreContextMut,
+        AsContextMut,
     },
 };
 
@@ -55,18 +55,9 @@ pub trait WasiHttpView: Send + Sized {
     fn table(&mut self) -> &mut ResourceTable;
 
     fn send_request(
-        store: StoreContextMut<'_, Self::Data>,
+        accessor: &mut Accessor<Self::Data>,
         request: Resource<Request>,
-    ) -> impl Future<
-        Output = impl FnOnce(
-            StoreContextMut<'_, Self::Data>,
-        ) -> wasmtime::Result<Result<Resource<Response>, ErrorCode>>
-                     + Send
-                     + Sync
-                     + 'static,
-    > + Send
-           + Sync
-           + 'static;
+    ) -> impl Future<Output = wasmtime::Result<Result<Resource<Response>, ErrorCode>>> + Send + Sync;
 }
 
 impl<T: WasiHttpView> WasiHttpView for &mut T {
@@ -77,19 +68,11 @@ impl<T: WasiHttpView> WasiHttpView for &mut T {
     }
 
     fn send_request(
-        store: StoreContextMut<'_, Self::Data>,
+        accessor: &mut Accessor<Self::Data>,
         request: Resource<Request>,
-    ) -> impl Future<
-        Output = impl FnOnce(
-            StoreContextMut<'_, Self::Data>,
-        ) -> wasmtime::Result<Result<Resource<Response>, ErrorCode>>
-                     + Send
-                     + Sync
-                     + 'static,
-    > + Send
-           + Sync
-           + 'static {
-        T::send_request(store, request)
+    ) -> impl Future<Output = wasmtime::Result<Result<Resource<Response>, ErrorCode>>> + Send + Sync
+    {
+        T::send_request(accessor, request)
     }
 }
 
@@ -103,19 +86,11 @@ impl<T: WasiHttpView> WasiHttpView for WasiHttpImpl<T> {
     }
 
     fn send_request(
-        store: StoreContextMut<'_, Self::Data>,
+        accessor: &mut Accessor<Self::Data>,
         request: Resource<Request>,
-    ) -> impl Future<
-        Output = impl FnOnce(
-            StoreContextMut<'_, Self::Data>,
-        ) -> wasmtime::Result<Result<Resource<Response>, ErrorCode>>
-                     + Send
-                     + Sync
-                     + 'static,
-    > + Send
-           + Sync
-           + 'static {
-        T::send_request(store, request)
+    ) -> impl Future<Output = wasmtime::Result<Result<Resource<Response>, ErrorCode>>> + Send + Sync
+    {
+        T::send_request(accessor, request)
     }
 }
 
@@ -255,33 +230,22 @@ where
         Ok(Ok(stream))
     }
 
-    fn finish(
-        mut store: StoreContextMut<'_, Self::BodyData>,
+    async fn finish(
+        accessor: &mut Accessor<Self::BodyData>,
         this: Resource<Body>,
-    ) -> impl Future<
-        Output = impl FnOnce(
-            StoreContextMut<'_, Self::BodyData>,
-        )
-            -> wasmtime::Result<Result<Option<Resource<Fields>>, ErrorCode>>
-                     + 'static,
-    > + Send
-           + Sync
-           + 'static {
-        let trailers = (|| {
+    ) -> wasmtime::Result<Result<Option<Resource<Fields>>, ErrorCode>> {
+        let trailers = accessor.with(|mut store| {
             let trailers = store.data_mut().table().delete(this)?.trailers;
             trailers
                 .map(|v| v.read(store.as_context_mut()).map(|v| v.into_future()))
                 .transpose()
-        })();
-        async move {
-            let trailers = match trailers {
-                Ok(Some(trailers)) => Ok(trailers.await),
-                Ok(None) => Ok(None),
-                Err(e) => Err(e),
-            };
+        })?;
 
-            component::for_any(move |_| Ok(Ok(trailers?)))
-        }
+        Ok(Ok(if let Some(trailers) = trailers {
+            trailers.await
+        } else {
+            None
+        }))
     }
 
     fn drop(&mut self, this: Resource<Body>) -> wasmtime::Result<()> {
@@ -530,20 +494,11 @@ where
 impl<T: WasiHttpView> wasi::http::handler::Host for WasiHttpImpl<T> {
     type Data = T::Data;
 
-    fn handle(
-        store: StoreContextMut<'_, Self::Data>,
+    async fn handle(
+        accessor: &mut Accessor<Self::Data>,
         request: Resource<Request>,
-    ) -> impl Future<
-        Output = impl FnOnce(
-            StoreContextMut<'_, Self::Data>,
-        ) -> wasmtime::Result<Result<Resource<Response>, ErrorCode>>
-                     + Send
-                     + Sync
-                     + 'static,
-    > + Send
-           + Sync
-           + 'static {
-        Self::send_request(store, request)
+    ) -> wasmtime::Result<Result<Resource<Response>, ErrorCode>> {
+        Self::send_request(accessor, request).await
     }
 }