85ed0b1 | plum | pyrossh

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

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

85ed0b1 — Peter John 2026-10-26T14:41:12+05:30

fix: fn-field nested call args, heap-valued consts, value-enum nested patterns and field assign through heap fields

Files changed (4) hide show

plum-checker/src/lib.rs +10 -0
plum-std/Heap.plum +1 -3
plum-wasm-codegen/src/lib.rs +389 -134
plum-wasm-codegen/tests/codegen_tests.rs +71 -0

plum-checker/src/lib.rs CHANGED Viewed

@@ -1300,6 +1300,7 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
     // `buildGlobalTables` only had literals to go on; now that every method/enum
     // table exists, re-infer each one with the full inferer. Two passes let a const
     // reference one declared later.
+    drainCalls();
     for _ in 0..2 {
         for item in &source.items {
             if let ast::Item::Const(c) = item {
@@ -1309,6 +1310,9 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
             }
         }
     }
+    // The calls inside a const initializer (`List(1, 2)`) are instantiated like a
+    // root fn's: codegen compiles each initializer once, outside any instantiation.
+    let const_calls = drainCalls();
     errors.extend(checkValueEnums(source));
@@ -1388,6 +1392,12 @@ fn checkSourceInner(source: &ast::Source) -> (CheckResult<()>, TypedInfo) {
         file,
     };
     drainCalls();
+    CALLS.with(|c| {
+        if let Some(v) = c.borrow_mut().as_mut() {
+            v.extend(const_calls);
+        }
+    });
+    registerCalls(&mut inst, &fn_by_key, &ctx, None);
     // Roots: every non-generic fn and every test. A generic fn is only
     // name-resolved here (its body is type-checked per instantiation below).

plum-std/Heap.plum CHANGED Viewed

@@ -29,9 +29,7 @@ enum Heap[T] =
     self.items.data.set(j, a)
   fun less(self, i: Int, j: Int) -> Bool =
-    a := self.items.data.get(i)
-    b := self.items.data.get(j)
-    return self.key(a) < self.key(b)
+    return self.key(self.items.data.get(i)) < self.key(self.items.data.get(j))
   fun siftUp(self, start: Int) -> Unit =
     i := start

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

@@ -2439,6 +2439,30 @@ fn compileSourceInner(
         Instruction::GlobalSet(global_idx).encode(&mut start_body);
     }
+    // Heap-valued consts (`TABLE = List(..)`): one lazily-initialised cached global and
+    // one accessor function each (`const#NAME`), compiled below.
+    let mut const_inits: Vec<(String, ConstInit, u32)> = Vec::new();
+    for item in &source.items {
+        let ast::Item::Const(c) = item else { continue };
+        if !isBuiltConstInit(&c.value) {
+            continue;
+        }
+        let Some(ty) = expr_types.get(&(&c.value as *const ast::Expr as usize)) else { continue };
+        if !matches!(ty, PlumType::TNamed(_) | PlumType::TApp(..)) || isValueTy(ty) {
+            continue;
+        }
+        let vt = plumTypeToValtype(ty);
+        let ValType::Ref(rt) = vt else { continue };
+        let mut init = Vec::new();
+        Instruction::RefNull(rt.heap_type).encode(&mut init);
+        let global = module.addGlobal(vt, true, &init);
+        let t = module.addType(&[], &[vt]);
+        let func_idx = module.addFunction(t, &[]);
+        module.nameFunction(func_idx, &format!("const.{}", c.name));
+        func_ids.insert(format!("const#{}", c.name), func_idx);
+        const_inits.push((c.name.clone(), ConstInit { expr: &c.value, ty: ty.clone(), global }, func_idx));
+    }
     Instruction::End.encode(&mut start_body);
     let mut final_start_body = vec![0u8];
     final_start_body.extend(start_body);
@@ -2501,6 +2525,25 @@ fn compileSourceInner(
         module.functions[slot].1 = body.clone();
     }
