a577529 | plum | pyrossh

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

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

a577529 — Peter John 2026-09-03T20:39:58+05:30

feat(plum): let match destructure a plain class like an enum variant

Files changed (4) hide show

examples/match.plum +35 -0
plum-checker/src/lib.rs +24 -6
plum-checker/tests/checker_tests.rs +33 -0
plum-wasm-codegen/src/lib.rs +105 -10

examples/match.plum CHANGED Viewed

@@ -189,3 +189,38 @@ fun bothOptions(a: Option, b: Option) -> Int =
 test "multi subject match with generic enum variant runs correctly"
   expect bothOptions(Some(3), Some(4)) == 7
+type Point =
+  x: Int
+  y: Int
+fun sumPoint(p: Point) -> Int =
+  match p
+    Point(x, y) => x + y
+test "match destructures a plain class the same way it destructures an enum variant"
+  expect sumPoint(Point(x: 3, y: 4)) == 7
+fun classifyPoint(p: Point) -> Str =
+  match p
+    Point(0, 0) => "origin"
+    Point(x, 0) => "on x axis"
+    Point(_, _) => "elsewhere"
+test "match on a plain class supports literal/wildcard sub-patterns and case fallthrough"
+  expect classifyPoint(Point(x: 0, y: 0)) == "origin"
+  expect classifyPoint(Point(x: 5, y: 0)) == "on x axis"
+  expect classifyPoint(Point(x: 5, y: 5)) == "elsewhere"
+enum Shape =
+  | Circle[Point]
+  | Square[Point]
+fun shapeMeasure(s: Shape) -> Int =
+  match s
+    Circle(Point(x, y)) => x + y
+    Square(Point(x, y)) => x * y
+test "a plain class nested inside an enum variant pattern destructures correctly"
+  expect shapeMeasure(Circle(Point(x: 3, y: 4))) == 7
+  expect shapeMeasure(Square(Point(x: 3, y: 4))) == 12

plum-checker/src/lib.rs CHANGED Viewed

@@ -885,13 +885,31 @@ fn checkPattern(pat: &ast::CasePattern, subject_ty: &PlumType, env: &mut TypeEnv
                 }
                 Ok(())
             }
+            // Not an enum variant — a PLAIN CLASS is destructured the same way (see
+            // `plum-wasm-codegen`'s matching `compileClassDestructureArm`): every
-            // Unmodeled/builtin variant: allow, codegen will catch.
+            // instance is already "the one variant", so there's no tag to check,
+            // just its declared fields (in declaration order) to match against.
-            None => {
+            None => match ctx.classes.get(name) {
-                for f in fields {
+                Some(class_fields) => {
+                    if fields.len() != class_fields.len() {
+                        return Err(format!(
+                            "constructor pattern '{}' expects {} field(s), got {}",
+                            name, class_fields.len(), fields.len()
+                        ));
+                    }
+                    for (f, (_, fty)) in fields.iter().zip(class_fields.iter()) {
-                    checkPattern(f, &PlumType::TVar("_".to_string()), env, ctx)?;
+                        checkPattern(f, fty, env, ctx)?;
+                    }
+                    Ok(())
                 }
+                // Unmodeled/builtin variant or class: allow, codegen will catch.
+                None => {
+                    for f in fields {
+                        checkPattern(f, &PlumType::TVar("_".to_string()), env, ctx)?;
+                    }
-                Ok(())
+                    Ok(())
-            }
+                }
+            },
         },
     }
 }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -1032,3 +1032,36 @@ type MyErr(Err) =
     let source = parse(src);
     assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
 }
+#[test]
+fn matchDestructuresPlainClassAndBindsFieldTypes() {
+    let src = "\
+type Point =
+  x: Int
+  y: Int
+fun sumPoint(p: Point) -> Int =
+  match p
+    Point(x, y) => x + y
+";
+    let source = parse(src);
+    assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
+}
+#[test]
+fn matchClassPatternWrongFieldCountIsError() {
+    let src = "\
+type Point =
+  x: Int
+  y: Int
+fun sumPoint(p: Point) -> Int =
+  match p
+    Point(x) => x
+";
+    let source = parse(src);
+    let result = checkSource(&source);
+    assert!(result.is_err());
+    let errs = result.unwrap_err();
+    assert!(errs.iter().any(|e| e.message.contains("expects 2 field(s), got 1")), "got: {:?}", errs);
+}

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

