Update wasm-tools dependencies (#12031)

* Change separator style

* Update wasm-tools dependencies

* Also update wit-bindgen
* Drop `[async]` name prefixes
* Plumb `async` as part of a function type

Runtime handling of async functions and new traps are to be implemented
in subsequent commits. This is just getting everything running again.

* Run clang-format, also add test

* Fix some more wast tests

---------

Co-authored-by: Sy Brand <sy.brand@fastly.com>

Author: alexcrichton

Cargo.lock

@@ -333,22 +333,22 @@ io-lifetimes = { version = "2.0.3", default-features = false }
 io-extras = "0.18.1"
 rustix = "1.0.8"
 # wit-bindgen:
-wit-bindgen = { version = "0.46.0", default-features = false }
-wit-bindgen-rust-macro = { version = "0.46.0", default-features = false }
+wit-bindgen = { version = "0.48.0", default-features = false }
+wit-bindgen-rust-macro = { version = "0.48.0", default-features = false }
 
 # wasm-tools family:
-wasmparser = { version = "0.240.0", default-features = false, features = ['simd'] }
-wat = "1.240.0"
-wast = "240.0.0"
-wasmprinter = "0.240.0"
-wasm-encoder = "0.240.0"
-wasm-smith = "0.240.0"
-wasm-mutate = "0.240.0"
-wit-parser = "0.240.0"
-wit-component = "0.240.0"
-wasm-wave = "0.240.0"
-wasm-compose = "0.240.0"
-json-from-wast = "0.240.0"
+wasmparser = { version = "0.241.0", default-features = false, features = ['simd'] }
+wat = "1.241.0"
+wast = "241.0.0"
+wasmprinter = "0.241.0"
+wasm-encoder = "0.241.0"
+wasm-smith = "0.241.0"
+wasm-mutate = "0.241.0"
+wit-parser = "0.241.0"
+wit-component = "0.241.0"
+wasm-wave = "0.241.0"
+wasm-compose = "0.241.0"
+json-from-wast = "0.241.0"
 
 # Non-Bytecode Alliance maintained dependencies:
 # --------------------------

Cargo.toml

@@ -29,6 +29,11 @@ wasmtime_component_func_type_clone(const wasmtime_component_func_type_t *ty);
 WASM_API_EXTERN
 void wasmtime_component_func_type_delete(wasmtime_component_func_type_t *ty);
 
+/// \brief Returns whether this is an async function.
+WASM_API_EXTERN
+bool wasmtime_component_func_type_async(
+    const wasmtime_component_func_type_t *ty);
+
 /// \brief Returns the number of parameters of a component function type.
 WASM_API_EXTERN
 size_t wasmtime_component_func_type_param_count(

crates/c-api/include/wasmtime/component/types/func.h

@@ -26,6 +26,9 @@ class FuncType {
     return wasmtime_component_func_type_param_count(ptr.get());
   }
 
+  /// Returns whether this is an async function.
+  bool async() const { return wasmtime_component_func_type_async(ptr.get()); }
+
   /// Retrieves the nth parameter.
   std::optional<std::pair<std::string_view, ValType>>
   param_nth(size_t nth) const {

crates/c-api/include/wasmtime/component/types/func.hh

@@ -11,6 +11,11 @@ type_wrapper! {
     delete: wasmtime_component_func_type_delete,
 }
 
+#[unsafe(no_mangle)]
+pub extern "C" fn wasmtime_component_func_type_async(ty: &wasmtime_component_func_type_t) -> bool {
+    ty.ty.async_()
+}
+
 #[unsafe(no_mangle)]
 pub extern "C" fn wasmtime_component_func_type_param_count(
     ty: &wasmtime_component_func_type_t,

crates/c-api/src/component/types/func.rs

@@ -316,6 +316,7 @@ TEST(types, func_result) {
   auto f1 = *instance.get_func(store, f1_index);
   auto f2 = *instance.get_func(store, f2_index);
 
+  EXPECT_FALSE(f1.type(store).async());
   EXPECT_EQ(f1.type(store).param_count(), 0);
   EXPECT_FALSE(f1.type(store).result().has_value());
 

crates/c-api/tests/component/types.cc

@@ -291,7 +291,7 @@ pub enum GlobalInitializer {
     /// from its `export` and stored into the `VMComponentContext` at the
     /// `index` specified. During this extraction, we will also capture the
     /// table's containing instance pointer to access the table at runtime. This
-    /// extraction is useful for `thread.spawn_indirect`.
+    /// extraction is useful for `thread.spawn-indirect`.
     ExtractTable(ExtractTable),
 
     /// Declares a new defined resource within this component.
@@ -1137,7 +1137,7 @@ pub enum Trampoline {
     /// Intrinsic used to implement the `thread.index` component model builtin.
     ThreadIndex,
 
-    /// Intrinsic used to implement the `thread.new_indirect` component model builtin.
+    /// Intrinsic used to implement the `thread.new-indirect` component model builtin.
     ThreadNewIndirect {
         /// The specific component instance which is calling the intrinsic.
         instance: RuntimeComponentInstanceIndex,

crates/environ/src/component/info.rs

@@ -550,6 +550,8 @@ pub struct TypeComponentInstance {
 /// A component function type in the component model.
 #[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
 pub struct TypeFunc {
+    /// Whether or not this is an async function.
+    pub async_: bool,
     /// Names of parameters.
     pub param_names: Vec<String>,
     /// Parameters to the function represented as a tuple.

crates/environ/src/component/types.rs

@@ -254,6 +254,7 @@ impl ComponentTypesBuilder {
         let params = self.new_tuple_type(params);
         let results = self.new_tuple_type(results);
         let ty = TypeFunc {
+            async_: ty.async_,
             param_names,
             params,
             results,

crates/environ/src/component/types_builder.rs

@@ -362,7 +362,7 @@ pub async fn test_round_trip(
         linker
             .root()
             .instance("local:local/baz")?
-            .func_new_concurrent("[async]foo", |_, _, params, results| {
+            .func_new_concurrent("foo", |_, _, params, results| {
                 Box::pin(async move {
                     sleep(Duration::from_millis(10)).await;
                     let Some(Val::String(s)) = params.into_iter().next() else {
@@ -380,11 +380,11 @@ pub async fn test_round_trip(
             .get_export_index(&mut store, None, "local:local/baz")
             .ok_or_else(|| anyhow!("can't find `local:local/baz` in instance"))?;
         let foo_function = instance
-            .get_export_index(&mut store, Some(&baz_instance), "[async]foo")
-            .ok_or_else(|| anyhow!("can't find `[async]foo` in instance"))?;
+            .get_export_index(&mut store, Some(&baz_instance), "foo")
+            .ok_or_else(|| anyhow!("can't find `foo` in instance"))?;
         let foo_function = instance
             .get_func(&mut store, foo_function)
-            .ok_or_else(|| anyhow!("can't find `[async]foo` in instance"))?;
+            .ok_or_else(|| anyhow!("can't find `foo` in instance"))?;
 
         if call_style == 3 || !cfg!(miri) {
             store