02b3582 | plum

git clone https://git.pyrossh.dev/plum

A statically typed, imperative programming language inspired by rust, python

02b3582 — Peter John 2026-08-10T13:20:39+05:30

feat(libs/std): implement List's add/set/removeAt/remove/clear/reverse on wasm-gc

Files changed (4) hide show

docs/superpowers/plans/2026-07-25-wasm-gc-migration.md +19 -9
libs/std/list.plum +81 -11
plum-wasm-codegen/src/lib.rs +91 -29
plum-wasm-codegen/tests/codegen_tests.rs +218 -0

docs/superpowers/plans/2026-07-25-wasm-gc-migration.md CHANGED Viewed

@@ -196,15 +196,25 @@ git commit -m "feat(plum-wasm-codegen): migrate structs, enums, strings, and clo
 - Consumes: `struct.new`/`struct.set`/`ref null` field semantics from Task 2 — specifically, that unlinking a `Node` (overwriting a `next`/`prev` field with `None`) makes it unreachable and GC-reclaimed with no explicit free.
 - Produces: `add`, `set`, `removeAt`, `remove`, `clear`, `reverse` on `List[T]` (currently `todo`) have real implementations; `Map` (built on `List`) works transitively.
-- [ ] **Step 1: Read `libs/std/list.plum`'s current `Node`/`List` field declarations and the already-implemented `get`/`length`/`each`/`map` methods** for the established style (`Option[Node]` traversal via `match current`) to match.
-- [ ] **Step 2: Implement `add`** — append (or prepend, per the existing doc comment on `add` — re-read it; the comment currently says "adds the specified elements to the start of the list" — confirm this is the intended semantic, since "add" more commonly means append, and fix the comment or the implementation, whichever is actually wrong, rather than silently implementing whichever is more convenient) by splicing a new `Node` in via `self.tail`/`self.head` and updating `size`.
-- [ ] **Step 3: Implement `set`** — traverse to index `i` (mirroring `get`'s traversal), overwrite the found node's `value` field, return `Some(oldValue)` or `None` if out of bounds.
-- [ ] **Step 4: Implement `removeAt`/`remove`** — traverse to the target node, splice it out by rewriting its neighbors' `prev`/`next` to point at each other (or to `None` at the list's ends, updating `self.head`/`self.tail` accordingly), decrement `size`. The removed node becomes unreachable once nothing points to it — no manual free needed.
-- [ ] **Step 5: Implement `clear`** — reset `self.head`/`self.tail` to `None` and `size` to `0`; every node becomes unreachable transitively.
-- [ ] **Step 6: Implement `reverse`** — build (or in-place relink) a new list with `prev`/`next` swapped at every node.
-- [ ] **Step 7: Add codegen tests** in `plum-wasm-codegen/tests/codegen_tests.rs` for each newly-implemented method, plus one test specifically proving a `Node.next: Option[Node]` field correctly becomes unreachable after `removeAt`/`clear` (per the spec's Testing section) — this can only be an indirect proof (e.g. removing many nodes in a loop and confirming the program still runs correctly and the list's `length`/traversal reflects the removal), since there's no direct "assert this was garbage collected" hook available from a compiled program's own execution.
-- [ ] **Step 8: Run `cargo test --workspace`.** Expected: 100% pass, including new tests.
-- [ ] **Step 9: Commit**
+- [x] **Step 1: Read `libs/std/list.plum`'s current `Node`/`List` field declarations and the already-implemented `get`/`length`/`each`/`map` methods** for the established style (`Option[Node]` traversal via `match current`) to match.
+- [x] **Step 2: Implement `add`** — append (or prepend, per the existing doc comment on `add` — re-read it; the comment currently says "adds the specified elements to the start of the list" — confirm this is the intended semantic, since "add" more commonly means append, and fix the comment or the implementation, whichever is actually wrong, rather than silently implementing whichever is more convenient) by splicing a new `Node` in via `self.tail`/`self.head` and updating `size`. **Was prepend in the doc comment, append in spirit (`makeList` builds in call order) — fixed the comment; implemented as append.**
+- [x] **Step 3: Implement `set`** — traverse to index `i` (mirroring `get`'s traversal), overwrite the found node's `value` field, return `Some(oldValue)` or `None` if out of bounds.
+- [x] **Step 4: Implement `removeAt`/`remove`** — traverse to the target node, splice it out by rewriting its neighbors' `prev`/`next` to point at each other (or to `None` at the list's ends, updating `self.head`/`self.tail` accordingly), decrement `size`. The removed node becomes unreachable once nothing points to it — no manual free needed. **Added a shared `unlink` helper for the splice logic, used by both.**
+- [x] **Step 5: Implement `clear`** — reset `self.head`/`self.tail` to `None` and `size` to `0`; every node becomes unreachable transitively.
+- [x] **Step 6: Implement `reverse`** — build (or in-place relink) a new list with `prev`/`next` swapped at every node. **The pre-existing declared signature was `reverse(self, v: fn(T) -> Bool) -> List` (a leftover, unrelated predicate param — looks copy-pasted from `sort`); fixed to `reverse(self) -> List`.**
+- [x] **Step 7: Add codegen tests** — with an important caveat discovered while writing them (see "Discovered pre-existing gaps" below): `libs/std/list.plum` itself **cannot currently compile** through `plum-wasm-codegen`, for reasons unrelated to Task 3's new method bodies — this was already true of the pre-existing `get`/`each`/`map` before this task touched the file. The tests therefore exercise a field-for-field/statement-for-statement port of the same six methods against a deliberately **non-generic** `Node`/`List`/`NodeLink` (swapping the generic `Option[Node]` for a monomorphic `NodeLink` enum) — this validates the actual wasm-gc mechanics (self-referential nullable-via-enum struct fields, `struct.set` mutation through an aliased reference, `ref.test` dispatch, GC reachability after `removeAt`/`clear`) without depending on the separate, deeper checker gap. Two tests added: `listAddSetRemoveAtRemoveClearReverseAllWorkCorrectly` and `removingEveryNodeInALoopLeavesAnEmptyCorrectlyFunctioningList` (the latter is this step's required unreachability proof).
+- [x] **Step 8: Run `cargo test --workspace`.** 100% pass (211 tests across the workspace), including the new tests.
+- [x] **Step 9: Commit**
+#### Discovered pre-existing gaps (found while implementing this task, NOT fixed — out of scope for "implement List's methods")
+While testing against the REAL generic `List[T]`/`Node[T]`/`Option[Node]` shape, compilation failed with errors like `unknown type 'Option' in GC type registry` and `type name 'None' is not yet supported as a value`. Root cause, confirmed by direct inspection of the monomorphized AST: **`plum_checker::plumTypeFromAst` drops generic type arguments entirely** (`Option[Int]` and bare `Option` both become `PlumType::TNamed("Option")`) — so a class or enum-variant field declared with a concrete instantiation of a generic type (`Node.next: Option[Node]`) keeps referencing the generic type's bare name. Once monomorphization actually specializes that generic type for a concrete argument (renaming it to e.g. `Option$Int` and REMOVING the unspecialized original — confirmed via direct inspection), the field's stored type annotation is left pointing at a name that no longer exists. This is a real, pre-existing gap in `plum-checker`'s generics/monomorphization support (not something Task 2's wasm-gc work introduced — it would misbehave identically under the old bump-allocator representation, just never crash as loudly), and it blocks `libs/std/list.plum`'s `get`/`each`/`map` from compiling too, not just this task's new methods. Properly fixing it needs `PlumType` to represent type applications (not just bare names) and the monomorphizer to rewrite field-type annotations consistently with however it renames the types they reference — a separate, sizable piece of work.
+Two smaller, genuinely wasm-gc-migration-scoped bugs were found and fixed along the way (both covered by the existing/new test suite):
+- `Expr::Compare`'s codegen unconditionally emitted `i64.eq`/`i64.ne` for any non-`Float` comparison — correct when `Bool`/enums were `i32`, but wrong now that they're wasm-gc refs. Fixed to emit `ref.eq` for `==`/`!=` between reference-typed operands (`plum-wasm-codegen/src/lib.rs`).
+- Method calls (`self.method(...)`/`obj.method(...)`) never packed trailing arguments into a GC array for a method with a variadic (`...T`) parameter — only plain function calls did. `add(self, values: ...T)` was the first variadic *method* anywhere in the codebase, which is how this surfaced. Fixed by porting the same variadic-packing logic to the method-call codegen path.
+Also found (not fixed, not wasm-gc-related): plum's grammar's `class_call` rule requires named (`field: value`) arguments — there is no positional class-construction syntax — so the pre-existing `makeList`'s `List(None, None, 0)` (positional) has never actually compiled either. Left as-is since fixing it also requires resolving a second, separate issue (passing an already-packed variadic array through to another variadic parameter in `List(...).add(values)`).
 ```bash
 git add libs/std/list.plum plum-wasm-codegen/tests/codegen_tests.rs

libs/std/list.plum CHANGED Viewed

@@ -30,33 +30,103 @@ type List[T: Stringable](Stringable) =
           break
     None
-  # sets the element at i'th index of the list
+  # sets the element at i'th index of the list, returning the old value (or None if i is out of bounds)
   fun set(self, i: Int, v: T) -> Option[T] =
+    current = self.head
+    index = 0
+    while current != None
+      match current
+        Some(node) =>
+          if index == i
+            old = node.value
+            node.value = v
+            return Some(old)
+          current = node.next
+          index = index + 1
+        None =>
+          break
-    todo
+    None
   # returns the no of elements in the list
   fun length(self) -> Int =
     self.size
-  # adds the specified elements to the start of the list
+  # adds the specified elements to the end of the list
   fun add(self, values: ...T) =
+    for v in values
+      node = Node(value: v, prev: self.tail, next: None)
+      match self.tail
+        Some(t) =>
+          t.next = Some(node)
+        None =>
+          self.head = Some(node)
+      self.tail = Some(node)
+      self.size = self.size + 1
+  # unlinks node from the list, patching its neighbors (or head/tail) to close the gap
+  fun unlink(self, node: Node) =
-    todo
+    match node.prev
+      Some(p) =>
+        p.next = node.next
+      None =>
+        self.head = node.next
+    match node.next
+      Some(n) =>
+        n.prev = node.prev
+      None =>
+        self.tail = node.prev
+    self.size = self.size - 1
   # removes the element at i'th index of the list
   fun removeAt(self, i: Int) =
+    current = self.head
+    index = 0
+    while current != None
+      match current
+        Some(node) =>
+          if index == i
+            self.unlink(node)
-    todo
+            return
+          current = node.next
+          index = index + 1
+        None =>
+          break
-  # removes the element v from list
+  # removes the first element equal to v from list
   fun remove(self, v: T) =
+    current = self.head
+    while current != None
+      match current
+        Some(node) =>
+          if node.value == v
+            self.unlink(node)
-    todo
+            return
+          current = node.next
+        None =>
+          break
   # removes all objects from this list
   fun clear(self) =
-    todo
+    self.head = None
+    self.tail = None
+    self.size = 0
-  # returns a new list with the elements in reverse order.
+  # returns the list with the elements relinked in reverse order.
-  fun reverse(self, v: fn(T) -> Bool) -> List =
+  fun reverse(self) -> List =
+    current = self.head
+    while current != None
+      match current
+        Some(node) =>
+          next = node.next
+          node.next = node.prev
+          node.prev = next
+          current = next
+        None =>
+          break
+    oldHead = self.head
+    self.head = self.tail
+    self.tail = oldHead
-    todo
+    self
   # returns a new list with the elements sorted by sorter
   fun sort(self, sorter: fn(T) -> Bool) -> List =

plum-wasm-codegen/src/lib.rs CHANGED Viewed

@@ -528,12 +528,19 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
             ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(idx) })
         }
         PlumType::TStr => ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(registry.str_type_idx) }),
-        PlumType::TNamed(name) => {
-            let idx = registry.class_type_idx.get(name)
-                .or_else(|| registry.enum_super_type_idx.get(name))
+        PlumType::TNamed(name) => match registry.class_type_idx.get(name).or_else(|| registry.enum_super_type_idx.get(name)) {
-                .unwrap_or_else(|| panic!("internal codegen error: unknown type '{}' in GC type registry", name));
-            ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(*idx) })
+            Some(idx) => ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(*idx) }),
+            // A field typed as a generic enum/class (e.g. `Node.next: Option[Node]`)
+            // resolves here to the BARE generic name — `ClassEnv`'s `plumTypeFromAst`
+            // has no representation for type arguments, so it can't know this means
+            // `Option$Int` once monomorphization specializes (and removes the
+            // unspecialized) `Option` — same permissive `anyref` fallback as
+            // `plumTypeToValtype` above, for the same "genuinely unmodeled" reason:
+            // `struct.get`/`ref.test`/`ref.cast` all work against `anyref` operands
+            // fine, so a field merely being STORED as `anyref` instead of the exact
+            // concrete type costs nothing but static precision.
+            None => ValType::Ref(RefType::ANYREF),
-        }
+        },
         // TFun (closures) and TVariadic get their own concrete representation once
         // Task 2 (closures/variadic calls) lands — `anyref` is a safe, valid-but-not-
         // yet-meaningful placeholder in the meantime, since nothing consumes it yet.
@@ -3168,29 +3175,50 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             pushBoolRefFromI32Flag(body, ctx);
         }
         ast::Expr::Compare(c) => {
-            let is_float = matches!(inferLocalType(&c.left, ctx), PlumType::TFloat);
+            let left_ty = inferLocalType(&c.left, ctx);
             compileExpr(&c.left, body, ctx, state)?;
             compileExpr(&c.right, body, ctx, state)?;
-            if is_float {
+            match left_ty {
+                PlumType::TFloat => {
-                match c.op {
+                    match c.op {
-                    ast::CmpOp::Lt => Instruction::F64Lt,
+                        ast::CmpOp::Lt => Instruction::F64Lt,
-                    ast::CmpOp::Lte => Instruction::F64Le,
+                        ast::CmpOp::Lte => Instruction::F64Le,
-                    ast::CmpOp::Eq => Instruction::F64Eq,
+                        ast::CmpOp::Eq => Instruction::F64Eq,
-                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::F64Ne,
+                        ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::F64Ne,
-                    ast::CmpOp::Gte => Instruction::F64Ge,
+                        ast::CmpOp::Gte => Instruction::F64Ge,
-                    ast::CmpOp::Gt => Instruction::F64Gt,
+                        ast::CmpOp::Gt => Instruction::F64Gt,
+                    }
+                    .encode(body);
                 }
+                // `TVar`/`TUnit` share `Int`'s `i64` wasm representation (see
+                // `plumTypeToValtype`) — an unresolved generic defaults the same way.
+                PlumType::TInt | PlumType::TVar(_) | PlumType::TUnit => {
+                    match c.op {
+                        ast::CmpOp::Lt => Instruction::I64LtS,
+                        ast::CmpOp::Lte => Instruction::I64LeS,
+                        ast::CmpOp::Eq => Instruction::I64Eq,
+                        ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne,
+                        ast::CmpOp::Gte => Instruction::I64GeS,
+                        ast::CmpOp::Gt => Instruction::I64GtS,
+                    }
-                .encode(body);
+                    .encode(body);
-            } else {
-                match c.op {
-                    ast::CmpOp::Lt => Instruction::I64LtS,
-                    ast::CmpOp::Lte => Instruction::I64LeS,
-                    ast::CmpOp::Eq => Instruction::I64Eq,
-                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => Instruction::I64Ne,
-                    ast::CmpOp::Gte => Instruction::I64GeS,
-                    ast::CmpOp::Gt => Instruction::I64GtS,
                 }
+                // Bool/Str/class/enum values are wasm-gc refs — `==`/`!=` compares
+                // reference identity via `ref.eq`. That's exactly right for a
+                // payload-free singleton (`None`/`True`/`False`, this migration
+                // plan's Decision 2) and for class-instance identity; it's NOT a
+                // deep/structural comparison (two distinct `Str` values holding
+                // equal text compare unequal) — the same caveat this codegen
+                // already had pre-wasm-gc, when it was an i32 POINTER comparison.
+                // Ordering a ref type has no meaning and was never valid.
+                _ => match &c.op {
+                    ast::CmpOp::Eq => Instruction::RefEq.encode(body),
+                    ast::CmpOp::Neq | ast::CmpOp::NotEq2 => {
-                .encode(body);
+                        Instruction::RefEq.encode(body);
+                        Instruction::I32Eqz.encode(body);
+                    }
+                    other => return Err(format!("codegen: '{:?}' is not supported between reference-typed values", other)),
+                },
             }
             pushBoolRefFromI32Flag(body, ctx);
         }
@@ -3362,13 +3390,47 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         .get(&key)
                         .ok_or_else(|| format!("codegen: unknown method '{}.{}'", class_name, call.name))?;
                     compileExpr(&attr.object, body, ctx, state)?; // push self
-                    for arg in &call.args {
+                    fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
-                        let arg_expr = match arg {
+                        match arg {
                             ast::Arg::Positional(e) => e,
                             ast::Arg::Keyword { value, .. } => value,
                             ast::Arg::Pair { value, .. } => value,
+                        }
+                    }
+                    // A trailing `...T` param (e.g. `add(self, values: ...T)`) packs its
+                    // trailing args into one GC array, exactly like a plain function call
+                    // (see the `Expr::FnCall` variadic-call arm) — `call.args` doesn't
+                    // include `self`, matching `ctx.methods`' own param list.
+                    let variadic_split = match ctx.methods.get(&(class_name.clone(), call.name.clone())) {
+                        Some(PlumType::TFun(params, _)) => match params.last() {
+                            Some(PlumType::TVariadic(elem)) => Some(((**elem).clone(), params.len() - 1)),
+                            _ => None,
+                        },
+                        _ => None,
-                        };
+                    };
+                    match variadic_split {
+                        Some((elem_ty, fixed_count)) => {
+                            for arg in call.args.iter().take(fixed_count) {
+                                compileExpr(argExprOf(arg), body, ctx, state)?;
+                            }
+                            let trailing: Vec<&ast::Expr> = call.args.iter().skip(fixed_count).map(argExprOf).collect();
+                            let elem_vt = plumTypeToValtype(&elem_ty);
+                            let array_type_idx = *ctx
+                                .gc_types
+                                .variadic_array_type_idx
+                                .get(&elem_vt)
+                                .ok_or_else(|| "internal codegen error: no variadic array type registered for this elem type".to_string())?;
+                            for arg_expr in &trailing {
-                        compileExpr(arg_expr, body, ctx, state)?;
+                                compileExpr(arg_expr, body, ctx, state)?;
+                            }
+                            Instruction::ArrayNewFixed { array_type_index: array_type_idx, array_size: trailing.len() as u32 }.encode(body);
+                        }
+                        None => {
+                            for arg in &call.args {
+                                compileExpr(argExprOf(arg), body, ctx, state)?;
+                            }
+                        }
                     }
                     Instruction::Call(func_idx).encode(body);
                 }

plum-wasm-codegen/tests/codegen_tests.rs CHANGED Viewed

@@ -2025,3 +2025,221 @@ fun main() -> Int =
     // this task is purely additive, nothing behavioral should have changed.
     assert_eq!(runMain(&bytes), 7);
 }
+/// Task 3 of the wasm-gc migration plan: `libs/std/list.plum`'s `add`/`unlink`/`set`/
+/// `removeAt`/`remove`/`clear`/`reverse`, ported field-for-field/statement-for-statement
+/// from the real file (see that file's identical method bodies), against the
+/// struct.new/struct.get/struct.set representation.
+///
+/// This uses `NodeLink`/`Int` in place of the real file's `Option[Node]`/generic `T`:
+/// `plum-checker`'s monomorphizer mangles a generic type's name once it's specialized
+/// (`Option` -> `Option$Int`) but does NOT rewrite `ClassEnv`/`EnumVariants`' OWN
+/// declared field types to match (`plumTypeFromAst` drops type arguments entirely,
+/// recording a class field typed `Option[Node]` as the bare, now-dangling `TNamed("Option")`)
+/// — a real, pre-existing gap in the checker's generics support, unrelated to and
+/// discovered while working on this migration, that currently blocks the REAL
+/// `libs/std/list.plum` (and its already-existing, unrelated `get`/`each`/`map`
+/// methods) from compiling at all. `NodeLink`/`Node` here are deliberately NOT
+/// generic, sidestepping that gap, so this test still exercises the exact wasm-gc
+/// struct/array mechanics (self-referential nullable-via-enum fields, `struct.set`
+/// mutation through an aliased reference, `ref.test` dispatch) Task 2 built.
+const LIST_SOURCE_PREFIX: &str = "\
+enum NodeLink =
+  | HasNode[Node]
+  | NoNode
+enum Option =
+  | Some[Int]
+  | None
+type Node =
+  value: Int
+  prev: NodeLink
+  next: NodeLink
+type List =
+  head: NodeLink
+  tail: NodeLink
+  size: Int
+  fun get(self, i: Int) -> Option =
+    current = self.head
+    index = 0
+    while current != NoNode
+      match current
+        HasNode(node) =>
+          if index == i
+            return Some(node.value)
+          current = node.next
+          index = index + 1
+        NoNode =>
+          break
+    None
+  fun length(self) -> Int =
+    self.size
+  fun add(self, values: ...Int) =
+    for v in values
+      node = Node(value: v, prev: self.tail, next: NoNode)
+      match self.tail
+        HasNode(t) =>
+          t.next = HasNode(node)
+        NoNode =>
+          self.head = HasNode(node)
+      self.tail = HasNode(node)
+      self.size = self.size + 1
+  fun unlink(self, node: Node) =
+    match node.prev
+      HasNode(p) =>
+        p.next = node.next
+      NoNode =>
+        self.head = node.next
+    match node.next
+      HasNode(n) =>
+        n.prev = node.prev
+      NoNode =>
+        self.tail = node.prev
+    self.size = self.size - 1
+  fun set(self, i: Int, v: Int) -> Option =
+    current = self.head
+    index = 0
+    while current != NoNode
+      match current
+        HasNode(node) =>
+          if index == i
+            old = node.value
+            node.value = v
+            return Some(old)
+          current = node.next
+          index = index + 1
+        NoNode =>
+          break
+    None
+  fun removeAt(self, i: Int) =
+    current = self.head
+    index = 0
+    while current != NoNode
+      match current
+        HasNode(node) =>
+          if index == i
+            self.unlink(node)
+            return
+          current = node.next
+          index = index + 1
+        NoNode =>
+          break
+  fun remove(self, v: Int) =
+    current = self.head
+    while current != NoNode
+      match current
+        HasNode(node) =>
+          if node.value == v
+            self.unlink(node)
+            return
+          current = node.next
+        NoNode =>
+          break
+  fun clear(self) =
+    self.head = NoNode
+    self.tail = NoNode
+    self.size = 0
+  fun reverse(self) -> List =
+    current = self.head
+    while current != NoNode
+      match current
+        HasNode(node) =>
+          next = node.next
+          node.next = node.prev
+          node.prev = next
+          current = next
+        NoNode =>
+          break
+    oldHead = self.head
+    self.head = self.tail
+    self.tail = oldHead
+    self
+fun optSum(o: Option) -> Int =
+  match o
+    Some(v) =>
+      v
+    None =>
+      -1000
+";
+#[test]
+fn listAddSetRemoveAtRemoveClearReverseAllWorkCorrectly() {
+    let src = format!("{LIST_SOURCE_PREFIX}\
+fun main() -> Int =
+  l = List(head: NoNode, tail: NoNode, size: 0)
+  l.add(1, 2, 3, 4, 5)
+  a = l.length()
+  b = optSum(l.get(0))
+  c = optSum(l.get(4))
+  oldVal = optSum(l.set(2, 30))
+  d = optSum(l.get(2))
+  l.removeAt(0)
+  e = l.length()
+  f = optSum(l.get(0))
+  l.remove(30)
+  g = l.length()
+  l.reverse()
+  h = optSum(l.get(0))
+  l.clear()
+  i = l.length()
+  a + b + c + oldVal + d + e + f + g + h + i
+");
+    let source = parse(&src);
+    let bytes = compileSource(&source).expect("compile failed");
+    let result = wasmparser::validate(&bytes);
+    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
+    // add(1,2,3,4,5): a=length=5, b=get(0)=1, c=get(4)=5
+    // set(2,30): oldVal=3, d=get(2)=30 -> list [1,2,30,4,5]
+    // removeAt(0): e=length=4, f=get(0)=2 -> list [2,30,4,5]
+    // remove(30): g=length=3 -> list [2,4,5]
+    // reverse(): h=get(0)=5 -> list [5,4,2]
+    // clear(): i=length=0
+    // 5+1+5+3+30+4+2+3+5+0 = 58
+    assert_eq!(runMain(&bytes), 58);
+}
+/// Proves `removeAt`/`clear` actually detach nodes from the list (not just decrement
+/// `size`) by removing every node one at a time via repeated `removeAt(0)` and
+/// confirming the list ends up correctly empty and reports zero length — the removed
+/// `Node`s (and their `NodeLink` links to each other) become unreachable and eligible
+/// for collection once nothing in the list still points to them, since there's no
+/// direct "assert this was garbage collected" hook available from a compiled
+/// program's own execution.
+#[test]
+fn removingEveryNodeInALoopLeavesAnEmptyCorrectlyFunctioningList() {
+    let src = format!("{LIST_SOURCE_PREFIX}\
+fun main() -> Int =
+  l = List(head: NoNode, tail: NoNode, size: 0)
+  l.add(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
+  i = 0
+  while i < 10
+    l.removeAt(0)
+    i = i + 1
+  afterLoopLength = l.length()
+  isEmpty = optSum(l.get(0))
+  l.add(42)
+  afterReAdd = optSum(l.get(0))
+  afterLoopLength + isEmpty + afterReAdd
+");
+    let source = parse(&src);
+    let bytes = compileSource(&source).expect("compile failed");
+    let result = wasmparser::validate(&bytes);
+    assert!(result.is_ok(), "wasm validation failed: {:?}", result.err());
+    // afterLoopLength=0, isEmpty(get(0) on empty list)=-1000, afterReAdd=42
+    // 0 + -1000 + 42 = -958
+    assert_eq!(runMain(&bytes), -958);
+}