@@ -505,6 +505,16 @@ fn withGcTypes<R>(f: impl FnOnce(&GcTypeRegistry) -> R) -> R {
     })
 }
+/// A constructor-pattern name (`nested_class_scratch_types`'s recorded name, or any
+/// other spot a pattern's own concrete GC type index is needed) is EITHER an enum
+/// variant or a plain class — see `compileClassDestructureArm`. Checks both
+/// registries so a scratch local narrows correctly either way.
+fn classOrVariantTypeIdx(r: &GcTypeRegistry, name: &str) -> u32 {
+    *r.variant_type_idx.get(name)
+        .or_else(|| r.class_type_idx.get(name))
+        .unwrap_or_else(|| panic!("internal codegen error: '{}' missing from the GC type registry (neither a variant nor a class)", name))
+}
 /// Resolves an `ast::Type`/`ast::ParamType`'s bare name (e.g. from a function
 /// signature, before any `PlumType`/checker involvement) to its wasm-gc `ValType`.
 fn astTypeToWasm(name: &str) -> Option<ValType> {
@@ -2496,6 +2506,11 @@ impl<'a> Collector<'a> {
                     for (f, fty) in fields.iter().zip(field_types.iter()) {
                         self.collectPattern(f, fty);
                     }
+                } else if let Some(class_fields) = self.cctx.classes.get(name) {
+                    let field_types: Vec<PlumType> = class_fields.iter().map(|(_, t)| t.clone()).collect();
+                    for (f, fty) in fields.iter().zip(field_types.iter()) {
+                        self.collectPattern(f, fty);
+                    }
                 }
             }
             _ => {}
@@ -2734,8 +2749,7 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
     // holding the narrowed (`ref.cast`) value to be statically typed as that exact
     // variant, and different slots very likely narrow to different variants.
     for vname in &collector.nested_class_scratch_types {
-        let variant_idx = withGcTypes(|r| *r.variant_type_idx.get(vname)
+        let variant_idx = withGcTypes(|r| classOrVariantTypeIdx(r, vname));
-            .unwrap_or_else(|| panic!("internal codegen error: variant '{}' missing from the GC type registry", vname)));
         groups.push(gcRef(variant_idx));
         idx += 1;
     }
@@ -3483,7 +3497,11 @@ fn compileCasePositions(
         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 } => {
+            if ctx.enum_variants.contains_key(name) {
-            compileVariantConstructorArm(pat, name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
+                compileVariantConstructorArm(pat, name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
+            } else {
+                compileClassDestructureArm(name, fields, subject_vt, scratch_local, case, pos, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state)
+            }
         }
     }
 }
@@ -3590,6 +3608,51 @@ fn compileVariantConstructorArm(
     Ok(())
 }
+/// Destructures a PLAIN CLASS constructor pattern (`Point(x, y)` where `Point` is a
+/// `type`, not an enum variant) — the counterpart to `compileVariantConstructorArm`.
+/// A class subject has only "the one shape": there's no discriminant to test, and
+/// the subject's own static type already IS this exact concrete GC struct type (the
+/// checker already verified `name` matches it), so this always matches — just
+/// destructure fields straight off `scratch_local` itself, no `ref.test`/`ref.cast`
+/// narrowing or separate scratch local needed at all.
+#[allow(clippy::too_many_arguments)]
+fn compileClassDestructureArm(
+    name: &str,
+    fields: &[ast::CasePattern],
+    subject_vt: ValType,
+    scratch_local: u32,
+    case: &ast::Case,
+    pos: usize,
+    all_subjects: &[(ValType, u32)],
+    rest: &[ast::Case],
+    result_vt: Option<ValType>,
+    exhaustive_fallback: bool,
+    body: &mut Vec<u8>,
+    ctx: &LocalCtx,
+    state: &mut ModuleState,
+) -> Result<(), String> {
+    let class_fields = ctx
+        .classes
+        .get(name)
+        .ok_or_else(|| format!("codegen: unknown constructor '{}' (neither an enum variant nor a class)", name))?;
+    if !matches!(subject_vt, ValType::Ref(_)) {
+        return Err(format!("codegen: constructor pattern '{}' against a non-class subject", name));
+    }
+    if fields.len() != class_fields.len() {
+        return Err(format!(
+            "codegen: constructor pattern '{}' expects {} field(s), got {}",
+            name, class_fields.len(), fields.len()
+        ));
+    }
+    let class_type_idx = *ctx.gc_types.class_type_idx.get(name)
+        .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", name))?;
+    let field_types: Vec<PlumType> = class_fields.iter().map(|(_, t)| t.clone()).collect();
+    compileFieldPatterns(
+        fields, &field_types, 0, scratch_local, class_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state,
+        &mut |body, state| compileCasePositions(case, pos + 1, all_subjects, rest, result_vt, exhaustive_fallback, body, ctx, state),
+    )
+}
 /// Checks `fields[fpos..]` (a constructor pattern's own sub-patterns, e.g. the `v` in
 /// `Some(v)`, or — recursively — the `Some(v)` in `Wrap(Some(v))`) against the
 /// already-loaded value in `container_local`, one field at a time. Once every field
