big Store->ComponentInstance refactor (#87)

* Enable async support in wast tests

This commit updates the `wasmtime-wast` crate to conditionally use the
`Config::async_support` mode of Wasmtime, notably executing
`instantiate_async` and `call_async`. At this time no actual concurrency
is supported and everything is immediately await'd on via `block_on` and
a local single-thread tokio runtime.

The motivation for this commit is that in the upcoming implementation of
WASIp3 async will effectively be the only way to invoke components.
Furthermore to test these components we're wanting to use async APIs as
the root of invocations for writing `*.wast` tests for testing
component-model async features.

In enabling this support this commit additionally updates the
`wast_tests` fuzzer to execute all tests both with and without async.
Effectively the async configuration is now a fuzz option, meaning that
all tests are being executed with async now as well to ensure that they
work (yay!).

The `--test wast` testing mode and `wasmtime wast` CLI command are both
updated to unconditionally use async. There should be no loss in test
coverage due to the fuzzer update, and right now knobs aren't provided
to conditionally use sync in these two modes, again because it's
currently expected that this won't be able to run component model async
tests, so the defaults are changing.

* big Store->ComponentInstance refactor

Previously, I had put a `ConcurrentState` field in `StoreInner`, not realizing
that it actually belonged in `ComponentInstance` instead.  Only when Alex opened
serially) by several `ComponentInstance`s, meaning that the state I had put in
`StoreInner` was being reused by multiple instances, with chaotic results.

This moves the state to `ComponentInstance`, which required changing a _lot_ of
code that assumed it could get everything it needed from a `StoreContextMut`.
In the process of all these changes, I was able to remove a lot of type
parameters from functions which never really needed the `T` in
`StoreContextMut<T>` anyway, which means the compiler doesn't need to do as much
monomorphization anymore.

Other notable changes:

- `Linker::func_{wrap|new}_concurrent` no longer need `Sync` futures, and now
  they take an `Accessor`, providing the same ergonomic advantages as
  `wasmtime-wit-bindgen`-generated code offers.

- I've changed the `{Future|Stream}{Writer|Reader}::watch_{writer|reader}`
  return value to make it easier to use and cancel.

- You now need a `component::Instance` to create a future or a stream.  You can
  get that from within host functions using `Accessor::instance` or
  `Access::instance`.  And in top-level embedder code, you can get it using
  `{Linker|InstancePre}::instantiate_async`.
    - Note that `wasmtime-wit-bindgen`-generated instantiation code tends to
      hide the `component::Instance` from you, but you can still get it by
      calling e.g. `Linker::instantiate_async` directly and then passing the
      result to the appropriate `new` function in the generated bindings.  See
      the tests for examples.

Fixes #30

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

---------

Signed-off-by: Joel Dice <joel.dice@fermyon.com>
Co-authored-by: Alex Crichton <alex@alexcrichton.com>

Author: dicej

Cargo.lock

@@ -199,13 +199,13 @@ pub mod foo {
                 fn take_char<T: 'static>(
                     accessor: &mut wasmtime::component::Accessor<T, Self>,
                     x: char,
-                ) -> impl ::core::future::Future<Output = ()> + Send + Sync
+                ) -> impl ::core::future::Future<Output = ()> + Send
                 where
                     Self: Sized;
                 /// A function that returns a character
                 fn return_char<T: 'static>(
                     accessor: &mut wasmtime::component::Accessor<T, Self>,
-                ) -> impl ::core::future::Future<Output = char> + Send + Sync
+                ) -> impl ::core::future::Future<Output = char> + Send
                 where
                     Self: Sized;
             }