+    for (name, ci, func_idx) in &const_inits {
+        let stand_in = ast::Fn {
+            name: format!("const#{name}"),
+            line: 0,
+            column: 0,
+            type_param: None,
+            is_extern: false,
+            params: Vec::new(),
+            returns: None,
+            body: ast::FnBody::Block(ast::Block { stmts: Vec::new() }),
+        };
+        let no_subst = Subst::new();
+        let uref = UnitRef { idx: usize::MAX, inst: None, subst: &no_subst, types: &expr_types };
+        let body = compileFnBodyImpl(&stand_in, Some(ci), &ctx, &mut state, &uref)
+            .map_err(|e| format!("{e} (in const '{name}')"))?;
+        let slot = (*func_idx - module.func_import_count) as usize;
+        module.functions[slot].1 = body;
+    }
     // Compile each closure literal's own body into its reserved function slot.
     let mut closure_bodies: Vec<(u32, Vec<u8>)> = Vec::new();
     for ((ui, ptr), info) in &ctx.closures {
@@ -3854,6 +3897,22 @@ impl<'a> Collector<'a> {
                         }
                         ast::AssignTarget::Field(object, _) => {
                             self.walkExpr(object);
+                            // `p.pos.x = v` through a heap field copies each value-enum
+                            // link of the chain out into a scratch (see `compileFieldStore`).
+                            let mut cur: &ast::Expr = object;
+                            loop {
+                                let t = self.ty(cur);
+                                if !isValueTy(&t) {
+                                    break;
+                                }
+                                self.bind(&rmwLocal(cur), t);
+                                match cur {
+                                    ast::Expr::Attribute(at) if matches!(at.attr, ast::AttrKind::Field(_)) => {
+                                        cur = &at.object
+                                    }
+                                    _ => break,
+                                }
+                            }
                         }
                     }
                 }
