Update wasm-tools dependencies

Cargo.toml

@@ -769,3 +769,18 @@ fpr = "fpr"
 
 [workspace.metadata.typos.files]
 extend-exclude = [ "docs/js/mermaid*.js", "crates/wasi-nn/**/*.txt", "*.isle" ]
+
+[patch.crates-io]
+wasmparser = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wat = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wast = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasmprinter = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-encoder = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-smith = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-mutate = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wit-parser = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wit-component = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-wave = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-compose = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+wasm-metadata = { git = 'https://github.com/bytecodealliance/wasm-tools' }
+json-from-wast = { git = 'https://github.com/bytecodealliance/wasm-tools' }

crates/environ/src/component/translate.rs

@@ -18,7 +18,7 @@ use wasmparser::component_types::{
     ComponentFuncTypeId, ComponentInstanceTypeId, ComponentValType,
 };
 use wasmparser::types::Types;
-use wasmparser::{Chunk, ComponentImportName, Encoding, Parser, Payload, Validator};
+use wasmparser::{Chunk, ComponentExternName, Encoding, Parser, Payload, Validator};
 
 mod adapt;
 pub use self::adapt::*;
@@ -176,7 +176,7 @@ struct Translation<'data> {
 // is straight from `wasmparser`'s passes.
 enum LocalInitializer<'data> {
     // imports
