d2640d2 | plum

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

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

d2640d2 — Peter John 2026-08-09T19:04:08+05:30

feat(plum-wasm-codegen): compile enum discriminant-value construction and field access

Files changed (3) hide show

plum-checker/tests/checker_tests.rs +18 -0
plum-wasm-codegen/src/lib.rs +73 -18
plum-wasm-codegen/tests/codegen_tests.rs +57 -0

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -115,6 +115,24 @@ fn method_self_unknown_field_is_error() {
     assert!(result.is_err());
 }
+#[test]
+fn nested_method_type_checks_identically_to_top_level_receiver_form() {
+    let nested_src = "type Cat =\n  name: Str\n  age: Int\n\n  fun getName(self) -> Str =\n    self.name\n";
+    let top_level_src = "type Cat =\n  name: Str\n  age: Int\n\nfun getName<Cat>() -> Str =\n  self.name\n";
+    let nested_result = check_source(&parse(nested_src));
+    let top_level_result = check_source(&parse(top_level_src));
+    assert!(nested_result.is_ok(), "expected Ok, got {:?}", nested_result.err());
+    assert!(top_level_result.is_ok(), "expected Ok, got {:?}", top_level_result.err());
+}
+#[test]
+fn nested_method_unknown_field_is_error_identically_to_top_level_receiver_form() {
+    let nested_src = "type Cat =\n  name: Str\n\n  fun getAge(self) -> Int =\n    self.age\n";
+    let top_level_src = "type Cat =\n  name: Str\n\nfun getAge<Cat>() -> Int =\n  self.age\n";
+    assert!(check_source(&parse(nested_src)).is_err());
+    assert!(check_source(&parse(top_level_src)).is_err());
+}
 #[test]
 fn self_outside_method_is_error() {
     let src = "fun bad() -> Int =\n  self\n";

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

@@ -1746,12 +1746,25 @@ impl<'a> Collector<'a> {
                     }
                 }
             }
+            ast::Expr::TypeName(n) => {
+                // A bare discriminant-variant reference (e.g. `READ_MIN_OCCURANCES`) heap-
+                // allocates via the SAME `compile_variant_construction` path a payload-carrying
+                // `FnCall` variant construction uses (see the `Expr::TypeName` arm in
+                // `compile_expr`), so it needs the same scratch slot registered here.
+                let carries_baked_in_payload = self.cctx.enum_variants.get(n)
+                    .map(|info| !info.values.is_empty())
+                    .unwrap_or(false);
+                if carries_baked_in_payload {
+                    let idx = self.next_classcall_slot;
+                    self.next_classcall_slot += 1;
+                    self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
+                }
+            }
             ast::Expr::Int(_)
             | ast::Expr::Float(_)
             | ast::Expr::String(_)
             | ast::Expr::Self_
-            | ast::Expr::Var(_)
-            | ast::Expr::TypeName(_) => {}
+            | ast::Expr::Var(_) => {}
             // A closure literal needs two construction scratch slots in the *enclosing*
             // function (env struct ptr, closure struct ptr). Its body's own locals are
             // NOT this function's — they belong to the separate closure function — so we
@@ -2524,6 +2537,12 @@ fn compile_variant_eq_arm(
     }
     let tag = info.tag;
     Instruction::LocalGet(scratch_local).encode(body);
+    if !info.field_types.is_empty() {
+        // A payload-carrying variant's scratch local holds a heap pointer, not the
+        // tag itself (unlike a payload-free variant, which stores the tag directly
+        // as its runtime value) — dereference slot 0 to compare against the tag.
+        emit_load(ValType::I32, 0, body);
+    }
     Instruction::I32Const(tag).encode(body);
     Instruction::I32Eq.encode(body);
     Instruction::If(block_type_for(result_vt)).encode(body);
@@ -2652,6 +2671,11 @@ fn compile_field_patterns(
             }
             Instruction::LocalGet(container_local).encode(body);
             emit_load(field_vt, offset, body);
+            if !info.field_types.is_empty() {
+                // Payload-carrying nested variant: the just-loaded field is a heap
+                // pointer, not the tag — dereference slot 0 to compare against it.
+                emit_load(ValType::I32, 0, body);
+            }
             Instruction::I32Const(info.tag).encode(body);
             Instruction::I32Eq.encode(body);
             Instruction::If(block_type_for(result_vt)).encode(body);