@@ -4049,6 +4108,37 @@ fn compileFnBody(
     ctx: &CompileCtx,
     state: &mut ModuleState,
     unit: &UnitRef,
+) -> Result<Vec<u8>, String> {
+    compileFnBodyImpl(f, None, ctx, state, unit)
+}
+/// A heap-valued top-level const (`TABLE = List(1, 2)`): its initializer expression
+/// (the ORIGINAL AST node, so the checker's per-expression tables apply), the const's
+/// type, and the mutable global caching the built value.
+struct ConstInit<'e> {
+    expr: &'e ast::Expr,
+    ty: PlumType,
+    global: u32,
+}
+/// Whether a const initializer builds a fresh object — compiled once into a cached
+/// global (see `ConstInit`) rather than inlined (re-evaluated) at every use.
+fn isBuiltConstInit(e: &ast::Expr) -> bool {
+    match e {
+        ast::Expr::ClassCall(_) | ast::Expr::FnCall(_) => true,
+        ast::Expr::Attribute(a) => matches!(a.attr, ast::AttrKind::Method(_)),
+        _ => false,
+    }
+}
+/// Compiles a function body. With `const_init`, `f` is a bodyless stand-in and the
+/// body is the lazily-run, cache-once initializer of that const, returning its value.
+fn compileFnBodyImpl(
+    f: &ast::Fn,
+    const_init: Option<&ConstInit>,
+    ctx: &CompileCtx,
+    state: &mut ModuleState,
+    unit: &UnitRef,
 ) -> Result<Vec<u8>, String> {
     let mut body = Vec::new();
@@ -4078,7 +4168,9 @@ fn compileFnBody(
         variadic_for_scratch: HashMap::new(),
         next_variadic_for_slot: 0,
     };
+    if let Some(ci) = const_init {
+        collector.walkExpr(ci.expr);
-    if let ast::FnBody::Block(block) = &f.body {
+    } else if let ast::FnBody::Block(block) = &f.body {
         collector.walkBlock(block);
     } else if let ast::FnBody::Expr(e) = &f.body {
         // An expression-bodied fn can still contain a closure literal (e.g.
@@ -4195,6 +4287,17 @@ fn compileFnBody(
         Some(plumTypeToValtype(&ret_decl))
     };
+    if let Some(ci) = const_init {
+        Instruction::GlobalGet(ci.global).encode(&mut body);
+        Instruction::RefIsNull.encode(&mut body);
+        Instruction::If(BlockType::Empty).encode(&mut body);
+        compileExprInto(ci.expr, &ci.ty, &mut body, &local_ctx, state)?;
+        Instruction::GlobalSet(ci.global).encode(&mut body);
+        Instruction::End.encode(&mut body);
+        Instruction::GlobalGet(ci.global).encode(&mut body);
+        Instruction::End.encode(&mut body);
+        return Ok(body);
+    }
     match &f.body {
         ast::FnBody::Expr(e) => {
             compileExpr(e, &mut body, &local_ctx, state)?;
@@ -4393,6 +4496,161 @@ fn compileBlockAsFnBody(
     }
 }
+/// What `compileFieldStore` assigns: its type and a pusher for it (natural form —
+/// flat leaves for a value enum — converted for a destination of the given type).
+struct StoreSrc<'a> {
+    ty: PlumType,
+    push: &'a dyn Fn(&PlumType, &mut Vec<u8>, &LocalCtx, &mut ModuleState) -> Result<(), String>,
+}
+/// The reserved scratch local holding a copy of the value-enum expression `e`
+/// while one of its fields is assigned (see `compileFieldStore`).
+fn rmwLocal(e: &ast::Expr) -> String {
+    format!("rmw#{}", e as *const ast::Expr as usize)
+}
+/// `object.field_name = src`. Heap objects get a `struct.set`. A field of a
+/// flattened value enum is assigned in the local's leaves when `object` is a local
+/// place; otherwise (`p.pos.x = 1.0` through a heap field) the value is copied out
+/// into a scratch local, the field set there, and the whole value stored back into
+/// the place it came from.
+fn compileFieldStore(
+    object: &ast::Expr,
+    field_name: &str,
+    src: &StoreSrc,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let obj_ty = inferLocalType(object, ctx);
+    if let Some((off, fty)) = valueFieldRange(&obj_ty, field_name) {
+        if let Some((base, _)) = valueLocalPlace(object, ctx) {
+            (src.push)(&fty, body, ctx, state)?;
+            emitSetLocals(base + off, &fty, body);
+            return Ok(());
+        }
+        let ast::Expr::Attribute(a) = object else {
+            return Err(format!(
+                "codegen: cannot assign field '{}' of a value enum that is not a variable or field; assign the whole value instead",
+                field_name
+            ));
+        };
+        let ast::AttrKind::Field(parent_field) = &a.attr else {
+            return Err(format!(
+                "codegen: cannot assign field '{}' of a value enum returned by a call; assign the whole value instead",
+                field_name
+            ));
+        };
+        let tmp = *ctx
+            .locals
+            .get(&rmwLocal(object))
+            .ok_or_else(|| "internal codegen error: missing value-field assignment scratch".to_string())?;
+        compileExpr(object, body, ctx, state)?;
+        emitSetLocals(tmp, &obj_ty, body);
+        (src.push)(&fty, body, ctx, state)?;
+        emitSetLocals(tmp + off, &fty, body);
+        let whole = StoreSrc {
+            ty: obj_ty.clone(),
+            push: &|_, body, _, _| {
+                emitGetLocals(tmp, &obj_ty, body);
+                Ok(())
+            },
+        };
+        return compileFieldStore(&a.object, parent_field, &whole, body, ctx, state);
+    }
+    let class_name = match plum_checker::nominalName(&obj_ty) {
+        Some(n) => n.to_string(),
+        None => {
+            return Err(format!(
+                "codegen: cannot assign field '{}' on non-class type {}",
+                field_name, obj_ty
+            ))
+        }
+    };
+    // struct.set expects [(ref null $t) value] on the stack (ref
+    // pushed first/deeper, value second/on top) — same push order
+    // this already used for the old memory store. Mirrors the read
+    // side's discriminant-enum-param / single-owning-variant
+    // fallback chain (`AttrKind::Field` below) — this also covers a
+    // record-shaped enum's own field (the `type X = ...`
+    // replacement), whose one variant is trivially its own unique
+    // owner of every field it declares.
+    match ctx.enum_params.get(&class_name) {
+        Some(params) => {
+            let field_idx = params
+                .iter()
+                .position(|(n, _)| n == field_name)
+                .ok_or_else(|| {
+                    format!(
+                        "codegen: no field '{}' on enum '{}'",
+                        field_name, class_name
+                    )
+                })?;
+            let super_type_idx = ctx
+                .gc_types
+                .superIdx(&obj_ty)
+                .ok_or_else(|| {
+                    format!(
+                        "codegen: enum '{}' missing from the GC type registry",
+                        class_name
+                    )
+                })?;
+            let sub_s: Subst = ctx
+                .enum_variants
+                .values()
+                .find(|i| i.enum_name == class_name)
+                .map(|i| match &obj_ty {
+                    PlumType::TApp(_, a) => i.generics.iter().cloned().zip(a.iter().cloned()).collect(),
+                    _ => Subst::new(),
+                })
+                .unwrap_or_default();
+            let fty = plum_checker::types::substitute(&params[field_idx].1, &sub_s);
+            compileExpr(object, body, ctx, state)?;
+            (src.push)(&fty, body, ctx, state)?;
+            boxIfValue(&src.ty, body);
+            Instruction::StructSet {
+                struct_type_index: super_type_idx,
+                field_index: field_idx as u32,
+            }
+            .encode(body);
+        }
+        None => {
+            let (variant_name, info) = ctx
+                .enum_variants
+                .iter()
+                .find(|(_, info)| {
+                    info.enum_name == class_name
+                        && info.field_names.iter().any(|n| n == field_name)
+                })
+                .ok_or_else(|| {
+                    format!(
+                        "codegen: no field '{}' on enum '{}'",
+                        field_name, class_name
+                    )
+                })?;
+            let field_idx = info
+                .field_names
+                .iter()
+                .position(|n| n == field_name)
+                .expect("just found by this field name");
+            let variant_type_idx = ctx.gc_types.variantIdx(&obj_ty, variant_name)
+                .ok_or_else(|| format!("codegen: variant '{}' of {} missing from the GC type registry", variant_name, obj_ty))?;
+            let fty = plum_checker::variantFields(info, &obj_ty)[field_idx].clone();
+            compileExpr(object, body, ctx, state)?;
+            Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))
+                .encode(body);
+            (src.push)(&fty, body, ctx, state)?;
+            boxIfValue(&src.ty, body);
+            Instruction::StructSet {
+                struct_type_index: variant_type_idx,
+                field_index: field_idx as u32,
+            }
+            .encode(body);
+        }
+    }
+    Ok(())
+}
 fn compileStmt(
     stmt: &ast::Stmt,
     body: &mut Vec<u8>,
@@ -4421,110 +4679,11 @@ fn compileStmt(
                             .insert(name.clone(), TypeScheme::mono(vty));
                     }
                     ast::AssignTarget::Field(object, field_name) => {
+                        let src = StoreSrc {
-                        let obj_ty = inferLocalType(object, ctx);
+                            ty: inferLocalType(value, ctx),
-                        // A field of a flattened value enum: assign straight into the
-                        // local copy's leaves (the original it was copied from is untouched).
-                        if let Some((off, fty)) = valueFieldRange(&obj_ty, field_name) {
-                            let (base, _) = valueLocalPlace(object, ctx).ok_or_else(|| {
-                                format!(
-                                    "codegen: cannot assign field '{}' of a value enum that is not a local variable; assign the whole value instead",
-                                    field_name
-                                )
-                            })?;
-                            compileExpr(value, body, ctx, state)?;
+                            push: &|dest, body, ctx, state| compileExprInto(value, dest, body, ctx, state),
-                            emitSetLocals(base + off, &fty, body);
-                            continue;
-                        }
-                        let class_name = match plum_checker::nominalName(&obj_ty) {
-                            Some(n) => n.to_string(),
-                            None => {
-                                return Err(format!(
-                                    "codegen: cannot assign field '{}' on non-class type {}",
-                                    field_name, obj_ty
-                                ))
-                            }
                         };
-                        // struct.set expects [(ref null $t) value] on the stack (ref
-                        // pushed first/deeper, value second/on top) — same push order
-                        // this already used for the old memory store. Mirrors the read
-                        // side's discriminant-enum-param / single-owning-variant
-                        // fallback chain (`AttrKind::Field` below) — this also covers a
-                        // record-shaped enum's own field (the `type X = ...`
-                        // replacement), whose one variant is trivially its own unique
-                        // owner of every field it declares.
-                        match ctx.enum_params.get(&class_name) {
-                            Some(params) => {
-                                let field_idx = params
-                                    .iter()
-                                    .position(|(n, _)| n == field_name)
-                                    .ok_or_else(|| {
-                                        format!(
-                                            "codegen: no field '{}' on enum '{}'",
-                                            field_name, class_name
-                                        )
-                                    })?;
-                                let super_type_idx = ctx
-                                    .gc_types
-                                    .superIdx(&obj_ty)
-                                    .ok_or_else(|| {
-                                        format!(
-                                            "codegen: enum '{}' missing from the GC type registry",
-                                            class_name
-                                        )
-                                    })?;
-                                let sub_s: Subst = ctx
-                                    .enum_variants
-                                    .values()
-                                    .find(|i| i.enum_name == class_name)
-                                    .map(|i| match &obj_ty {
-                                        PlumType::TApp(_, a) => i.generics.iter().cloned().zip(a.iter().cloned()).collect(),
-                                        _ => Subst::new(),
-                                    })
-                                    .unwrap_or_default();
-                                let fty = plum_checker::types::substitute(&params[field_idx].1, &sub_s);
-                                compileExpr(object, body, ctx, state)?;
-                                compileExprInto(value, &fty, body, ctx, state)?;
+                        compileFieldStore(object, field_name, &src, body, ctx, state)?;
-                                boxIfValue(&inferLocalType(value, ctx), body);
-                                Instruction::StructSet {
-                                    struct_type_index: super_type_idx,
-                                    field_index: field_idx as u32,
-                                }
-                                .encode(body);
-                            }
-                            None => {
-                                let (variant_name, info) = ctx
-                                    .enum_variants
-                                    .iter()
-                                    .find(|(_, info)| {
-                                        info.enum_name == class_name
-                                            && info.field_names.iter().any(|n| n == field_name)
-                                    })
-                                    .ok_or_else(|| {
-                                        format!(
-                                            "codegen: no field '{}' on enum '{}'",
-                                            field_name, class_name
-                                        )
-                                    })?;
-                                let field_idx = info
-                                    .field_names
-                                    .iter()
-                                    .position(|n| n == field_name)
-                                    .expect("just found by this field name");
-                                let variant_type_idx = ctx.gc_types.variantIdx(&obj_ty, variant_name)
-                                    .ok_or_else(|| format!("codegen: variant '{}' of {} missing from the GC type registry", variant_name, obj_ty))?;
-                                let fty = plum_checker::variantFields(info, &obj_ty)[field_idx].clone();
-                                compileExpr(object, body, ctx, state)?;
-                                Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx))
-                                    .encode(body);
-                                compileExprInto(value, &fty, body, ctx, state)?;
-                                boxIfValue(&inferLocalType(value, ctx), body);
-                                Instruction::StructSet {
-                                    struct_type_index: variant_type_idx,
-                                    field_index: field_idx as u32,
-                                }
-                                .encode(body);
-                            }
-                        }
                     }
                 }
             }
