Update to wasm-tools 245 (#12571)

* Intrinsics updates

* Remove ds_store

* Update to wasm-tools 245

* Add vets

* Fixup tests

* Add missing feature for `indexmap`

---------

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

Author: alexcrichton

Cargo.lock

@@ -343,18 +343,18 @@ wit-bindgen = { version = "0.51.0", default-features = false }
 wit-bindgen-rust-macro = { version = "0.51.0", default-features = false }
 
 # wasm-tools family:
-wasmparser = { version = "0.244.0", default-features = false, features = ['simd'] }
-wat = "1.244.0"
-wast = "244.0.0"
-wasmprinter = "0.244.0"
-wasm-encoder = "0.244.0"
-wasm-smith = "0.244.0"
-wasm-mutate = "0.244.0"
-wit-parser = "0.244.0"
-wit-component = "0.244.0"
-wasm-wave = "0.244.0"
-wasm-compose = "0.244.0"
-json-from-wast = "0.244.0"
+wasmparser = { version = "0.245.0", default-features = false, features = ['simd'] }
+wat = "1.245.0"
+wast = "245.0.0"
+wasmprinter = "0.245.0"
+wasm-encoder = "0.245.0"
+wasm-smith = "0.245.0"
+wasm-mutate = "0.245.0"
+wit-parser = "0.245.0"
+wit-component = "0.245.0"
+wasm-wave = "0.245.0"
+wasm-compose = "0.245.0"
+json-from-wast = "0.245.0"
 
 # Non-Bytecode Alliance maintained dependencies:
 # --------------------------

Cargo.toml

@@ -767,12 +767,30 @@ impl<'a> TrampolineCompiler<'a> {
                     },
                 );
             }
