Initial fixed size list implementation

crates/c/src/lib.rs

@@ -1671,6 +1671,16 @@ impl<'a> wit_bindgen_core::AnonymousTypeGenerator<'a> for InterfaceGenerator<'a>
     fn anonymous_type_type(&mut self, _id: TypeId, _ty: &Type, _docs: &Docs) {
         todo!("print_anonymous_type for type");
     }
+
+    fn anonymous_type_fixed_size_list(
+        &mut self,
+        _id: TypeId,
+        _ty: &Type,
+        _size: u32,
+        _docs: &Docs,
+    ) {
+        todo!("print_anonymous_type for fixed size list");
+    }
 }
 
 pub enum CTypeNameInfo<'a> {

crates/core/src/abi.rs

@@ -307,6 +307,28 @@ def_instruction! {
             ty: TypeId,
         } : [2] => [1],
 
+        /// Pops all fields for a fixed list off the stack and then composes them
+        /// into an array.
+        FixedSizeListLift {
+            element: &'a Type,
+            size: u32,
+            id: TypeId,
+        } : [*size as usize] => [1],
+
+        /// Pops an array off the stack, decomposes the elements and then pushes them onto the stack.
+        FixedSizeListLower {
+            element: &'a Type,
+            size: u32,
+            id: TypeId,
+        } : [1] => [*size as usize],
+
+        /// Pops an array and an address off the stack, passes each element to a block storing it
+        FixedSizeListLowerMemory {
+            element: &'a Type,
+            size: u32,
+            id: TypeId,
+        } : [2] => [0],
+
         /// Pushes an operand onto the stack representing the list item from
         /// each iteration of the list.
         ///
@@ -832,7 +854,7 @@ fn needs_deallocate(resolve: &Resolve, ty: &Type, what: Deallocate) -> bool {
             TypeDefKind::Flags(_) | TypeDefKind::Enum(_) => false,
             TypeDefKind::Future(_) | TypeDefKind::Stream(_) => what.handles(),
             TypeDefKind::Unknown => unreachable!(),
-            TypeDefKind::FixedSizeList(..) => todo!(),
+            TypeDefKind::FixedSizeList(t, _) => needs_deallocate(resolve, t, what),
         },
 
         Type::Bool
@@ -1444,7 +1466,21 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                     });
                 }
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(..) => todo!(),
+                TypeDefKind::FixedSizeList(ty, size) => {
+                    self.emit(&FixedSizeListLower {
+                        element: ty,
+                        size: *size,
+                        id,
+                    });
+                    let mut values = self
+                        .stack
+                        .drain(self.stack.len() - (*size as usize)..)
+                        .collect::<Vec<_>>();
+                    for value in values.drain(..) {
+                        self.stack.push(value);
+                        self.lower(ty);
+                    }
+                }
             },
         }
     }
@@ -1627,7 +1663,24 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                     });
                 }
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(..) => todo!(),
+                TypeDefKind::FixedSizeList(ty, size) => {
+                    let temp = flat_types(self.resolve, ty).unwrap();
+                    let flat_per_elem = temp.to_vec().len();
+                    let flatsize = flat_per_elem * (*size as usize);
+                    let mut lowered_args = self
+                        .stack
+                        .drain(self.stack.len() - flatsize..)
+                        .collect::<Vec<_>>();
+                    for _ in 0..*size {
+                        self.stack.extend(lowered_args.drain(..flat_per_elem));
+                        self.lift(ty);
+                    }
+                    self.emit(&FixedSizeListLift {
+                        element: ty,
+                        size: *size,
+                        id,
+                    });
+                }
             },
         }
     }
