380a51c | plum

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

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

380a51c — Peter John 2026-07-20T11:43:17+05:30

feat(plum-wasm-codegen): compile general enum variant construction

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +92 -17
plum-wasm-codegen/tests/codegen_tests.rs +56 -0

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

@@ -3,7 +3,7 @@ use std::cell::RefCell;
 use std::collections::HashMap;
 use plum_core::ast;
 use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
-use plum_checker::{ClassEnv, MethodEnv, EnumVariants};
+use plum_checker::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo};
 /// Bump-allocated heap for class instances starts at the second 64KiB page so it can
 /// never collide with the (small, compile-time-sized) string literal data area below it.
@@ -478,6 +478,14 @@ impl<'a> Collector<'a> {
                 self.walk_expr(&t.else_);
             }
             ast::Expr::FnCall(call) => {
+                let carries_payload = self.cctx.enum_variants.get(&call.name)
+                    .map(|info| !info.field_types.is_empty())
+                    .unwrap_or(false);
+                if carries_payload {
+                    let idx = self.next_classcall_slot;
+                    self.next_classcall_slot += 1;
+                    self.classcall_scratch.insert(expr as *const ast::Expr as usize, idx);
+                }
                 for arg in &call.args {
                     self.walk_arg(arg);
                 }
@@ -1038,19 +1046,23 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
             Instruction::End.encode(body);
         }
         ast::Expr::FnCall(call) => {
+            if let Some(info) = ctx.enum_variants.get(&call.name) {
+                compile_variant_construction(info, call, expr, body, ctx, state)?;
+            } else {
-            for arg in &call.args {
+                for arg in &call.args {
-                let arg_expr = match arg {
+                    let arg_expr = match arg {
-                    ast::Arg::Positional(e) => e,
+                        ast::Arg::Positional(e) => e,
-                    ast::Arg::Keyword { value, .. } => value,
+                        ast::Arg::Keyword { value, .. } => value,
-                    ast::Arg::Pair { value, .. } => value,
+                        ast::Arg::Pair { value, .. } => value,
-                };
+                    };
-                compile_expr(arg_expr, body, ctx, state)?;
+                    compile_expr(arg_expr, body, ctx, state)?;
+                }
+                let func_idx = ctx
+                    .func_ids
+                    .get(&call.name)
+                    .ok_or_else(|| format!("unknown function '{}'", call.name))?;
+                Instruction::Call(*func_idx).encode(body);
             }
-            let func_idx = ctx
-                .func_ids
-                .get(&call.name)
-                .ok_or_else(|| format!("unknown function '{}'", call.name))?;
-            Instruction::Call(*func_idx).encode(body);
         }
         ast::Expr::Self_ => {
             let idx = ctx
@@ -1060,10 +1072,12 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
                 .ok_or_else(|| "codegen: 'self' used outside a method".to_string())?;
             Instruction::LocalGet(idx).encode(body);
         }
-        ast::Expr::TypeName(n) => match n.as_str() {
+        ast::Expr::TypeName(n) => match ctx.enum_variants.get(n) {
+            Some(info) if info.field_types.is_empty() => {
-            "True" => Instruction::I32Const(1).encode(body),
+                Instruction::I32Const(info.tag).encode(body);
+            }
-            "False" => Instruction::I32Const(0).encode(body),
+            Some(_) => return Err(format!("codegen: '{}' carries a payload — construct it with '{}(...)'", n, n)),
-            other => return Err(format!("codegen: type name '{}' is not yet supported as a value", other)),
+            None => return Err(format!("codegen: type name '{}' is not yet supported as a value", n)),
         },
         ast::Expr::ClassCall(call) => {
             let fields = ctx
@@ -1176,3 +1190,64 @@ fn compile_expr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mu
     }
     Ok(())
 }
+/// Compiles a variant-construction call. A payload-free variant (`None`, called as
+/// `None()` rather than used bare) is just its tag. A payload variant bump-allocates
+/// `[tag: i32][field0][field1]...` (8-byte stride per slot, matching class field
+/// layout) and leaves the base pointer on the stack.
+fn compile_variant_construction(
+    info: &EnumVariantInfo,
+    call: &ast::FnCall,
+    expr: &ast::Expr,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    if call.args.len() != info.field_types.len() {
+        return Err(format!(
+            "codegen: variant '{}' expects {} arg(s), got {}",
+            call.name, info.field_types.len(), call.args.len()
+        ));
+    }
+    if info.field_types.is_empty() {
+        Instruction::I32Const(info.tag).encode(body);
+        return Ok(());
+    }
+    let size = (1 + info.field_types.len() as i32) * 8;
+    let scratch_key = expr as *const ast::Expr as usize;
+    let scratch_idx = *ctx
+        .classcall_scratch
+        .get(&scratch_key)
+        .ok_or_else(|| "internal codegen error: missing variant-call scratch slot".to_string())?;
+    let scratch_local = ctx.classcall_scratch_base + scratch_idx;
+    Instruction::GlobalGet(ctx.bump_global).encode(body);
+    Instruction::LocalSet(scratch_local).encode(body);
+    Instruction::GlobalGet(ctx.bump_global).encode(body);
+    Instruction::I32Const(size).encode(body);
+    Instruction::I32Add.encode(body);
+    Instruction::GlobalSet(ctx.bump_global).encode(body);
+    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::I32Const(info.tag).encode(body);
+    Instruction::I32Store(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
+    for (i, (arg, field_ty)) in call.args.iter().zip(info.field_types.iter()).enumerate() {
+        let arg_expr = match arg {
+            ast::Arg::Positional(e) => e,
+            ast::Arg::Keyword { value, .. } => value,
+            ast::Arg::Pair { value, .. } => value,
+        };
+        Instruction::LocalGet(scratch_local).encode(body);
+        compile_expr(arg_expr, body, ctx, state)?;
+        let offset = ((i + 1) as u64) * 8;
+        match plum_type_to_valtype(field_ty) {
+            ValType::I64 => Instruction::I64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+            ValType::F64 => Instruction::F64Store(MemArg { offset, align: 3, memory_index: 0 }).encode(body),
+            _ => Instruction::I32Store(MemArg { offset, align: 2, memory_index: 0 }).encode(body),
+        };
+    }
+    Instruction::LocalGet(scratch_local).encode(body);
+    Ok(())
+}

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

@@ -366,3 +366,59 @@ main() -> Int =
     let err = main.call(&mut store, ()).expect_err("todo should trap");
     assert_eq!(err.downcast_ref::<wasmtime::Trap>(), Some(&wasmtime::Trap::UnreachableCodeReached), "got: {}", err);
 }
+#[test]
+fn payload_free_variant_construction_compiles() {
+    let src = "\
+enum Color =
+  | Red
+  | Green
+  | Blue
+main() -> Int =\n  x = Green\n  0\n";
+    assert_valid(src);
+}
+#[test]
+fn payload_variant_construction_compiles_and_runs() {
+    let src = "\
+enum Option =
+  | Some(Int)
+  | None
+unwrapOr(o: Option, default: Int) -> Int =
+  match o
+    Some(v) =>
+      return v
+    None =>
+      return default
+main() -> Int =
+  unwrapOr(Some(7), 0)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 7);
+}
+#[test]
+fn multi_field_variant_construction_compiles_and_runs() {
+    let src = "\
+enum Shape =
+  | Rect(Int, Int)
+  | Circle(Int)
+area(s: Shape) -> Int =
+  match s
+    Rect(w, h) =>
+      return w * h
+    Circle(r) =>
+      return r * r
+main() -> Int =
+  area(Rect(3, 4))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 12);
+}