Replace GetHost with a function pointer, add HasData

This commit is a refactoring to the fundamentals of the `bindgen!` macro
and the functions that it generates. Prior to this change the
fundamental entrypoint generated by `bindgen!` was a function
`add_to_linker_get_host` which takes a value of type `G: GetHost`. This
`GetHost` implementation is effectively an alias for a closure whose
return value is able to close over the parameter given lfietime-wise.

The `GetHost` abstraction was added to Wasmtime originally to enable
using any type that implements `Host` traits, not just `&mut U` as was
originally supported. The definition of `GetHost` was _just_ right to
enable a type such as `MyThing<&mut T>` to implement `Host` and a
closure could be provided that could return it. At the time that
`GetHost` was added it was known to be problematic from an
understandability point of view, namely:

* It has a non-obvious definition.
* It's pretty advanced Rust voodoo to understand what it's actually
  doing
* Using `GetHost` required lots of `for<'a> ...` in places which is
  unfamiliar syntax for many.
* `GetHost` values couldn't be type-erased (e.g. put in a trait object)
  as we couldn't figure out the lifetime syntax to do so.

Despite these issues it was the only known solution at hand so we landed
it and kept the previous `add_to_linker` style (`&mut T -> &mut U`) as a
convenience. While this has worked reasonable well (most folks just try
to not look at `GetHost`) it has reached a breaking point in the WASIp3
work.

In the WASIp3 work it's effectively now going to be required that the
`G: GetHost` value is packaged up and actually stored inside of
accessors provided to host functions. This means that `GetHost` values
now need to not only be taken in `add_to_linker` but additionally
provided to the rest of the system through an "accessor". This was made
possible in bytecodealliance#10746 by moving the `GetHost` type into Wasmtime itself (as
opposed to generated code where it lived prior).

While this worked with WASIp3 and it was possible to plumb `G: GetHost`
safely around, this ended up surfacing more issues. Namely all
"concurrent" host functions started getting significantly more
complicated `where` clauses and type signatures. At the end of the day I
felt that we had reached the end of the road to `GetHost` and wanted to
search for alternatives, hence this change.

The fundamental purpose of `GetHost` was to be able to express, in a
generic fashion:

* Give me a closure that takes `&mut T` and returns `D`.
* The `D` type can close over the lifetime in `&mut T`.
* The `D` type must implement `bindgen!`-generated traits.

A realization I had was that we could model this with a generic
associated type in Rust. Rust support for generic associated types is
relatively new and not something I've used much before, but it ended up
being a perfect model for this. The definition of the new `HasData`
trait is deceptively simple:

    trait HasData {
        type Data<'a>;
    }

What this enables us to do though is to generate `add_to_linker`
functions that look like this:

    fn add_to_linker<T, D>(
        linker: &mut Linker<T>,
        getter: fn(&mut T) -> D::Data<'_>,
    ) -> Result<()>
      where
        D: HasData,
        for<'a> D::Data<'a>: Host;

This definition here models `G: GetHost` as a literal function pointer,
and the ability to close over the `&mut T` lifetime with type (not just
`&mut U`) is expressed through the type constructor `type Data<'a>`).
Ideally we could take a generic generic associated type (I'm not even
sure what to call that), but that's not something Rust has today.

Overall this felt like a much simpler way of modeling `GetHost` and its
requirements. This plumbed well throughout the WASIp3 work and the
signatures for concurrent functions felt much more appropriate in terms
of complexity after this change. Taking this change to the limit means
that `GetHost` in its entirety could be purged since all usages of it
could be replaced with `fn(&mut T) -> D::Data<'a>`, a hopefully much
more understandable type.

This change is not all rainbows however, there are some gotchas that
remain:

* One is that all `add_to_linker` generated functions have a `D:
  HasData` type parameter. This type parameter cannot be inferred and
  must always be explicitly specified, and it's not easy to know what to
  supply here without reading documentation. Actually supplying the type
  parameter is quite easy once you know what to do (and what to fill
  in), but it may involve defining a small struct with a custom
  `HasData` implementation which can be non-obvious.

