implement Alex' suggetions, part one

cpetig · cpetig · commit 8d2ededcdbcf · 2025-02-11T13:22:54.000+01:00
diff --git a/crates/wasm-compose/src/encoding.rs b/crates/wasm-compose/src/encoding.rs
@@ -731,7 +731,7 @@ impl<'a> TypeEncoder<'a> {
         &self,
         state: &mut TypeState<'a>,
         ty: ct::ComponentValType,
-        elements: usize,
+        elements: u32,
     ) -> u32 {
         let ty = self.component_val_type(state, ty);
         let index = state.cur.encodable.type_count();
diff --git a/crates/wasm-encoder/src/component/types.rs b/crates/wasm-encoder/src/component/types.rs
@@ -606,10 +606,10 @@ impl ComponentDefinedTypeEncoder<'_> {
     }
 
     /// Define a fixed size list type.
-    pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: usize) {
+    pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: u32) {
         self.0.push(0x67);
         ty.into().encode(self.0);
-        (elements as u32).encode(self.0);
+        elements.encode(self.0);
     }
 
     /// Define a tuple type.
diff --git a/crates/wasm-wave/src/value/ty.rs b/crates/wasm-wave/src/value/ty.rs
@@ -10,7 +10,7 @@ pub struct Type(pub(super) TypeEnum);
 pub(super) enum TypeEnum {
     Simple(SimpleType),
     List(Arc<ListType>),
-    FixedSizeList(Arc<ListType>, usize),
+    FixedSizeList(Arc<ListType>, u32),
     Record(Arc<RecordType>),
     Tuple(Arc<TupleType>),
     Variant(Arc<VariantType>),
@@ -57,7 +57,7 @@ impl Type {
     }
 
     /// Returns a list type with the given element type.
-    pub fn fixed_size_list(element_type: impl Into<Self>, elements: usize) -> Self {
+    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 }),
diff --git a/crates/wasm-wave/src/value/wit.rs b/crates/wasm-wave/src/value/wit.rs
@@ -149,7 +149,7 @@ impl<'a> TypeResolver<'a> {
         Ok(value::Type::list(element_type))
     }
 
-    fn resolve_fixed_size_list(&self, element_type: &Type, elements: usize) -> ValueResult {
+    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))
     }
diff --git a/crates/wasmparser/src/features.rs b/crates/wasmparser/src/features.rs
@@ -231,6 +231,8 @@ define_wasm_features! {
         pub wide_arithmetic: WIDE_ARITHMETIC(1 << 28) = false;
         /// Support for component model async lift/lower ABI, as well as streams, futures, and errors.
         pub component_model_async: COMPONENT_MODEL_ASYNC(1 << 29) = false;
+        /// Support for fixed size lists
+        pub component_model_fixed_size_list: COMPONENT_MODEL_FIXED_SIZE_LIST(1 << 30) = false;
     }
 }
 
diff --git a/crates/wasmparser/src/readers/component/types.rs b/crates/wasmparser/src/readers/component/types.rs
@@ -487,7 +487,7 @@ pub enum ComponentDefinedType<'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, usize),
+    FixedSizeList(ComponentValType, u32),
     /// The type is a tuple of the given value types.
     Tuple(Box<[ComponentValType]>),
     /// The type is flags with the given names.
@@ -529,9 +529,6 @@ impl<'a> ComponentDefinedType<'a> {
                     .collect::<Result<_>>()?,
             ),
             0x70 => ComponentDefinedType::List(reader.read()?),
-            0x67 => {
-                ComponentDefinedType::FixedSizeList(reader.read()?, reader.read_var_u32()? as usize)
-            }
             0x6f => ComponentDefinedType::Tuple(
                 reader
                     .read_iter(MAX_WASM_TUPLE_TYPES, "tuple types")?
@@ -555,8 +552,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()?),
             0x64 => ComponentDefinedType::ErrorContext,
             x => return reader.invalid_leading_byte(x, "component defined type"),
         })
