Fixed length list support (#1992)

* support fixed length lists, part 1

* more fixed size

* fix tests for wit-parser

* re-implement as two separate types (outside of WIT)

* adapt the tests for the new type

* handle reading correctly

* wat parsing

* generate fixed size lists in wit-smith

* proper rustfmt (whitespace change)

* implement Alex' suggetions, part one

* implement roundtrip tests

* limit the maximum size of a fixed list. to avoid memory explosion at parsing

* separate list types, as proposed by Alex

* post-rebase fixes

* fix the tests

* Move local test to CLI test

* use same command line order as proposed by Alex

* prefer the name chosen by Alex

* apply missing changes by Alex (I should have fetched before rebase)

* limit the size of flattened fixed size lists, forbid empty ones

* test for zero and too high number

* check for type mismatch during composition

* clearly separate list from fixed-size-list in code

* separate list types in encoder as well

* manually run rustfmt

---------

Co-authored-by: Alex Crichton <[email protected]>

Author: cpetig

crates/wasm-compose/src/encoding.rs

@@ -649,6 +649,9 @@ impl<'a> TypeEncoder<'a> {
             ComponentDefinedType::Record(r) => self.record(state, r),
             ComponentDefinedType::Variant(v) => self.variant(state, v),
             ComponentDefinedType::List(ty) => self.list(state, *ty),
+            ComponentDefinedType::FixedSizeList(ty, elements) => {
+                self.fixed_size_list(state, *ty, *elements)
+            }
             ComponentDefinedType::Tuple(t) => self.tuple(state, t),
             ComponentDefinedType::Flags(names) => Self::flags(&mut state.cur.encodable, names),
             ComponentDefinedType::Enum(cases) => Self::enum_type(&mut state.cur.encodable, cases),
@@ -709,6 +712,23 @@ impl<'a> TypeEncoder<'a> {
         index
     }
 
+    fn fixed_size_list(
+        &self,
+        state: &mut TypeState<'a>,
+        ty: ct::ComponentValType,
+        elements: u32,
+    ) -> u32 {
+        let ty = self.component_val_type(state, ty);
+        let index = state.cur.encodable.type_count();
+        state
+            .cur
+            .encodable
+            .ty()
+            .defined_type()
+            .fixed_size_list(ty, elements);
+        index
+    }
+
     fn tuple(&self, state: &mut TypeState<'a>, tuple: &TupleType) -> u32 {
         let types = tuple
             .types
@@ -1228,7 +1248,9 @@ impl DependencyRegistrar<'_, '_> {
             ComponentDefinedType::Primitive(_)
             | ComponentDefinedType::Enum(_)
             | ComponentDefinedType::Flags(_) => {}
-            ComponentDefinedType::List(t) | ComponentDefinedType::Option(t) => self.val_type(*t),
+            ComponentDefinedType::List(t)
+            | ComponentDefinedType::FixedSizeList(t, _)
+            | ComponentDefinedType::Option(t) => self.val_type(*t),
             ComponentDefinedType::Own(r) | ComponentDefinedType::Borrow(r) => {
                 self.ty(ComponentAnyTypeId::Resource(*r))
             }

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

@@ -593,6 +593,13 @@ impl ComponentDefinedTypeEncoder<'_> {
         ty.into().encode(self.0);
     }
 
+    /// Define a fixed size list type.
+    pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: u32) {
+        self.0.push(0x67);
+        ty.into().encode(self.0);
+        elements.encode(self.0);
+    }
+
     /// Define a tuple type.
     pub fn tuple<I, T>(self, types: I)
     where

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

@@ -767,6 +767,9 @@ pub mod component_utils {
             wasmparser::ComponentDefinedType::List(t) => {
                 defined.list(reencoder.component_val_type(t));
             }
+            wasmparser::ComponentDefinedType::FixedSizeList(t, elements) => {
+                defined.fixed_size_list(reencoder.component_val_type(t), elements);
+            }
             wasmparser::ComponentDefinedType::Tuple(t) => {
                 defined.tuple(t.iter().map(|t| reencoder.component_val_type(*t)));
             }

crates/wasm-wave/src/value/ty.rs

@@ -10,6 +10,7 @@ pub struct Type(pub(super) TypeEnum);
 pub(super) enum TypeEnum {
     Simple(SimpleType),
     List(Arc<ListType>),
+    FixedSizeList(Arc<ListType>, u32),
     Record(Arc<RecordType>),
     Tuple(Arc<TupleType>),
     Variant(Arc<VariantType>),
@@ -55,6 +56,15 @@ impl Type {
         Self(TypeEnum::List(Arc::new(ListType { element })))
     }
 
+    /// Returns a list type with the given element type.
+    pub fn fixed_size_list(element_type: impl Into<Self>, elements: u32) -> Self {
+        let element = element_type.into();
+        Self(TypeEnum::FixedSizeList(
+            Arc::new(ListType { element }),
+            elements,
+        ))
+    }
+
     /// Returns a record type with the given field types. Returns None if
     /// `fields` is empty.
     pub fn record<T: Into<Box<str>>>(
@@ -189,6 +199,7 @@ impl WasmType for Type {
         match self.0 {
             TypeEnum::Simple(simple) => simple.0,
             TypeEnum::List(_) => WasmTypeKind::List,
+            TypeEnum::FixedSizeList(_, _) => WasmTypeKind::FixedSizeList,
             TypeEnum::Record(_) => WasmTypeKind::Record,
             TypeEnum::Tuple(_) => WasmTypeKind::Tuple,
             TypeEnum::Variant(_) => WasmTypeKind::Variant,

crates/wasm-wave/src/value/wit.rs

@@ -70,6 +70,9 @@ impl<'a> TypeResolver<'a> {
             TypeDefKind::Option(some_type) => self.resolve_option(some_type),
             TypeDefKind::Result(result) => self.resolve_result(result),
             TypeDefKind::List(element_type) => self.resolve_list(element_type),
+            TypeDefKind::FixedSizeList(element_type, elements) => {
+                self.resolve_fixed_size_list(element_type, *elements)
+            }
             TypeDefKind::Type(Type::Bool) => Ok(value::Type::BOOL),
             TypeDefKind::Type(Type::U8) => Ok(value::Type::U8),
             TypeDefKind::Type(Type::U16) => Ok(value::Type::U16),
@@ -145,6 +148,11 @@ impl<'a> TypeResolver<'a> {
         let element_type = self.resolve_type(*element_type)?;
         Ok(value::Type::list(element_type))
     }
+
+    fn resolve_fixed_size_list(&self, element_type: &Type, elements: u32) -> ValueResult {
+        let element_type = self.resolve_type(*element_type)?;
+        Ok(value::Type::fixed_size_list(element_type, elements))
+    }
 }
 
 #[cfg(test)]

crates/wasm-wave/src/wasm/ty.rs

@@ -20,6 +20,7 @@ pub enum WasmTypeKind {
     Char,
     String,
     List,
+    FixedSizeList,
     Record,
     Tuple,
     Variant,
@@ -48,6 +49,7 @@ impl std::fmt::Display for WasmTypeKind {
             WasmTypeKind::Char => "char",
             WasmTypeKind::String => "string",
             WasmTypeKind::List => "list",
+            WasmTypeKind::FixedSizeList => "list<_,N>",
             WasmTypeKind::Record => "record",
             WasmTypeKind::Tuple => "tuple",
             WasmTypeKind::Variant => "variant",

crates/wasm-wave/src/writer.rs

@@ -75,6 +75,16 @@ impl<W: Write> Writer<W> {
                 }
                 self.write_str("]")
             }
+            WasmTypeKind::FixedSizeList => {
+                self.write_str("[")?;
+                for (idx, val) in val.unwrap_list().enumerate() {
+                    if idx != 0 {
+                        self.write_str(", ")?;
+                    }
+                    self.write_value(&*val)?;
+                }
+                self.write_str("]")
+            }
             WasmTypeKind::Record => {
                 self.write_str("{")?;
                 let mut first = true;

crates/wasmparser/src/features.rs

@@ -254,6 +254,11 @@ define_wasm_features! {
         /// Corresponds to the 📝 character in
         /// <https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md>.
         pub cm_error_context: CM_ERROR_CONTEXT(1 << 30) = false;
+        /// Support for fixed size lists
+        ///
+        /// Corresponds to the 🔧 character in
+        /// <https://github.com/WebAssembly/component-model/blob/main/design/mvp/Explainer.md>.
+        pub cm_fixed_size_list: CM_FIXED_SIZE_LIST(1 << 31) = false;
     }
 }
 

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

@@ -441,6 +441,8 @@ pub enum ComponentDefinedType<'a> {
     Variant(Box<[VariantCase<'a>]>),
     /// The type is a list of the given value type.
     List(ComponentValType),
+    /// The type is a fixed size list of the given value type.
+    FixedSizeList(ComponentValType, u32),
     /// The type is a tuple of the given value types.
     Tuple(Box<[ComponentValType]>),
     /// The type is flags with the given names.
@@ -503,8 +505,9 @@ impl<'a> ComponentDefinedType<'a> {
             },
             0x69 => ComponentDefinedType::Own(reader.read()?),
             0x68 => ComponentDefinedType::Borrow(reader.read()?),
-            0x65 => ComponentDefinedType::Future(reader.read()?),
+            0x67 => ComponentDefinedType::FixedSizeList(reader.read()?, reader.read_var_u32()?),
             0x66 => ComponentDefinedType::Stream(reader.read()?),
+            0x65 => ComponentDefinedType::Future(reader.read()?),
             x => return reader.invalid_leading_byte(x, "component defined type"),
         })
     }

crates/wasmparser/src/validator/component.rs

@@ -724,9 +724,9 @@ impl ComponentState {
                         .map(|t| types.type_named_valtype(t, set))
                         .unwrap_or(true)
             }
-            ComponentDefinedType::List(ty) | ComponentDefinedType::Option(ty) => {
-                types.type_named_valtype(ty, set)
-            }
+            ComponentDefinedType::List(ty)
+            | ComponentDefinedType::FixedSizeList(ty, _)
+            | ComponentDefinedType::Option(ty) => types.type_named_valtype(ty, set),
 
             // The resource referred to by own/borrow must be named.
             ComponentDefinedType::Own(id) | ComponentDefinedType::Borrow(id) => {
@@ -3475,6 +3475,21 @@ impl ComponentState {
             crate::ComponentDefinedType::List(ty) => Ok(ComponentDefinedType::List(
                 self.create_component_val_type(ty, offset)?,
             )),
+            crate::ComponentDefinedType::FixedSizeList(ty, elements) => {
+                if !self.features.cm_fixed_size_list() {
+                    bail!(
+                        offset,
+                        "Fixed size lists require the component model fixed size list feature"
+                    )
+                }
+                if elements < 1 {
+                    bail!(offset, "Fixed size lists must have more than zero elements")
+                }
+                Ok(ComponentDefinedType::FixedSizeList(
+                    self.create_component_val_type(ty, offset)?,
+                    elements,
+                ))
+            }
             crate::ComponentDefinedType::Tuple(tys) => {
                 self.create_tuple_type(tys.as_ref(), types, offset)
             }