-    Import(ComponentImportName<'data>, ComponentEntityType),
+    Import(ComponentExternName<'data>, ComponentEntityType),
 
     // An import of an intrinsic for compile-time builtins.
     IntrinsicsImport,
@@ -768,11 +768,12 @@ impl<'a, 'data> Translator<'a, 'data> {
                     let import = import?;
                     let types = self.validator.types(0).unwrap();
                     let ty = types
-                        .component_entity_type_of_import(import.name.0)
-                        .unwrap();
+                        .component_item_for_import(import.name.name)
+                        .unwrap()
+                        .ty;
 
-                    if self.is_unsafe_intrinsics_import(import.name.0) {
-                        self.check_unsafe_intrinsics_import(import.name.0, ty)?;
+                    if self.is_unsafe_intrinsics_import(import.name.name) {
+                        self.check_unsafe_intrinsics_import(import.name.name, ty)?;
                         self.result
                             .initializers
                             .push(LocalInitializer::IntrinsicsImport);
@@ -1309,7 +1310,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                 for export in s {
                     let export = export?;
                     let item = self.kind_to_item(export.kind, export.index)?;
-                    let prev = self.result.exports.insert(export.name.0, item);
+                    let prev = self.result.exports.insert(export.name.name, item);
                     assert!(prev.is_none());
                     self.result
                         .initializers
@@ -1451,7 +1452,7 @@ impl<'a, 'data> Translator<'a, 'data> {
         let mut map = HashMap::with_capacity(exports.len());
         for export in exports {
             let idx = self.kind_to_item(export.kind, export.index)?;
-            map.insert(export.name.0, idx);
+            map.insert(export.name.name, idx);
         }
 
         Ok(LocalInitializer::ComponentSynthetic(map, ty))
@@ -1662,13 +1663,13 @@ impl<'a, 'data> Translator<'a, 'data> {
         );
 
         for (name, ty) in &instance_ty.exports {
-            let ComponentEntityType::Func(func_ty) = ty else {
+            let ComponentEntityType::Func(func_ty) = ty.ty else {
                 bail!(
                     "bad unsafe intrinsics import: imported instance `{import}` must \
                      only export functions"
                 )
             };
-            let func_ty = &types[*func_ty];
+            let func_ty = &types[func_ty];
 
             fn ty_eq(a: &InterfaceType, b: &wasmparser::component_types::ComponentValType) -> bool {
                 use wasmparser::{PrimitiveValType as P, component_types::ComponentValType as C};

crates/environ/src/component/translate/inline.rs

@@ -114,9 +114,12 @@ pub(super) fn run(
         if let TypeDef::Interface(_) = ty {
             continue;
         }
-        let index = inliner.result.import_types.push((name.0.to_string(), ty));
+        let index = inliner
+            .result
+            .import_types
+            .push((name.name.to_string(), ty));
         let path = ImportPath::root(index);
-        args.insert(name.0, ComponentItemDef::from_import(path, ty)?);
+        args.insert(name.name, ComponentItemDef::from_import(path, ty)?);
     }
 
     // This will run the inliner to completion after being seeded with the
@@ -441,7 +444,7 @@ impl<'a> Inliner<'a> {
             // was provided as an import at the instantiation-site to what was
             // needed during the component's instantiation.
             Import(name, ty) => {
-                let arg = match frame.args.get(name.0) {
+                let arg = match frame.args.get(name.name) {
                     Some(arg) => arg,
 
                     // Not all arguments need to be provided for instantiation,

crates/environ/src/component/types_builder.rs

@@ -325,17 +325,17 @@ impl ComponentTypesBuilder {
         let ty = &types[id];
         let mut result = TypeComponent::default();
         for (name, ty) in ty.imports.iter() {
-            self.register_abstract_component_entity_type(types, *ty);
+            self.register_abstract_component_entity_type(types, ty.ty);
             result.imports.insert(
                 name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
+                self.convert_component_entity_type(types, ty.ty)?,
             );
         }
         for (name, ty) in ty.exports.iter() {
-            self.register_abstract_component_entity_type(types, *ty);
+            self.register_abstract_component_entity_type(types, ty.ty);
             result.exports.insert(
                 name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
+                self.convert_component_entity_type(types, ty.ty)?,
             );
         }
         Ok(self.component_types.components.push(result))
@@ -350,10 +350,10 @@ impl ComponentTypesBuilder {
         let ty = &types[id];
         let mut result = TypeComponentInstance::default();
         for (name, ty) in ty.exports.iter() {
-            self.register_abstract_component_entity_type(types, *ty);
+            self.register_abstract_component_entity_type(types, ty.ty);
             result.exports.insert(
                 name.clone(),
-                self.convert_component_entity_type(types, *ty)?,
+                self.convert_component_entity_type(types, ty.ty)?,
             );
         }
         Ok(self.component_types.component_instances.push(result))

crates/environ/src/component/types_builder/resources.rs

@@ -247,7 +247,7 @@ impl ResourcesBuilder {
                 let ty = &types[id];
                 for (name, ty) in ty.exports.iter() {
                     path.push(name);
-                    self.register_component_entity_type_(types, *ty, path, register);
+                    self.register_component_entity_type_(types, ty.ty, path, register);
                     path.pop();
                 }
             }

crates/test-util/src/component_fuzz.rs

@@ -1722,6 +1722,21 @@ impl<'a> TestCase<'a> {
 
         let mut options = u.arbitrary::<TestCaseOptions>()?;
 
+        // Handle async ABI options. If async is enabled then the function type
+        // in question must also be `async`.
+        if let LiftAbi::AsyncStackful | LiftAbi::AsyncCallback = options.caller_lift_abi {
+            options.guest_caller_async = true;
+        }
+        if let LiftAbi::AsyncStackful | LiftAbi::AsyncCallback = options.callee_lift_abi {
+            options.guest_callee_async = true;
+        }
+        if let LowerAbi::Async = options.caller_lower_abi {
+            options.guest_callee_async = true;
+        }
+        if let LowerAbi::Async = options.callee_lower_abi {
+            options.host_async = true;
+        }
+
         // Sync tasks cannot call async functions via a sync lower, nor can they
         // block in other ways (e.g. by calling `waitable-set.wait`, returning
         // `CALLBACK_CODE_WAIT`, etc.) prior to returning.  Therefore,

crates/test-util/src/wast.rs

@@ -472,6 +472,9 @@ impl WastTest {
             // changes
             "test/async/same-component-stream-future.wast",
             "test/async/trap-if-block-and-sync.wast",
+            // Not updated upstream yet
+            "test/async/cross-abi-calls.wast",
+            "test/async/trap-on-reenter.wast",
         ];
         if unsupported.iter().any(|part| self.path.ends_with(part)) {
             return true;

crates/wasmtime/src/compile/code_builder/compile_time_builtins.rs

@@ -89,13 +89,13 @@ impl<'a> CodeBuilder<'a> {
                         // unfortunately the `wasm-compose` API is not powerful
                         // enough for us to do all that.
                         ensure!(
-                            imp.name.0 != intrinsics_import,
+                            imp.name.name != intrinsics_import,
                             "main Wasm cannot import the unsafe intrinsics (`{intrinsics_import}`) \
                              when using compile-time builtins"
                         );
 
                         if let wasmparser::ComponentTypeRef::Instance(_) = imp.ty {
-                            instance_imports.insert(imp.name.0);
+                            instance_imports.insert(imp.name.name);
                         }
                     }
                 }

crates/wizer/src/component/rewrite.rs

@@ -236,7 +236,7 @@ impl ReencodeComponent for Reencoder<'_> {
     ) -> Result<(), Error> {
         for export in section {
             let export = export?;
-            if !self.wizer.get_keep_init_func() && export.name.0 == self.wizer.get_init_func() {
+            if !self.wizer.get_keep_init_func() && export.name.name == self.wizer.get_init_func() {
                 self.removed_func = Some(self.funcs);
             } else {
                 if export.kind == wasmparser::ComponentExternalKind::Func {

crates/wizer/tests/all/component.rs

@@ -637,7 +637,7 @@ async fn export_is_removed() -> Result<()> {
                 wasmparser::Payload::ComponentExportSection(s) => Some(s),
                 _ => None,
             })
-            .flat_map(|section| section.into_iter().map(|e| e.unwrap().name.0))
+            .flat_map(|section| section.into_iter().map(|e| e.unwrap().name.name))
             .collect()
     }
 }

tests/all/component_model/bindgen.rs

@@ -108,7 +108,7 @@ mod no_imports_concurrent {
                         (with "" (instance (export "task.return" (func $task-return))))
                     ))
 
-                    (func $f (export "bar")
+                    (func $f (export "bar") async
                         (canon lift (core func $i "bar") async (callback (func $i "callback")))
                     )
 

tests/all/component_model/func.rs

@@ -908,7 +908,7 @@ async fn test_many_parameters(dynamic: bool, concurrent: bool) -> Result<()> {
                 (with "libc" (instance $libc))
             ))
 
-            (type $t (func
+            (type $t (func async
                 (param "p1" s8)              ;; offset  0, size 1
                 (param "p2" u64)             ;; offset  8, size 8
                 (param "p3" float32)         ;; offset 16, size 4
@@ -1379,7 +1379,7 @@ async fn test_many_results(dynamic: bool, concurrent: bool) -> Result<()> {
                 (with "libc" (instance $libc))
             ))
 
-            (type $t (func (result $tuple)))
+            (type $t (func async (result $tuple)))
             (func (export "many-results") (type $t)
                 (canon lift
                     (core func $i "foo")