6b983a7 | plum | pyrossh

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

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

6b983a7 — Peter John 2026-11-02T19:20:27+05:30

checker: infer field-assignment statements in closure bodies

Files changed (4) hide show

docs/plans/2026-11-02-traits.review.md +6 -0
plum-checker/src/lib.rs +4 -2
plum-checker/tests/checker_tests.rs +40 -0
plum-wasm-codegen/tests/codegen_tests.rs +53 -0

docs/plans/2026-11-02-traits.review.md CHANGED Viewed

@@ -42,6 +42,7 @@ for e := range scene.entities
 | Code generation | Emits the field reads and writes, and checks the dispatch and conversion paths reused from union enums | M | a careful helper |
 | Formatter and editor | Formats traits idempotently; hover, completion and go-to-definition for embedded fields | M | a fast helper |
 | Docs and example | README section, an example program with tests, and a game-style example (Scene of Entity values) | S | a fast helper |
+| Scene → `Actor` trait | Migrates `std/game/Scene` from closure-based nodes (`act: fn(Node, Float)`) to libGDX Scene2D-style subclassing: a `trait Actor(x, y, width, height, originX, originY, scaleX, scaleY, rotation, color, visible, children: List[Actor], …)` with default `act`/`draw`/`hit` methods that games override by embedding it (`record Unit(Actor, hp: Int)`); keeps z-index, `sortChildren`, culling and `Stage`; updates `plum-examples/scene.plum`, the stress fixtures and the README; benchmarks against the closure version | M | a careful helper |
 ## How it fits together
 ```mermaid
@@ -75,6 +76,7 @@ flowchart TB
     ED[Editor support]
   end
   D[Docs and examples]
+  SC["Scene -> Actor trait (after the closure field-assignment fix)"]
   G --> TL
   G --> F
   TL --> CK
@@ -83,6 +85,7 @@ flowchart TB
   FA --> CG
   CK --> ED
   CG --> D
+  CG --> SC
 ```
 ## Decisions you can change
@@ -101,6 +104,8 @@ flowchart TB
 - **Union rules leaking into traits.** Union enums are exhaustive and allow any shared method. Traits need the opposite on both counts. The checker keeps an explicit "this union came from a trait" mark, and tests cover both rules.
 - **Grammar ambiguity.** A bare name in a record's field list next to `name: Type` fields. We regenerate with optimizations disabled (a known landmine here) and run the full corpus.
 - **Name clashes after copying.** Copied default methods and fields could clash with the record's own. Lowering checks this first and reports the error at the record, not at a generated copy.
+- **A trait whose field holds its own type.** `Actor` has `children: List[Actor]` (a Scene2D group is an actor with children). The lowering and the GC type registry must handle that recursion. A test covers a three-level tree of mixed game records.
+- **Scene performance.** Each `add` boxes the record once, not once per frame. Draw and act dispatch on the record type instead of calling a closure. The Scene benchmark (5k and 20k with culling, in `plum-game/web-test/BENCHMARK.md`) is re-run against the closure version. If the trait version is slower by more than 10%, the box-free subtyping option above becomes part of this work.
 - **Same record in a trait and a union enum.** Both use hidden wrapping, which could produce two candidate conversions. Tests cover a record that is both an `Entity` and a member of an enum.
 ## Out of scope
@@ -117,6 +122,7 @@ flowchart TB
 - Each error listed under "What you will get" has a test asserting its message and position.
 - A `match` on a trait without `_` is rejected. With `_`, it narrows to the record and binds its fields.
 - `plum format` on the new example makes no changes when run twice.
+- `std/game/Scene` is built on `trait Actor`. A game record that embeds `Actor` and overrides `act` and `draw`, e.g. `record Walker(Actor, speed: Float)`, works in a `Stage` exactly like a libGDX `Actor` subclass. Z-index, `sortChildren`, culling and `hit` keep their tests green. `plum-examples/scene.plum` uses it and passes the browser check. The Scene benchmark is recorded for both versions.
 - The full Plum and Rust test suites and the tree-sitter corpus pass.
 ## Rough time and cost

plum-checker/src/lib.rs CHANGED Viewed

