fix doc tests; address review feedback

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

Author: dicej

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

@@ -1,6 +1,6 @@
 use anyhow::Context as _;
 use futures::FutureExt;
-use std::future::{self, Future};
+use std::future::Future;
 use std::pin::Pin;
 use wasmtime::component::Resource;
 use wasmtime::AsContextMut;
@@ -16,27 +16,26 @@ impl Proxy {
         &self,
         mut store: S,
         req: R,
-    ) -> Pin<
-        Box<
-            dyn Future<Output = wasmtime::Result<Result<Resource<Response>, ErrorCode>>>
-                + Send
-                + 'static,
+    ) -> wasmtime::Result<
+        Pin<
+            Box<
+                dyn Future<Output = wasmtime::Result<Result<Resource<Response>, ErrorCode>>>
+                    + Send
+                    + 'static,
+            >,
         >,
     >
     where
         T: ResourceView + Send,
     {
         let mut store = store.as_context_mut();
         let table = store.data_mut().table();
-        match table
+        let req = table
             .push(req.into())
-            .context("failed to push request to table")
-        {
-            Ok(req) => self
-                .wasi_http_handler()
-                .call_handle(&mut store, req)
-                .boxed(),
-            Err(e) => future::ready(Err(e)).boxed(),
-        }
+            .context("failed to push request to table")?;
+        Ok(self
+            .wasi_http_handler()
+            .call_handle(&mut store, req)
+            .boxed())
     }
 }

crates/wasi-http/tests/all/p3/incoming.rs

@@ -39,7 +39,7 @@ async fn run_wasi_http<E: Into<ErrorCode> + 'static>(
     wasmtime_wasi_http::p3::add_to_linker(&mut linker)?;
     let instance = linker.instantiate_async(&mut store, &component).await?;
     let proxy = Proxy::new(&mut store, &instance)?;
