Simplify WASI internal implementations (#11365)

* Simplify WASI internal implementations

This commit migrates the WASIp2 implementation to be closer to the
upcoming WASIp3 implementation in terms of how things are implemented
internally. Previously the way things worked with WASIp2 is:

* Embedders call `add_to_linker` with `T: WasiView`
* Internally `add_to_linker` is called which creates `WasiImpl<&mut T>`
* All internal implementations were `impl<T> Host for WasiImpl<T> where T: WasiView`
* A forwarding impl of `impl<T: WasiView> WasiView for &mut T` was
  required

While this all worked it's a bit complicated for a few reasons:

1. Dealing with generically named structures like `WasiImpl` (or
   `IoImpl` or `WasiHttpImpl`) is a bit baroque and not always obvious
   as to what's going on.
2. The extra layer of generics in `impl<T> Host for WasiImpl<T>` adds a
   layer of conceptual indirection which is non-obvious.
3. Other WASI proposal implementations do not use this strategy and
   instead use "view" types or `impl Host for TheType` for example.
4. Internal incantations of `add_to_linker` had to deal with mixtures of
   `IoImpl` and `WasiImpl` and aligning everything just right.
5. An extra layer of generics on all impls meant that everything was
   generic meaning that `wasmtime-wasi`-the-crate didn't generate much
   code, causing longer codegen times for consumers.

The goal of this commit is to migrate towards the style of what WASIp3
is prototyping for how impls are modeled. This is done to increase the
amount of code that can be shared between WASIp2 and WASIp3. This has a
number of benefits such as being easier to understand and also being
more modular where `wasi:clocks` implementations of traits don't require
filesystem context to be present (as is the case today). This in theory
helps a more mix-and-match paradigm of blending together various bits
and pieces of `wasmtime-wasi` implementations.

Concretely the changes made here are:

* `WasiView` no longer inherits from `IoView`, they're unrelated traits
  now.
* `WasiView` now returns `WasiViewCtx<'a>` which has `ctx: &'a mut WasiCtx`
  and `table: &'a mut ResourceTable`. That means it basically does the
  same thing before but in a slightly different fashion.
* Implementations of `Host` traits are now directly for
  `WasiCtxView<'_>` and don't involve any generics at all. These are
  hopefully easier to understand and also better from a
  codegen/compile-time perspective.
* Embedders no longer need to implement `IoView` directly and instead
  fold that functionality into `WasiView`.
* `WasiHttpView` no longer inherits from `IoView` and instead has a
  direct `fn table` method. Additionally `WasiHttpImpl` no longer embeds
  `IoImpl` inside of it.
* Host traits for `wasi:io` are now implemented directly for
  `ResourceTable` instead of `IoImpl<T>`.

The immediate goal of this refactoring is to enable more sharing along
the lines of #11362. This was not possible prior because WASIp3 requires
a simultaneous borrow on the table/ctx while the trait hierarchy
previously gave you one-or-the-other. With this new organization it will
be possible to get both at the same time meaning more
structure/contexts/etc can be shared between implementations.

prtest:full

* CI fixes

* More CI fixes

* More CI fixes

Author: alexcrichton

crates/c-api/src/store.rs

@@ -103,17 +103,13 @@ pub struct WasmtimeStoreData {
     pub(crate) wasip2: Option<wasmtime_wasi::p2::WasiCtx>,
 }
 
-#[cfg(all(feature = "component-model", feature = "wasi"))]
-impl wasmtime_wasi::p2::IoView for WasmtimeStoreData {
-    fn table(&mut self) -> &mut wasmtime_wasi::ResourceTable {
-        &mut self.resource_table
-    }
-}
-
 #[cfg(all(feature = "component-model", feature = "wasi"))]
 impl wasmtime_wasi::p2::WasiView for WasmtimeStoreData {
-    fn ctx(&mut self) -> &mut wasmtime_wasi::p2::WasiCtx {
-        self.wasip2.as_mut().unwrap()
+    fn ctx(&mut self) -> wasmtime_wasi::p2::WasiCtxView<'_> {
+        wasmtime_wasi::p2::WasiCtxView {
+            ctx: self.wasip2.as_mut().unwrap(),
+            table: &mut self.resource_table,
+        }
     }
 }
 

crates/misc/component-async-tests/src/borrowing_host.rs

@@ -1,6 +1,5 @@
 use anyhow::Result;
 use wasmtime::component::Resource;
-use wasmtime_wasi::p2::IoView;
 
 use super::Ctx;
 
@@ -20,16 +19,16 @@ pub struct MyX;
 
 impl bindings::local::local::borrowing_types::HostX for &mut Ctx {
     fn new(&mut self) -> Result<Resource<MyX>> {
-        Ok(IoView::table(self).push(MyX)?)
+        Ok(self.table.push(MyX)?)
     }
 
     fn foo(&mut self, x: Resource<MyX>) -> Result<()> {
-        _ = IoView::table(self).get(&x)?;
+        _ = self.table.get(&x)?;
         Ok(())
     }
 
     fn drop(&mut self, x: Resource<MyX>) -> Result<()> {
-        IoView::table(self).delete(x)?;
+        self.table.delete(x)?;
         Ok(())
     }
 }

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

@@ -4,7 +4,7 @@ use std::sync::{Arc, Mutex};
 use std::task::Waker;
 
 use wasmtime::component::{HasData, ResourceTable};
-use wasmtime_wasi::p2::{IoView, WasiCtx, WasiView};
+use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiView};
 
 pub mod borrowing_host;
 pub mod closed_streams;