@@ -3675,11 +3738,8 @@ fn compileFieldPatterns(
         }
         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: inner_fields } => {
+        ast::CasePattern::Class { name, fields: inner_fields } if ctx.enum_variants.contains_key(name) => {
-            let info = ctx
-                .enum_variants
-                .get(name)
-                .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
+            let info = ctx.enum_variants.get(name).expect("just checked contains_key");
             if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
                 return Err(format!("codegen: constructor pattern '{}' against a non-enum field", name));
             }
@@ -3716,6 +3776,42 @@ fn compileFieldPatterns(
             Instruction::End.encode(body);
             Ok(())
         }
+        // A plain class nested inside another constructor pattern's fields (see
+        // `compileClassDestructureArm`'s doc comment) — there's only ever "the one
+        // shape" to match, so no `ref.test`/`ref.cast` narrowing is needed; just
+        // load the field into its own local (`compileFieldPatterns` needs a LOCAL
+        // to repeatedly `struct.get` against, not a bare stack value) and recurse.
+        ast::CasePattern::Class { name, fields: inner_fields } => {
+            let class_fields = ctx
+                .classes
+                .get(name)
+                .ok_or_else(|| format!("codegen: unknown constructor '{}' (neither an enum variant nor a class)", name))?;
+            if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
+                return Err(format!("codegen: constructor pattern '{}' against a non-class field", name));
+            }
+            if inner_fields.len() != class_fields.len() {
+                return Err(format!(
+                    "codegen: constructor pattern '{}' expects {} field(s), got {}",
+                    name, class_fields.len(), inner_fields.len()
+                ));
+            }
+            let inner_class_type_idx = *ctx.gc_types.class_type_idx.get(name)
+                .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", name))?;
+            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())?;
+            let nested_local = ctx.nested_class_scratch_base + slot;
+            let inner_field_types: Vec<PlumType> = class_fields.iter().map(|(_, t)| t.clone()).collect();
+            Instruction::LocalGet(container_local).encode(body);
+            Instruction::StructGet { struct_type_index: container_type_idx, field_index: fpos as u32 }.encode(body);
+            Instruction::LocalSet(nested_local).encode(body);
+            compileFieldPatterns(inner_fields, &inner_field_types, 0, nested_local, inner_class_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, &mut |body, state| {
+                compileFieldPatterns(fields, field_types, fpos + 1, container_local, container_type_idx, rest, all_subjects, result_vt, exhaustive_fallback, body, ctx, state, on_match)
+            })
+        }
     }
 }
@@ -4494,8 +4590,7 @@ fn compileClosureBody(
     // holding the narrowed (`ref.cast`) value to be statically typed as that exact
     // variant, and different slots very likely narrow to different variants.
     for vname in &collector.nested_class_scratch_types {
-        let variant_idx = withGcTypes(|r| *r.variant_type_idx.get(vname)
+        let variant_idx = withGcTypes(|r| classOrVariantTypeIdx(r, vname));
-            .unwrap_or_else(|| panic!("internal codegen error: variant '{}' missing from the GC type registry", vname)));
         groups.push(gcRef(variant_idx));
         idx += 1;
     }