@@ -4441,7 +4441,9 @@ fn inferExprInner(
             // `Assign` may declare a name the final statement depends on.
             if let Some((_, earlier)) = cl.body.stmts.split_last() {
                 for stmt in earlier {
+                    let declares_only = matches!(stmt, ast::Stmt::Assign(a)
+                        if a.targets.iter().all(|t| matches!(t, ast::AssignTarget::Var(_))));
-                    if let ast::Stmt::Assign(a) = stmt {
+                    if let (true, ast::Stmt::Assign(a)) = (declares_only, stmt) {
                         for (target, value) in a.targets.iter().zip(a.values.iter()) {
                             if let ast::AssignTarget::Var(name) = target {
                                 let ann = a.ty.as_ref().map(plumTypeFromAstG);
@@ -4451,7 +4453,7 @@ fn inferExprInner(
                         }
                     } else {
                         // Walk every other statement (`if`, loops, `match`, plain
-                        // calls) so the types of the expressions inside are
+                        // calls, field assignments like `m.x = k`) so the types of the expressions inside are
                         // recorded for codegen. Errors are deliberately dropped:
                         // the closure's params may still be unresolved here.
                         let _ = checkStmt(

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -931,3 +931,43 @@ fn discardTargetTwiceInOneScopeIsFine() {
             .is_ok()
     );
 }
+/// A field assignment before the last statement of a closure body (`m.x = k`)
+/// records the types of its object and value, as every other statement does —
+/// codegen types the closure's captures (`m`, `k`) from them.
+#[test]
+fn closure_earlier_field_assign_records_types() {
+    let src = "\
+record Pair2(x: Int, y: Int)
+fun main() -> Int =
+  m := Pair2(x: 0, y: 0)
+  k := 5
+  f := ||
+    m.x = k
+    m.y = k + 1
+  f()
+  m.y
+";
+    let source = parseClean(src);
+    let info = typedSource(&source).unwrap_or_else(|e| {
+        panic!("{:?}", e.iter().map(|x| x.message.clone()).collect::<Vec<_>>())
+    });
+    let checked: &Source = info.lowered.as_deref().unwrap_or(&source);
+    let main = checked
+        .items
+        .iter()
+        .find_map(|i| match i {
+            Item::Fn(f) if f.name == "main" => Some(f),
+            _ => None,
+        })
+        .expect("main");
+    let FnBody::Block(b) = &main.body else { panic!("main has a block body") };
+    let Stmt::Assign(fa) = &b.stmts[2] else { panic!("f := closure") };
+    let Expr::Closure(cl) = &fa.values[0] else { panic!("closure literal") };
+    let Stmt::Assign(first) = &cl.body.stmts[0] else { panic!("m.x = k") };
+    let AssignTarget::Field(object, _) = &first.targets[0] else { panic!("field target") };
+    let ty = |e: &Expr| info.expr_types.get(&(e as *const Expr as usize)).cloned();
+    assert_eq!(ty(object), Some(PlumType::TNamed("Pair2".to_string())));
+    assert_eq!(ty(&first.values[0]), Some(PlumType::TInt));
+}

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

@@ -3201,3 +3201,56 @@ fun main() -> Int =
     assert!(exportsMemory("mem_with", with));
     assert!(!exportsMemory("mem_without", without));
 }
+// ---- closures assigning fields of captured values ----
+const CAPTURED_FIELDS: &str = "\
+record Pair3(x: Int, y: Int, z: Int)
+record Inner(x: Int)
+record Outer(inner: Inner, n: Int)
+struct Pt(x: Int, y: Int)
+";
+fn runCapturedFields(name: &str, main_body: &str) -> i64 {
+    let src = format!("{}{}\nfun main() -> Int =\n{}", STD_HEAD, CAPTURED_FIELDS, main_body);
+    runMerged::<i64>(name, &src)
+}
+#[test]
+fn closure_assigns_two_fields_of_captured_record() {
+    let body = "  m := Pair3(x: 0, y: 0, z: 0)\n  f := ||\n    m.x = 5\n    m.y = 6\n  f()\n  m.x * 10 + m.y\n";
+    assert_eq!(runCapturedFields("capfields2", body), 56);
+}
+#[test]
+fn closure_assigns_three_fields_of_captured_record() {
+    let body = "  m := Pair3(x: 0, y: 0, z: 0)\n  f := ||\n    m.x = 1\n    m.y = 2\n    m.z = 3\n  f()\n  m.x * 100 + m.y * 10 + m.z\n";
+    assert_eq!(runCapturedFields("capfields3", body), 123);
+}
+#[test]
+fn closure_assigns_fields_from_captured_local() {
+    let body = "  m := Pair3(x: 0, y: 0, z: 0)\n  k := 5\n  f := ||\n    m.x = k\n    m.y = k + 1\n  f()\n  m.x * 10 + m.y\n";
+    assert_eq!(runCapturedFields("capfieldsk", body), 56);
+}
+#[test]
+fn closure_assigns_nested_record_field() {
+    let body = "  o := Outer(inner: Inner(x: 0), n: 0)\n  f := ||\n    o.inner.x = 1\n    o.n = 2\n  f()\n  o.inner.x * 10 + o.n\n";
+    assert_eq!(runCapturedFields("capfieldsnested", body), 12);
+}
+#[test]
+fn closure_assigning_captured_record_fields_runs_twice() {
+    let body = "  m := Pair3(x: 0, y: 0, z: 0)\n  f := ||\n    m.x = m.x + 1\n    m.y = m.y + 2\n  f()\n  f()\n  m.x * 10 + m.y\n";
+    assert_eq!(runCapturedFields("capfieldstwice", body), 24);
+}
+/// A struct is a value: the closure captures a copy when it is created, and each
+/// call starts from that copy. Field writes inside the closure are seen by the
+/// rest of that call only — not by the next call, nor by the enclosing scope.
+#[test]
+fn closure_assigning_captured_struct_fields_writes_its_own_copy() {
+    let body = "  p := Pt(x: 0, y: 0)\n  f := ||\n    p.x = p.x + 1\n    p.y = p.y + 2\n    p.x * 10 + p.y\n  a := f()\n  b := f()\n  a * 10000 + b * 100 + p.x * 10 + p.y\n";
+    assert_eq!(runCapturedFields("capfieldsstruct", body), 121200);
+}