@@ -5472,6 +5631,7 @@ fn compileVariantConstructorArm(
             0,
             scratch_local,
             if name == "Ok" { NULLABLE_OK } else { NULLABLE_ERR },
+            None,
             rest,
             all_subjects,
             result_vt,
@@ -5507,12 +5667,11 @@ fn compileVariantConstructorArm(
     // Payload types instantiated by the subject's type arguments.
     let inst_types = instFields(info, &sty);
     let field_types = inst_types.clone();
-    if isValueTy(&sty) && inst_types.iter().any(isValueTy) {
-        return Err(format!(
-            "codegen: cannot destructure nested value-enum fields in a pattern for '{}'; bind the whole value and use its fields",
+    // A value enum's box struct holds its fields FLATTENED into leaves, so field `i`
+    // of the pattern lives at leaf `value_leaf_map[i]` (nested value fields span several).
+    let value_leaf_map: Option<Vec<u32>> = valueFieldsOf(&sty).map(|fs| {
-            name
+        fs.iter().map(|(n, _)| valueFieldRange(&sty, n).map(|(o, _)| o).unwrap_or(0)).collect()
-        ));
+    });
-    }
     // This pattern's own narrowly-typed scratch local (declared with variant's exact
     // concrete ref type — see `nested_class_scratch_types`), distinct from
@@ -5543,6 +5702,7 @@ fn compileVariantConstructorArm(
         0,
         narrow_local,
         variant_idx,
+        value_leaf_map.as_deref(),
         rest,
         all_subjects,
         result_vt,
@@ -5592,6 +5752,7 @@ fn emitContainerField(
     container_local: u32,
     container_type_idx: u32,
     fpos: usize,
+    leaf_map: Option<&[u32]>,
 ) {
     match container_type_idx {
         NULLABLE_OK => Instruction::LocalGet(container_local).encode(body),
@@ -5600,7 +5761,7 @@ fn emitContainerField(
             Instruction::LocalGet(container_local).encode(body);
             Instruction::StructGet {
                 struct_type_index: idx,
-                field_index: fpos as u32,
+                field_index: leaf_map.map(|m| m[fpos]).unwrap_or(fpos as u32),
             }
             .encode(body);
         }
@@ -5622,6 +5783,7 @@ fn compileFieldPatterns(
     fpos: usize,
     container_local: u32,
     container_type_idx: u32,
+    leaf_map: Option<&[u32]>,
     rest: &[ast::Case],
     all_subjects: &[(ValType, u32)],
     result_vt: Option<ValType>,
@@ -5646,7 +5808,7 @@ fn compileFieldPatterns(
                 pat,
                 tags,
                 &|b: &mut Vec<u8>| {
-                    emitContainerField(b, ctx, container_local, container_type_idx, fpos);
+                    emitContainerField(b, ctx, container_local, container_type_idx, fpos, leaf_map);
                 },
                 result_vt,
                 body,
@@ -5660,6 +5822,7 @@ fn compileFieldPatterns(
                         fpos + 1,
                         container_local,
                         container_type_idx,
+                        leaf_map,
                         rest,
                         all_subjects,
                         result_vt,
@@ -5693,6 +5856,7 @@ fn compileFieldPatterns(
             fpos + 1,
             container_local,
             container_type_idx,
+            leaf_map,
             rest,
             all_subjects,
             result_vt,
@@ -5704,7 +5868,7 @@ fn compileFieldPatterns(
         ),
         // A nested `True`/`False` against a `Bool` field: i32 compare.
         ast::CasePattern::Name(n) if n == "True" || n == "False" => {
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
             if n == "False" {
                 Instruction::I32Eqz.encode(body);
             }
@@ -5716,6 +5880,7 @@ fn compileFieldPatterns(
                 fpos + 1,
                 container_local,
                 container_type_idx,
+                leaf_map,
                 rest,
                 all_subjects,
                 result_vt,
@@ -5748,12 +5913,22 @@ fn compileFieldPatterns(
                 ctx.locals.get(n).copied().ok_or_else(|| {
                     format!("internal codegen error: missing binding local '{}'", n)
                 })?;
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            if let (true, Some(m)) = (isValueTy(field_ty), leaf_map) {
+                // Flattened container: the nested value's leaves are consecutive fields.
-            if isValueTy(field_ty) {
+                for j in 0..leafCount(field_ty) {
+                    Instruction::LocalGet(container_local).encode(body);
+                    Instruction::StructGet { struct_type_index: container_type_idx, field_index: m[fpos] + j }
-                emitUnbox(field_ty, body);
+                        .encode(body);
+                }
                 emitSetLocals(idx, field_ty, body);
             } else {
+                emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
+                if isValueTy(field_ty) {
+                    emitUnbox(field_ty, body);
+                    emitSetLocals(idx, field_ty, body);
+                } else {
-                Instruction::LocalSet(idx).encode(body);
+                    Instruction::LocalSet(idx).encode(body);
+                }
             }
             ctx.type_env
                 .borrow_mut()
@@ -5765,6 +5940,7 @@ fn compileFieldPatterns(
                 fpos + 1,
                 container_local,
                 container_type_idx,
+                leaf_map,
                 rest,
                 all_subjects,
                 result_vt,
@@ -5790,7 +5966,7 @@ fn compileFieldPatterns(
             let variant_idx = ctx.gc_types.variantIdx(field_ty, n).ok_or_else(|| {
                 format!("codegen: variant '{}' of {} missing from the GC type registry", n, field_ty)
             })?;
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
             Instruction::RefTestNonNull(HeapType::Concrete(variant_idx)).encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
             compileFieldPatterns(
@@ -5800,6 +5976,7 @@ fn compileFieldPatterns(
                 fpos + 1,
                 container_local,
                 container_type_idx,
+                leaf_map,
                 rest,
                 all_subjects,
                 result_vt,
@@ -5826,7 +6003,7 @@ fn compileFieldPatterns(
             if inst_vt != ValType::I64 {
                 return Err("codegen: integer match pattern against a non-Int field".to_string());
             }
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
             Instruction::I64Const(*n).encode(body);
             Instruction::I64Eq.encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
@@ -5837,6 +6014,7 @@ fn compileFieldPatterns(
                 fpos + 1,
                 container_local,
                 container_type_idx,
+                leaf_map,
                 rest,
                 all_subjects,
                 result_vt,
@@ -5887,6 +6065,71 @@ fn compileFieldPatterns(
                     inner_fields.len()
                 ));
             }
+            // A nested VALUE-enum field (`Rect(Vec2(px, py), size)`): there is exactly
+            // one constructor, so nothing to test — destructure its leaves in place.
+            // Inside a flattened (value) container they are consecutive fields of the
+            // same struct; inside a heap container the field holds the value's box.
+            if let Some(vfields) = valueFieldsOf(field_ty) {
+                let box_idx = ctx.gc_types.classIdx(field_ty).ok_or_else(|| {
+                    format!("codegen: value enum '{}' missing from the GC type registry", field_ty)
+                })?;
+                let (inner_container, inner_idx, base, prelude_nested) = match leaf_map {
+                    Some(m) => (container_local, container_type_idx, m[fpos], false),
+                    None => {
+                        let key = pat as *const ast::CasePattern as usize;
+                        let slot = *ctx.nested_class_scratch.get(&key).ok_or_else(|| {
+                            "internal codegen error: missing nested constructor pattern scratch slot"
+                                .to_string()
+                        })?;
+                        (ctx.nested_class_scratch_base + slot, box_idx, 0, true)
+                    }
+                };
+                if prelude_nested {
+                    emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
+                    Instruction::RefCastNonNull(HeapType::Concrete(box_idx)).encode(body);
+                    Instruction::LocalSet(inner_container).encode(body);
+                }
+                let inner_map: Vec<u32> = vfields
+                    .iter()
+                    .map(|(n, _)| base + valueFieldRange(field_ty, n).map(|(o, _)| o).unwrap_or(0))
+                    .collect();
+                let inner_types: Vec<PlumType> = vfields.iter().map(|(_, t)| t.clone()).collect();
+                return compileFieldPatterns(
+                    inner_fields,
+                    &inner_types,
+                    &inner_types,
+                    0,
+                    inner_container,
+                    inner_idx,
+                    Some(&inner_map),
+                    rest,
+                    all_subjects,
+                    result_vt,
+                    exhaustive_fallback,
+                    body,
+                    ctx,
+                    state,
+                    &mut |body, state| {
+                        compileFieldPatterns(
+                            fields,
+                            field_types,
+                            inst_types,
+                            fpos + 1,
+                            container_local,
+                            container_type_idx,
+                            leaf_map,
+                            rest,
+                            all_subjects,
+                            result_vt,
+                            exhaustive_fallback,
+                            body,
+                            ctx,
+                            state,
+                            on_match,
+                        )
+                    },
+                );
+            }
             let inner_variant_idx = ctx.gc_types.variantIdx(field_ty, name).ok_or_else(|| {
                 format!(
                     "codegen: variant '{}' of {} missing from the GC type registry",
@@ -5902,11 +6145,11 @@ fn compileFieldPatterns(
             let inner_inst_types = instFields(info, field_ty);
             let inner_field_types = inner_inst_types.clone();
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
             Instruction::RefTestNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
             Instruction::If(blockTypeFor(result_vt)).encode(body);
             // Narrow into `nested_local` now that ref.test just above proved it's safe.
-            emitContainerField(body, ctx, container_local, container_type_idx, fpos);
+            emitContainerField(body, ctx, container_local, container_type_idx, fpos, leaf_map);
             Instruction::RefCastNonNull(HeapType::Concrete(inner_variant_idx)).encode(body);
             Instruction::LocalSet(nested_local).encode(body);
             compileFieldPatterns(
@@ -5916,6 +6159,7 @@ fn compileFieldPatterns(
                 0,
                 nested_local,
                 inner_variant_idx,
+                None,
                 rest,
                 all_subjects,
                 result_vt,
@@ -5931,6 +6175,7 @@ fn compileFieldPatterns(
                         fpos + 1,
                         container_local,
                         container_type_idx,
+                        leaf_map,
                         rest,
                         all_subjects,
                         result_vt,
@@ -6772,6 +7017,9 @@ fn compileExprCore(
                 None => {
                     let const_value = CURRENT_CONSTS.with(|c| c.borrow().get(n).cloned());
                     match const_value {
+                        Some(_) if ctx.func_ids.contains_key(&format!("const#{n}")) => {
+                            Instruction::Call(ctx.func_ids[&format!("const#{n}")]).encode(body);
+                        }
                         Some(value) => compileExpr(&value, body, ctx, state)?,
                         None if n
                             .chars()
@@ -7190,13 +7438,7 @@ fn compileMethodCall(
     if !ctx.func_ids.contains_key(&key) && ctx.locals.contains_key(&field_local) {
         compileFieldRead(object, &call.name, obj_ty, result_expr, body, ctx, state)?;
         Instruction::LocalSet(ctx.locals[&field_local]).encode(body);
-        let field_call = ast::FnCall {
-            name: field_local,
-            args: call.args.clone(),
-            line: call.line,
-            column: call.column,
-        };
-        return compileClosureCall(&field_call, result_expr, body, ctx, state);
+        return compileClosureCallArgs(&field_local, &call.args, body, ctx, state);
     }
     let func_idx = *ctx
         .func_ids
@@ -7534,20 +7776,33 @@ fn compileClosureCall(
     body: &mut Vec<u8>,
     ctx: &LocalCtx,
     state: &mut ModuleState,
+) -> Result<(), String> {
+    compileClosureCallArgs(&call.name, &call.args, body, ctx, state)
+}
+/// `compileClosureCall` over the local `name` with explicit `args` — the args must be
+/// the ORIGINAL AST nodes (not clones): the checker's per-call tables are keyed by
+/// expression address, so a cloned arg containing a call would not be found.
+fn compileClosureCallArgs(
+    name: &str,
+    args: &[ast::Arg],
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
 ) -> Result<(), String> {
     let closure_local = *ctx
         .locals
-        .get(&call.name)
+        .get(name)
-        .ok_or_else(|| format!("codegen: closure '{}' is not a local", call.name))?;
+        .ok_or_else(|| format!("codegen: closure '{}' is not a local", name))?;
     let closure_type_idx = ctx.gc_types.closure_type_idx;
-    let Some(PlumType::TFun(ps, r)) = ctx.local_decl_types.get(&call.name) else {
+    let Some(PlumType::TFun(ps, r)) = ctx.local_decl_types.get(name) else {
-        return Err(format!("codegen: '{}' is not a function-typed local", call.name));
+        return Err(format!("codegen: '{}' is not a function-typed local", name));
     };
     let key = closureSigKey(ps, r, ctx.gc_types);
     let type_index = *ctx.closure_call_types.get(&key).ok_or_else(|| {
         format!(
             "internal codegen error: no call_indirect type for closure '{}' of type fn{:?}",
-            call.name, key
+            name, key
         )
     })?;
@@ -7558,7 +7813,7 @@ fn compileClosureCall(
         field_index: 1,
     }
     .encode(body);
-    for (i, arg) in call.args.iter().enumerate() {
+    for (i, arg) in args.iter().enumerate() {
         match ps.get(i) {
             Some(p) => compileExprInto(argExprOf(arg), p, body, ctx, state)?,
             None => compileExpr(argExprOf(arg), body, ctx, state)?,

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

@@ -2382,3 +2382,74 @@ fn extern_value_multi_value() {
     let main = instance.get_typed_func::<(), i64>(&mut store, "main").unwrap();
     assert_eq!(main.call(&mut store, ()).unwrap(), 1);
 }
+// ---- fixes: nested call as fn-field arg, collection consts, value-enum patterns/assign ----
+#[test]
+fn fn_field_nested_call_arg() {
+    let src = format!("{}\
+import std/Array
+enum Keyed[T] =
+  | Keyed(items: List[T], key: fn(T) -> Int)
+  fun first(self) -> Int =
+    self.key(self.items.data.get(0))
+fun main() -> Int =
+  k := Keyed[Int](items: List(5, 6), key: |n| n * 8)
+  k.first() + 2
+", STD_HEAD);
+    assert_eq!(runMerged::<i64>("fnfieldnested", &src), 42);
+}
+#[test]
+fn const_list_table() {
+    let src = format!("{}\
+TABLE = List(10, 20, 30)
+fun total() -> Int =
+  TABLE.reduce(0, |a, b| a + b)
+fun main() -> Int =
+  TABLE.push(4)
+  TABLE.get(1).unwrap() + TABLE.length() + total() - 78 + 4
+", STD_HEAD);
+    // TABLE is a single shared object, initialised once: push(4) persists, so
+    // total() sees 64 (60 + 4), length 4, get(1) 20 -> 20 + 4 + 64 - 78 + 4 = 14
+    assert_eq!(runMerged::<i64>("constlist", &src), 14);
+}
+#[test]
+fn value_nested_pattern() {
+    let src = format!(
+        "{VEC2}value enum Rect =\n  | Rect(pos: Vec2, size: Vec2)\n\nfun f(r: Rect) -> Float =\n  match r\n    Rect(Vec2(px, py), size) => px + py * 10.0 + size.x * 100.0 + size.y * 1000.0\n\nfun g(v: Vec2) -> Float =\n  match v\n    Vec2(a, b) => a - b\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  if f(r) == 4321.0 && g(r.pos) == 0.0 - 1.0\n    return 1\n  return 0\n"
+    );
+    assert_eq!(runMerged::<i64>("value_nested_pattern", &src), 1);
+}
+#[test]
+fn local_value_subfield_assign() {
+    let src = format!(
+        "{VEC2}value enum Rect =\n  | Rect(pos: Vec2, size: Vec2)\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  r.pos.x = 7.0\n  r.size.y = 9.0\n  if r.pos.x == 7.0 && r.pos.y == 2.0 && r.size.x == 3.0 && r.size.y == 9.0\n    return 1\n  return 0\n"
+    );
+    assert_eq!(runMerged::<i64>("local_value_subfield_assign", &src), 1);
+}
+#[test]
+fn heap_field_value_subfield_assign() {
+    let src = format!(
+        "{VEC2}enum Player =\n  | Player(pos: Vec2, hp: Int)\n\nvalue enum Rect =\n  | Rect(pos: Vec2, size: Vec2)\n\nenum Body =\n  | Body(bounds: Rect, id: Int)\n\nfun main() -> Int =\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 5)\n  p.pos.x = 8.0\n  b := Body(bounds: Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0)), id: 1)\n  b.bounds.size.y = 6.0\n  if p.pos.x == 8.0 && p.pos.y == 2.0 && p.hp == 5 && b.bounds.size.y == 6.0 && b.bounds.size.x == 3.0 && b.bounds.pos.y == 2.0\n    return 1\n  return 0\n"
+    );
+    assert_eq!(runMerged::<i64>("heap_field_value_subfield_assign", &src), 1);
+}
+#[test]
+fn value_nested_pattern_mixed() {
+    // Whole-value binding next to a nested destructure, and a heap container
+    // (class-like enum) holding a value-enum field.
+    let src = format!(
+        "{VEC2}value enum Rect =\n  | Rect(pos: Vec2, size: Vec2)\n\nenum Player =\n  | Player(pos: Vec2, hp: Float)\n\nfun f(r: Rect) -> Float =\n  match r\n    Rect(p, Vec2(w, h)) => p.x + p.y * 10.0 + w * 100.0 + h * 1000.0\n\nfun g(p: Player) -> Float =\n  match p\n    Player(Vec2(x, y), hp) => x + y * 10.0 + hp * 100.0\n\nfun main() -> Int =\n  r := Rect(pos: Vec2(x: 1.0, y: 2.0), size: Vec2(x: 3.0, y: 4.0))\n  p := Player(pos: Vec2(x: 1.0, y: 2.0), hp: 3.0)\n  if f(r) == 4321.0 && g(p) == 321.0\n    return 1\n  return 0\n"
+    );
+    assert_eq!(runMerged::<i64>("value_nested_pattern_mixed", &src), 1);
+}