diff --git a/crates/wasmparser/src/validator/component.rs b/crates/wasmparser/src/validator/component.rs
@@ -3278,6 +3278,12 @@ impl ComponentState {
                 self.create_component_val_type(ty, offset)?,
             )),
             crate::ComponentDefinedType::FixedSizeList(ty, elements) => {
+                if !features.component_model_fixed_size_list() {
+                    bail!(
+                        offset,
+                        "Fixed size lists require the component model fixed size list feature"
+                    )
+                }
                 Ok(ComponentDefinedType::FixedSizeList(
                     self.create_component_val_type(ty, offset)?,
                     elements,
diff --git a/crates/wasmparser/src/validator/component_types.rs b/crates/wasmparser/src/validator/component_types.rs
@@ -1041,7 +1041,7 @@ pub enum ComponentDefinedType {
     /// The type is a list.
     List(ComponentValType),
     /// The type is a fixed size list.
-    FixedSizeList(ComponentValType, usize),
+    FixedSizeList(ComponentValType, u32),
     /// The type is a tuple.
     Tuple(TupleType),
     /// The type is a set of flags.
@@ -1215,7 +1215,8 @@ impl ComponentDefinedType {
             ComponentDefinedType::Enum(_) => "enum",
             ComponentDefinedType::Flags(_) => "flags",
             ComponentDefinedType::Option(_) => "option",
-            ComponentDefinedType::List(_) | ComponentDefinedType::FixedSizeList(_, _) => "list",
+            ComponentDefinedType::List(_) => "list",
+            ComponentDefinedType::FixedSizeList(_, _) => "fixed size list",
             ComponentDefinedType::Result { .. } => "result",
             ComponentDefinedType::Own(_) => "own",
             ComponentDefinedType::Borrow(_) => "borrow",
diff --git a/crates/wasmprinter/src/component.rs b/crates/wasmprinter/src/component.rs
@@ -171,7 +171,7 @@ impl Printer<'_, '_> {
         &mut self,
         state: &State,
         element_ty: &ComponentValType,
-        elements: usize,
+        elements: u32,
     ) -> Result<()> {
         self.start_group("list ")?;
         self.print_component_val_type(state, element_ty)?;
diff --git a/crates/wast/src/component/types.rs b/crates/wast/src/component/types.rs
@@ -580,18 +580,14 @@ pub struct List<'a> {
     /// The element type of the array.
     pub element: Box<ComponentValType<'a>>,
     /// Optional fixed size
-    pub elements: Option<usize>,
+    pub elements: Option<u32>,
 }
 
 impl<'a> Parse<'a> for List<'a> {
     fn parse(parser: Parser<'a>) -> Result<Self> {
         parser.parse::<kw::list>()?;
         let tp = parser.parse()?;
-        let elements = if !parser.is_empty() {
-            Some(parser.parse::<u32>()? as usize)
-        } else {
-            None
-        };
+        let elements = parser.parse()?;
         Ok(Self {
             element: Box::new(tp),
             elements,
diff --git a/crates/wit-component/src/encoding.rs b/crates/wit-component/src/encoding.rs
@@ -320,7 +320,7 @@ impl TypeContents {
                 }
                 TypeDefKind::Enum(_) => Self::empty(),
                 TypeDefKind::List(t) => Self::for_type(resolve, t) | Self::LIST,
-                TypeDefKind::FixedSizeList(t, _elements) => Self::for_type(resolve, t) | Self::LIST,
+                TypeDefKind::FixedSizeList(t, _elements) => Self::for_type(resolve, t),
                 TypeDefKind::Type(t) => Self::for_type(resolve, t),
                 TypeDefKind::Future(_) => Self::empty(),
                 TypeDefKind::Stream(_) => Self::empty(),
diff --git a/crates/wit-component/src/printing.rs b/crates/wit-component/src/printing.rs
@@ -976,7 +976,7 @@ impl<O: Output> WitPrinter<O> {
         resolve: &Resolve,
         name: Option<&str>,
         ty: &Type,
-        elements: usize,
+        elements: u32,
     ) -> Result<()> {
         if let Some(name) = name {
             self.output.keyword("type");
diff --git a/crates/wit-encoder/src/ty.rs b/crates/wit-encoder/src/ty.rs
@@ -25,7 +25,7 @@ pub enum Type {
     Borrow(Ident),
     Option(Box<Type>),
     Result(Box<Result_>),
-    List(Box<Type>, Option<usize>),
+    List(Box<Type>, Option<u32>),
     Tuple(Tuple),
     Future(Option<Box<Type>>),
     Stream(Option<Box<Type>>),
@@ -55,7 +55,7 @@ impl Type {
     pub fn result_empty() -> Self {
         Type::Result(Box::new(Result_::empty()))
     }
-    pub fn list(type_: Type, size: Option<usize>) -> Self {
+    pub fn list(type_: Type, size: Option<u32>) -> Self {
         Type::List(Box::new(type_), size)
     }
     pub fn tuple(types: impl IntoIterator<Item = Type>) -> Self {
diff --git a/crates/wit-parser/src/ast.rs b/crates/wit-parser/src/ast.rs
@@ -902,7 +902,7 @@ struct Option_<'a> {
 struct List<'a> {
     span: Span,
     ty: Box<Type<'a>>,
-    fixed_size: Option<usize>,
+    fixed_size: Option<u32>,
 }
 
 struct Future<'a> {
@@ -1379,7 +1379,7 @@ impl<'a> Type<'a> {
                 let size = if tokens.eat(Token::Comma)? {
                     let number = tokens.next()?;
                     if let Some((span, Token::Integer)) = number {
-                        let size: usize = tokens.get_span(span).parse()?;
+                        let size: u32 = tokens.get_span(span).parse()?;
                         Some(size)
                     } else {
                         return Err(err_expected(tokens, "fixed size", number).into());
diff --git a/crates/wit-parser/src/ast/resolve.rs b/crates/wit-parser/src/ast/resolve.rs
@@ -91,7 +91,7 @@ enum Key {
     Flags(Vec<String>),
     Tuple(Vec<Type>),
     Enum(Vec<String>),
-    List(Type, Option<usize>),
+    List(Type, Option<u32>),
     Option(Type),
     Result(Option<Type>, Option<Type>),
     Future(Option<Type>),
diff --git a/crates/wit-parser/src/decoding.rs b/crates/wit-parser/src/decoding.rs
@@ -1602,13 +1602,6 @@ impl Registrar<'_> {
             ComponentDefinedType::FixedSizeList(t, elements) => {
                 let ty = match &self.resolve.types[id].kind {
                     TypeDefKind::FixedSizeList(r, elements2) if elements2 == elements => r,
-                    // Note that all cases below have this match and the general
-                    // idea is that once a type is named or otherwise identified
-                    // here there's no need to recurse. The purpose of this
-                    // registrar is to build connections for anonymous types
-                    // that don't otherwise have a name to ensure that they're
-                    // decoded to reuse the same constructs consistently. For
-                    // that reason once something is named we can bail out.
                     TypeDefKind::Type(Type::Id(_)) => return Ok(()),
                     _ => bail!("expected a fixed size {elements} list"),
                 };
diff --git a/crates/wit-parser/src/lib.rs b/crates/wit-parser/src/lib.rs
@@ -569,7 +569,7 @@ pub enum TypeDefKind {
     Option(Type),
     Result(Result_),
     List(Type),
-    FixedSizeList(Type, usize),
+    FixedSizeList(Type, u32),
     Future(Option<Type>),
     Stream(Option<Type>),
     ErrorContext,
@@ -598,7 +598,8 @@ impl TypeDefKind {
             TypeDefKind::Enum(_) => "enum",
             TypeDefKind::Option(_) => "option",
             TypeDefKind::Result(_) => "result",
-            TypeDefKind::List(_) | TypeDefKind::FixedSizeList(..) => "list",
+            TypeDefKind::List(_) => "list",
+            TypeDefKind::FixedSizeList(..) => "fixed size list",
             TypeDefKind::Future(_) => "future",
             TypeDefKind::Stream(_) => "stream",
             TypeDefKind::ErrorContext => "error-context",
diff --git a/crates/wit-parser/src/sizealign.rs b/crates/wit-parser/src/sizealign.rs
@@ -246,7 +246,10 @@ impl SizeAlign {
                 let field_align = self.align(t);
                 let field_size = self.size(t);
                 ElementInfo::new(
-                    ArchitectureSize::new(field_size.bytes * size, field_size.pointers * size),
+                    ArchitectureSize::new(
+                        field_size.bytes.checked_mul(*size as usize).unwrap(),
+                        field_size.pointers.checked_mul(*size as usize).unwrap(),
+                    ),
                     field_align,
                 )
             }
diff --git a/crates/wit-smith/src/generate.rs b/crates/wit-smith/src/generate.rs
@@ -803,7 +803,7 @@ impl<'a> InterfaceGenerator<'a> {
                         Some(fuel) => fuel,
                         None => continue,
                     };
-                    let elements = u.int_in_range(1..=self.config.max_type_parts)?;
+                    let elements = u.int_in_range(1..=self.config.max_type_parts as u32)?;
                     dst.push_str("list<");
                     self.gen_type(u, fuel, dst)?;
                     dst.push_str(&format!(", {elements}>"));

Original file line number	Diff line number	Diff line change
`@@ -606,10 +606,10 @@ impl ComponentDefinedTypeEncoder<'_> {`
`606`	`606`	`}`
`607`	`607`
`608`	`608`	`/// Define a fixed size list type.`
`609`		`- pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: usize) {`
	`609`	`+ pub fn fixed_size_list(self, ty: impl Into<ComponentValType>, elements: u32) {`
`610`	`610`	`self.0.push(0x67);`
`611`	`611`	`ty.into().encode(self.0);`
`612`		`- (elements as u32).encode(self.0);`
	`612`	`+ elements.encode(self.0);`
`613`	`613`	`}`
`614`	`614`
`615`	`615`	`/// Define a tuple type.`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ impl<'a> TypeResolver<'a> {`
`149`	`149`	`Ok(value::Type::list(element_type))`
`150`	`150`	`}`
`151`	`151`
`152`		`- fn resolve_fixed_size_list(&self, element_type: &Type, elements: usize) -> ValueResult {`
	`152`	`+ fn resolve_fixed_size_list(&self, element_type: &Type, elements: u32) -> ValueResult {`
`153`	`153`	`let element_type = self.resolve_type(*element_type)?;`
`154`	`154`	`Ok(value::Type::fixed_size_list(element_type, elements))`
`155`	`155`	`}`
Original file line number	Diff line number	Diff line change
`@@ -231,6 +231,8 @@ define_wasm_features! {`
`231`	`231`	`pub wide_arithmetic: WIDE_ARITHMETIC(1 << 28) = false;`
`232`	`232`	`/// Support for component model async lift/lower ABI, as well as streams, futures, and errors.`
`233`	`233`	`pub component_model_async: COMPONENT_MODEL_ASYNC(1 << 29) = false;`
	`234`	`+ /// Support for fixed size lists`
	`235`	`+ pub component_model_fixed_size_list: COMPONENT_MODEL_FIXED_SIZE_LIST(1 << 30) = false;`
`234`	`236`	`}`
`235`	`237`	`}`
`236`	`238`