add enough implementation to make wasmtime compile

Author: cpetig

crates/c-api/src/component/types/val.rs

@@ -32,6 +32,7 @@ pub enum wasmtime_component_valtype_t {
     Stream(Box<wasmtime_component_stream_type_t>),
     ErrorContext,
     Map(Box<wasmtime_component_map_type_t>),
+    FixedLengthList(Box<wasmtime_component_list_type_t>),
 }
 
 impl From<Type> for wasmtime_component_valtype_t {
@@ -63,6 +64,7 @@ impl From<Type> for wasmtime_component_valtype_t {
             Type::Future(ty) => Self::Future(Box::new(ty.into())),
             Type::Stream(ty) => Self::Stream(Box::new(ty.into())),
             Type::Map(ty) => Self::Map(Box::new(ty.into())),
+            Type::FixedLengthList(ty) => Self::FixedLengthList(Box::new(ty.into())),
             Type::ErrorContext => Self::ErrorContext,
         }
     }

crates/c-api/src/component/val.rs

@@ -274,6 +274,7 @@ pub enum wasmtime_component_val_t {
     Flags(wasmtime_component_valflags_t),
     Resource(Box<wasmtime_component_resource_any_t>),
     Map(wasmtime_component_valmap_t),
+    FixedLengthList(wasmtime_component_vallist_t),
 }
 
 // Safety: the C API async contract (documented in async.h) guarantees that
@@ -321,6 +322,7 @@ impl From<&wasmtime_component_val_t> for Val {
             wasmtime_component_val_t::Flags(x) => Val::Flags(x.into()),
             wasmtime_component_val_t::Map(x) => Val::Map(x.into()),
             wasmtime_component_val_t::Resource(x) => Val::Resource(x.resource),
+            wasmtime_component_val_t::FixedSizeList(x) => Val::FixedSizeList(x.into()),
         }
     }
 }
@@ -363,6 +365,9 @@ impl From<&Val> for wasmtime_component_val_t {
             Val::Future(_) => todo!(),
             Val::Stream(_) => todo!(),
             Val::ErrorContext(_) => todo!(),
+            Val::FixedSizeList(ty) => wasmtime_component_val_t::FixedSizeList(
+                wasmtime_component_vallist_t::from(ty.as_ref()),
+            ),
         }
     }
 }

crates/fuzzing/src/oracles/component_api.rs

@@ -138,6 +138,11 @@ fn arbitrary_val(
                 })
                 .collect::<arbitrary::Result<_>>()?,
         ),
+        Type::FixedSizeList(list) => Val::FixedSizeList(
+            (0..list.size())
+                .map(|_| arbitrary_val(&list.ty(), input))
+                .collect::<arbitrary::Result<_>>()?,
+        ),
 
         Type::Map(map) => {
             let mut pairs = Vec::new();

crates/wast/src/component.rs

@@ -291,6 +291,7 @@ fn mismatch(expected: &ComponentConst<'_>, actual: &Val) -> Result<()> {
         Val::Stream(..) => "stream",
         Val::ErrorContext(..) => "error-context",
         Val::Map(..) => "map",
+        Val::FixedLengthList(..) => "list<_, N>",
     };
     bail!("expected `{expected}` got `{actual}`")
 }