Remove some async annotations in bindings generation (#12042)

These are no longer necessary now that there's a sync `Access`-binding
mode.

Author: alexcrichton

crates/wasi-http/src/p3/bindings.rs

@@ -6,13 +6,13 @@ mod generated {
         path: "src/p3/wit",
         world: "wasi:http/proxy",
         imports: {
-            "wasi:http/handler.handle": async | store | trappable | tracing,
+            "wasi:http/handler.handle": store | trappable | tracing,
             "wasi:http/types.[drop]request": store | trappable | tracing,
             "wasi:http/types.[drop]response": store | trappable | tracing,
-            "wasi:http/types.[static]request.consume-body": async | store | trappable | tracing,
-            "wasi:http/types.[static]request.new": async | store | trappable | tracing,
-            "wasi:http/types.[static]response.consume-body": async | store | trappable | tracing,
-            "wasi:http/types.[static]response.new": async | store | trappable | tracing,
+            "wasi:http/types.[static]request.consume-body": store | trappable | tracing,
+            "wasi:http/types.[static]request.new": store | trappable | tracing,
+            "wasi:http/types.[static]response.consume-body": store | trappable | tracing,
+            "wasi:http/types.[static]response.new": store | trappable | tracing,
             default: trappable | tracing,
         },
         exports: { default: async | store | task_exit },

crates/wasi-http/src/p3/host/types.rs

@@ -14,7 +14,7 @@ use http::header::CONTENT_LENGTH;
 use std::sync::Arc;
 use tokio::sync::oneshot;
 use wasmtime::component::{
-    Access, Accessor, FutureProducer, FutureReader, Resource, ResourceTable, StreamReader,
+    Access, FutureProducer, FutureReader, Resource, ResourceTable, StreamReader,
 };
 use wasmtime::{AsContextMut, StoreContextMut};
 
@@ -312,72 +312,68 @@ impl HostFields for WasiHttpCtxView<'_> {
 }
 
 impl HostRequestWithStore for WasiHttp {
-    async fn new<T>(
-        store: &Accessor<T, Self>,
+    fn new<T>(
+        mut store: Access<T, Self>,
         headers: Resource<Headers>,
         contents: Option<StreamReader<u8>>,
         trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
         options: Option<Resource<RequestOptions>>,
     ) -> wasmtime::Result<(Resource<Request>, FutureReader<Result<(), ErrorCode>>)> {
-        store.with(|mut store| {
-            let (result_tx, result_rx) = oneshot::channel();
-            let body = match contents
-                .map(|rx| rx.try_into::<HostBodyStreamProducer<T>>(store.as_context_mut()))
-            {
-                Some(Ok(mut producer)) => Body::Host {
-                    body: mem::take(&mut producer.body),
-                    result_tx,
-                },
-                Some(Err(rx)) => Body::Guest {
-                    contents_rx: Some(rx),
-                    trailers_rx: trailers,
-                    result_tx,
-                },
-                None => Body::Guest {
-                    contents_rx: None,
-                    trailers_rx: trailers,
-                    result_tx,
-                },
-            };
-            let WasiHttpCtxView { table, .. } = store.get();
-            let headers = delete_fields(table, headers)?;
-            let options = options
-                .map(|options| delete_request_options(table, options))
-                .transpose()?;
-            let req = Request {
-                method: http::Method::GET,
-                scheme: None,
-                authority: None,
-                path_with_query: None,
-                headers: headers.into(),
-                options: options.map(Into::into),
-                body,
-            };
-            let req = table.push(req).context("failed to push request to table")?;
-            Ok((
-                req,
-                FutureReader::new(&mut store, GuestBodyResultProducer::Receiver(result_rx)),
-            ))
-        })
-    }
-
-    async fn consume_body<T>(
-        store: &Accessor<T, Self>,
+        let (result_tx, result_rx) = oneshot::channel();
+        let body = match contents
+            .map(|rx| rx.try_into::<HostBodyStreamProducer<T>>(store.as_context_mut()))
+        {
+            Some(Ok(mut producer)) => Body::Host {
+                body: mem::take(&mut producer.body),
+                result_tx,
+            },
+            Some(Err(rx)) => Body::Guest {
+                contents_rx: Some(rx),
+                trailers_rx: trailers,
+                result_tx,
+            },
+            None => Body::Guest {
+                contents_rx: None,
+                trailers_rx: trailers,
+                result_tx,
+            },
+        };
+        let WasiHttpCtxView { table, .. } = store.get();
+        let headers = delete_fields(table, headers)?;
+        let options = options
+            .map(|options| delete_request_options(table, options))
+            .transpose()?;
+        let req = Request {
+            method: http::Method::GET,
+            scheme: None,
+            authority: None,
+            path_with_query: None,
+            headers: headers.into(),
+            options: options.map(Into::into),
+            body,
+        };
+        let req = table.push(req).context("failed to push request to table")?;
+        Ok((
+            req,
+            FutureReader::new(&mut store, GuestBodyResultProducer::Receiver(result_rx)),
+        ))
+    }
+
+    fn consume_body<T>(
+        mut store: Access<T, Self>,
         req: Resource<Request>,
         fut: FutureReader<Result<(), ErrorCode>>,
     ) -> wasmtime::Result<(
         StreamReader<u8>,
         FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
     )> {
         let getter = store.getter();
-        store.with(|mut store| {
-            let Request { body, .. } = store
-                .get()
-                .table
-                .delete(req)
-                .context("failed to delete request from table")?;
-            Ok(body.consume(store, fut, getter))
-        })
+        let Request { body, .. } = store
+            .get()
+            .table
+            .delete(req)
+            .context("failed to delete request from table")?;
+        Ok(body.consume(store, fut, getter))
     }
 
     fn drop<T>(mut store: Access<'_, T, Self>, req: Resource<Request>) -> wasmtime::Result<()> {
@@ -602,66 +598,62 @@ impl HostRequestOptions for WasiHttpCtxView<'_> {
 }
 
 impl HostResponseWithStore for WasiHttp {
-    async fn new<T>(
-        store: &Accessor<T, Self>,
+    fn new<T>(
+        mut store: Access<T, Self>,
         headers: Resource<Headers>,
         contents: Option<StreamReader<u8>>,
         trailers: FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
     ) -> wasmtime::Result<(Resource<Response>, FutureReader<Result<(), ErrorCode>>)> {
-        store.with(|mut store| {
-            let (result_tx, result_rx) = oneshot::channel();
-            let body = match contents
-                .map(|rx| rx.try_into::<HostBodyStreamProducer<T>>(store.as_context_mut()))
-            {
-                Some(Ok(mut producer)) => Body::Host {
-                    body: mem::take(&mut producer.body),
-                    result_tx,
-                },
-                Some(Err(rx)) => Body::Guest {
-                    contents_rx: Some(rx),
-                    trailers_rx: trailers,
-                    result_tx,
-                },
-                None => Body::Guest {
-                    contents_rx: None,
-                    trailers_rx: trailers,
-                    result_tx,
-                },
-            };
-            let WasiHttpCtxView { table, .. } = store.get();
-            let headers = delete_fields(table, headers)?;
-            let res = Response {
-                status: http::StatusCode::OK,
-                headers: headers.into(),
-                body,
-            };
-            let res = table
-                .push(res)
-                .context("failed to push response to table")?;
-            Ok((
-                res,
-                FutureReader::new(&mut store, GuestBodyResultProducer::Receiver(result_rx)),
-            ))
-        })
-    }
-
-    async fn consume_body<T>(
-        store: &Accessor<T, Self>,
+        let (result_tx, result_rx) = oneshot::channel();
+        let body = match contents
+            .map(|rx| rx.try_into::<HostBodyStreamProducer<T>>(store.as_context_mut()))
+        {
+            Some(Ok(mut producer)) => Body::Host {
+                body: mem::take(&mut producer.body),
+                result_tx,
+            },
+            Some(Err(rx)) => Body::Guest {
+                contents_rx: Some(rx),
+                trailers_rx: trailers,
+                result_tx,
+            },
+            None => Body::Guest {
+                contents_rx: None,
+                trailers_rx: trailers,
+                result_tx,
+            },
+        };
+        let WasiHttpCtxView { table, .. } = store.get();
+        let headers = delete_fields(table, headers)?;
+        let res = Response {
+            status: http::StatusCode::OK,
+            headers: headers.into(),
+            body,
+        };
+        let res = table
+            .push(res)
+            .context("failed to push response to table")?;
+        Ok((
+            res,
+            FutureReader::new(&mut store, GuestBodyResultProducer::Receiver(result_rx)),
+        ))
+    }
+
+    fn consume_body<T>(
+        mut store: Access<T, Self>,
         res: Resource<Response>,
         fut: FutureReader<Result<(), ErrorCode>>,
     ) -> wasmtime::Result<(
         StreamReader<u8>,
         FutureReader<Result<Option<Resource<Trailers>>, ErrorCode>>,
     )> {
         let getter = store.getter();
-        store.with(|mut store| {
-            let Response { body, .. } = store
-                .get()
-                .table
-                .delete(res)
-                .context("failed to delete response from table")?;
-            Ok(body.consume(store, fut, getter))
-        })
+        let Response { body, .. } = store
+            .get()
+            .table
+            .delete(res)
+            .context("failed to delete response from table")?;
+        Ok(body.consume(store, fut, getter))
     }
 
     fn drop<T>(mut store: Access<'_, T, Self>, res: Resource<Response>) -> wasmtime::Result<()> {

crates/wasi/src/p3/bindings.rs

@@ -79,10 +79,10 @@ mod generated {
         path: "src/p3/wit",
         world: "wasi:cli/command",
         imports: {
-            "wasi:cli/stdin": async | store | tracing | trappable,
-            "wasi:cli/stdout": async | store | tracing | trappable,
-            "wasi:cli/stderr": async | store | tracing | trappable,
-            "wasi:filesystem/types.[method]descriptor.read-via-stream": async | store | tracing | trappable,
+            "wasi:cli/stdin": store | tracing | trappable,
+            "wasi:cli/stdout": store | tracing | trappable,
+            "wasi:cli/stderr": store | tracing | trappable,
+            "wasi:filesystem/types.[method]descriptor.read-via-stream": store | tracing | trappable,
             "wasi:sockets/types.[method]tcp-socket.bind": async | store | tracing | trappable,
             "wasi:sockets/types.[method]tcp-socket.listen": async | store | tracing | trappable,
             "wasi:sockets/types.[method]tcp-socket.receive": async | store | tracing | trappable,

crates/wasi/src/p3/cli/host.rs

@@ -15,7 +15,7 @@ use std::io::{self, Cursor};
 use tokio::io::{AsyncRead, AsyncWrite, ReadBuf};
 use tokio::sync::oneshot;
 use wasmtime::component::{
-    Accessor, Destination, FutureReader, Resource, Source, StreamConsumer, StreamProducer,
+    Access, Accessor, Destination, FutureReader, Resource, Source, StreamConsumer, StreamProducer,
     StreamReader, StreamResult,
 };
 use wasmtime::{AsContextMut as _, StoreContextMut};
@@ -193,27 +193,25 @@ impl terminal_stderr::Host for WasiCliCtxView<'_> {
 }
 
 impl stdin::HostWithStore for WasiCli {
-    async fn read_via_stream<U>(
-        store: &Accessor<U, Self>,
+    fn read_via_stream<U>(
+        mut store: Access<U, Self>,
     ) -> wasmtime::Result<(StreamReader<u8>, FutureReader<Result<(), ErrorCode>>)> {
-        store.with(|mut store| {
-            let rx = store.get().ctx.stdin.async_stream();
-            let (result_tx, result_rx) = oneshot::channel();
-            let stream = StreamReader::new(
-                &mut store,
-                InputStreamProducer {
-                    rx: Box::into_pin(rx),
-                    result_tx: Some(result_tx),
-                },
-            );
-            let future = FutureReader::new(&mut store, async {
-                anyhow::Ok(match result_rx.await {
-                    Ok(err) => Err(err),
-                    Err(_) => Ok(()),
-                })
-            });
-            Ok((stream, future))
-        })
+        let rx = store.get().ctx.stdin.async_stream();
+        let (result_tx, result_rx) = oneshot::channel();
+        let stream = StreamReader::new(
+            &mut store,
+            InputStreamProducer {
+                rx: Box::into_pin(rx),
+                result_tx: Some(result_tx),
+            },
+        );
+        let future = FutureReader::new(&mut store, async {
+            anyhow::Ok(match result_rx.await {
+                Ok(err) => Err(err),
+                Err(_) => Ok(()),
+            })
+        });
+        Ok((stream, future))
     }
 }