fix: implement deallocation for fixed-length lists with heap elements

The deallocate and deallocate_indirect functions in the core ABI had
incomplete handling for FixedLengthList types. deallocate had a todo!()
that would panic when flat deallocation was needed for fixed-length
lists containing resources. deallocate_indirect was a silent no-op
that would leak memory for fixed-length lists containing heap-allocated
elements like strings or nested lists.

For flat deallocation, reuse flat_for_each_record_type with repeated
element types. For indirect deallocation, reuse deallocate_indirect_fields
with a vec of repeated element types to correctly compute memory offsets
and deallocate each element.

Author: sumleo

.idea/workspace.xml

@@ -2404,7 +2404,13 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 TypeDefKind::Resource => unreachable!(),
                 TypeDefKind::Unknown => unreachable!(),
 
-                TypeDefKind::FixedLengthList(..) => todo!(),
+                TypeDefKind::FixedLengthList(element, size) => {
+                    self.flat_for_each_record_type(
+                        ty,
+                        iter::repeat_n(element, *size as usize),
+                        |me, ty| me.deallocate(ty, what),
+                    );
+                }
                 TypeDefKind::Map(..) => todo!(),
             },
         }
@@ -2526,7 +2532,10 @@ impl<'a, B: Bindgen> Generator<'a, B> {
                 TypeDefKind::Future(_) => unreachable!(),
                 TypeDefKind::Stream(_) => unreachable!(),
                 TypeDefKind::Unknown => unreachable!(),
-                TypeDefKind::FixedLengthList(_, _) => {}
+                TypeDefKind::FixedLengthList(element, size) => {
+                    let tys: Vec<Type> = iter::repeat_n(*element, *size as usize).collect();
+                    self.deallocate_indirect_fields(&tys, addr, offset, what);
+                }
                 TypeDefKind::Map(..) => todo!(),
             },
         }

crates/core/src/abi.rs

@@ -142,6 +142,44 @@ mod newtyped_list {
         }
     }
 }
+
+#[test]
+fn fixed_length_list_deallocation() {
+    let wit = r#"
+        package test:fll-dealloc;
+
+        world test {
+            export return-string-array: func() -> list<string, 3>;
+            export accept-string-array: func(a: list<string, 3>);
+        }
+    "#;
+
+    let mut resolve = wit_bindgen_core::wit_parser::Resolve::default();
+    let pkg = resolve.push_str("test.wit", wit).unwrap();
+    let world = resolve.select_world(&[pkg], None).unwrap();
+
+    let opts = wit_bindgen_rust::Opts {
+        generate_all: true,
+        ..Default::default()
+    };
+
+    let mut generator = opts.build();
+    let mut files = wit_bindgen_core::Files::default();
+    use wit_bindgen_core::WorldGenerator;
+    generator.generate(&mut resolve, world, &mut files).unwrap();
+
+    let (_name, contents) = files.iter().next().unwrap();
+    let code = String::from_utf8_lossy(contents);
+
+    // Verify post-return deallocation functions are generated for
+    // fixed-length lists containing heap-allocated elements (strings)
+    assert!(
+        code.contains("cabi_post_"),
+        "expected cabi_post_ deallocation function for fixed-length list \
+         with string elements, but none was generated"
+    );
+}
+
 #[allow(unused, reason = "testing codegen, not functionality")]
 mod retyped_list {
     use std::ops::Deref;