8ecbf56 | plum

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

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

8ecbf56 — Peter John 2026-07-20T11:47:23+05:30

feat(plum-wasm-codegen): compile general enum match patterns (tags + constructors)

Files changed (2) hide show

plum-wasm-codegen/src/lib.rs +90 -13
plum-wasm-codegen/tests/codegen_tests.rs +47 -0

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

@@ -431,12 +431,25 @@ impl<'a> Collector<'a> {
                 for case in &m.cases {
                     let saved = self.env.clone();
                     if m.subjects.len() == 1 {
+                        match case.patterns.first() {
-                        if let Some(ast::CasePattern::Name(n)) = case.patterns.first() {
+                            Some(ast::CasePattern::Name(n)) => {
-                            let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
+                                let is_variant = n.chars().next().map(|c| c.is_uppercase()).unwrap_or(false)
-                                && self.cctx.enum_variants.contains_key(n);
+                                    && self.cctx.enum_variants.contains_key(n);
-                            if !is_variant {
+                                if !is_variant {
-                                self.bind(n, subject_ty.clone());
+                                    self.bind(n, subject_ty.clone());
+                                }
                             }
+                            Some(ast::CasePattern::Class { name, fields }) => {
+                                if let Some(info) = self.cctx.enum_variants.get(name) {
+                                    let field_types = info.field_types.clone();
+                                    for (f, fty) in fields.iter().zip(field_types.iter()) {
+                                        if let ast::CasePattern::Name(n) = f {
+                                            self.bind(n, fty.clone());
+                                        }
+                                    }
+                                }
+                            }
+                            _ => {}
                         }
                     }
                     self.walk_block(&case.body);
@@ -901,7 +914,9 @@ fn compile_match_arms(
         }
         ast::CasePattern::String(_) => Err("codegen: string match patterns are not yet supported".to_string()),
         ast::CasePattern::Float(_) => Err("codegen: float match patterns are not yet supported".to_string()),
+        ast::CasePattern::Class { name, fields } => {
-        ast::CasePattern::Class { .. } => Err("codegen: constructor match patterns are not yet supported".to_string()),
+            compile_variant_constructor_arm(name, fields, subject_vt, scratch_local, case, rest, body, ctx, state)
+        }
     }
 }
@@ -916,15 +931,14 @@ fn compile_variant_eq_arm(
     ctx: &LocalCtx,
     state: &mut ModuleState,
 ) -> Result<(), String> {
-    // Only Bool's own variants have a concrete runtime representation in v1.5.
-    let tag = match name {
+    let info = ctx
-        "True" => 1i32,
+        .enum_variants
-        "False" => 0i32,
+        .get(name)
-        other => return Err(format!("codegen: enum variant pattern '{}' is not yet supported (only True/False)", other)),
+        .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
-    };
     if subject_vt != ValType::I32 {
-        return Err("codegen: Bool match pattern against a non-Bool subject".to_string());
+        return Err(format!("codegen: enum tag pattern '{}' against a non-enum subject", name));
     }
+    let tag = info.tag;
     Instruction::LocalGet(scratch_local).encode(body);
     Instruction::I32Const(tag).encode(body);
     Instruction::I32Eq.encode(body);
@@ -936,6 +950,69 @@ fn compile_variant_eq_arm(
     Ok(())
 }
+#[allow(clippy::too_many_arguments)]
+fn compile_variant_constructor_arm(
+    name: &str,
+    fields: &[ast::CasePattern],
+    subject_vt: ValType,
+    scratch_local: u32,
+    case: &ast::Case,
+    rest: &[ast::Case],
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let info = ctx
+        .enum_variants
+        .get(name)
+        .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
+    if subject_vt != ValType::I32 {
+        return Err(format!("codegen: constructor pattern '{}' against a non-enum subject", name));
+    }
+    if fields.len() != info.field_types.len() {
+        return Err(format!(
+            "codegen: constructor pattern '{}' expects {} field(s), got {}",
+            name, info.field_types.len(), fields.len()
+        ));
+    }
+    let tag = info.tag;
+    let field_types = info.field_types.clone();
+    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::If(BlockType::Empty).encode(body);
+    for (i, (pat, field_ty)) in fields.iter().zip(field_types.iter()).enumerate() {
+        let bind_name = match pat {
+            ast::CasePattern::Name(n) => Some(n.as_str()),
+            ast::CasePattern::Wildcard => None,
+            _ => return Err("codegen: only bare bindings or '_' are supported inside a constructor pattern".to_string()),
+        };
+        if let Some(n) = bind_name {
+            let idx = ctx
+                .locals
+                .get(n)
+                .copied()
+                .ok_or_else(|| format!("internal codegen error: missing binding local '{}'", n))?;
+            Instruction::LocalGet(scratch_local).encode(body);
+            let offset = ((i + 1) as u64) * 8;
+            match plum_type_to_valtype(field_ty) {
+                ValType::I64 => Instruction::I64Load(MemArg { offset, align: 3, memory_index: 0 }),
+                ValType::F64 => Instruction::F64Load(MemArg { offset, align: 3, memory_index: 0 }),
+                _ => Instruction::I32Load(MemArg { offset, align: 2, memory_index: 0 }),
+            }.encode(body);
+            Instruction::LocalSet(idx).encode(body);
+            ctx.type_env.borrow_mut().insert(n.to_string(), TypeScheme::mono(field_ty.clone()));
+        }
+    }
+    compile_block(&case.body, body, ctx, state)?;
+    Instruction::Else.encode(body);
+    compile_match_arms(rest, subject_vt, scratch_local, body, ctx, state)?;
+    Instruction::End.encode(body);
+    Ok(())
+}
 fn plum_type_from_valtype_hint(vt: ValType) -> PlumType {
     match vt {
         ValType::I64 => PlumType::TInt,

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

@@ -422,3 +422,50 @@ main() -> Int =
     let bytes = compile_source(&source).expect("compile failed");
     assert_eq!(run_main(&bytes), 12);
 }
+#[test]
+fn non_bool_bare_tag_pattern_runs_correctly() {
+    let src = "\
+enum Color =
+  | Red
+  | Green
+  | Blue
+code(c: Color) -> Int =
+  match c
+    Red =>
+      return 1
+    Green =>
+      return 2
+    Blue =>
+      return 3
+main() -> Int =
+  code(Green)
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 2);
+}
+#[test]
+fn constructor_pattern_wildcard_field_runs_correctly() {
+    let src = "\
+enum Option =
+  | Some(Int)
+  | None
+isSome(o: Option) -> Int =
+  match o
+    Some(_) =>
+      return 1
+    None =>
+      return 0
+main() -> Int =
+  isSome(Some(99))
+";
+    let source = parse(src);
+    let bytes = compile_source(&source).expect("compile failed");
+    assert_eq!(run_main(&bytes), 1);
+}