necessary parts to make the wit-bindgen test pass

Author: cpetig

crates/cli-flags/src/lib.rs

@@ -409,6 +409,9 @@ wasmtime_option_group! {
         pub exceptions: Option<bool>,
         /// Whether or not any GC infrastructure in Wasmtime is enabled or not.
         pub gc_support: Option<bool>,
+        /// Component model support for fixed size lists: this corresponds
+        /// to the 🔧 emoji in the component model specification
+        pub component_model_fixed_size_list: Option<bool>,
     }
 
     enum Wasm {
@@ -1067,6 +1070,7 @@ impl CommonOptions {
             ("component-model-async", component_model_async_stackful, wasm_component_model_async_stackful)
             ("component-model-async", component_model_threading, wasm_component_model_threading)
             ("component-model", component_model_error_context, wasm_component_model_error_context)
+            ("component-model", component_model_fixed_size_list, wasm_component_model_fixed_size_lists)
             ("threads", threads, wasm_threads)
             ("gc", gc, wasm_gc)
             ("gc", reference_types, wasm_reference_types)

crates/environ/src/component/types.rs

@@ -89,6 +89,8 @@ indices! {
     pub struct TypeResultIndex(u32);
     /// Index pointing to a list type in the component model.
     pub struct TypeListIndex(u32);
+    /// Index pointing to a fixed size list type in the component model.
+    pub struct TypeFixedSizeListIndex(u32);
     /// Index pointing to a future type in the component model.
     pub struct TypeFutureIndex(u32);
 
@@ -296,6 +298,7 @@ pub struct ComponentTypes {
     pub(super) stream_tables: PrimaryMap<TypeStreamTableIndex, TypeStreamTable>,
     pub(super) error_context_tables:
         PrimaryMap<TypeComponentLocalErrorContextTableIndex, TypeErrorContextTable>,
+    pub(super) fixed_size_lists: PrimaryMap<TypeFixedSizeListIndex, TypeFixedSizeList>,
 }
 
 impl TypeTrace for ComponentTypes {
@@ -369,6 +372,7 @@ impl ComponentTypes {
             InterfaceType::Enum(i) => &self[*i].abi,
             InterfaceType::Option(i) => &self[*i].abi,
             InterfaceType::Result(i) => &self[*i].abi,
+            InterfaceType::FixedSizeList(i) => &self[*i].abi,
         }
     }
 
@@ -418,6 +422,7 @@ impl_index! {
     impl Index<TypeFutureTableIndex> for ComponentTypes { TypeFutureTable => future_tables }
     impl Index<TypeStreamTableIndex> for ComponentTypes { TypeStreamTable => stream_tables }
     impl Index<TypeComponentLocalErrorContextTableIndex> for ComponentTypes { TypeErrorContextTable => error_context_tables }
+    impl Index<TypeFixedSizeListIndex> for ComponentTypes { TypeFixedSizeList => fixed_size_lists }
 }
 
 // Additionally forward anything that can index `ModuleTypes` to `ModuleTypes`
@@ -595,6 +600,7 @@ pub enum InterfaceType {
     Future(TypeFutureTableIndex),
     Stream(TypeStreamTableIndex),
     ErrorContext(TypeComponentLocalErrorContextTableIndex),
+    FixedSizeList(TypeFixedSizeListIndex),
 }
 
 /// Bye information about a type in the canonical ABI, with metadata for both
@@ -1175,6 +1181,17 @@ pub struct TypeList {
     pub element: InterfaceType,
 }
 
+/// Shape of a "fixed size list" interface type.
+#[derive(Serialize, Deserialize, Clone, Hash, Eq, PartialEq, Debug)]
+pub struct TypeFixedSizeList {
+    /// The element type of the list.
+    pub element: InterfaceType,
+    /// The fixed length of the list.
+    pub size: u32,
+    /// Byte information about this type in the canonical ABI.
+    pub abi: CanonicalAbiInfo,
+}
+
 /// Maximum number of flat types, for either params or results.
 pub const MAX_FLAT_TYPES: usize = if MAX_FLAT_PARAMS > MAX_FLAT_RESULTS {
     MAX_FLAT_PARAMS

crates/environ/src/component/types_builder.rs

@@ -50,6 +50,7 @@ pub struct ComponentTypesBuilder {
     future_tables: HashMap<TypeFutureTable, TypeFutureTableIndex>,
     stream_tables: HashMap<TypeStreamTable, TypeStreamTableIndex>,
     error_context_tables: HashMap<TypeErrorContextTable, TypeComponentLocalErrorContextTableIndex>,
+    fixed_size_lists: HashMap<TypeFixedSizeList, TypeFixedSizeListIndex>,
 
     component_types: ComponentTypes,
     module_types: ModuleTypesBuilder,
@@ -118,6 +119,7 @@ impl ComponentTypesBuilder {
             type_info: TypeInformationCache::default(),
             resources: ResourcesBuilder::default(),
             abstract_resources: 0,
+            fixed_size_lists: HashMap::default(),
         }
     }
 
@@ -456,8 +458,8 @@ impl ComponentTypesBuilder {
             ComponentDefinedType::Stream(ty) => {
                 InterfaceType::Stream(self.stream_table_type(types, ty)?)
             }
-            ComponentDefinedType::FixedSizeList(..) => {
-                bail!("support not implemented for fixed-size-lists");
+            ComponentDefinedType::FixedSizeList(ty, size) => {
+                InterfaceType::FixedSizeList(self.fixed_size_list_type(types, ty, *size)?)
             }
             ComponentDefinedType::Map(..) => {
                 bail!("support not implemented for map type");
@@ -575,6 +577,19 @@ impl ComponentTypesBuilder {
         self.add_tuple_type(TypeTuple { types, abi })
     }
 
+    fn fixed_size_list_type(&mut self, types: TypesRef<'_>, ty: &ComponentValType, size: u32) -> Result<TypeFixedSizeListIndex> {
+        assert_eq!(types.id(), self.module_types.validator_id());
+        let element = self.valtype(types, ty)?;
+        Ok(self.new_fixed_size_list_type(element, size))
+    }
+
+    pub(crate) fn new_fixed_size_list_type(&mut self, element: InterfaceType, size: u32) -> TypeFixedSizeListIndex {
+        let element_abi = self.component_types.canonical_abi(&element);
+        let abi = CanonicalAbiInfo::record(
+            (0..size).into_iter().map(|_| element_abi));
+        self.add_fixed_size_list_type(TypeFixedSizeList { element, size, abi })
+    }
+
     fn flags_type(&mut self, flags: &IndexSet<KebabString>) -> TypeFlagsIndex {
         let flags = TypeFlags {
             names: flags.iter().map(|s| s.to_string()).collect(),
@@ -691,6 +706,11 @@ impl ComponentTypesBuilder {
         intern_and_fill_flat_types!(self, tuples, ty)
     }
 
+    /// Interns a new tuple type within this type information.
+    pub fn add_fixed_size_list_type(&mut self, ty: TypeFixedSizeList) -> TypeFixedSizeListIndex {
+        intern_and_fill_flat_types!(self, fixed_size_lists, ty)
+    }
+
     /// Interns a new variant type within this type information.
     pub fn add_variant_type(&mut self, ty: TypeVariant) -> TypeVariantIndex {
         intern_and_fill_flat_types!(self, variants, ty)
@@ -826,6 +846,7 @@ impl ComponentTypesBuilder {
             InterfaceType::Enum(i) => &self.type_info.enums[*i],
             InterfaceType::Option(i) => &self.type_info.options[*i],
             InterfaceType::Result(i) => &self.type_info.results[*i],
+            InterfaceType::FixedSizeList(i) => &self.type_info.fixed_size_lists[*i],
         }
     }
 }
@@ -935,6 +956,7 @@ struct TypeInformationCache {
     options: PrimaryMap<TypeOptionIndex, TypeInformation>,
     results: PrimaryMap<TypeResultIndex, TypeInformation>,
     lists: PrimaryMap<TypeListIndex, TypeInformation>,
+    fixed_size_lists: PrimaryMap<TypeFixedSizeListIndex, TypeInformation>,
 }
 
 struct TypeInformation {
@@ -1084,6 +1106,10 @@ impl TypeInformation {
         self.build_record(ty.types.iter().map(|t| types.type_information(t)));
     }
 
+    fn fixed_size_lists(&mut self, types: &ComponentTypesBuilder, ty: &TypeFixedSizeList) {
+        self.build_record((0..ty.size).into_iter().map(|_| types.type_information(&ty.element)));
+    }
+
     fn enums(&mut self, _types: &ComponentTypesBuilder, _ty: &TypeEnum) {
         self.depth = 1;
         self.flat.push(FlatType::I32, FlatType::I32);

crates/environ/src/fact/trampoline.rs

@@ -1107,6 +1107,7 @@ impl<'a, 'b> Compiler<'a, 'b> {
             | InterfaceType::Future(_)
             | InterfaceType::Stream(_)
             | InterfaceType::ErrorContext(_) => 1,
+            InterfaceType::FixedSizeList(i) => self.types[*i].size as usize,
         };
 
         match self.fuel.checked_sub(cost) {
@@ -1146,6 +1147,9 @@ impl<'a, 'b> Compiler<'a, 'b> {
                     InterfaceType::ErrorContext(t) => {
                         self.translate_error_context(*t, src, dst_ty, dst)
                     }
+                    InterfaceType::FixedSizeList(t) => {
+                        self.translate_fixed_size_list(*t, src, dst_ty, dst);
+                    }
                 }
             }
 
@@ -2839,6 +2843,31 @@ impl<'a, 'b> Compiler<'a, 'b> {
         }
     }
 
+    fn translate_fixed_size_list(
+        &mut self,
+        src_ty: TypeFixedSizeListIndex,
+        src: &Source<'_>,
+        dst_ty: &InterfaceType,
+        dst: &Destination,
+    ) {
+        let src_ty = &self.types[src_ty];
+        let dst_ty = match dst_ty {
+            InterfaceType::FixedSizeList(t) => &self.types[*t],
+            _ => panic!("expected a fixed size list"),
+        };
+
+        // TODO: subtyping
+        assert_eq!(src_ty.size, dst_ty.size);
+
+        let srcs = src
+            .record_field_srcs(self.types, (0..src_ty.size).into_iter().map(|_| src_ty.element));
+        let dsts = dst
+            .record_field_dsts(self.types, (0..dst_ty.size).into_iter().map(|_| dst_ty.element));
+        for (src, dst) in srcs.zip(dsts) {
+            self.translate(&src_ty.element, &src, &dst_ty.element, &dst);
+        }
+    }
+
     fn translate_variant(
         &mut self,
         src_ty: TypeVariantIndex,

crates/wasmtime/src/config.rs

@@ -1296,6 +1296,16 @@ impl Config {
         self
     }
 
+    /// This corresponds to the 🔧 emoji in the component model specification.
+    ///
+    /// Please note that Wasmtime's support for this feature is _very_
+    /// incomplete.
+    #[cfg(feature = "component-model")]
+    pub fn wasm_component_model_fixed_size_lists(&mut self, enable: bool) -> &mut Self {
+        self.wasm_feature(WasmFeatures::CM_FIXED_SIZE_LIST, enable);
+        self
+    }
+
     /// Configures whether the [Exception-handling proposal][proposal] is enabled or not.
     ///
     /// [proposal]: https://github.com/WebAssembly/exception-handling

crates/wasmtime/src/runtime/component/func/typed.rs

@@ -2895,6 +2895,7 @@ pub fn desc(ty: &InterfaceType) -> &'static str {
         InterfaceType::Future(_) => "future",
         InterfaceType::Stream(_) => "stream",
         InterfaceType::ErrorContext(_) => "error-context",
+        InterfaceType::FixedSizeList(_) => "list<_, N>",
     }
 }
 

crates/wasmtime/src/runtime/component/types.rs

@@ -158,6 +158,7 @@ impl TypeChecker<'_> {
             (InterfaceType::Stream(_), _) => false,
             (InterfaceType::ErrorContext(_), InterfaceType::ErrorContext(_)) => true,
             (InterfaceType::ErrorContext(_), _) => false,
+            (InterfaceType::FixedSizeList(_), _) => todo!(),
         }
     }
 
@@ -855,6 +856,7 @@ impl Type {
             InterfaceType::Future(index) => Type::Future(instance.future_type(*index)),
             InterfaceType::Stream(index) => Type::Stream(instance.stream_type(*index)),
             InterfaceType::ErrorContext(_) => Type::ErrorContext,
+            InterfaceType::FixedSizeList(_) => todo!(),
         }
     }
 

crates/wasmtime/src/runtime/component/values.rs

@@ -215,6 +215,7 @@ impl Val {
             InterfaceType::ErrorContext(_) => {
                 ErrorContext::linear_lift_from_flat(cx, ty, next(src))?.into_val()
             }
+            InterfaceType::FixedSizeList(_) => todo!(),
         })
     }
 
@@ -341,6 +342,7 @@ impl Val {
             InterfaceType::ErrorContext(_) => {
                 ErrorContext::linear_lift_from_memory(cx, ty, bytes)?.into_val()
             }
+            InterfaceType::FixedSizeList(_) => todo!(),
         })
     }
 
@@ -491,6 +493,7 @@ impl Val {
                 )
             }
             (InterfaceType::ErrorContext(_), _) => unexpected(ty, self),
+            (InterfaceType::FixedSizeList(_), _) => todo!(),
         }
     }
 
@@ -644,6 +647,7 @@ impl Val {
                 )
             }
             (InterfaceType::ErrorContext(_), _) => unexpected(ty, self),
+            (InterfaceType::FixedSizeList(_), _) => todo!(),
         }
     }