-    let handle = proxy.handle(&mut store, req);
+    let handle = proxy.handle(&mut store, req)?;
     let res = match instance.run(&mut store, handle).await?? {
         Ok(res) => res,
         Err(err) => return Ok(Err(Some(err))),

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

@@ -2314,9 +2314,6 @@ impl Instance {
     /// #
     /// # async fn foo() -> Result<()> {
     /// # let mut config = Config::new();
-    /// # config.wasm_component_model(true);
-    /// # config.wasm_component_model_async(true);
-    /// # config.async_support(true);
     /// # let engine = Engine::new(&config)?;
     /// # let mut store = Store::new(&engine, ());
     /// # let mut linker = Linker::new(&engine);
@@ -2336,7 +2333,7 @@ impl Instance {
     /// // let (future,) = call.await?;
     ///
     /// // OK, since we use `Instance::run` to poll `call` inside the event loop:
-    /// let (future,) = instance.run(&mut store, call).await?;
+    /// let (future,) = instance.run(&mut store, call).await??;
     ///
     /// let future = future.into_reader(&mut store);
     ///
@@ -2386,28 +2383,72 @@ impl Instance {
     /// futures passed to `run`.
     ///
     /// ```
+    /// # use {
+    /// #   anyhow::Result,
+    /// #   wasmtime::{
+    /// #     component::{ Component, Linker, Resource, ResourceTable },
+    /// #     Config, Engine, Store
+    /// #   },
+    /// # };
+    /// #
+    /// # struct MyResource(u32);
+    /// # struct Ctx { table: ResourceTable }
+    /// #
+    /// # async fn foo() -> Result<()> {
+    /// # let mut config = Config::new();
+    /// # let engine = Engine::new(&config)?;
+    /// # let mut store = Store::new(&engine, Ctx { table: ResourceTable::new() });
+    /// # let mut linker = Linker::new(&engine);
+    /// # let component = Component::new(&engine, "")?;
+    /// # let instance = linker.instantiate_async(&mut store, &component).await?;
+    /// # let foo = instance.get_typed_func::<(Resource<MyResource>,), (Resource<MyResource>,)>(&mut store, "foo")?;
+    /// # let bar = instance.get_typed_func::<(u32,), ()>(&mut store, "bar")?;
     /// let resource = store.data_mut().table.push(MyResource(42))?;
     /// let call = foo.call_concurrent(&mut store, (resource,));
-    /// let (another_resource,) = instance.run(&mut store, call).await?;
+    /// let (another_resource,) = instance.run(&mut store, call).await??;
     /// let value = store.data_mut().table.delete(another_resource)?;
     /// let call = bar.call_concurrent(&mut store, (value.0,));
-    /// instance.run(&mut store, call).await?;
+    /// instance.run(&mut store, call).await??;
+    /// # Ok(())
+    /// # }
     /// ```
     ///
     /// - Call `run_with` once and use `Accessor::with` to access the store from
     /// within the future.
     ///
     /// ```
-    /// instance.run_with(&mut store, Box::pin(|accessor| async move {
-    ///    let another_resource = accessor.with(|store| {
-    ///        let resource = store.data_mut().table.push(MyResource(42))?;
-    ///        Ok(foo.call_concurrent(store, (resource,)))
+    /// # use {
+    /// #   anyhow::{Result, Error},
+    /// #   wasmtime::{
+    /// #     component::{ Component, Linker, Resource, ResourceTable, Accessor, Access },
+    /// #     Config, Engine, Store
+    /// #   },
+    /// # };
+    /// #
+    /// # struct MyResource(u32);
+    /// # struct Ctx { table: ResourceTable }
+    /// #
+    /// # async fn foo() -> Result<()> {
+    /// # let mut config = Config::new();
+    /// # let engine = Engine::new(&config)?;
+    /// # let mut store = Store::new(&engine, Ctx { table: ResourceTable::new() });
+    /// # let mut linker = Linker::new(&engine);
+    /// # let component = Component::new(&engine, "")?;
+    /// # let instance = linker.instantiate_async(&mut store, &component).await?;
+    /// # let foo = instance.get_typed_func::<(Resource<MyResource>,), (Resource<MyResource>,)>(&mut store, "foo")?;
+    /// # let bar = instance.get_typed_func::<(u32,), ()>(&mut store, "bar")?;
+    /// instance.run_with(&mut store, move |accessor: &mut Accessor<_, _>| Box::pin(async move {
+    ///    let (another_resource,) = accessor.with(|mut access: Access<Ctx, Ctx>| {
+    ///        let resource = access.table.push(MyResource(42))?;
+    ///        Ok::<_, Error>(foo.call_concurrent(access, (resource,)))
     ///    })?.await?;
-    ///    accessor.with(|store| {
-    ///        let value = store.data_mut().table.delete(another_resource)?;
-    ///        Ok(bar.call_concurrent(store, (value.0,)))
+    ///    accessor.with(|mut access: Access<Ctx, Ctx>| {
+    ///        let value = access.table.delete(another_resource)?;
+    ///        Ok::<_, Error>(bar.call_concurrent(access, (value.0,)))
     ///    })?.await
-    /// })).await?;
+    /// })).await??;
+    /// # Ok(())
+    /// # }
     /// ```
     pub async fn run_with<U: Send, V: Send + Sync + 'static, F>(
         &self,

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

@@ -116,7 +116,7 @@ mod values;
 pub use self::component::{Component, ComponentExportIndex};
 #[cfg(feature = "component-model-async")]
 pub use self::concurrent::{
-    AbortOnDropHandle, Accessor, AccessorTask, ErrorContext, FutureReader, FutureWriter,
+    AbortOnDropHandle, Access, Accessor, AccessorTask, ErrorContext, FutureReader, FutureWriter,
     HostFuture, HostStream, ReadBuffer, StreamReader, StreamWriter, VMComponentAsyncStore,
     VecBuffer, Watch, WriteBuffer,
 };

src/commands/serve.rs

@@ -592,8 +592,8 @@ impl ServeCommand {
                                 )?;
                                 let (req, body) = req.into_parts();
                                 let body = body.map_err(wasmtime_wasi_http::p3::bindings::http::types::ErrorCode::from_hyper_request_error);
-                                let handle =
-                                    proxy.handle(&mut store, http::Request::from_parts(req, body));
+                                let handle = proxy
+                                    .handle(&mut store, http::Request::from_parts(req, body))?;
                                 let res = instance.run(&mut store, handle).await???;
                                 let (res, tx, io) =
                                     wasmtime_wasi_http::p3::Response::resource_into_http(