post-merge fixes

Author: cpetig

crates/environ/src/component/types_builder.rs

@@ -536,16 +536,24 @@ impl ComponentTypesBuilder {
         self.add_tuple_type(TypeTuple { types, abi })
     }
 
-    fn fixed_size_list_type(&mut self, types: TypesRef<'_>, ty: &ComponentValType, size: u32) -> Result<TypeFixedSizeListIndex> {
+    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 {
+    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));
+        let abi = CanonicalAbiInfo::record((0..size).into_iter().map(|_| element_abi));
         self.add_fixed_size_list_type(TypeFixedSizeList { element, size, abi })
     }
 
@@ -1066,7 +1074,11 @@ impl TypeInformation {
     }
 
     fn fixed_size_lists(&mut self, types: &ComponentTypesBuilder, ty: &TypeFixedSizeList) {
-        self.build_record((0..ty.size).into_iter().map(|_| types.type_information(&ty.element)));
+        self.build_record(
+            (0..ty.size)
+                .into_iter()
+                .map(|_| types.type_information(&ty.element)),
+        );
     }
 
     fn enums(&mut self, _types: &ComponentTypesBuilder, _ty: &TypeEnum) {

crates/environ/src/fact/trampoline.rs

@@ -19,9 +19,9 @@ use crate::component::{
     CanonicalAbiInfo, ComponentTypesBuilder, FLAG_MAY_ENTER, FLAG_MAY_LEAVE, FixedEncoding as FE,
     FlatType, InterfaceType, MAX_FLAT_ASYNC_PARAMS, MAX_FLAT_PARAMS, PREPARE_ASYNC_NO_RESULT,
     PREPARE_ASYNC_WITH_RESULT, StringEncoding, Transcode, TypeComponentLocalErrorContextTableIndex,
-    TypeEnumIndex, TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex, TypeOptionIndex,
-    TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex, TypeStreamTableIndex, TypeTupleIndex,
-    TypeVariantIndex, VariantInfo,
+    TypeEnumIndex, TypeFixedSizeListIndex, TypeFlagsIndex, TypeFutureTableIndex, TypeListIndex,
+    TypeOptionIndex, TypeRecordIndex, TypeResourceTableIndex, TypeResultIndex,
+    TypeStreamTableIndex, TypeTupleIndex, TypeVariantIndex, VariantInfo,
 };
 use crate::fact::signature::Signature;
 use crate::fact::transcode::Transcoder;
@@ -2850,10 +2850,14 @@ impl<'a, 'b> Compiler<'a, 'b> {
         // 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));
+        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);
         }

crates/wasmtime/src/config.rs

@@ -1166,8 +1166,9 @@ impl Config {
     #[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
     }
-    
+
     /// This corresponds to the 📝 emoji in the component model specification.
     ///
     /// Please note that Wasmtime's support for this feature is _very_

crates/wasmtime/src/engine/serialization.rs

@@ -208,7 +208,37 @@ impl Metadata<'_> {
         let engine_target = engine.target();
         let module_target =
             target_lexicon::Triple::from_str(&self.target).map_err(|e| anyhow!(e))?;
+
+        if module_target.architecture != engine_target.architecture {
+            bail!(
+                "Module was compiled for architecture '{}'",
+                module_target.architecture
+            );
+        }
+
+        if module_target.operating_system != engine_target.operating_system {
+            bail!(
+                "Module was compiled for operating system '{}'",
+                module_target.operating_system
+            );
+        }
+
+        Ok(())
+    }
+
+    fn check_shared_flags(&mut self, engine: &Engine) -> Result<()> {
+        for (name, val) in self.shared_flags.iter() {
+            engine
+                .check_compatible_with_shared_flag(name, val)
+                .map_err(|s| anyhow::Error::msg(s))
+                .context("compilation settings of module incompatible with native host")?;
+        }
+        Ok(())
+    }
+
+    fn check_isa_flags(&mut self, engine: &Engine) -> Result<()> {
         for (name, val) in self.isa_flags.iter() {
+            engine
                 .check_compatible_with_isa_flag(name, val)
                 .map_err(|s| anyhow::Error::msg(s))
                 .context("compilation settings of module incompatible with native host")?;