@@ -1809,7 +1862,21 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 }
 
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(..) => todo!(),
+                TypeDefKind::FixedSizeList(element, size) => {
+                    // resembles write_list_to_memory
+                    self.push_block();
+                    self.emit(&IterElem { element });
+                    self.emit(&IterBasePointer);
+                    let elem_addr = self.stack.pop().unwrap();
+                    self.write_to_memory(element, elem_addr, offset);
+                    self.finish_block(0);
+                    self.stack.push(addr);
+                    self.emit(&FixedSizeListLowerMemory {
+                        element,
+                        size: *size,
+                        id,
+                    });
+                }
             },
         }
     }
@@ -1996,7 +2063,19 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 }
 
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(..) => todo!(),
+                TypeDefKind::FixedSizeList(ty, size) => {
+                    let increment = self.bindgen.sizes().size(ty);
+                    let mut position = offset;
+                    for _ in 0..*size {
+                        self.read_from_memory(ty, addr.clone(), position);
+                        position = position + increment;
+                    }
+                    self.emit(&FixedSizeListLift {
+                        element: ty,
+                        size: *size,
+                        id,
+                    });
+                }
             },
         }
     }
@@ -2305,7 +2384,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 TypeDefKind::Future(_) => unreachable!(),
                 TypeDefKind::Stream(_) => unreachable!(),
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(..) => todo!(),
+                TypeDefKind::FixedSizeList(_, _) => {}
             },
         }
     }

crates/core/src/lib.rs

@@ -195,6 +195,7 @@ pub trait AnonymousTypeGenerator<'a> {
     fn anonymous_type_option(&mut self, id: TypeId, ty: &Type, docs: &Docs);
     fn anonymous_type_result(&mut self, id: TypeId, ty: &Result_, docs: &Docs);
     fn anonymous_type_list(&mut self, id: TypeId, ty: &Type, docs: &Docs);
+    fn anonymous_type_fixed_size_list(&mut self, id: TypeId, ty: &Type, size: u32, docs: &Docs);
     fn anonymous_type_future(&mut self, id: TypeId, ty: &Option<Type>, docs: &Docs);
     fn anonymous_type_stream(&mut self, id: TypeId, ty: &Option<Type>, docs: &Docs);
     fn anonymous_type_type(&mut self, id: TypeId, ty: &Type, docs: &Docs);
@@ -217,7 +218,9 @@ pub trait AnonymousTypeGenerator<'a> {
             TypeDefKind::Future(f) => self.anonymous_type_future(id, f, &ty.docs),
             TypeDefKind::Stream(s) => self.anonymous_type_stream(id, s, &ty.docs),
             TypeDefKind::Handle(handle) => self.anonymous_type_handle(id, handle, &ty.docs),
-            TypeDefKind::FixedSizeList(..) => todo!(),
+            TypeDefKind::FixedSizeList(t, size) => {
+                self.anonymous_type_fixed_size_list(id, t, *size, &ty.docs)
+            }
             TypeDefKind::Unknown => unreachable!(),
         }
     }

crates/core/src/types.rs

@@ -203,7 +203,9 @@ impl Types {
                 // should use the same ownership semantics as `own<T>`
                 info.has_own_handle = true;
             }
-            TypeDefKind::FixedSizeList(..) => todo!(),
+            TypeDefKind::FixedSizeList(ty, _) => {
+                info = self.type_info(resolve, ty);
+            }
             TypeDefKind::Unknown => unreachable!(),
         }
         let prev = self.type_info.insert(ty, info);

crates/cpp/src/lib.rs

@@ -74,6 +74,7 @@ struct Includes {
     // needs wit types
     needs_wit: bool,
     needs_memory: bool,
+    needs_array: bool,
 }
 
 #[derive(Default)]