-            Trampoline::ThreadSwitchTo {
+            Trampoline::ThreadSuspendToSuspended {
                 instance,
                 cancellable,
             } => {
                 self.translate_libcall(
-                    host::thread_switch_to,
+                    host::thread_suspend_to_suspended,
+                    TrapSentinel::NegativeOne,
+                    WasmArgs::InRegisters,
+                    |me, params| {
+                        params.push(me.index_value(*instance));
+                        params.push(
+                            me.builder
+                                .ins()
+                                .iconst(ir::types::I8, i64::from(*cancellable)),
+                        );
+                    },
+                );
+            }
+            Trampoline::ThreadSuspendTo {
+                instance,
+                cancellable,
+            } => {
+                self.translate_libcall(
+                    host::thread_suspend_to,
                     TrapSentinel::NegativeOne,
                     WasmArgs::InRegisters,
                     |me, params| {
@@ -803,22 +821,22 @@ impl<'a> TrampolineCompiler<'a> {
                     },
                 );
             }
-            Trampoline::ThreadResumeLater { instance } => {
+            Trampoline::ThreadUnsuspend { instance } => {
                 self.translate_libcall(
-                    host::thread_resume_later,
+                    host::thread_unsuspend,
                     TrapSentinel::Falsy,
                     WasmArgs::InRegisters,
                     |me, params| {
                         params.push(me.index_value(*instance));
                     },
                 );
             }
-            Trampoline::ThreadYieldTo {
+            Trampoline::ThreadYieldToSuspended {
                 instance,
                 cancellable,
             } => {
                 self.translate_libcall(
-                    host::thread_yield_to,
+                    host::thread_yield_to_suspended,
                     TrapSentinel::NegativeOne,
                     WasmArgs::InRegisters,
                     |me, params| {
@@ -1472,11 +1490,12 @@ impl<'a> TrampolineCompiler<'a> {
             | Trampoline::WaitableSetDrop { instance }
             | Trampoline::WaitableJoin { instance }
             | Trampoline::ThreadYield { instance, .. }
-            | Trampoline::ThreadSwitchTo { instance, .. }
             | Trampoline::ThreadNewIndirect { instance, .. }
             | Trampoline::ThreadSuspend { instance, .. }
-            | Trampoline::ThreadResumeLater { instance }
-            | Trampoline::ThreadYieldTo { instance, .. }
+            | Trampoline::ThreadSuspendToSuspended { instance, .. }
+            | Trampoline::ThreadSuspendTo { instance, .. }
+            | Trampoline::ThreadUnsuspend { instance, .. }
+            | Trampoline::ThreadYieldToSuspended { instance, .. }
             | Trampoline::SubtaskDrop { instance }
             | Trampoline::SubtaskCancel { instance, .. }
             | Trampoline::ErrorContextNew { instance, .. }

crates/cranelift/src/compiler/component.rs

@@ -194,13 +194,15 @@ macro_rules! foreach_builtin_component_function {
             #[cfg(feature = "component-model-async")]
             thread_new_indirect(vmctx: vmctx, caller_instance: u32, func_ty_id: u32, func_table_idx: u32, func_idx: u32, context: u32) -> u64;
             #[cfg(feature = "component-model-async")]
-            thread_switch_to(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
+            thread_suspend_to_suspended(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
+            #[cfg(feature = "component-model-async")]
+            thread_suspend_to(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
             #[cfg(feature = "component-model-async")]
             thread_suspend(vmctx: vmctx, caller_instance: u32, cancellable: u8) -> u32;
             #[cfg(feature = "component-model-async")]
-            thread_resume_later(vmctx: vmctx, caller_instance: u32, thread_idx: u32) -> bool;
+            thread_unsuspend(vmctx: vmctx, caller_instance: u32, thread_idx: u32) -> bool;
             #[cfg(feature = "component-model-async")]
-            thread_yield_to(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
+            thread_yield_to_suspended(vmctx: vmctx, caller_instance: u32, cancellable: u8, thread_idx: u32) -> u32;
 
             trap(vmctx: vmctx, code: u32) -> bool;
 

crates/environ/src/component.rs

@@ -490,18 +490,22 @@ pub enum Trampoline {
         start_func_ty_idx: ComponentTypeIndex,
         start_func_table_id: TableId,
     },
-    ThreadSwitchTo {
+    ThreadSuspendToSuspended {
         instance: RuntimeComponentInstanceIndex,
         cancellable: bool,
     },
     ThreadSuspend {
         instance: RuntimeComponentInstanceIndex,
         cancellable: bool,
     },
-    ThreadResumeLater {
+    ThreadSuspendTo {
+        instance: RuntimeComponentInstanceIndex,
+        cancellable: bool,
+    },
+    ThreadUnsuspend {
         instance: RuntimeComponentInstanceIndex,
     },
-    ThreadYieldTo {
+    ThreadYieldToSuspended {
         instance: RuntimeComponentInstanceIndex,
         cancellable: bool,
     },
@@ -1181,10 +1185,17 @@ impl LinearizeDfg<'_> {
                 start_func_ty_idx: *start_func_ty_idx,
                 start_func_table_idx: self.runtime_table(*start_func_table_id),
             },
-            Trampoline::ThreadSwitchTo {
+            Trampoline::ThreadSuspendToSuspended {
+                instance,
+                cancellable,
+            } => info::Trampoline::ThreadSuspendToSuspended {
+                instance: *instance,
+                cancellable: *cancellable,
+            },
+            Trampoline::ThreadSuspendTo {
                 instance,
                 cancellable,
-            } => info::Trampoline::ThreadSwitchTo {
+            } => info::Trampoline::ThreadSuspendTo {
                 instance: *instance,
                 cancellable: *cancellable,
             },
@@ -1195,13 +1206,13 @@ impl LinearizeDfg<'_> {
                 instance: *instance,
                 cancellable: *cancellable,
             },
-            Trampoline::ThreadResumeLater { instance } => info::Trampoline::ThreadResumeLater {
+            Trampoline::ThreadUnsuspend { instance } => info::Trampoline::ThreadUnsuspend {
                 instance: *instance,
             },
-            Trampoline::ThreadYieldTo {
+            Trampoline::ThreadYieldToSuspended {
                 instance,
                 cancellable,
-            } => info::Trampoline::ThreadYieldTo {
+            } => info::Trampoline::ThreadYieldToSuspended {
                 instance: *instance,
                 cancellable: *cancellable,
             },

crates/environ/src/component/dfg.rs

@@ -1144,8 +1144,17 @@ pub enum Trampoline {
         start_func_table_idx: RuntimeTableIndex,
     },
 
-    /// Intrinsic used to implement the `thread.switch-to` component model builtin.
-    ThreadSwitchTo {
+    /// Intrinsic used to implement the `thread.suspend-to-suspended` component model builtin.
+    ThreadSuspendToSuspended {
+        /// The specific component instance which is calling the intrinsic.
+        instance: RuntimeComponentInstanceIndex,
+        /// If `true`, indicates the caller instance may receive notification
+        /// of task cancellation.
+        cancellable: bool,
+    },
+
+    /// Intrinsic used to implement the `thread.suspend-to` component model builtin.
+    ThreadSuspendTo {
         /// The specific component instance which is calling the intrinsic.
         instance: RuntimeComponentInstanceIndex,
         /// If `true`, indicates the caller instance may receive notification
@@ -1162,14 +1171,14 @@ pub enum Trampoline {
         cancellable: bool,
     },
 
-    /// Intrinsic used to implement the `thread.resume-later` component model builtin.
-    ThreadResumeLater {
+    /// Intrinsic used to implement the `thread.unsuspend` component model builtin.
+    ThreadUnsuspend {
         /// The specific component instance which is calling the intrinsic.
         instance: RuntimeComponentInstanceIndex,
     },
 
-    /// Intrinsic used to implement the `thread.yield-to` component model builtin.
-    ThreadYieldTo {
+    /// Intrinsic used to implement the `thread.yield-to-suspended` component model builtin.
+    ThreadYieldToSuspended {
         /// The specific component instance which is calling the intrinsic.
         instance: RuntimeComponentInstanceIndex,
         /// If `true`, indicates the caller instance may receive notification
@@ -1242,10 +1251,11 @@ impl Trampoline {
             ContextSet { .. } => format!("context-set"),
             ThreadIndex => format!("thread-index"),
             ThreadNewIndirect { .. } => format!("thread-new-indirect"),
-            ThreadSwitchTo { .. } => format!("thread-switch-to"),
+            ThreadSuspendToSuspended { .. } => format!("thread-suspend-to-suspended"),
+            ThreadSuspendTo { .. } => format!("thread-suspend-to"),
             ThreadSuspend { .. } => format!("thread-suspend"),
-            ThreadResumeLater { .. } => format!("thread-resume-later"),
-            ThreadYieldTo { .. } => format!("thread-yield-to"),
+            ThreadUnsuspend { .. } => format!("thread-unsuspend"),
+            ThreadYieldToSuspended { .. } => format!("thread-yield-to-suspended"),
         }
     }
 }

crates/environ/src/component/info.rs

@@ -319,18 +319,22 @@ enum LocalInitializer<'data> {
         start_func_ty: ComponentTypeIndex,
         start_func_table_index: TableIndex,
     },
-    ThreadSwitchTo {
+    ThreadSuspendToSuspended {
         func: ModuleInternedTypeIndex,
         cancellable: bool,
     },
     ThreadSuspend {
         func: ModuleInternedTypeIndex,
         cancellable: bool,
     },
-    ThreadResumeLater {
+    ThreadSuspendTo {
+        func: ModuleInternedTypeIndex,
+        cancellable: bool,
+    },
+    ThreadUnsuspend {
         func: ModuleInternedTypeIndex,
     },
-    ThreadYieldTo {
+    ThreadYieldToSuspended {
         func: ModuleInternedTypeIndex,
         cancellable: bool,
     },
@@ -1150,25 +1154,30 @@ impl<'a, 'data> Translator<'a, 'data> {
                                 start_func_table_index: TableIndex::from_u32(table_index),
                             }
                         }
-                        wasmparser::CanonicalFunction::ThreadSwitchTo { cancellable } => {
+                        wasmparser::CanonicalFunction::ThreadSuspendToSuspended { cancellable } => {
                             let func = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
-                            LocalInitializer::ThreadSwitchTo { func, cancellable }
+                            LocalInitializer::ThreadSuspendToSuspended { func, cancellable }
                         }
                         wasmparser::CanonicalFunction::ThreadSuspend { cancellable } => {
                             let func = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
                             LocalInitializer::ThreadSuspend { func, cancellable }
                         }
-                        wasmparser::CanonicalFunction::ThreadResumeLater => {
+                        wasmparser::CanonicalFunction::ThreadSuspendTo { cancellable } => {
+                            let func = self.core_func_signature(core_func_index)?;
+                            core_func_index += 1;
+                            LocalInitializer::ThreadSuspendTo { func, cancellable }
+                        }
+                        wasmparser::CanonicalFunction::ThreadUnsuspend => {
                             let func = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
-                            LocalInitializer::ThreadResumeLater { func }
+                            LocalInitializer::ThreadUnsuspend { func }
                         }
-                        wasmparser::CanonicalFunction::ThreadYieldTo { cancellable } => {
+                        wasmparser::CanonicalFunction::ThreadYieldToSuspended { cancellable } => {
                             let func = self.core_func_signature(core_func_index)?;
                             core_func_index += 1;
-                            LocalInitializer::ThreadYieldTo { func, cancellable }
+                            LocalInitializer::ThreadYieldToSuspended { func, cancellable }
                         }
                     };
                     self.result.initializers.push(init);

crates/environ/src/component/translate.rs

@@ -1123,10 +1123,20 @@ impl<'a> Inliner<'a> {
                 ));
                 frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));
             }
-            ThreadSwitchTo { func, cancellable } => {
+            ThreadSuspendToSuspended { func, cancellable } => {
                 let index = self.result.trampolines.push((
                     *func,
-                    dfg::Trampoline::ThreadSwitchTo {
+                    dfg::Trampoline::ThreadSuspendToSuspended {
+                        instance: frame.instance,
+                        cancellable: *cancellable,
+                    },
+                ));
+                frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));
+            }
+            ThreadSuspendTo { func, cancellable } => {
+                let index = self.result.trampolines.push((
+                    *func,
+                    dfg::Trampoline::ThreadSuspendTo {
                         instance: frame.instance,
                         cancellable: *cancellable,
                     },
@@ -1143,19 +1153,19 @@ impl<'a> Inliner<'a> {
                 ));
                 frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));
             }
-            ThreadResumeLater { func } => {
+            ThreadUnsuspend { func } => {
                 let index = self.result.trampolines.push((
                     *func,
-                    dfg::Trampoline::ThreadResumeLater {
+                    dfg::Trampoline::ThreadUnsuspend {
                         instance: frame.instance,
                     },
                 ));
                 frame.funcs.push((*func, dfg::CoreDef::Trampoline(index)));
             }
-            ThreadYieldTo { func, cancellable } => {
+            ThreadYieldToSuspended { func, cancellable } => {
                 let index = self.result.trampolines.push((
                     *func,
-                    dfg::Trampoline::ThreadYieldTo {
+                    dfg::Trampoline::ThreadYieldToSuspended {
                         instance: frame.instance,
                         cancellable: *cancellable,
                     },

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

@@ -458,7 +458,7 @@ impl ComponentTypesBuilder {
             ComponentDefinedType::Stream(ty) => {
                 InterfaceType::Stream(self.stream_table_type(types, ty)?)
             }
-            ComponentDefinedType::FixedSizeList(ty, size) => {
+            ComponentDefinedType::FixedLengthList(ty, size) => {
                 InterfaceType::FixedLengthList(self.fixed_length_list_type(types, ty, *size)?)
             }
             ComponentDefinedType::Map(..) => {
@@ -536,11 +536,6 @@ impl ComponentTypesBuilder {
             .cases
             .iter()
             .map(|(name, case)| {
-                // FIXME: need to implement `refines`, not sure what that
-                // is at this time.
-                if case.refines.is_some() {
-                    bail!("refines is not supported at this time");
-                }
                 Ok((
                     name.to_string(),
                     match &case.ty.as_ref() {

crates/environ/src/component/types_builder.rs

@@ -441,6 +441,17 @@ impl WastTest {
             return true;
         }
 
+        // These tests in the `component-model` submodule have not yet been
+        // updated to account for the recent threading-related intrinsic
+        // changes
+        let unsupported = [
+            "test/async/same-component-stream-future.wast",
+            "test/async/trap-if-block-and-sync.wast",
+        ];
+        if unsupported.iter().any(|part| self.path.ends_with(part)) {
+            return true;
+        }
+
         // Some tests are known to fail with the pooling allocator
         if config.pooling {
             let unsupported = [