support composing with fixed size lists

Cargo.toml

@@ -63,13 +63,13 @@ wac-parser = { path = "crates/wac-parser", version = "0.7.0-dev", default-featur
 wac-resolver = { path = "crates/wac-resolver", version = "0.7.0-dev", default-features = false }
 wac-graph = { path = "crates/wac-graph", version = "0.7.0-dev" }
 wac-types = { path = "crates/wac-types", version = "0.7.0-dev" }
-wit-parser = "0.229.0"
-wasmparser = "0.229.0"
-wit-component = "0.229.0"
-wasm-encoder = "0.229.0"
-wasmprinter = "0.229.0"
-wasm-metadata = "0.229.0"
-wat = "1.229.0"
+wit-parser = "0.235.0"
+wasmparser = "0.235.0"
+wit-component = "0.235.0"
+wasm-encoder = "0.235.0"
+wasmprinter = "0.235.0"
+wasm-metadata = "0.235.0"
+wat = "1.235.0"
 anyhow = "1.0.81"
 clap = { version = "4.5.4", features = ["derive"] }
 semver = { version = "1.0.22", features = ["serde"] }

crates/wac-graph/src/encoding.rs

@@ -243,6 +243,7 @@ impl<'a> TypeEncoder<'a> {
         let index = match ty {
             DefinedType::Tuple(types) => self.tuple(state, types),
             DefinedType::List(ty) => self.list(state, *ty),
+            DefinedType::FixedSizeList(ty, elements) => self.fixed_size_list(state, *ty, *elements),
             DefinedType::Option(ty) => self.option(state, *ty),
             DefinedType::Result { ok, err } => self.result(state, *ok, *err),
             DefinedType::Variant(v) => self.variant(state, v),
@@ -552,6 +553,18 @@ impl<'a> TypeEncoder<'a> {
         index
     }
 
+    fn fixed_size_list(&self, state: &mut State, ty: ValueType, elements: u32) -> u32 {
+        let ty = self.value_type(state, ty);
+        let index = state.current.encodable.type_count();
+        state
+            .current
+            .encodable
+            .ty()
+            .defined_type()
+            .fixed_size_list(ty, elements);
+        index
+    }
+
     fn stream(&self, state: &mut State, ty: Option<ValueType>) -> u32 {
         let ty = ty.map(|ty| self.value_type(state, ty));
         let index = state.current.encodable.type_count();

crates/wac-types/src/aggregator.rs

@@ -789,6 +789,9 @@ impl TypeAggregator {
                     .collect::<Result<_>>()?,
             ),
             DefinedType::List(ty) => DefinedType::List(self.remap_value_type(types, *ty, checker)?),
+            DefinedType::FixedSizeList(ty, elements) => {
+                DefinedType::FixedSizeList(self.remap_value_type(types, *ty, checker)?, *elements)
+            }
             DefinedType::Option(ty) => {
                 DefinedType::Option(self.remap_value_type(types, *ty, checker)?)
             }

crates/wac-types/src/checker.rs

@@ -551,6 +551,13 @@ impl<'a> SubtypeChecker<'a> {
             (DefinedType::List(a), DefinedType::List(b)) => self
                 .value_type(*a, at, *b, bt)
                 .context("mismatched type for list element"),
+            (DefinedType::FixedSizeList(a, asize), DefinedType::FixedSizeList(b, bsize)) => {
+                if asize != bsize {
+                    bail!("mismatched size for fixed size list element");
+                }
+                self.value_type(*a, at, *b, bt)
+                    .context("mismatched type for fixed size list element")
+            }
             (DefinedType::Future(a), DefinedType::Future(b)) => self
                 .payload(*a, at, *b, bt)
                 .context("mismatched type for future payload"),
@@ -583,6 +590,7 @@ impl<'a> SubtypeChecker<'a> {
 
             (DefinedType::Tuple(_), _)
             | (DefinedType::List(_), _)
+            | (DefinedType::FixedSizeList(_, _), _)
             | (DefinedType::Option(_), _)
             | (DefinedType::Result { .. }, _)
             | (DefinedType::Variant(_), _)

crates/wac-types/src/component.rs

@@ -659,6 +659,8 @@ pub enum DefinedType {
     Tuple(Vec<ValueType>),
     /// A list type.
     List(ValueType),
+    /// A fixed size array
+    FixedSizeList(ValueType, u32),
     /// An option type.
     Option(ValueType),
     /// A result type.
@@ -689,7 +691,7 @@ impl DefinedType {
     pub fn contains_borrow(&self, types: &Types) -> bool {
         match self {
             Self::Tuple(tys) => tys.iter().any(|ty| ty.contains_borrow(types)),
-            Self::List(ty) => ty.contains_borrow(types),
+            Self::List(ty) | Self::FixedSizeList(ty, _) => ty.contains_borrow(types),
             Self::Option(ty) => ty.contains_borrow(types),
             Self::Result { ok, err } => {
                 ok.map(|ty| ty.contains_borrow(types)).unwrap_or(false)
@@ -721,7 +723,7 @@ impl DefinedType {
 
                 Ok(())
             }
-            DefinedType::List(ty) | DefinedType::Option(ty) => {
+            DefinedType::List(ty) | DefinedType::Option(ty) | DefinedType::FixedSizeList(ty, _) => {
                 ty._visit_defined_types(types, visitor, false)
             }
             DefinedType::Result { ok, err } => {
@@ -765,6 +767,7 @@ impl DefinedType {
         match self {
             Self::Tuple(_) => "tuple",
             Self::List(_) => "list",
+            Self::FixedSizeList(_, _) => "list<,N>",
             Self::Option(_) => "option",
             Self::Result { .. } => "result",
             Self::Variant(_) => "variant",

crates/wac-types/src/package.rs

@@ -754,6 +754,10 @@ impl<'a> TypeConverter<'a> {
                 let option = ty.map(|ty| self.component_val_type(ty)).transpose()?;
                 ValueType::Defined(self.types.add_defined_type(DefinedType::Future(option)))
             }
+            wasm::ComponentDefinedType::FixedSizeList(ty, _) => {
+                let ty = self.component_val_type(*ty)?;
+                ValueType::Defined(self.types.add_defined_type(DefinedType::List(ty)))
+            }
         };
 
         self.cache.insert(key, Entity::Type(Type::Value(ty)));