fix: support named fixed-length list types in code generation (#1537)

The `define_type` function dispatches to `type_fixed_length_list` on the
`InterfaceGenerator` trait for named fixed-length list types like
`type my-array = list<u32, 4>`.

This makes `type_fixed_length_list` a required trait method (no default)
and adds implementations in all backends:

- Rust: generates `pub type Name = [T; N];`
- Go: generates `type Name = [N]Type`
- Markdown: delegates to `type_alias`
- Moonbit: no-op (maps to `FixedArray[T]` natively)
- C, C++, C#: explicit `todo!()` (not yet supported)

Also adds a shared codegen test in `tests/codegen/named-fixed-length-list.wit`
with expected failures for backends that don't yet support this.

Author: sumleo

crates/c/src/lib.rs

@@ -1735,6 +1735,17 @@ void __wasm_export_{ns}_{snake}_dtor({ns}_{snake}_t* arg) {{
         self.finish_typedef_struct(id);
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        _id: TypeId,
+        _name: &str,
+        _ty: &Type,
+        _size: u32,
+        _docs: &Docs,
+    ) {
+        todo!("named fixed-length list types are not yet supported in the C backend")
+    }
+
     fn type_future(&mut self, id: TypeId, _name: &str, _ty: &Option<Type>, docs: &Docs) {
         self.src.h_defs("\n");
         self.docs(docs, SourceType::HDefs);

crates/core/src/lib.rs

@@ -165,6 +165,7 @@ pub trait InterfaceGenerator<'a> {
     fn type_enum(&mut self, id: TypeId, name: &str, enum_: &Enum, docs: &Docs);
     fn type_alias(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_list(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
+    fn type_fixed_length_list(&mut self, id: TypeId, name: &str, ty: &Type, size: u32, docs: &Docs);
     fn type_builtin(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs);
     fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs);
     fn type_stream(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs);
@@ -199,7 +200,9 @@ where
         TypeDefKind::Future(t) => generator.type_future(id, name, t, &ty.docs),
         TypeDefKind::Stream(t) => generator.type_stream(id, name, t, &ty.docs),
         TypeDefKind::Handle(_) => panic!("handle types do not require definition"),
-        TypeDefKind::FixedLengthList(..) => todo!(),
+        TypeDefKind::FixedLengthList(t, size) => {
+            generator.type_fixed_length_list(id, name, t, *size, &ty.docs)
+        }
         TypeDefKind::Map(..) => todo!(),
         TypeDefKind::Unknown => unreachable!(),
     }

crates/cpp/src/lib.rs

@@ -2221,6 +2221,17 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for CppInterfaceGenerator<'a>
         // nothing to do here
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        _id: TypeId,
+        _name: &str,
+        _ty: &wit_bindgen_core::wit_parser::Type,
+        _size: u32,
+        _docs: &wit_bindgen_core::wit_parser::Docs,
+    ) {
+        todo!("named fixed-length list types are not yet supported in the C++ backend")
+    }
+
     fn type_builtin(
         &mut self,
         _id: TypeId,

crates/csharp/src/interface.rs

@@ -1544,6 +1544,17 @@ impl<'a> CoreInterfaceGenerator<'a> for InterfaceGenerator<'a> {
         self.type_name(&Type::Id(id));
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        _id: TypeId,
+        _name: &str,
+        _ty: &Type,
+        _size: u32,
+        _docs: &Docs,
+    ) {
+        todo!("named fixed-length list types are not yet supported in the C# backend")
+    }
+
     fn type_builtin(&mut self, _id: TypeId, _name: &str, _ty: &Type, _docs: &Docs) {
         unimplemented!();
     }

crates/go/src/lib.rs

@@ -2874,6 +2874,13 @@ const (
         uwriteln!(self.src, "{docs}type {name} = []{ty}");
     }
 
+    fn type_fixed_length_list(&mut self, _: TypeId, name: &str, ty: &Type, size: u32, docs: &Docs) {
+        let name = name.to_upper_camel_case();
+        let ty = self.type_name(self.resolve, *ty);
+        let docs = format_docs(docs);
+        uwriteln!(self.src, "{docs}type {name} = [{size}]{ty}");
+    }
+
     fn type_builtin(&mut self, id: TypeId, name: &str, ty: &Type, docs: &Docs) {
         _ = (id, name, ty, docs);
         todo!()

crates/markdown/src/lib.rs

@@ -650,6 +650,17 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
         self.type_alias(id, name, &Type::Id(id), docs);
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        id: TypeId,
+        name: &str,
+        _ty: &Type,
+        _size: u32,
+        docs: &Docs,
+    ) {
+        self.type_alias(id, name, &Type::Id(id), docs);
+    }
+
     fn type_future(&mut self, id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
         _ = (id, name, ty, docs);
         todo!()

crates/moonbit/src/lib.rs

@@ -1319,6 +1319,17 @@ impl<'a> wit_bindgen_core::InterfaceGenerator<'a> for InterfaceGenerator<'a> {
         // Not needed. They will become `Array[T]` or `FixedArray[T]` in Moonbit
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        _id: TypeId,
+        _name: &str,
+        _ty: &Type,
+        _size: u32,
+        _docs: &Docs,
+    ) {
+        // Not needed. They will become `FixedArray[T]` in Moonbit
+    }
+
     fn type_future(&mut self, _id: TypeId, _name: &str, _ty: &Option<Type>, _docs: &Docs) {
         unimplemented!() // Not needed
     }

crates/rust/src/interface.rs

@@ -2889,6 +2889,24 @@ impl<'a> {camel}Borrow<'a>{{
         }
     }
 
+    fn type_fixed_length_list(
+        &mut self,
+        id: TypeId,
+        _name: &str,
+        ty: &Type,
+        size: u32,
+        docs: &Docs,
+    ) {
+        for (name, mode) in self.modes_of(id) {
+            self.rustdoc(docs);
+            self.push_str(&format!("pub type {name}"));
+            self.print_generics(mode.lifetime);
+            self.push_str(" = [");
+            self.print_ty(ty, mode);
+            self.push_str(&format!("; {size}];\n"));
+        }
+    }
+
     fn type_future(&mut self, _id: TypeId, name: &str, ty: &Option<Type>, docs: &Docs) {
         let async_support = self.r#gen.async_support_path();
         let mode = TypeMode {

crates/test/src/c.rs

@@ -52,11 +52,11 @@ impl LanguageMethods for C {
 
     fn should_fail_verify(
         &self,
-        _name: &str,
+        name: &str,
         config: &crate::config::WitConfig,
         _args: &[String],
     ) -> bool {
-        config.error_context
+        config.error_context || name.starts_with("named-fixed-length-list.wit")
     }
 
     fn codegen_test_variants(&self) -> &[(&str, &[&str])] {

crates/test/src/cpp.rs

@@ -46,7 +46,7 @@ impl LanguageMethods for Cpp {
         _args: &[String],
     ) -> bool {
         return match name {
-            "issue1514-6.wit" => true,
+            "issue1514-6.wit" | "named-fixed-length-list.wit" => true,
             _ => false,
         } || config.async_;
     }