* Another is that the `G: GetHost` value was previously a full Rust
  closure, but now it's transitioning to a function pointer. This is
  done in preparation for WASIp3 work where the function needs to be
  passed around, and doing that behind a generic parameter is more
  effort than it's worth. This means that embedders relying on the true
  closure-like nature here will have to update to using a function
  pointer instead.

* The function pointer is stored in locations that require `'static`,
  and while `fn(T)` might be expected to be `'static` regardless of `T`
  is is, in fact, not. This means that practically `add_to_linker`
  requires `T: 'static`. Relative to just before this change this is a
  possible regression in functionality, but there orthogonal reasons
  beyond just this that we want to start requiring `T: 'static` anyway.
  That means that this isn't actually a regression relative to bytecodealliance#10760, a
  related change.

The first point is partially ameliorated with WASIp3 work insofar that
the `D` type parameter will start serving as a location to specify where
concurrent implementations are found. These concurrent methods don't
take `&mut self` but instead are implemented for `T: HasData` types. In
that sense it's more justified to have this weird type parameter, but in
the meantime without this support it'll feel a bit odd to have this
little type parameter hanging off the side.

This change has been integrated into the WASIp3 prototyping repository
with success. This has additionally been integrated into the Spin
embedding which has one of the more complicated reliances on
`*_get_host` functions known. Given that it's expected that while this
is not necessarily a trivial change to rebase over it should at least be
possible.

Finally the `HasData` trait here has been included with what I'm hoping
is a sufficient amount of documentation to at least give folks a spring
board to understand it. If folks have confusion about this `D` type
parameter my hope is they'll make their way to `HasData` which showcases
various patterns for "librarifying" host implementations of WIT
interfaces. These patterns are all used throughout Wasmtime and WASI
currently in crates and tests and such.

Author: alexcrichton

Cargo.lock

@@ -12,14 +12,15 @@ macro_rules! gentest {
                     async: true,
                 });
             }