@@ -399,6 +400,9 @@ impl Cpp {
         if self.dependencies.needs_memory {
             self.include("<memory>");
         }
+        if self.dependencies.needs_array {
+            self.include("<array>");
+        }
         if self.dependencies.needs_bit {
             self.include("<bit>");
         }
@@ -1579,7 +1583,13 @@ impl CppInterfaceGenerator<'_> {
                 TypeDefKind::Future(_) => todo!(),
                 TypeDefKind::Stream(_) => todo!(),
                 TypeDefKind::Type(ty) => self.type_name(ty, from_namespace, flavor),
-                TypeDefKind::FixedSizeList(_, _) => todo!(),
+                TypeDefKind::FixedSizeList(ty, size) => {
+                    self.r#gen.dependencies.needs_array = true;
+                    format!(
+                        "std::array<{}, {size}>",
+                        self.type_name(ty, from_namespace, flavor)
+                    )
+                }
                 TypeDefKind::Unknown => todo!(),
             },
             Type::ErrorContext => todo!(),
@@ -2438,7 +2448,57 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                     results.push(move_if_necessary(&result));
                 }
             }
-            abi::Instruction::IterElem { .. } => results.push("IterElem".to_string()),
+            abi::Instruction::FixedSizeListLift {
+                element,
+                size,
+                id: _,
+            } => {
+                let tmp = self.tmp();
+                let result = format!("result{tmp}");
+                let typename = self
+                    .gen
+                    .type_name(element, &self.namespace, Flavor::InStruct);
+                self.push_str(&format!("std::array<{typename}, {size}> {result} = {{",));
+                for a in operands.drain(0..(*size as usize)) {
+                    self.push_str(&a);
+                    self.push_str(", ");
+                }
+                self.push_str("};\n");
+                results.push(result);
+            }
+            abi::Instruction::FixedSizeListLower { .. } => todo!(),
+            abi::Instruction::FixedSizeListLowerMemory {
+                element,
+                size: elemsize,
+                id: _,
+            } => {
+                let body = self.blocks.pop().unwrap();
+                let vec = operands[0].clone();
+                let target = operands[1].clone();
+                let size = self.r#gen.sizes.size(element);
+                let size_str = size.format(POINTER_SIZE_EXPRESSION);
+                let typename = self
+                    .r#gen
+                    .type_name(element, &self.namespace, Flavor::InStruct);
+                let ptr_type = self.r#gen.r#gen.opts.ptr_type();
+                self.push_str(&format!(
+                    "{{
+                    {ptr_type} outer_base = {target};\n"
+                ));
+                let target: String = "outer_base".into();
+                self.push_str(&format!(
+                    "std::array<{typename}, {elemsize}>& outer_vec = {vec};\n"
+                ));
+                let vec: String = "outer_vec".into();
+                self.push_str(&format!("for (unsigned i = 0; i<{vec}.size(); ++i) {{\n",));
+                self.push_str(&format!(
+                    "{ptr_type} base = {target} + i * {size_str};
+                     {typename}& iter_elem = {vec}[i];\n"
+                ));
+                self.push_str(&body.0);
+                self.push_str("\n}\n}\n");
+            }
+            abi::Instruction::IterElem { .. } => results.push("iter_elem".to_string()),
             abi::Instruction::IterBasePointer => results.push("base".to_string()),
             abi::Instruction::RecordLower { record, .. } => {
                 let op = &operands[0];
@@ -2975,7 +3035,7 @@ impl<'a, 'b> Bindgen for FunctionBindgen<'a, 'b> {
                             self.src.push_str(">(");
                         }
                         if *amt == 1 {
-                            if operands[0].starts_with("std::move(") {
+                            if operands[0].starts_with("std::move(") && !operands[0].contains('.') {
                                 // remove the std::move due to return value optimization (and complex rules about when std::move harms)
                                 self.src.push_str(&operands[0][9..]);
                             } else {

crates/csharp/src/function.rs

@@ -1251,7 +1251,10 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::ErrorContextLower { .. }
             | Instruction::ErrorContextLift { .. }
             | Instruction::DropHandle { .. }
-            => todo!(),
+             => todo!(),
+            Instruction::FixedSizeListLift { .. } => todo!(),
+            Instruction::FixedSizeListLower { .. } => todo!(),
+            Instruction::FixedSizeListLowerMemory { .. } => todo!(),
         }
     }
 

crates/moonbit/src/lib.rs

@@ -2668,6 +2668,9 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             | Instruction::ErrorContextLower { .. }
             | Instruction::ErrorContextLift { .. }
             | Instruction::DropHandle { .. } => todo!(),
+            Instruction::FixedSizeListLift { .. } => todo!(),
+            Instruction::FixedSizeListLower { .. } => todo!(),
+            Instruction::FixedSizeListLowerMemory { .. } => todo!(),
         }
     }
 