@@ -25,15 +25,12 @@ pub struct Ctx {
     pub continue_: bool,
 }
 
-impl IoView for Ctx {
-    fn table(&mut self) -> &mut ResourceTable {
-        &mut self.table
-    }
-}
-
 impl WasiView for Ctx {
-    fn ctx(&mut self) -> &mut WasiCtx {
-        &mut self.wasi
+    fn ctx(&mut self) -> WasiCtxView {
+        WasiCtxView {
+            ctx: &mut self.wasi,
+            table: &mut self.table,
+        }
     }
 }
 

crates/misc/component-async-tests/src/resource_stream.rs

@@ -2,7 +2,6 @@ use anyhow::Result;
 use wasmtime::component::{
     Accessor, AccessorTask, GuardedStreamWriter, Resource, StreamReader, StreamWriter,
 };
-use wasmtime_wasi::p2::IoView;
 
 use super::Ctx;
 
@@ -24,12 +23,12 @@ pub struct ResourceStreamX;
 
 impl bindings::local::local::resource_stream::HostX for Ctx {
     fn foo(&mut self, x: Resource<ResourceStreamX>) -> Result<()> {
-        self.table().get(&x)?;
+        self.table.get(&x)?;
         Ok(())
     }
 
     fn drop(&mut self, x: Resource<ResourceStreamX>) -> Result<()> {
-        IoView::table(self).delete(x)?;
+        self.table.delete(x)?;
         Ok(())
     }
 }
@@ -49,8 +48,7 @@ impl bindings::local::local::resource_stream::HostWithStore for Ctx {
             async fn run(self, accessor: &Accessor<T, Ctx>) -> Result<()> {
                 let mut tx = GuardedStreamWriter::new(accessor, self.tx);
                 for _ in 0..self.count {
-                    let item =
-                        accessor.with(|mut view| view.get().table().push(ResourceStreamX))?;
+                    let item = accessor.with(|mut view| view.get().table.push(ResourceStreamX))?;
                     tx.write_all(Some(item)).await;
                 }
                 Ok(())

crates/wasi-config/src/lib.rs

@@ -17,7 +17,7 @@
 //!     component::{Linker, ResourceTable},
 //!     Config, Engine, Result, Store,
 //! };
-//! use wasmtime_wasi::p2::{IoView, WasiCtx, WasiCtxBuilder, WasiView};
+//! use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiCtxBuilder, WasiView};
 //! use wasmtime_wasi_config::{WasiConfig, WasiConfigVariables};
 //!
 //! #[tokio::main]
@@ -53,11 +53,10 @@
 //!     wasi_config_vars: WasiConfigVariables,
 //! }
 //!
-//! impl IoView for Ctx {
-//!     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
-//! }
 //! impl WasiView for Ctx {
-//!     fn ctx(&mut self) -> &mut WasiCtx { &mut self.wasi_ctx }
+//!     fn ctx(&mut self) -> WasiCtxView<'_> {
+//!         WasiCtxView { ctx: &mut self.wasi_ctx, table: &mut self.table }
+//!     }
 //! }
 //! ```
 //!

crates/wasi-config/tests/main.rs

@@ -5,7 +5,7 @@ use wasmtime::{
     component::{Component, Linker, ResourceTable},
 };
 use wasmtime_wasi::p2::{
-    IoView, WasiCtx, WasiCtxBuilder, WasiView, add_to_linker_async, bindings::Command,
+    WasiCtx, WasiCtxBuilder, WasiCtxView, WasiView, add_to_linker_async, bindings::Command,
 };
 use wasmtime_wasi_config::{WasiConfig, WasiConfigVariables};
 
@@ -15,14 +15,12 @@ struct Ctx {
     wasi_config_vars: WasiConfigVariables,
 }
 
-impl IoView for Ctx {
-    fn table(&mut self) -> &mut ResourceTable {
-        &mut self.table
-    }
-}
 impl WasiView for Ctx {
-    fn ctx(&mut self) -> &mut WasiCtx {
-        &mut self.wasi_ctx
+    fn ctx(&mut self) -> WasiCtxView<'_> {
+        WasiCtxView {
+            ctx: &mut self.wasi_ctx,
+            table: &mut self.table,
+        }
     }
 }
 

crates/wasi-http/src/http_impl.rs

@@ -14,7 +14,6 @@ use bytes::Bytes;
 use http_body_util::{BodyExt, Empty};
 use hyper::Method;
 use wasmtime::component::Resource;
-use wasmtime_wasi::p2::IoView;
 
 impl<T> outgoing_handler::Host for WasiHttpImpl<T>
 where

crates/wasi-http/src/lib.rs

@@ -71,7 +71,7 @@
 //! use tokio::net::TcpListener;
 //! use wasmtime::component::{Component, Linker, ResourceTable};
 //! use wasmtime::{Config, Engine, Result, Store};
-//! use wasmtime_wasi::p2::{IoView, WasiCtx, WasiCtxBuilder, WasiView};
+//! use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiCtxBuilder, WasiView};
 //! use wasmtime_wasi_http::bindings::ProxyPre;
 //! use wasmtime_wasi_http::bindings::http::types::Scheme;
 //! use wasmtime_wasi_http::body::HyperOutgoingBody;
@@ -197,21 +197,21 @@
 //!     http: WasiHttpCtx,
 //!     table: ResourceTable,
 //! }
-//! impl IoView for MyClientState {
-//!     fn table(&mut self) -> &mut ResourceTable {
-//!         &mut self.table
-//!     }
-//! }
+//!
 //! impl WasiView for MyClientState {
-//!     fn ctx(&mut self) -> &mut WasiCtx {
-//!         &mut self.wasi
+//!     fn ctx(&mut self) -> WasiCtxView<'_> {
+//!         WasiCtxView { ctx: &mut self.wasi, table: &mut self.table }
 //!     }
 //! }
 //!
 //! impl WasiHttpView for MyClientState {
 //!     fn ctx(&mut self) -> &mut WasiHttpCtx {
 //!         &mut self.http
 //!     }
+//!
+//!     fn table(&mut self) -> &mut ResourceTable {
+//!         &mut self.table
+//!     }
 //! }
 //! ```
 
@@ -238,7 +238,6 @@ pub use crate::types::{
     WasiHttpImpl, WasiHttpView,
 };
 use wasmtime::component::{HasData, Linker};
-use wasmtime_wasi::p2::IoImpl;
 
 /// Add all of the `wasi:http/proxy` world's interfaces to a [`wasmtime::component::Linker`].
 ///
@@ -254,7 +253,7 @@ use wasmtime_wasi::p2::IoImpl;
 /// ```
 /// use wasmtime::{Engine, Result, Config};
 /// use wasmtime::component::{ResourceTable, Linker};
-/// use wasmtime_wasi::p2::{IoView, WasiCtx, WasiView};
+/// use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiView};
 /// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
 ///
 /// fn main() -> Result<()> {
@@ -275,14 +274,15 @@ use wasmtime_wasi::p2::IoImpl;
 ///     table: ResourceTable,
 /// }
 ///
-/// impl IoView for MyState {
-///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
-/// }
 /// impl WasiHttpView for MyState {
 ///     fn ctx(&mut self) -> &mut WasiHttpCtx { &mut self.http_ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
 /// }
+///
 /// impl WasiView for MyState {
-///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn ctx(&mut self) -> WasiCtxView<'_> {
+///         WasiCtxView { ctx: &mut self.ctx, table: &mut self.table }
+///     }
 /// }
 /// ```
 pub fn add_to_linker_async<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
@@ -306,10 +306,10 @@ where
 {
     let options = crate::bindings::LinkOptions::default(); // FIXME: Thread through to the CLI options.
     crate::bindings::http::outgoing_handler::add_to_linker::<_, WasiHttp<T>>(l, |x| {
-        WasiHttpImpl(IoImpl(x))
+        WasiHttpImpl(x)
     })?;
     crate::bindings::http::types::add_to_linker::<_, WasiHttp<T>>(l, &options.into(), |x| {
-        WasiHttpImpl(IoImpl(x))
+        WasiHttpImpl(x)
     })?;
 
     Ok(())
@@ -332,7 +332,7 @@ impl<T: 'static> HasData for WasiHttp<T> {
 /// ```
 /// use wasmtime::{Engine, Result, Config};
 /// use wasmtime::component::{ResourceTable, Linker};
-/// use wasmtime_wasi::p2::{IoView, WasiCtx, WasiView};
+/// use wasmtime_wasi::p2::{WasiCtx, WasiCtxView, WasiView};
 /// use wasmtime_wasi_http::{WasiHttpCtx, WasiHttpView};
 ///
 /// fn main() -> Result<()> {
@@ -351,14 +351,14 @@ impl<T: 'static> HasData for WasiHttp<T> {
 ///     http_ctx: WasiHttpCtx,
 ///     table: ResourceTable,
 /// }
-/// impl IoView for MyState {
-///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
-/// }
 /// impl WasiHttpView for MyState {
 ///     fn ctx(&mut self) -> &mut WasiHttpCtx { &mut self.http_ctx }
+///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
 /// }
 /// impl WasiView for MyState {
-///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
+///     fn ctx(&mut self) -> WasiCtxView<'_> {
+///         WasiCtxView { ctx: &mut self.ctx, table: &mut self.table }
+///     }
 /// }
 /// ```
 pub fn add_to_linker_sync<T>(l: &mut Linker<T>) -> anyhow::Result<()>
@@ -380,10 +380,10 @@ where
 {
     let options = crate::bindings::LinkOptions::default(); // FIXME: Thread through to the CLI options.
     crate::bindings::sync::http::outgoing_handler::add_to_linker::<_, WasiHttp<T>>(l, |x| {
-        WasiHttpImpl(IoImpl(x))
+        WasiHttpImpl(x)
     })?;
     crate::bindings::sync::http::types::add_to_linker::<_, WasiHttp<T>>(l, &options.into(), |x| {
-        WasiHttpImpl(IoImpl(x))
+        WasiHttpImpl(x)
     })?;
 
     Ok(())