-            mod concurrent {
-                wasmtime::component::bindgen!({
-                    path: $path,
-                    async: true,
-                    concurrent_imports: true,
-                    concurrent_exports: true,
-                });
-            }
+            // TODO: re-enable this when wasip3 is merged back into this repo
+            // mod concurrent {
+            //     wasmtime::component::bindgen!({
+            //         path: $path,
+            //         async: true,
+            //         concurrent_imports: true,
+            //         concurrent_exports: true,
+            //     });
+            // }
             mod tracing {
                 wasmtime::component::bindgen!({
                     path: $path,

crates/component-macro/tests/codegen.rs

@@ -15,13 +15,14 @@ macro_rules! genexpand {
             stringify: true,
         }))?;
 
-        process_expanded($path, "_concurrent", wasmtime::component::bindgen!({
-            path: $path,
-            async: true,
-            concurrent_imports: true,
-            concurrent_exports: true,
-            stringify: true,
-        }))?;
+        // TODO: re-enable this when wasip3 is merged back into this repo
+        // process_expanded($path, "_concurrent", wasmtime::component::bindgen!({
+        //     path: $path,
+        //     async: true,
+        //     concurrent_imports: true,
+        //     concurrent_exports: true,
+        //     stringify: true,
+        // }))?;
 
         process_expanded($path, "_tracing_async", wasmtime::component::bindgen!({
             path: $path,

crates/component-macro/tests/expanded.rs

@@ -69,6 +69,7 @@
 
 use anyhow::Result;
 use std::collections::HashMap;
+use wasmtime::component::HasData;
 
 mod gen_ {
     wasmtime::component::bindgen!({
@@ -140,10 +141,16 @@ impl generated::Host for WasiConfig<'_> {
 }
 
 /// Add all the `wasi-config` world's interfaces to a [`wasmtime::component::Linker`].
-pub fn add_to_linker<T>(
+pub fn add_to_linker<T: 'static>(
     l: &mut wasmtime::component::Linker<T>,
-    f: impl Fn(&mut T) -> WasiConfig<'_> + Send + Sync + Copy + 'static,
+    f: fn(&mut T) -> WasiConfig<'_>,
 ) -> Result<()> {
-    generated::add_to_linker_get_host(l, f)?;
+    generated::add_to_linker::<T, HasWasiConfig>(l, f)?;
     Ok(())
 }
+
+struct HasWasiConfig;
+
+impl HasData for HasWasiConfig {
+    type Data<'a> = WasiConfig<'a>;
+}

crates/wasi-config/src/lib.rs

@@ -27,6 +27,7 @@ http-body = { workspace = true }
 http-body-util = { workspace = true }
 tracing = { workspace = true }
 wasmtime-wasi = { workspace = true }
+wasmtime-wasi-io = { workspace = true }
 wasmtime = { workspace = true, features = ['component-model'] }
 tokio-rustls = { workspace = true }
 rustls = { workspace = true }

crates/wasi-http/Cargo.toml

@@ -236,7 +236,9 @@ pub use crate::types::{
     WasiHttpCtx, WasiHttpImpl, WasiHttpView, DEFAULT_OUTGOING_BODY_BUFFER_CHUNKS,
     DEFAULT_OUTGOING_BODY_CHUNK_SIZE,
 };
+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`].
 ///
 /// This function will add the `async` variant of all interfaces into the
@@ -284,46 +286,12 @@ use wasmtime_wasi::p2::IoImpl;
 /// ```
 pub fn add_to_linker_async<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
 where
-    T: WasiHttpView + wasmtime_wasi::p2::WasiView,
+    T: WasiHttpView + wasmtime_wasi::p2::WasiView + 'static,
 {
-    let io_closure = type_annotate_io::<T, _>(|t| wasmtime_wasi::p2::IoImpl(t));
-    wasmtime_wasi::p2::bindings::io::poll::add_to_linker_get_host(l, io_closure)?;
-    wasmtime_wasi::p2::bindings::io::error::add_to_linker_get_host(l, io_closure)?;
-    wasmtime_wasi::p2::bindings::io::streams::add_to_linker_get_host(l, io_closure)?;
-
-    let closure =
-        type_annotate_wasi::<T, _>(|t| wasmtime_wasi::p2::WasiImpl(wasmtime_wasi::p2::IoImpl(t)));
-    wasmtime_wasi::p2::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::random::random::add_to_linker_get_host(l, closure)?;
-
+    wasmtime_wasi::p2::add_to_linker_proxy_interfaces_async(l)?;
     add_only_http_to_linker_async(l)
 }
 
-// NB: workaround some rustc inference - a future refactoring may make this
-// obsolete.
-fn type_annotate_http<T, F>(val: F) -> F
-where
-    F: Fn(&mut T) -> WasiHttpImpl<&mut T>,
-{
-    val
-}
-fn type_annotate_wasi<T, F>(val: F) -> F
-where
-    F: Fn(&mut T) -> wasmtime_wasi::p2::WasiImpl<&mut T>,
-{
-    val
-}
-fn type_annotate_io<T, F>(val: F) -> F
-where
-    F: Fn(&mut T) -> wasmtime_wasi::p2::IoImpl<&mut T>,
-{
-    val
-}
-
 /// A slimmed down version of [`add_to_linker_async`] which only adds
 /// `wasi:http` interfaces to the linker.
 ///
@@ -333,15 +301,22 @@ pub fn add_only_http_to_linker_async<T>(
     l: &mut wasmtime::component::Linker<T>,
 ) -> anyhow::Result<()>
 where
-    T: WasiHttpView,
+    T: WasiHttpView + 'static,
 {
-    let closure = type_annotate_http::<T, _>(|t| WasiHttpImpl(IoImpl(t)));
-    crate::bindings::http::outgoing_handler::add_to_linker_get_host(l, closure)?;
-    crate::bindings::http::types::add_to_linker_get_host(l, closure)?;
+    crate::bindings::http::outgoing_handler::add_to_linker::<_, WasiHttp<T>>(l, |x| {
+        WasiHttpImpl(IoImpl(x))
+    })?;
+    crate::bindings::http::types::add_to_linker::<_, WasiHttp<T>>(l, |x| WasiHttpImpl(IoImpl(x)))?;
 
     Ok(())
 }
 
+struct WasiHttp<T>(T);
+
+impl<T: 'static> HasData for WasiHttp<T> {
+    type Data<'a> = WasiHttpImpl<&'a mut T>;
+}
+
 /// Add all of the `wasi:http/proxy` world's interfaces to a [`wasmtime::component::Linker`].
 ///
 /// This function will add the `sync` variant of all interfaces into the
@@ -382,46 +357,29 @@ where
 ///     fn ctx(&mut self) -> &mut WasiCtx { &mut self.ctx }
 /// }
 /// ```
-pub fn add_to_linker_sync<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+pub fn add_to_linker_sync<T>(l: &mut Linker<T>) -> anyhow::Result<()>
 where
-    T: WasiHttpView + wasmtime_wasi::p2::WasiView,
+    T: WasiHttpView + wasmtime_wasi::p2::WasiView + 'static,
 {
-    let io_closure = type_annotate_io::<T, _>(|t| wasmtime_wasi::p2::IoImpl(t));
-    // For the sync linker, use the definitions of poll and streams from the
-    // wasmtime_wasi::p2::bindings::sync space because those are defined using in_tokio.
-    wasmtime_wasi::p2::bindings::sync::io::poll::add_to_linker_get_host(l, io_closure)?;
-    wasmtime_wasi::p2::bindings::sync::io::streams::add_to_linker_get_host(l, io_closure)?;
-    // The error interface in the wasmtime_wasi is synchronous
-    wasmtime_wasi::p2::bindings::io::error::add_to_linker_get_host(l, io_closure)?;
-
-    let closure =
-        type_annotate_wasi::<T, _>(|t| wasmtime_wasi::p2::WasiImpl(wasmtime_wasi::p2::IoImpl(t)));
-
-    wasmtime_wasi::p2::bindings::clocks::wall_clock::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::clocks::monotonic_clock::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stdin::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stdout::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::cli::stderr::add_to_linker_get_host(l, closure)?;
-    wasmtime_wasi::p2::bindings::random::random::add_to_linker_get_host(l, closure)?;
-
-    add_only_http_to_linker_sync(l)?;
-
-    Ok(())
+    wasmtime_wasi::p2::add_to_linker_proxy_interfaces_sync(l)?;
+    add_only_http_to_linker_sync(l)
 }
 
 /// A slimmed down version of [`add_to_linker_sync`] which only adds
 /// `wasi:http` interfaces to the linker.
 ///
 /// This is useful when using [`wasmtime_wasi::p2::add_to_linker_sync`] for
 /// example to avoid re-adding the same interfaces twice.
-pub fn add_only_http_to_linker_sync<T>(l: &mut wasmtime::component::Linker<T>) -> anyhow::Result<()>
+pub fn add_only_http_to_linker_sync<T>(l: &mut Linker<T>) -> anyhow::Result<()>
 where
-    T: WasiHttpView,
+    T: WasiHttpView + 'static,
 {
-    let closure = type_annotate_http::<T, _>(|t| WasiHttpImpl(IoImpl(t)));
-
-    crate::bindings::http::outgoing_handler::add_to_linker_get_host(l, closure)?;
-    crate::bindings::http::types::add_to_linker_get_host(l, closure)?;
+    crate::bindings::sync::http::outgoing_handler::add_to_linker::<_, WasiHttp<T>>(l, |x| {
+        WasiHttpImpl(IoImpl(x))
+    })?;
+    crate::bindings::sync::http::types::add_to_linker::<_, WasiHttp<T>>(l, |x| {
+        WasiHttpImpl(IoImpl(x))
+    })?;
 
     Ok(())
 }

crates/wasi-http/src/lib.rs

@@ -36,7 +36,7 @@ pub use async_trait::async_trait;
 pub use ::bytes;
 
 use alloc::boxed::Box;
-use wasmtime::component::ResourceTable;
+use wasmtime::component::{HasData, ResourceTable};
 
 /// A trait which provides access to the [`ResourceTable`] inside the
 /// embedder's `T` of [`Store<T>`][`Store`].
@@ -168,21 +168,17 @@ impl<T: IoView> IoView for IoImpl<T> {
 ///     fn table(&mut self) -> &mut ResourceTable { &mut self.table }
 /// }
 /// ```
-pub fn add_to_linker_async<T: IoView>(
+pub fn add_to_linker_async<T: IoView + 'static>(
     l: &mut wasmtime::component::Linker<T>,
 ) -> wasmtime::Result<()> {
-    let closure = io_type_annotate::<T, _>(|t| IoImpl(t));
-    crate::bindings::wasi::io::error::add_to_linker_get_host(l, closure)?;
-    crate::bindings::wasi::io::poll::add_to_linker_get_host(l, closure)?;
-    crate::bindings::wasi::io::streams::add_to_linker_get_host(l, closure)?;
+    crate::bindings::wasi::io::error::add_to_linker::<T, HasIo<T>>(l, |x| IoImpl(x))?;
+    crate::bindings::wasi::io::poll::add_to_linker::<T, HasIo<T>>(l, |x| IoImpl(x))?;
+    crate::bindings::wasi::io::streams::add_to_linker::<T, HasIo<T>>(l, |x| IoImpl(x))?;
     Ok(())
 }
 
-// NB: workaround some rustc inference - a future refactoring may make this
-// obsolete.
-fn io_type_annotate<T: IoView, F>(val: F) -> F
-where
-    F: Fn(&mut T) -> IoImpl<&mut T>,
-{
-    val
+struct HasIo<T>(T);
+
+impl<T: 'static> HasData for HasIo<T> {
+    type Data<'a> = IoImpl<&'a mut T>;
 }

crates/wasi-io/src/lib.rs

@@ -84,7 +84,7 @@ mod generated {
 use self::generated::wasi::keyvalue;
 use anyhow::Result;
 use std::collections::HashMap;
-use wasmtime::component::{Resource, ResourceTable, ResourceTableError};
+use wasmtime::component::{HasData, Resource, ResourceTable, ResourceTableError};
 
 #[doc(hidden)]
 pub enum Error {
@@ -288,12 +288,18 @@ impl keyvalue::batch::Host for WasiKeyValue<'_> {
 }
 
 /// Add all the `wasi-keyvalue` world's interfaces to a [`wasmtime::component::Linker`].
-pub fn add_to_linker<T: Send>(
+pub fn add_to_linker<T: Send + 'static>(
     l: &mut wasmtime::component::Linker<T>,
-    f: impl Fn(&mut T) -> WasiKeyValue<'_> + Send + Sync + Copy + 'static,
+    f: fn(&mut T) -> WasiKeyValue<'_>,
 ) -> Result<()> {
-    keyvalue::store::add_to_linker_get_host(l, f)?;
-    keyvalue::atomics::add_to_linker_get_host(l, f)?;
-    keyvalue::batch::add_to_linker_get_host(l, f)?;
+    keyvalue::store::add_to_linker::<_, HasWasiKeyValue>(l, f)?;
+    keyvalue::atomics::add_to_linker::<_, HasWasiKeyValue>(l, f)?;
+    keyvalue::batch::add_to_linker::<_, HasWasiKeyValue>(l, f)?;
     Ok(())
 }
+
+struct HasWasiKeyValue;
+
+impl HasData for HasWasiKeyValue {
+    type Data<'a> = WasiKeyValue<'a>;
+}

crates/wasi-keyvalue/src/lib.rs

@@ -21,7 +21,7 @@ use anyhow::anyhow;
 use std::collections::HashMap;
 use std::hash::Hash;
 use std::{fmt, str::FromStr};
-use wasmtime::component::{Resource, ResourceTable};
+use wasmtime::component::{HasData, Resource, ResourceTable};
 
 /// Capture the state necessary for calling into the backend ML libraries.
 pub struct WasiNnCtx {
@@ -150,17 +150,23 @@ pub use generated_::Ml as ML;
 
 /// Add the WIT-based version of the `wasi-nn` API to a
 /// [`wasmtime::component::Linker`].
-pub fn add_to_linker<T>(
+pub fn add_to_linker<T: 'static>(
     l: &mut wasmtime::component::Linker<T>,
-    f: impl Fn(&mut T) -> WasiNnView<'_> + Send + Sync + Copy + 'static,
+    f: fn(&mut T) -> WasiNnView<'_>,
 ) -> anyhow::Result<()> {
-    generated::graph::add_to_linker_get_host(l, f)?;
-    generated::tensor::add_to_linker_get_host(l, f)?;
-    generated::inference::add_to_linker_get_host(l, f)?;
-    generated::errors::add_to_linker_get_host(l, f)?;
+    generated::graph::add_to_linker::<_, HasWasiNnView>(l, f)?;
+    generated::tensor::add_to_linker::<_, HasWasiNnView>(l, f)?;
+    generated::inference::add_to_linker::<_, HasWasiNnView>(l, f)?;
+    generated::errors::add_to_linker::<_, HasWasiNnView>(l, f)?;
     Ok(())
 }
 
+struct HasWasiNnView;
+
+impl HasData for HasWasiNnView {
+    type Data<'a> = WasiNnView<'a>;
+}
+
 impl generated::graph::Host for WasiNnView<'_> {
     fn load(
         &mut self,

crates/wasi-nn/src/wit.rs

@@ -81,7 +81,7 @@ use std::{future::Future, mem, pin::Pin, sync::LazyLock};
 use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
 use tokio::sync::Mutex;
 use tokio_rustls::client::TlsStream;
-use wasmtime::component::{Resource, ResourceTable};
+use wasmtime::component::{HasData, Resource, ResourceTable};
 use wasmtime_wasi::async_trait;
 use wasmtime_wasi::p2::bindings::io::{
     error::Error as HostIoError,
@@ -139,15 +139,21 @@ impl<'a> WasiTlsCtx<'a> {
 impl<'a> generated::types::Host for WasiTlsCtx<'a> {}
 
 /// Add the `wasi-tls` world's types to a [`wasmtime::component::Linker`].
-pub fn add_to_linker<T: Send>(
+pub fn add_to_linker<T: Send + 'static>(
     l: &mut wasmtime::component::Linker<T>,
     opts: &mut LinkOptions,
-    f: impl Fn(&mut T) -> WasiTlsCtx + Send + Sync + Copy + 'static,
+    f: fn(&mut T) -> WasiTlsCtx<'_>,
 ) -> Result<()> {
-    generated::types::add_to_linker_get_host(l, &opts, f)?;
+    generated::types::add_to_linker::<_, WasiTls>(l, &opts, f)?;
     Ok(())
 }
 
+struct WasiTls;
+
+impl HasData for WasiTls {
+    type Data<'a> = WasiTlsCtx<'a>;
+}
+
 enum TlsError {
     /// The component should trap. Under normal circumstances, this only occurs
     /// when the underlying transport stream returns [`StreamError::Trap`].