@@ -247,6 +247,7 @@ pub mod foo {
             >(
                 getter: G,
                 store: wasmtime::VMStoreRawPtr,
+                instance: Option<wasmtime::component::Instance>,
                 cx: &mut wasmtime::component::__internal::Context,
                 future: wasmtime::component::__internal::Pin<&mut F>,
             ) -> wasmtime::component::__internal::Poll<F::Output> {
@@ -271,8 +272,10 @@ pub mod foo {
                     (future.poll(cx), STATE.with(|v| v.take()).unwrap().spawned)
                 };
                 for spawned in spawned {
-                    store_cx
+                    instance
+                        .unwrap()
                         .spawn(
+                            &mut store_cx,
                             wasmtime::component::__internal::poll_fn(move |cx| {
                                 let mut spawned = spawned.try_lock().unwrap();
                                 let inner = mem::replace(
@@ -284,6 +287,7 @@ pub mod foo {
                                     let result = poll_with_state(
                                         getter,
                                         store,
+                                        instance,
                                         cx,
                                         future.as_mut(),
                                     );
@@ -325,50 +329,79 @@ pub mod foo {
                 let mut inst = linker.instance("foo:foo/chars")?;
                 inst.func_wrap_concurrent(
                     "take-char",
-                    move |caller: wasmtime::StoreContextMut<'_, T>, (arg0,): (char,)| {
+                    move |
+                        caller: &mut wasmtime::component::Accessor<T, T>,
+                        (arg0,): (char,)|
+                    {
                         let mut accessor = unsafe {
                             wasmtime::component::Accessor::<
                                 T,
                                 _,
-                            >::new(get_host_and_store, spawn_task)
+                            >::new(
+                                get_host_and_store,
+                                spawn_task,
+                                caller.maybe_instance(),
+                            )
                         };
                         let mut future = wasmtime::component::__internal::Box::pin(async move {
                             let r = <G::Host as Host>::take_char(&mut accessor, arg0)
                                 .await;
                             Ok(r)
                         });
-                        let store = wasmtime::VMStoreRawPtr(caller.traitobj());
+                        let store = wasmtime::VMStoreRawPtr(
+                            caller
+                                .with(|mut v| {
+                                    wasmtime::AsContextMut::as_context_mut(&mut v).traitobj()
+                                }),
+                        );
+                        let instance = caller.maybe_instance();
                         wasmtime::component::__internal::Box::pin(
-                            wasmtime::component::__internal::poll_fn(move |cx| poll_with_state(
-                                host_getter,
-                                store,
-                                cx,
-                                future.as_mut(),
-                            )),
+                            wasmtime::component::__internal::poll_fn(move |cx| {
+                                poll_with_state(
+                                    host_getter,
+                                    store,
+                                    instance,
+                                    cx,
+                                    future.as_mut(),
+                                )
+                            }),
                         )
                     },
                 )?;
                 inst.func_wrap_concurrent(
                     "return-char",
-                    move |caller: wasmtime::StoreContextMut<'_, T>, (): ()| {
+                    move |caller: &mut wasmtime::component::Accessor<T, T>, (): ()| {
                         let mut accessor = unsafe {
                             wasmtime::component::Accessor::<
                                 T,
                                 _,
-                            >::new(get_host_and_store, spawn_task)
+                            >::new(
+                                get_host_and_store,
+                                spawn_task,
+                                caller.maybe_instance(),
+                            )
                         };
                         let mut future = wasmtime::component::__internal::Box::pin(async move {
                             let r = <G::Host as Host>::return_char(&mut accessor).await;
                             Ok((r,))
                         });
-                        let store = wasmtime::VMStoreRawPtr(caller.traitobj());
+                        let store = wasmtime::VMStoreRawPtr(
+                            caller
+                                .with(|mut v| {
+                                    wasmtime::AsContextMut::as_context_mut(&mut v).traitobj()
+                                }),
+                        );
+                        let instance = caller.maybe_instance();
                         wasmtime::component::__internal::Box::pin(
-                            wasmtime::component::__internal::poll_fn(move |cx| poll_with_state(
-                                host_getter,
-                                store,
-                                cx,
-                                future.as_mut(),
-                            )),
+                            wasmtime::component::__internal::poll_fn(move |cx| {
+                                poll_with_state(
+                                    host_getter,
+                                    store,
+                                    instance,
+                                    cx,
+                                    future.as_mut(),
+                                )
+                            }),
                         )
                     },
                 )?;