more fixed list implementation

Author: cpetig

crates/core/src/abi.rs

@@ -1371,7 +1371,17 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                     });
                 }
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(_, _) => todo!(),
+                TypeDefKind::FixedSizeList(ty, size) => {
+                    self.emit(&FixedSizeListLower { elements: 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);
+                    }
+                }
             },
         }
     }
@@ -1740,7 +1750,15 @@ 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.write_to_memory(ty, addr.clone(), position);
+                        position = position + increment;
+                    }
+                    self.emit(&FixedSizeListLower { elements: ty, size: *size, id });
+                }
             },
         }
     }
@@ -1927,7 +1945,15 @@ 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 { elements: ty, size: *size, id });
+                }
             },
         }
     }
@@ -2110,7 +2136,7 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 TypeDefKind::Future(_) => todo!("read future from memory"),
                 TypeDefKind::Stream(_) => todo!("read stream from memory"),
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedSizeList(_, _) => todo!(),
+                TypeDefKind::FixedSizeList(_, _) => {}
             },
         }
     }

crates/rust/src/bindgen.rs

@@ -1202,8 +1202,24 @@ impl Bindgen for FunctionBindgen<'_, '_> {
                     align = align.format(POINTER_SIZE_EXPRESSION)
                 ));
             }
-            Instruction::FixedSizeListLift { .. } => todo!(),
-            Instruction::FixedSizeListLower { .. } => todo!(),
+            Instruction::FixedSizeListLift { elements: _, size, id: _ } => {
+                let tmp = self.tmp();
+                let result = format!("result{tmp}");
+                self.push_str(&format!(
+                    "let mut {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 { elements: _, size, id: _ } => {
+                for i in 0..(*size as usize) {
+                    results.push(format!("{}[{i}]", operands[0]));
+                }
+            }
         }
     }
 }

crates/rust/src/interface.rs

@@ -2933,7 +2933,9 @@ impl<'a, 'b> wit_bindgen_core::AnonymousTypeGenerator<'a> for AnonTypeGenerator<
         self.interface.push_str(">");
     }
 
-    fn anonymous_type_fixed_size_list(&mut self, _id: TypeId, _ty: &Type, _size: u32, _docs: &Docs) {
-        todo!()
+    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}]"));
     }
 }

tests/runtime/fixed-size-list/test.wit

@@ -3,6 +3,7 @@ package test:lists;
 interface to-test {
   list-param: func(a: list<u32, 4>);
   list-param2: func(a: list<list<u32, 2>, 2>);
+  list-param3: func(a: list<s32, 20>);
   list-result: func() -> list<u8, 8>;
 
   list-minmax16: func(a: list<u16, 4>, b: list<s16, 4>) -> tuple<list<u16, 4>, list<s16, 4>>;