Bake async into component model function types (#2376)

* Bake `async` into component model function types

This commit is a breaking change to the component-model-async
implementation in this repository. This will effectively invalidate all
WASIp3 binaries created prior to this commit. Given that this feature is
off-by-default everywhere (right? right?) it's expected that while this
will have churn it's the appropriate time to make such a change as this.

Concretely the changes here are:

* Function types in the component model now reflect whether they're
  `async`-or-not. This is no longer WIT-level sugar.
* Kebab names no longer support `[async]`, `[async method]`, or
  `[async static]`.
* The text format now supports `(func async? (param ...))`.

The binary format previously used 0x40 as the prefix byte for "this is a
component function type" and now 0x43 is used as "this is an async
function type". The `async_` boolean is plumbed throughout component
function type locations and is required to be handled by callers. For
now there is no subtyping relationship between async and non-async
functions, they must be exactly the same when linking.

The rationale for this change is going to be expanded on more fully in
an upcoming PR to the component-model repository itself. The rough
tl;dr; is that to fully support JS in/out of components the component
model is going to need to require traps in some dynamic situations such
as when a synchronous function-type function tries to block. This is
required to respect JS's "cannot block the main thread" semantics, for
example. This will be more fully explain in the component-model PR and
this PR is not intended to serve as justification alone for this change.
Instead this PR is intended to change/update Wasmtime as quickly as
possible to understand the new binary format so implementation work can
proceed as most of the work here is on the runtime side of things, not
validation.

One minor caveat for this change is that the `wit-dylib` crate has some
tests which exercise async functionality. Those are now all disabled or
set as "expect this to fail" because Wasmtime, the runner for these
tests, no longer understands the binaries it's ingesting.

* Delete outdated snapshot

* Propagate async-ness in wasm-compose too

* Add `async` to the function type hash key

Author: alexcrichton

Cargo.lock

@@ -482,7 +482,7 @@ impl<'a> TypeEncoder<'a> {
         let index = state.cur.encodable.type_count();
         let mut f = state.cur.encodable.ty().function();
 
-        f.params(params).result(result);
+        f.async_(ty.async_).params(params).result(result);
 
         index
     }

crates/wasm-compose/src/encoding.rs

@@ -353,21 +353,44 @@ impl Encode for InstanceType {
 /// Used to encode component function types.
 #[derive(Debug)]
 pub struct ComponentFuncTypeEncoder<'a> {
+    async_encoded: bool,
     params_encoded: bool,
     results_encoded: bool,
     sink: &'a mut Vec<u8>,
 }
 
 impl<'a> ComponentFuncTypeEncoder<'a> {
     fn new(sink: &'a mut Vec<u8>) -> Self {
-        sink.push(0x40);
         Self {
+            async_encoded: false,
             params_encoded: false,
             results_encoded: false,
             sink,
         }
     }
 
+    /// Indicates whether this is an `async` function or not.
+    ///
+    /// If this function is not invoked then the function type will not be
+    /// `async`.
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if parameters or results have already been
+    /// encoded.
+    pub fn async_(&mut self, is_async: bool) -> &mut Self {
+        assert!(!self.params_encoded);
+        assert!(!self.results_encoded);
+        assert!(!self.async_encoded);
+        self.async_encoded = true;
+        if is_async {
+            self.sink.push(0x43);
+        } else {
+            self.sink.push(0x40);
+        }
+        self
+    }
+
     /// Defines named parameters.
     ///
     /// Parameters must be defined before defining results.
@@ -383,6 +406,9 @@ impl<'a> ComponentFuncTypeEncoder<'a> {
         T: Into<ComponentValType>,
     {
         assert!(!self.params_encoded);
+        if !self.async_encoded {
+            self.async_(false);
+        }
         self.params_encoded = true;
         let params = params.into_iter();
         params.len().encode(self.sink);
@@ -402,6 +428,7 @@ impl<'a> ComponentFuncTypeEncoder<'a> {
     /// This method will panic if the function is called twice, called before
     /// the `params` method, or called in addition to the `results` method.
     pub fn result(&mut self, ty: Option<ComponentValType>) -> &mut Self {
+        assert!(self.async_encoded);
         assert!(self.params_encoded);
         assert!(!self.results_encoded);
         self.results_encoded = true;

crates/wasm-encoder/src/component/types.rs

@@ -731,6 +731,7 @@ pub mod component_utils {
         mut func: crate::ComponentFuncTypeEncoder<'_>,
         ty: wasmparser::ComponentFuncType<'_>,
     ) -> Result<(), Error<T::Error>> {
+        func.async_(ty.async_);
         func.params(
             Vec::from(ty.params)
                 .into_iter()

crates/wasm-encoder/src/reencode/component.rs

@@ -282,12 +282,16 @@ impl<'a> FromReader<'a> for ComponentType<'a> {
                     b => return reader.invalid_leading_byte(b, "resource destructor"),
                 },
             },
-            0x40 => {
+            byte @ (0x40 | 0x43) => {
                 let params = reader
                     .read_iter(MAX_WASM_FUNCTION_PARAMS, "component function parameters")?
                     .collect::<Result<_>>()?;
                 let result = read_resultlist(reader)?;
-                ComponentType::Func(ComponentFuncType { params, result })
+                ComponentType::Func(ComponentFuncType {
+                    async_: byte == 0x43,
+                    params,
+                    result,
+                })
             }
             0x41 => ComponentType::Component(
                 reader
@@ -387,6 +391,8 @@ impl<'a> FromReader<'a> for InstanceTypeDeclaration<'a> {
 /// Represents a type of a function in a WebAssembly component.
 #[derive(Debug, Clone, Eq, PartialEq)]
 pub struct ComponentFuncType<'a> {
+    /// Whether or not this is an async function.
+    pub async_: bool,
     /// The function parameters.
     pub params: Box<[(&'a str, ComponentValType)]>,
     /// The function result.

crates/wasmparser/src/readers/component/types.rs

@@ -1447,6 +1447,7 @@ impl ComponentState {
         }
 
         let func_ty = ComponentFuncType {
+            async_: false,
             info: TypeInfo::new(),
             params: result
                 .iter()
@@ -3051,6 +3052,13 @@ impl ComponentState {
     ) -> Result<ComponentFuncType> {
         let mut info = TypeInfo::new();
 
+        if ty.async_ && !self.features.cm_async() {
+            bail!(
+                offset,
+                "async component functions require the component model async feature"
+            );
+        }
+
         let mut set = Set::default();
         set.reserve(core::cmp::max(
             ty.params.len(),
@@ -3092,6 +3100,7 @@ impl ComponentState {
             .transpose()?;
 
         Ok(ComponentFuncType {
+            async_: ty.async_,
             info,
             params,
             result,
@@ -4534,11 +4543,8 @@ impl ComponentNameContext {
         if let ExternKind::Export = kind {
             match kebab.kind() {
                 ComponentNameKind::Label(_)
-                | ComponentNameKind::AsyncLabel(_)
                 | ComponentNameKind::Method(_)
-                | ComponentNameKind::AsyncMethod(_)
                 | ComponentNameKind::Static(_)
-                | ComponentNameKind::AsyncStatic(_)
                 | ComponentNameKind::Constructor(_)
                 | ComponentNameKind::Interface(_) => {}
 
@@ -4552,7 +4558,7 @@ impl ComponentNameContext {
 
         // Validate that the kebab name, if it has structure such as
         // `[method]a.b`, is indeed valid with respect to known resources.
-        self.validate(&kebab, ty, types, offset, features)
+        self.validate(&kebab, ty, types, offset)
             .with_context(|| format!("{} name `{kebab}` is not valid", kind.desc()))?;
 
         // Top-level kebab-names must all be unique, even between both imports
@@ -4593,7 +4599,6 @@ impl ComponentNameContext {
         ty: &ComponentEntityType,
         types: &TypeAlloc,
         offset: usize,
-        features: &WasmFeatures,
     ) -> Result<()> {
         let func = || {
             let id = match ty {
@@ -4602,24 +4607,10 @@ impl ComponentNameContext {
             };
             Ok(&types[id])
         };
-        match name.kind() {
-            ComponentNameKind::AsyncLabel(_)
-            | ComponentNameKind::AsyncMethod(_)
-            | ComponentNameKind::AsyncStatic(_) => {
-                if !features.cm_async() {
-                    bail!(
-                        offset,
-                        "async kebab-names require the component model async feature"
-                    );
-                }
-            }
-            _ => {}
-        }
 
         match name.kind() {
             // No validation necessary for these styles of names
             ComponentNameKind::Label(_)
-            | ComponentNameKind::AsyncLabel(_)
             | ComponentNameKind::Interface(_)
             | ComponentNameKind::Url(_)
             | ComponentNameKind::Dependency(_)
@@ -4630,6 +4621,9 @@ impl ComponentNameContext {
             // within this context to match `rname`.
             ComponentNameKind::Constructor(rname) => {
                 let ty = func()?;
+                if ty.async_ {
+                    bail!(offset, "constructor function cannot be async");
+                }
                 let ty = match ty.result {
                     Some(result) => result,
                     None => bail!(offset, "function should return one value"),
@@ -4661,7 +4655,7 @@ impl ComponentNameContext {
             // Methods must take `(param "self" (borrow $resource))` as the
             // first argument where `$resources` matches the name `resource` as
             // named in this context.
-            ComponentNameKind::Method(name) | ComponentNameKind::AsyncMethod(name) => {
+            ComponentNameKind::Method(name) => {
                 let ty = func()?;
                 if ty.params.len() == 0 {
                     bail!(offset, "function should have at least one argument");
@@ -4693,7 +4687,7 @@ impl ComponentNameContext {
             // Static methods don't have much validation beyond that they must
             // be a function and the resource name referred to must already be
             // in this context.
-            ComponentNameKind::Static(name) | ComponentNameKind::AsyncStatic(name) => {
+            ComponentNameKind::Static(name) => {
                 func()?;
                 if !self.all_resource_names.contains(name.resource().as_str()) {
                     bail!(offset, "static resource name is not known in this context");

crates/wasmparser/src/validator/component.rs

@@ -1086,6 +1086,8 @@ impl TypeData for ComponentInstanceType {
 pub struct ComponentFuncType {
     /// Metadata about this function type.
     pub(crate) info: TypeInfo,
+    /// Whether or not this is an async function.
+    pub async_: bool,
     /// The function parameters.
     pub params: Box<[(KebabString, ComponentValType)]>,
     /// The function's result.
@@ -3237,6 +3239,15 @@ impl<'a> SubtypeCx<'a> {
         let a = &self.a[a];
         let b = &self.b[b];
 
+        if a.async_ != b.async_ {
+            let a_desc = if a.async_ { "async" } else { "sync" };
+            let b_desc = if b.async_ { "async" } else { "sync" };
+            bail!(
+                offset,
+                "expected {a_desc} function, found {b_desc} function",
+            );
+        }
+
         // Note that this intentionally diverges from the upstream
         // specification in terms of subtyping. This is a full
         // type-equality check which ensures that the structure of `a`