5e131a3 | plum

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

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

5e131a3 — Peter John 2026-07-20T12:14:54+05:30

fix(plum-wasm-codegen): guard constructor-pattern match against payload-free sibling values

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +12 -0
plum-wasm-codegen/tests/codegen_tests.rs +83 -0

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

@@ -978,10 +978,22 @@ fn compile_variant_constructor_arm(
     let tag = info.tag;
     let field_types = info.field_types.clone();
+    // A constructor pattern can only match if the runtime subject is actually
+    // a heap pointer (payload variants are always >= HEAP_BASE); a
+    // payload-free sibling variant is a small int tag, and loading i32 from
+    // that address would read unrelated/zeroed memory instead of a real tag.
+    // Guard with a range check before doing the I32Load.
+    Instruction::LocalGet(scratch_local).encode(body);
+    Instruction::I32Const(HEAP_BASE as i32).encode(body);
+    Instruction::I32GeU.encode(body);
+    Instruction::If(BlockType::Result(ValType::I32)).encode(body);
     Instruction::LocalGet(scratch_local).encode(body);
     Instruction::I32Load(MemArg { offset: 0, align: 2, memory_index: 0 }).encode(body);
     Instruction::I32Const(tag).encode(body);
     Instruction::I32Eq.encode(body);
+    Instruction::Else.encode(body);
+    Instruction::I32Const(0).encode(body);
+    Instruction::End.encode(body);
     Instruction::If(BlockType::Empty).encode(body);
     for (i, (pat, field_ty)) in fields.iter().zip(field_types.iter()).enumerate() {
         let bind_name = match pat {

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

@@ -159,6 +159,36 @@ fn match_string_pattern_is_a_clear_error() {
     assert!(err.contains("string match"), "got: {}", err);
 }
+#[test]
+fn nested_constructor_pattern_is_a_clear_error() {
+    let src = "\
+enum Option =
+  | Some(Int)
+  | None
+enum Nested =
+  | Wrap(Option)
+  | Empty
+f(n: Nested) -> Int =
+  match n
+    Wrap(Some(v)) =>
+      return v
+    Empty =>
+      return 0
+main() -> Int =
+  f(Empty)
+";
+    let source = parse(src);
+    let err = compile_source(&source).expect_err("nested constructor patterns are not yet supported");
+    assert!(
+        err.contains("only bare bindings or '_' are supported inside a constructor pattern"),
+        "got: {}",
+        err
+    );
+}
 /// Runs `main`'s wasm bytes and returns its i64 result. wasm's own validator
 /// (via wasmparser, above) only proves the module is well-formed — it can't catch
 /// wrong *values*, so these tests actually execute the compiled output.
@@ -469,3 +499,56 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 1);
 }
+#[test]
+fn constructor_pattern_does_not_misfire_on_payload_free_sibling() {
+    // Regression test: `None` is a small-int tag, not a heap pointer. The
+    // constructor-pattern arm for `Some(v)` must not treat a payload-free
+    // sibling value as if it were a pointer to a `Some` payload.
+    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(None, 5)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 5);
+}
+#[test]
+fn enum_class_field_construct_and_destructure_runs_correctly() {
+    // Interop check: a class with a field of an enum type, constructed with a
+    // payload variant, then matched via the class field.
+    let src = "\
+enum Option =
+  | Some(Int)
+  | None
+type Box =
+  value: Option
+unwrap<Box>(default: Int) -> Int =
+  match self.value
+    Some(v) =>
+      return v
+    None =>
+      return default
+main() -> Int =
+  b = Box(value: Some(42))
+  b.unwrap(0)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 42);
+}