crates/rust/src/bindgen.rs

@@ -777,6 +777,24 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                 results.push(len);
             }
 
+            Instruction::FixedSizeListLowerMemory {
+                element,
+                size: _,
+                id: _,
+            } => {
+                let body = self.blocks.pop().unwrap();
+                let vec = operands[0].clone();
+                let target = operands[1].clone();
+                let size = self.r#gen.sizes.size(element);
+                self.push_str(&format!("for (i, e) in {vec}.into_iter().enumerate() {{\n",));
+                self.push_str(&format!(
+                    "let base = {target}.add(i * {});\n",
+                    size.format(POINTER_SIZE_EXPRESSION)
+                ));
+                self.push_str(&body);
+                self.push_str("\n}\n");
+            }
+
             Instruction::ListLift { element, .. } => {
                 let body = self.blocks.pop().unwrap();
                 let tmp = self.tmp();
@@ -1190,6 +1208,30 @@ impl Bindgen for FunctionBindgen<'_, '_> {
             Instruction::DropHandle { .. } => {
                 uwriteln!(self.src, "let _ = {};", operands[0]);
             }
+            Instruction::FixedSizeListLift {
+                element: _,
+                size,
+                id: _,
+            } => {
+                let tmp = self.tmp();
+                let result = format!("result{tmp}");
+                self.push_str(&format!("let {result} = [",));
+                for a in operands.drain(0..(*size as usize)) {
+                    self.push_str(&a);
+                    self.push_str(", ");
+                }
+                self.push_str("];\n");
+                results.push(result);
+            }
+            Instruction::FixedSizeListLower {
+                element: _,
+                size,
+                id: _,
+            } => {
+                for i in 0..(*size as usize) {
+                    results.push(format!("{}[{i}]", operands[0]));
+                }
+            }
         }
     }
 }

crates/rust/src/interface.rs

@@ -2982,4 +2982,17 @@ impl<'a, 'b> wit_bindgen_core::AnonymousTypeGenerator<'a> for AnonTypeGenerator<
         self.interface.print_optional_ty(ty.as_ref(), mode);
         self.interface.push_str(">");
     }
+
+    fn anonymous_type_fixed_size_list(&mut self, _id: TypeId, ty: &Type, size: u32, _docs: &Docs) {
+        self.interface.push_str("[");
+        self.interface.print_ty(
+            ty,
+            TypeMode {
+                lifetime: None,
+                lists_borrowed: false,
+                style: TypeOwnershipStyle::Owned,
+            },
+        );
+        self.interface.push_str(&format!("; {size}]"));
+    }
 }

crates/test/Cargo.toml

@@ -24,9 +24,10 @@ regex = "1.11.1"
 serde = { workspace = true }
 toml = "0.8.20"
 wasi-preview1-component-adapter-provider = "30.0.2"
-wac-parser = "0.6.1"
-wac-types = "0.6.1"
-wac-graph = "0.6.1"
+# We need https://github.com/bytecodealliance/wac/pull/156 which isn't released, yet
+wac-parser = { git = "https://github.com/bytecodealliance/wac" }
+wac-types = { git = "https://github.com/bytecodealliance/wac" }
+wac-graph = { git = "https://github.com/bytecodealliance/wac" }
 wasm-compose = { workspace = true }
 indexmap = { workspace = true }
 wasm-encoder = { workspace = true }