@@ -2938,6 +2962,16 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
             Some(info) if info.field_types.is_empty() => {
                 Instruction::I32Const(info.tag).encode(body);
             }
+            Some(info) if !info.values.is_empty() => {
+                // A discriminant variant's own declared literal values ARE its
+                // construction arguments — there is no call site to take them from, so
+                // build one synthetically and reuse the existing payload-variant path.
+                let synthetic_call = ast::FnCall {
+                    name: n.clone(),
+                    args: info.values.iter().cloned().map(ast::Arg::Positional).collect(),
+                };
+                compile_variant_construction(info, &synthetic_call, expr, body, ctx, state)?;
+            }
             Some(_) => return Err(format!("codegen: '{}' carries a payload — construct it with '{}(...)'", n, n)),
             None => return Err(format!("codegen: type name '{}' is not yet supported as a value", n)),
         },
@@ -2990,22 +3024,43 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
                         PlumType::TNamed(n) => n.clone(),
                         other => return Err(format!("codegen: cannot access field '{}' on non-class type {}", field_name, other)),
                     };
+                    match ctx.classes.get(&class_name) {
+                        Some(fields) => {
+                            let (field_idx, field_ty) = fields
+                                .iter()
+                                .position(|(n, _)| n == field_name)
+                                .map(|i| (i, fields[i].1.clone()))
+                                .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                            compile_expr(&attr.object, body, ctx, state)?;
+                            let offset = (field_idx as u64) * 8;
+                            match plum_type_to_valtype(&field_ty) {
+                                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                            };
+                        }
+                        // Not a class: fall back to a discriminant enum's shared params.
+                        // Slot 0 is always the variant's tag, so field N lives at slot N+1 —
+                        // NOT the same offset a class field of the same index would use.
+                        None => {
-                    let fields = ctx
+                            let params = ctx
-                        .classes
+                                .enum_params
-                        .get(&class_name)
+                                .get(&class_name)
-                        .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
+                                .ok_or_else(|| format!("codegen: unknown class '{}'", class_name))?;
-                    let (field_idx, field_ty) = fields
+                            let (field_idx, field_ty) = params
-                        .iter()
+                                .iter()
-                        .position(|(n, _)| n == field_name)
+                                .position(|(n, _)| n == field_name)
-                        .map(|i| (i, fields[i].1.clone()))
+                                .map(|i| (i, params[i].1.clone()))
-                        .ok_or_else(|| format!("codegen: no field '{}' on class '{}'", field_name, class_name))?;
+                                .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-                    compile_expr(&attr.object, body, ctx, state)?;
+                            compile_expr(&attr.object, body, ctx, state)?;
-                    let offset = (field_idx as u64) * 8;
+                            let offset = ((field_idx + 1) as u64) * 8;
-                    match plum_type_to_valtype(&field_ty) {
+                            match plum_type_to_valtype(&field_ty) {
-                        ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                        ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+                                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
-                        _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+                                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
-                    };
+                            };
+                        }
+                    }
                 }
                 ast::AttrKind::Method(call) => {
                     let class_name = match &obj_ty {

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

@@ -403,6 +403,63 @@ fun main() -> Int =
     assert_eq!(run_main(&bytes), 7);
 }
+#[test]
+fn nested_method_declaration_runs_correctly() {
+    let src = "\
+type Cat =
+  name: Str
+  age: Int
+  fun getAge(self) -> Int =
+    self.age
+fun main() -> Int =
+  c = Cat(name: \"x\", age: 7)
+  c.getAge()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn enum_discriminant_value_field_access_runs_correctly_for_each_variant() {
+    let src = "\
+enum Step(n: Int) =
+  | ReadMin(10)
+  | ReadMax(20)
+  fun toNumber(self) -> Int =
+    self.n
+fun main() -> Int =
+  ReadMin.toNumber() * 100 + ReadMax.toNumber()
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 1020);
+}
+#[test]
+fn enum_discriminant_value_matches_by_variant_name_correctly() {
+    let src = "\
+enum Step(n: Int) =
+  | ReadMin(10)
+  | ReadMax(20)
+fun toNumber(s: Step) -> Int =
+  match s
+    ReadMin => 1
+    ReadMax => 2
+fun main() -> Int =
+  toNumber(ReadMin) * 10 + toNumber(ReadMax)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 12);
+}
 #[test]
 fn nested_class_call_runs_correctly() {
     let src = "\