5f2f962 | plum | pyrossh

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

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

5f2f962 — Peter John 2026-09-08T12:01:22+05:30

feat(lang): remove type/class entirely, enum is the only declaration form

Files changed (42) hide show

README.md +18 -12
plum-checker/src/lib.rs +128 -184
plum-checker/src/monomorphize.rs +158 -367
plum-checker/tests/checker_tests.rs +49 -82
plum-checker/tests/monomorphize_tests.rs +2 -27
plum-core/src/ast.rs +6 -16
plum-core/src/builtin_usage.rs +0 -5
plum-core/src/loader.rs +11 -11
plum-core/src/parser.rs +15 -50
plum-core/tests/formatter_test.rs +3 -4
plum-core/tests/loader_test.rs +4 -4
plum-core/tests/parser_test.rs +8 -8
plum-examples/closures.plum +2 -2
plum-examples/functions.plum +6 -6
plum-examples/match.plum +2 -3
plum-examples/methods.plum +4 -6
plum-examples/oop_visitor.plum +8 -17
plum-examples/types.plum +19 -24
plum-std/Array.plum +3 -1
plum-std/Buffer.plum +2 -3
plum-std/Byte.plum +3 -1
plum-std/ByteSlice.plum +3 -1
plum-std/Http.plum +2 -4
plum-std/Json.plum +4 -6
plum-std/List.plum +4 -8
plum-std/Map.plum +4 -6
plum-std/Str.plum +2 -2
plum-std/Time.plum +6 -8
plum-std/Uuid.plum +2 -2
plum-tooling/tree-sitter-plum/grammar.js +11 -16
plum-tooling/tree-sitter-plum/queries/plum/format.scm +7 -32
plum-tooling/tree-sitter-plum/queries/plum/highlights.scm +1 -1
plum-tooling/tree-sitter-plum/queries/plum/indents.scm +0 -2
plum-tooling/tree-sitter-plum/queries/plum/tags.scm +0 -3
plum-tooling/tree-sitter-plum/queries/plum/textobjects.scm +0 -3
plum-tooling/tree-sitter-plum/src/grammar.json +0 -0
plum-tooling/tree-sitter-plum/src/node-types.json +0 -0
plum-tooling/tree-sitter-plum/src/parser.c +0 -0
plum-tooling/tree-sitter-plum/test/corpus/type.txt +64 -54
plum-tooling/tree-sitter-plum/test/highlight/sample.plum +2 -3
plum-wasm-codegen/src/lib.rs +158 -277
plum-wasm-codegen/tests/codegen_tests.rs +6 -9

README.md CHANGED Viewed

@@ -170,13 +170,14 @@ $ plum test plum-examples/testing.plum
 ## Types: records, traits, enums
+There's a single declaration form, `enum` — a record type is just a single-variant enum whose one variant shares the enum's own name:
 ```plum
-type Point =
+enum Point =
-  x: Int
+  | Point(x: Int, y: Int)
-  y: Int
-type Named(ToStr) = # implements ToStr
+enum Named(ToStr) = # implements ToStr
-  name: Str
+  | Named(name: Str)
 trait Shape =
   area() -> Float
@@ -203,8 +204,8 @@ enum Step(n: Int) = # a shared field on every variant ...
 ## Generics
 ```plum
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
 trait Comparable[T: Ord] = # bounded generic param
   compareTo(other: T) -> Int
@@ -235,12 +236,11 @@ A closure literal is `|params| body`. Capture is snapshot-by-value: a closure co
 ## `self`, field access, and methods
-A `fun` declared indented directly inside a `type`/`enum` body is a method, with an implicit `self`:
+A `fun` declared indented directly inside an `enum` body is a method, with an implicit `self`:
 ```plum
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun getAge(self) -> Int =
     self.age
   fun birthday(self) -> Int =
@@ -259,7 +259,13 @@ fun main() -> Int =
 Cat(name: "Whiskers", age: 3)
 ```
-Construct a `type` value by calling its name with `field: value` pairs (any order; every field required).
+Construct a record-shaped enum value by calling its name with `field: value` pairs (any order; every field required).
+Fields are mutable (`c.age = c.age + 1`), and a Gleam-style spread updates a copy from an existing value, overriding just the fields you name:
+```plum
+older := Cat(..c, age: c.age + 1)
+```
 ## `match`

plum-checker/src/lib.rs CHANGED Viewed

@@ -163,8 +163,6 @@ pub fn lookup(env: &TypeEnv, name: &str) -> Result<PlumType, String> {
         .ok_or_else(|| format!("undefined name '{}'", name))
 }
-/// Field names and types for every `type ClassName = ...` declaration in the source.
-pub type ClassEnv = BTreeMap<String, Vec<(String, PlumType)>>;
 /// `(receiver type, method name) -> TFun` for every `name<Receiver>(...)` method.
 pub type MethodEnv = BTreeMap<(String, String), PlumType>;
 /// Info about one `enum` variant: which enum it belongs to, its 0-based runtime tag
@@ -221,7 +219,6 @@ pub fn buildMinRequiredArgs(source: &ast::Source) -> MinRequiredArgs {
 /// Shared, read-only lookup tables built once from the whole source, threaded through
 /// every check/infer call alongside the (mutable, scope-local) `TypeEnv`.
 pub struct CheckCtx<'a> {
-    pub classes: &'a ClassEnv,
     pub methods: &'a MethodEnv,
     pub enum_variants: &'a EnumVariants,
     pub enum_params: &'a EnumParams,
@@ -232,27 +229,23 @@ pub struct CheckCtx<'a> {
 /// signatures, enum variants) from a whole source. Shared by `checkSource` and by
 /// `plum-wasm-codegen`, which needs the same tables to resolve `self`, field access,
 /// and method dispatch during code generation.
-pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv, EnumVariants, EnumParams) {
+pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, MethodEnv, EnumVariants, EnumParams) {
     let mut global_env: TypeEnv = TypeEnv::new();
-    let mut classes: ClassEnv = BTreeMap::new();
     let mut methods: MethodEnv = BTreeMap::new();
     let mut enum_variants: EnumVariants = BTreeMap::new();
     let mut enum_params: EnumParams = BTreeMap::new();
-    // First pass: register class fields, THEN enum variants, so a bare variant
+    // First pass: find every "record-shaped" enum — exactly one variant, whose
+    // name equals the enum's own name (the `type X = ...` replacement shape,
-    // (`| FantasyBook`, no `[...]` payload) that names an already-declared
+    // e.g. `enum Cat = | Cat(name: Str)`) — so a bare variant elsewhere naming
-    // `type` can be recognized as sugar for wrapping that whole class as its
+    // one can wrap it as sugar (see the bare-wrap arm below), regardless of
-    // single payload field — regardless of whether the `type` or the `enum`
-    // appears first in the file. Resolves `self.field`, `ClassName(...)`, and
-    // bare enum-tag patterns for later passes.
+    // which declaration appears first in the file.
-    for item in &source.items {
+    let record_shaped: std::collections::BTreeSet<&str> = source.items.iter()
-        if let ast::Item::Class(c) = item {
+        .filter_map(|item| match item {
-            let fields = c.fields.iter()
-                .map(|f| (f.name.clone(), plumTypeFromAst(&f.ty)))
+            ast::Item::Enum(e) if e.variants.len() == 1 && e.variants[0].name == e.name => Some(e.name.as_str()),
+            _ => None,
+        })
-                .collect();
+        .collect();
-            classes.insert(c.name.clone(), fields);
-        }
-    }
     for item in &source.items {
         match item {
             ast::Item::Enum(e) => {
@@ -274,31 +267,25 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
                         // `plum-std/Number.plum`) — the wrapped payload is the
                         // dedicated primitive `PlumType` itself (`TInt`/
                         // `TFloat`), not a `TNamed` self-reference. Checked
-                        // BEFORE the class bare-wrap case below: historically
+                        // BEFORE the record-shaped bare-wrap case below, since
-                        // `Int`/`Float` were ALSO registered as zero-field
-                        // "method-holder" classes (`type Int = fun
-                        // abs(self)...`, attaching methods to the primitive
-                        // receiver, before their methods moved into `Number`
-                        // itself) — this ordering is what made a real
-                        // primitive win that name collision over the
-                        // incidentally-same-named class, and stays a
-                        // defensive safeguard against a future same-named
-                        // class reintroducing it. This is what lets a bare
-                        // `Int`/`Float` value be used directly wherever
+                        // `Int`/`Float` have no such enum of their own to wrap.
+                        // This is what lets a bare `Int`/`Float` value be used
-                        // `Number` is expected with no wrapper syntax — see
+                        // directly wherever `Number` is expected with no wrapper
-                        // `unify`'s matching
+                        // syntax — see `unify`'s matching
                         // primitive-vs-enum arm, and
                         // `monomorphize::wrapPrimitiveAgainstExpected`, which
                         // does the actual AST rewrite into this variant's
                         // constructor at specific expected-type usage sites.
                         (vec![plumTypeFromName(&v.name)], Vec::new())
-                    } else if v.fields.is_empty() && classes.contains_key(&v.name) {
+                    } else if v.fields.is_empty() && e.name != v.name && record_shaped.contains(v.name.as_str()) {
-                        // Bare-type variant sugar: `| FantasyBook` (no `[...]`)
+                        // Bare-type variant sugar: `| Cat` (no `[...]`) naming a
-                        // naming a class declared elsewhere means "this variant
+                        // DIFFERENT, already-declared record-shaped enum means "this
-                        // wraps one payload field of that same-named class" —
+                        // variant wraps one payload field of that whole record" —
-                        // shorthand for the equivalent `| FantasyBook[FantasyBook]`,
+                        // shorthand for the equivalent `| Cat[Cat]`, so `enum Animal
+                        // = | Cat | Dog` needs no separate wrapper tag distinct from
+                        // the record it holds. Excludes `e.name == v.name` (a plain
-                        // so `enum Book = | FantasyBook | ScifiBook` needs no
+                        // payload-free singleton like `enum Foo = | Foo`, which is
-                        // separate wrapper tag distinct from the record it holds.
+                        // already exactly what it says — nothing else to wrap).
                         (vec![PlumType::TNamed(v.name.clone())], Vec::new())
                     } else {
                         (v.fields.iter().map(plumTypeFromAst).collect(), v.field_names.clone())
@@ -359,7 +346,7 @@ pub fn buildGlobalTables(source: &ast::Source) -> (TypeEnv, ClassEnv, MethodEnv,
         }
     }
-    (global_env, classes, methods, enum_variants, enum_params)
+    (global_env, methods, enum_variants, enum_params)
 }
 /// A `Type`'s name for comparison purposes only — deliberately ignores `.generics`
@@ -406,21 +393,21 @@ fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
         .collect();
     for item in &source.items {
-        let ast::Item::Class(c) = item else { continue };
+        let ast::Item::Enum(e) = item else { continue };
-        for trait_name in &c.implements {
+        for trait_name in &e.implements {
             let Some(tr) = traits.get(trait_name.as_str()) else { continue };
             for tm in &tr.methods {
-                let Some(f) = methods_by_receiver.get(&(c.name.as_str(), tm.name.as_str())) else {
+                let Some(f) = methods_by_receiver.get(&(e.name.as_str(), tm.name.as_str())) else {
                     errors.push(CheckError {
-                        message: format!("class '{}' claims to implement trait '{}' but is missing method '{}'", c.name, trait_name, tm.name),
+                        message: format!("enum '{}' claims to implement trait '{}' but is missing method '{}'", e.name, trait_name, tm.name),
                     });
                     continue;
                 };
                 if f.params.len() != tm.params.len() {
                     errors.push(CheckError {
                         message: format!(
-                            "class '{}' method '{}' (implementing trait '{}'): expected {} param(s), got {}",
+                            "enum '{}' method '{}' (implementing trait '{}'): expected {} param(s), got {}",
-                            c.name, tm.name, trait_name, tm.params.len(), f.params.len()
+                            e.name, tm.name, trait_name, tm.params.len(), f.params.len()
                         ),
                     });
                     continue;
@@ -430,8 +417,8 @@ fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
                     if actual != expected {
                         errors.push(CheckError {
                             message: format!(
-                                "class '{}' method '{}' (implementing trait '{}'): param {} ('{}'): expected type '{}', got '{}'",
+                                "enum '{}' method '{}' (implementing trait '{}'): param {} ('{}'): expected type '{}', got '{}'",
-                                c.name, tm.name, trait_name, i, tp.name,
+                                e.name, tm.name, trait_name, i, tp.name,
                                 expected.unwrap_or("<fn>"), actual.unwrap_or("<fn>")
                             ),
                         });
@@ -441,16 +428,16 @@ fn checkTraitConformance(source: &ast::Source) -> Vec<CheckError> {
                     (Some(ft), Some(tt)) if ft.name != tt.name => {
                         errors.push(CheckError {
                             message: format!(
-                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got '{}'",
+                                "enum '{}' method '{}' (implementing trait '{}'): expected return type '{}', got '{}'",
-                                c.name, tm.name, trait_name, tt.name, ft.name
+                                e.name, tm.name, trait_name, tt.name, ft.name
                             ),
                         });
                     }
                     (None, Some(tt)) => {
                         errors.push(CheckError {
                             message: format!(
-                                "class '{}' method '{}' (implementing trait '{}'): expected return type '{}', got none",
+                                "enum '{}' method '{}' (implementing trait '{}'): expected return type '{}', got none",
-                                c.name, tm.name, trait_name, tt.name
+                                e.name, tm.name, trait_name, tt.name
                             ),
                         });
                     }
@@ -467,33 +454,9 @@ pub fn checkSource(source: &ast::Source) -> CheckResult<()> {
     // see `checkTraitConformance`'s own doc comment for why.
     let mut errors: Vec<CheckError> = checkTraitConformance(source);
     let source = monomorphize::monomorphizeSource(source).map_err(|e| vec![CheckError { message: e }])?;
-    let (global_env, classes, methods, enum_variants, enum_params) = buildGlobalTables(&source);
+    let (global_env, methods, enum_variants, enum_params) = buildGlobalTables(&source);
     let min_required = buildMinRequiredArgs(&source);
-    let ctx = CheckCtx { classes: &classes, methods: &methods, enum_variants: &enum_variants, enum_params: &enum_params, min_required: &min_required };
+    let ctx = CheckCtx { methods: &methods, enum_variants: &enum_variants, enum_params: &enum_params, min_required: &min_required };
-    // A name that is both a class and an enum variant is ambiguous: `Name(...)`
-    // could mean either construction, and downstream code (both the checker's
-    // `inferExpr` and codegen) consults `enum_variants` first, so the class
-    // constructor would be silently shadowed with no diagnostic. Reject it —
-    // UNLESS it's the bare-type variant sugar (`enum Book = | FantasyBook`,
-    // see `buildGlobalTables`), which deliberately reuses the class's own name
-    // as its variant tag and self-wraps it (`field_types == [TNamed(name)]`).
-    for name in classes.keys() {
-        if let Some(info) = enum_variants.get(name) {
-            // Same exemption, but for a "union" enum's primitive bare-wrap
-            // variant (`enum Number = | Int | Float`) — `Int`/`Float` are
-            // ALSO registered as zero-field "method-holder" classes (see
-            // `buildGlobalTables`'s primitive-bare-wrap comment), so this
-            // exact collision is expected and deliberate for them too.
-            let is_bare_variant_wrap = info.field_types == [PlumType::TNamed(name.clone())]
-                || info.field_types == [plumTypeFromName(name)];
-            if !is_bare_variant_wrap {
-                errors.push(CheckError {
-                    message: format!("'{}' is declared as both a class and an enum variant", name),
-                });
-            }
-        }
-    }
     // A discriminant enum (`enum Foo(n: Int) = ...`) requires every variant to supply
     // exactly one value per declared param, unified against that param's type. An
@@ -933,37 +896,14 @@ fn inferClassCallRaw(call: &ast::ClassCall, env: &TypeEnv, ctx: &CheckCtx) -> Re
             }
         }
     }
-    match ctx.classes.get(&call.type_name) {
+    match ctx.enum_variants.get(&call.type_name) {
-        Some(fields) => {
-            for fa in &call.fields {
-                match fields.iter().find(|(n, _)| n == &fa.name) {
-                    Some((_, expected)) => {
-                        let actual = inferExpr(&fa.value, env, ctx)?;
-                        unifyArg(expected, &actual, &fa.value, ctx)
-                            .map_err(|e| format!("class '{}' field '{}': {}", call.type_name, fa.name, e))?;
-                    }
-                    None => return Err(format!("unknown field '{}' on class '{}'", fa.name, call.type_name)),
-                }
-            }
-            match &call.spread {
-                Some(spread) => checkSpreadSource(spread, &call.type_name, &call.type_name, env, ctx)?,
-                None => {
-                    for (field_name, _) in fields {
-                        if !call.fields.iter().any(|fa| &fa.name == field_name) {
-                            return Err(format!("class '{}' missing field '{}'", call.type_name, field_name));
-                        }
-                    }
-                }
-            }
-            Ok(PlumType::TNamed(call.type_name.clone()))
-        }
-        // Not a class — a NAMED-payload enum variant (`Circle(radius: Int)`, as
+        // A NAMED-payload enum variant (`Circle(radius: Int)`, as opposed to the
-        // opposed to the positional/generic-payload form `Some[T]`) is constructed
+        // positional/generic-payload form `Some[T]`, which never sets `field_names`
-        // the same `Type(field: value, ...)` way a class is; `field_names` is empty
-        // for the positional form, so this never fires for it (falls through to the
-        // permissive "unmodeled" case below, exactly as before).
+        // and so falls through to the permissive "unmodeled" case below) — this is
+        // ALSO how a record-shaped, single-variant enum (the `type X = ...`
+        // replacement, e.g. `enum Cat = | Cat(name: Str)`) constructs, with no
+        // separate class-construction path needed.
-        None if ctx.enum_variants.get(&call.type_name).is_some_and(|info| !info.field_names.is_empty()) => {
+        Some(info) if !info.field_names.is_empty() => {
-            let info = ctx.enum_variants.get(&call.type_name).expect("just checked is_some");
             for fa in &call.fields {
                 match info.field_names.iter().position(|n| n == &fa.name) {
                     Some(i) => {
@@ -987,8 +927,10 @@ fn inferClassCallRaw(call: &ast::ClassCall, env: &TypeEnv, ctx: &CheckCtx) -> Re
             }
             Ok(PlumType::TNamed(info.enum_name.clone()))
         }
+        // Positional/generic-payload variant (`Some[T]`, constructed via `Expr::FnCall`
+        // elsewhere instead), a payload-free variant, or an unmodeled (e.g.
-        // Unmodeled (e.g. builtin/std) type: allow, codegen will catch.
+        // builtin/std) type: allow, codegen will catch a genuine mismatch.
-        None => Ok(PlumType::TNamed(call.type_name.clone())),
+        _ => Ok(PlumType::TNamed(call.type_name.clone())),
     }
 }
@@ -1026,6 +968,10 @@ fn checkPattern(pat: &ast::CasePattern, subject_ty: &PlumType, env: &mut TypeEnv
             }
         }
         ast::CasePattern::Class { name, fields } => match ctx.enum_variants.get(name) {
+            // Also how a record-shaped, single-variant enum (the `type X = ...`
+            // replacement) destructures — its one variant already IS the whole
+            // value, so there's no tag to check, just its declared fields (in
+            // declaration order) to match against, same as any other variant.
             Some(info) => {
                 if fields.len() != info.field_types.len() {
                     return Err(format!(
@@ -1038,31 +984,13 @@ 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
-            // instance is already "the one variant", so there's no tag to check,
-            // just its declared fields (in declaration order) to match against.
-            None => match ctx.classes.get(name) {
-                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, fty, env, ctx)?;
-                    }
-                    Ok(())
-                }
-                // Unmodeled/builtin variant or class: allow, codegen will catch.
+            // Unmodeled/builtin variant: allow, codegen will catch.
-                None => {
+            None => {
-                    for f in fields {
+                for f in fields {
-                        checkPattern(f, &PlumType::TVar("_".to_string()), env, ctx)?;
+                    checkPattern(f, &PlumType::TVar("_".to_string()), env, ctx)?;
-                    }
-                    Ok(())
                 }
+                Ok(())
-            },
+            }
         },
     }
 }
@@ -1073,7 +1001,7 @@ fn checkPattern(pat: &ast::CasePattern, subject_ty: &PlumType, env: &mut TypeEnv
 /// closure assigned to a variable (not passed directly as a call argument,
 /// which the checker never even sees as a `Closure` literal at all) gives
 /// every param a fresh, unresolved `TVar`, and `TVar` can't be looked up in
-/// `ctx.classes` — any field access on it is a hard error, even though the
+/// `ctx.enum_variants` — any field access on it is a hard error, even though the
 /// exact same shape works fine once compiled (`plum-wasm-codegen`'s own
 /// `resolveClosureParamTypesFromUsage` already does this same resolution, just
 /// too late to help the type-CHECK pass, which runs first). Deliberately a
@@ -1095,10 +1023,10 @@ fn resolveClosureParamFromFieldUsage(
             ast::Expr::Attribute(a) => {
                 if let (ast::AttrKind::Field(field_name), ast::Expr::Var(n)) = (&a.attr, &a.object) {
                     if params.contains(n.as_str()) && !resolved.contains_key(n.as_str()) {
-                        let mut matches = ctx.classes.iter()
+                        let mut matches = ctx.enum_variants.values()
-                            .filter(|(_, fields)| fields.iter().any(|(fname, _)| fname == field_name));
+                            .filter(|info| info.field_names.iter().any(|fname| fname == field_name));
-                        if let (Some((class_name, _)), None) = (matches.next(), matches.next()) {
+                        if let (Some(info), None) = (matches.next(), matches.next()) {
-                            resolved.insert(n.clone(), PlumType::TNamed(class_name.clone()));
+                            resolved.insert(n.clone(), PlumType::TNamed(info.enum_name.clone()));
                         }
                     }
                 }
@@ -1133,39 +1061,46 @@ fn resolveClosureParamFromFieldUsage(
 /// Resolves `class_name`'s field named `field_name` to its type — shared by
 /// `.field` reads (`inferExpr`'s `AttrKind::Field` arm) and `.field = value`
 /// writes (`checkStmt`'s `AssignTarget::Field` arm), so mutation gets the same
-/// class / discriminant-enum-param / single-owning-variant fallback chain
+/// discriminant-enum-param / single-owning-variant fallback chain reads
-/// reads already have. See the call sites' own comments for why each fallback
+/// already have. See the call sites' own comments for why each fallback is
-/// is safe (in particular: exactly one variant may own a given field name;
+/// safe (in particular: exactly one variant may own a given field name; more
-/// more than one is ambiguous and a compile error).
+/// than one is ambiguous and a compile error) — this also covers a
+/// record-shaped, single-variant enum (the `type X = ...` replacement), whose
+/// one variant is trivially its own unique owner of every field it declares.
-fn lookupFieldType(class_name: &str, field_name: &str, ctx: &CheckCtx) -> Result<PlumType, String> {
+pub(crate) fn lookupFieldType(class_name: &str, field_name: &str, ctx: &CheckCtx) -> Result<PlumType, String> {
-    match ctx.classes.get(class_name) {
+    match ctx.enum_params.get(class_name) {
-        Some(fields) => fields.iter()
+        Some(params) => params.iter()
             .find(|(n, _)| n == field_name)
             .map(|(_, t)| t.clone())
             .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
-        None => match ctx.enum_params.get(class_name) {
-            Some(params) => params.iter()
-                .find(|(n, _)| n == field_name)
-                .map(|(_, t)| t.clone())
-                .ok_or_else(|| format!("no field '{}' on type '{}'", field_name, class_name)),
-            None => {
+        None => {
-                let owners: Vec<&EnumVariantInfo> = ctx.enum_variants.values()
+            let owners: Vec<&EnumVariantInfo> = ctx.enum_variants.values()
-                    .filter(|info| info.enum_name == class_name
+                .filter(|info| info.enum_name == class_name
-                        && info.field_names.iter().any(|n| n == field_name))
+                    && info.field_names.iter().any(|n| n == field_name))
-                    .collect();
+                .collect();
-                match owners.as_slice() {
+            match owners.as_slice() {
-                    [info] => {
+                [info] => {
-                        let idx = info.field_names.iter().position(|n| n == field_name).expect("just filtered on this");
+                    let idx = info.field_names.iter().position(|n| n == field_name).expect("just filtered on this");
-                        Ok(info.field_types[idx].clone())
+                    Ok(info.field_types[idx].clone())
-                    }
-                    [] => Ok(PlumType::TVar("_".to_string())),
-                    _ => Err(format!(
-                        "field '{}' is ambiguous across multiple variants of enum '{}' — use a match",
-                        field_name, class_name
-                    )),
                 }
+                // Empty is genuinely ambiguous between two cases that look identical
+                // from here: `class_name` names a real, known NAMED-payload-capable
+                // enum that simply has no field by this name (a hard error), or it's
+                // an unresolved/unmodeled type name, OR a real enum whose variants
+                // are all positional/payload-free (`enum Option = | Some(Int) |
+                // None`, no `field_names` at all to check against — permissive,
+                // codegen will catch a genuine mismatch, exactly as it always has).
+                // Distinguish by whether any variant belonging to this enum name
+                // declares named fields at all.
+                [] if ctx.enum_variants.values().any(|info| info.enum_name == class_name && !info.field_names.is_empty()) =>
+                    Err(format!("no field '{}' on type '{}'", field_name, class_name)),
+                [] => Ok(PlumType::TVar("_".to_string())),
+                _ => Err(format!(
+                    "field '{}' is ambiguous across multiple variants of enum '{}' — use a match",
+                    field_name, class_name
+                )),
             }
-        },
+        }
     }
 }
@@ -1310,6 +1245,31 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 // handling just below, exactly as if this special case didn't
                 // exist for this call.
             }
+            // `Type(1, 2, 3)` — a call with bare POSITIONAL args on a record-shaped
+            // type's name (as opposed to `Type(field: value, ...)`, which parses as a
+            // `ClassCall` instead — see `class_argument_list` vs `fn_argument_list` in
+            // the grammar) — is sugar for `Type.init(1, 2, 3)`, the same constructor
+            // pattern as `Type()`'s own `ClassCall` handling above, letting `init`
+            // take real params (e.g. `List`'s own variadic `init(values: ...T)`)
+            // instead of being limited to zero args. Checked BEFORE the ordinary
+            // positional-variant-construction case just below: a record-shaped
+            // enum's own name is ALSO its one variant's name (see
+            // `buildGlobalTables`), so without this ordering a call meant as
+            // `List.init(1, 2, 3)` could instead misfire as "construct the List
+            // variant positionally" whenever the arg count happens to match its
+            // real field count — a record-shaped type never supported positional
+            // field construction via bare `Type(...)` even before enums/classes
+            // merged into one representation, only through `init` or the named
+            // `Type(field: value, ...)` form.
+            if ctx.enum_variants.get(&call.name).is_some_and(|info| info.enum_name == call.name)
+                && ctx.methods.contains_key(&(call.name.clone(), "init".to_string()))
+            {
+                let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
+                    object: ast::Expr::TypeName(call.name.clone()),
+                    attr: ast::AttrKind::Method(ast::FnCall { name: "init".to_string(), args: call.args.clone() }),
+                }));
+                return inferExpr(&synthetic, env, ctx);
+            }
             if let Some(info) = ctx.enum_variants.get(&call.name) {
                 if call.args.len() != info.field_types.len() {
                     return Err(format!(
@@ -1339,22 +1299,6 @@ pub fn inferExpr(expr: &ast::Expr, env: &TypeEnv, ctx: &CheckCtx) -> Result<Plum
                 }
                 return Ok(PlumType::TNamed(info.enum_name.clone()));
             }
-            // `Type(1, 2, 3)` — a call with bare POSITIONAL args on a class name (as
-            // opposed to `Type(field: value, ...)`, which parses as a `ClassCall`
-            // instead — see `class_argument_list` vs `fn_argument_list` in the
-            // grammar) — is sugar for `Type.init(1, 2, 3)`, the same constructor
-            // pattern as `Type()`'s own `ClassCall` handling above, letting `init`
-            // take real params (e.g. `List`'s own variadic `init(values: ...T)`)
-            // instead of being limited to zero args.
-            if ctx.classes.contains_key(&call.name)
-                && ctx.methods.contains_key(&(call.name.clone(), "init".to_string()))
-            {
-                let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
-                    object: ast::Expr::TypeName(call.name.clone()),
-                    attr: ast::AttrKind::Method(ast::FnCall { name: "init".to_string(), args: call.args.clone() }),
-                }));
-                return inferExpr(&synthetic, env, ctx);
-            }
             match lookup(env, &call.name) {
                 Ok(PlumType::TFun(param_types, ret)) => {
                     match param_types.last() {

plum-checker/src/monomorphize.rs CHANGED Viewed

@@ -4,8 +4,8 @@ use crate::types::PlumType;
 /// A single uppercase letter (`T`, `U`, `K`, ...) is the grammar's only legal
 /// spelling for a generic type parameter — this is how we recognize one, since
-/// `ast::Fn` and `ast::Enum` (unlike `ast::Class`/`ast::Trait`) carry no explicit
+/// `ast::Fn` (unlike `ast::Enum`/`ast::Trait`) carries no explicit generics
-/// generics declaration list.
+/// declaration list.
 pub fn isGenericParamName(name: &str) -> bool {
     let mut chars = name.chars();
     match (chars.next(), chars.next()) {
@@ -14,11 +14,6 @@ pub fn isGenericParamName(name: &str) -> bool {
     }
 }
-/// The generic parameter names introduced by a `Class`, in declaration order.
-pub fn classGenericParams(c: &ast::Class) -> Vec<String> {
-    c.generics.iter().map(|g| g.name.clone()).collect()
-}
 /// Collects every distinct single-uppercase-letter type name appearing
 /// anywhere in `t`, RECURSING into `t.generics` — so `List[T]` (a container
 /// type applied to the bare letter `T`) is recognized as introducing `T`,
@@ -54,8 +49,8 @@ pub fn fnGenericParams(f: &ast::Fn) -> Vec<String> {
 }
 /// The generic parameter names an `Enum` introduces — its OWN declared
-/// generics (`enum Option[T] = ...`, mirroring `classGenericParams`) if it
+/// generics (`enum Option[T] = ...`) if it declares any, else (for an
-/// declares any, else (for an enum that doesn't) every distinct
+/// enum that doesn't) every distinct
 /// single-uppercase-letter variant field type name, in first-appearance
 /// order — the older, purely-implicit inference this replaces.
 pub fn enumGenericParams(e: &ast::Enum) -> Vec<String> {
@@ -178,22 +173,6 @@ pub fn mangle(base: &str, type_args: &[PlumType]) -> String {
     out
 }
-/// Produces a concrete, specialized copy of a generic class under `mangled_name`,
-/// substituting every field whose declared type names one of the class's generic
-/// parameters with its resolved concrete type. The class's own `generics` list is
-/// cleared on the copy (it is now fully concrete).
-pub fn specializeClass(c: &ast::Class, subst: &Substitution, mangled_name: &str) -> ast::Class {
-    ast::Class {
-        name: mangled_name.to_string(),
-        implements: c.implements.clone(),
-        generics: vec![],
-        fields: c.fields.iter().map(|f| ast::Field {
-            name: f.name.clone(),
-            ty: substituteType(&f.ty, subst),
-        }).collect(),
-    }
-}
 /// Produces a concrete, specialized copy of a generic function (or method) under
 /// `mangled_name`. `new_type_param` overrides the receiver-type name for a method
 /// whose receiver class was itself specialized (e.g. a method declared on `Box`
@@ -375,6 +354,7 @@ pub fn specializeEnum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -
     ast::Enum {
         name: mangled_name.to_string(),
         generics: vec![],
+        implements: e.implements.clone(),
         params: e.params.clone(),
         variants: e.variants.iter().map(|v| ast::EnumVariant {
             name: mangle(&v.name, &type_args),
@@ -387,10 +367,9 @@ pub fn specializeEnum(e: &ast::Enum, subst: &Substitution, mangled_name: &str) -
 use std::collections::BTreeSet;
 use crate::types::{TypeEnv, TypeScheme};
-use crate::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo, EnumParams, CheckCtx};
+use crate::{MethodEnv, EnumVariants, EnumVariantInfo, EnumParams, CheckCtx};
 enum PendingSpecialization<'a> {
-    Class { base: &'a ast::Class, subst: Substitution, mangled: String },
     Fn { base: &'a ast::Fn, subst: Substitution, mangled: String, new_receiver: Option<String> },
     Enum { base: &'a ast::Enum, subst: Substitution, mangled: String },
 }
@@ -539,14 +518,10 @@ fn renameVarInArg(arg: &mut ast::Arg, old: &str, new: &str) {
 }
 struct Monomorphizer<'a> {
-    classes_generic: BTreeMap<String, &'a ast::Class>,
     fns_generic: BTreeMap<String, &'a ast::Fn>,
-    methods_generic_on: BTreeMap<String, Vec<&'a ast::Fn>>,
-    /// Same as `methods_generic_on`, but for a method declared on a generic ENUM
+    /// Every method declared on a generic enum (e.g. `Result`'s `isOk`/`isErr`,
-    /// (e.g. `Result`'s `isOk`/`isErr`) rather than a generic class — a separate map
+    /// or a record-shaped `List`/`Map`'s own methods), keyed by the enum's own
-    /// because the two need separate lookups keyed by their own base-name maps
-    /// (`enums_generic_by_name` vs `classes_generic`) at both classification and
-    /// specialization time.
+    /// bare name.
     methods_generic_on_enum: BTreeMap<String, Vec<&'a ast::Fn>>,
     /// Bare variant name (e.g. `"Some"`) -> the generic `Enum` it belongs to. Keyed
     /// by variant name because a construction site (`Some(5)`) parses as a `FnCall`
@@ -566,22 +541,21 @@ struct Monomorphizer<'a> {
     /// sites like `Some(5)`).
     enums_generic_by_name: BTreeMap<String, &'a ast::Enum>,
     /// Free functions that are NOT generic by `fnGenericParams`'s lowercase-letter
-    /// convention, but whose param type(s) bare-name a generic class or enum (e.g.
+    /// convention, but whose param type(s) bare-name a generic enum (e.g.
     /// `unwrapOr(o: Option, ...)`) — such a function still needs its own
-    /// per-call-site specialization, since its receiver generic class/enum is
+    /// per-call-site specialization, since its receiver generic enum is
     /// dropped from the monomorphized output and the bare name would otherwise
     /// resolve to nothing.
     fns_bare_generic: BTreeMap<String, &'a ast::Fn>,
-    /// Mangled class/enum name -> (its own TEMPLATE name, the generic-param
+    /// Mangled enum name -> (its own TEMPLATE name, the generic-param
     /// bindings it was specialized with), e.g. `"List$Int" -> ("List", {"T":
-    /// TInt})`. Populated wherever a class/enum specialization's `mangled`
+    /// TInt})`. Populated wherever an enum specialization's `mangled`
     /// name is first computed. Used by `resolveMethodOwnGenerics` to look up
     /// a method's OWNER template (to find its original, doubly-generic
     /// `ast::Fn`) and the receiver's own already-known bindings (e.g. `T`),
     /// given only the receiver's mangled type name at a method call site.
     class_specialization_info: BTreeMap<String, (String, BTreeMap<String, PlumType>)>,
     global_env: TypeEnv,
-    classes: ClassEnv,
     methods: MethodEnv,
     enum_variants: EnumVariants,
     enum_params: EnumParams,
@@ -646,7 +620,7 @@ impl<'a> Monomorphizer<'a> {
         // silently no-op'ing on the very next statement (`l.map(...)`).
         let mut merged_env = self.global_env.clone();
         merged_env.extend(env.iter().map(|(k, v)| (k.clone(), v.clone())));
-        let ctx = CheckCtx { classes: &self.classes, methods: &self.methods, enum_variants: &self.enum_variants, enum_params: &self.enum_params, min_required: &self.min_required };
+        let ctx = CheckCtx { methods: &self.methods, enum_variants: &self.enum_variants, enum_params: &self.enum_params, min_required: &self.min_required };
         crate::inferExpr(e, &merged_env, &ctx).unwrap_or(PlumType::TVar("_".to_string()))
     }
@@ -812,7 +786,7 @@ impl<'a> Monomorphizer<'a> {
         let needs = match &f.returns {
             None => resolve_return,
             Some(rt) => {
-                // A generic class/enum named WITH concrete type args already
+                // A generic enum named WITH concrete type args already
                 // (`-> List[Str]`, `-> Result[Int, Str]`) is already fully
                 // resolved — only a genuinely BARE reference (`-> List`,
                 // `-> Box`, no `[...]` at all) is the "unresolved" shape this
@@ -824,7 +798,6 @@ impl<'a> Monomorphizer<'a> {
                 // class name — corrupting an otherwise-correct declaration.
                 rt.generics.is_empty()
                     && (isGenericParamName(&rt.name)
-                        || self.classes_generic.contains_key(&rt.name)
                         || self.enums_generic_by_name.contains_key(&rt.name))
             }
         };
@@ -889,25 +862,6 @@ impl<'a> Monomorphizer<'a> {
                         };
                         self.manglePattern(f, fty, field_mangling.as_ref(), case_env, body, guard.as_deref_mut());
                     }
-                } else if let PlumType::TNamed(concrete_name) = ty {
-                    // A PLAIN CLASS pattern (`Node(value, prev, next)`, not an enum
-                    // variant) — `ty` is already this subject's own concrete, possibly
-                    // mangled class name (whatever resolved it — a field type, a
-                    // variant's own payload, ...— already went through the same
-                    // generic-field-type resolution ordinary `.field` ACCESS relies
-                    // on). Rewrite the pattern's bare/generic name to match (a no-op
-                    // if it's already concrete, e.g. a non-generic class) — without
-                    // this, a GENERIC class's pattern name is left as the bare
-                    // template name (`Node`), which no longer exists in the final
-                    // monomorphized `ClassEnv` (only `Node$Int`/`Node$Str`/... do),
-                    // so the checker/codegen's own `ctx.classes` lookup would silently
-                    // fall back to treating every field as an unresolved `TVar`.
-                    if let Some(class_fields) = self.classes.get(concrete_name).cloned() {
-                        *name = concrete_name.clone();
-                        for (f, (_, fty)) in fields.iter_mut().zip(class_fields.iter()) {
-                            self.manglePattern(f, fty, None, case_env, body, guard.as_deref_mut());
-                        }
-                    }
                 }
             }
             _ => {}
@@ -926,9 +880,8 @@ impl<'a> Monomorphizer<'a> {
                     // written into does.
                     if let ast::AssignTarget::Field(object, field_name) = target {
                         if let PlumType::TNamed(class_name) = self.infer(object, env) {
+                            let ctx = CheckCtx { methods: &self.methods, enum_variants: &self.enum_variants, enum_params: &self.enum_params, min_required: &self.min_required };
-                            if let Some(field_ty) = self.classes.get(&class_name)
+                            if let Ok(field_ty) = crate::lookupFieldType(&class_name, field_name, &ctx) {
-                                .and_then(|fields| fields.iter().find(|(n, _)| n == field_name).map(|(_, t)| t.clone()))
-                            {
                                 self.resolveBareVariantAgainstExpected(value, &field_ty);
                                 self.wrapPrimitiveAgainstExpected(value, &field_ty, env);
                             }
@@ -1061,13 +1014,22 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
+    /// Resolves a `Type(field: value, ...)` construction of a generic,
+    /// record-shaped (single-variant, named-payload) enum — the `type X[T] =
+    /// ...` replacement shape, e.g. `List[T]`/`Map[K, V]`. `ClassCall` is the
+    /// shared AST node this call shape ALSO uses for a non-generic or already-
+    /// mangled enum variant's own named-payload construction (see
+    /// `plum-checker`'s `inferClassCallRaw`) — this only fires for one that's
+    /// still a bare, generic TEMPLATE name.
     fn resolveClassInstantiation(&mut self, call: &mut ast::ClassCall, env: &TypeEnv) -> Result<(), String> {
-        let Some(class) = self.classes_generic.get(call.type_name.as_str()).copied() else { return Ok(()) };
+        let Some(e) = self.enums_generic_by_name.get(call.type_name.as_str()).copied() else { return Ok(()) };
-        let params = classGenericParams(class);
+        let params = enumGenericParams(e);
+        let variant = &e.variants[0];
         let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
         for gp in &params {
-            if let Some(field) = class.fields.iter().find(|f| f.ty.name == *gp) {
+            if let Some(idx) = variant.fields.iter().position(|t| t.name == *gp) {
+                let field_name = &variant.field_names[idx];
-                if let Some(fa) = call.fields.iter().find(|fa| fa.name == field.name) {
+                if let Some(fa) = call.fields.iter().find(|fa| &fa.name == field_name) {
                     // A bare payload-free variant reference (`None`) carries
                     // no type of its own to bind a generic param FROM — skip
                     // it here; it gets resolved AGAINST the binding (once
@@ -1079,7 +1041,7 @@ impl<'a> Monomorphizer<'a> {
                 }
             }
         }
-        // No field is EVER directly typed as a bare generic param for a class
+        // No field is EVER directly typed as a bare generic param for a type
         // like `List[T]` (its fields are `Option[Node[T]]`/`Int`, never a bare
         // `T`) — and even where one exists, constructing with a payload-free
         // value (`List(head: None, ...)`) gives no VALUE to infer a type from
@@ -1095,7 +1057,7 @@ impl<'a> Monomorphizer<'a> {
                     // `plumTypeFromAst` alone would silently flatten to the
                     // bare, unmangled `TNamed("Pair")` (it drops `.generics`
                     // entirely) — exactly the same recursive resolution
-                    // `resolveFieldType` already does for a class FIELD's own
+                    // `resolveFieldType` already does for a field's own
                     // declared type, just applied here to an explicit
                     // call-site type argument instead.
                     let resolved = self.resolveFieldType(gt);
@@ -1134,48 +1096,23 @@ impl<'a> Monomorphizer<'a> {
                 call.type_name, call.type_name
             ));
         }
-        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
-        let mangled = mangle(&call.type_name, &type_args);
+        let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-        self.class_specialization_info.entry(mangled.clone()).or_insert_with(|| (call.type_name.clone(), bindings.clone()));
         // Now that every generic param is bound, resolve any bare
-        // payload-free-variant field values (`None`) against THIS class's own
+        // payload-free-variant field values (`None`) against THIS
-        // (about-to-be-specialized) field types — codegen only ever sees the
+        // specialization's own field types — codegen only ever sees the
-        // mangled specializations (the generic template is dropped), so a
+        // mangled specialization (the generic template is dropped), so a
         // still-bare `None` would be an unresolvable reference by the time it
-        // gets there. `specializeClass` is a pure function; calling it here
-        // ahead of the worklist actually processing this specialization is
-        // fine — the worklist dedups on `mangled` regardless of how many
-        // times it's computed.
+        // gets there.
-        let spec_class = specializeClass(class, &Substitution(bindings.clone()), &mangled);
+        if let Some(info) = self.enum_variants.get(&mangled).cloned() {
-        for fa in &mut call.fields {
+            for fa in &mut call.fields {
-            if let Some(field) = spec_class.fields.iter().find(|f| f.name == fa.name) {
+                if let Some(idx) = info.field_names.iter().position(|n| n == &fa.name) {
-                let field_ty = self.resolveFieldType(&field.ty);
-                let expected = crate::plumTypeFromAst(&field_ty);
+                    let expected = info.field_types[idx].clone();
-                self.resolveBareVariantAgainstExpected(&mut fa.value, &expected);
+                    self.resolveBareVariantAgainstExpected(&mut fa.value, &expected);
-                self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
+                    self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
+                }
             }
         }
-        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-            self.enqueued.insert(mangled.clone());
-            self.worklist.push(PendingSpecialization::Class { base: class, subst: Substitution(bindings.clone()), mangled: mangled.clone() });
-        }
-        // Register this specialization's own field types and its methods'
-        // signatures right now — a construction site like this one can appear
-        // inside an ORDINARY (non-generic) function, which gets rewritten in
-        // the pass BEFORE the worklist above ever runs. Any later statement in
-        // that SAME function body (e.g. `l.get(1)` followed by a `match` on
-        // its result) needs `self.methods`/`self.classes` to already know
-        // about "List$Int" right now, not once the worklist eventually
-        // catches up.
-        if !self.classes.contains_key(&mangled) {
-            let field_types: Vec<(String, PlumType)> = spec_class.fields.iter()
-                .map(|f| (f.name.clone(), crate::plumTypeFromAst(&self.resolveFieldType(&f.ty))))
-                .collect();
-            self.classes.insert(mangled.clone(), field_types);
-        }
-        self.registerClassMethodSignatures(class, &mangled, &bindings);
         call.type_name = mangled;
         Ok(())
     }
@@ -1212,8 +1149,7 @@ impl<'a> Monomorphizer<'a> {
         let mut method_and_bindings: Option<(&'a ast::Fn, BTreeMap<String, PlumType>)> = None;
         if let PlumType::TNamed(mangled_receiver) = self.inferConcrete(object, env) {
             if let Some((template_name, class_bindings)) = self.class_specialization_info.get(&mangled_receiver).cloned() {
-                let method = self.methods_generic_on.get(template_name.as_str())
+                let method = self.methods_generic_on_enum.get(template_name.as_str())
-                    .or_else(|| self.methods_generic_on_enum.get(template_name.as_str()))
                     .and_then(|methods| methods.iter().find(|m| m.name == call.name).copied());
                 if let Some(method) = method {
                     method_and_bindings = Some((method, class_bindings));
@@ -1251,24 +1187,23 @@ impl<'a> Monomorphizer<'a> {
     }
     /// If `call` invokes a method that has generic param(s) of its OWN, beyond
-    /// its receiver class/enum's own (e.g. `List[T].map`'s `U`) — a shape
+    /// its receiver enum's own (e.g. `List[T].map`'s `U`) — a shape
-    /// `registerClassMethodSignatures`/the `PendingSpecialization::Class`/`Enum`
+    /// `registerEnumMethodSignatures`/the `PendingSpecialization::Enum`
-    /// worklist arms deliberately skip producing anything for — infers those
+    /// worklist arm deliberately skip producing anything for — infers those
     /// extra param(s) from `call`'s own arguments (a plain arg's own type for a
     /// bare-letter param, or a closure argument's INFERRED BODY TYPE for a
     /// closure-typed param whose return is the letter), then specializes+
     /// registers a new per-CALL-SITE mangled method (e.g. `"map$Str"`) — the
     /// same idea as a truly generic free function's own `fns_generic`/
     /// `resolveFnInstantiation`, just combined with the receiver's own already-
-    /// known class-level bindings (e.g. `T = Int`) — and rewrites `call.name`
+    /// known enum-level bindings (e.g. `T = Int`) — and rewrites `call.name`
     /// to it. No-op if `object`'s type isn't a specialization this pass has
     /// recorded `class_specialization_info` for, or the method has no extra
     /// generics of its own (the ordinary, already-handled case).
     fn resolveMethodOwnGenerics(&mut self, object: &ast::Expr, call: &mut ast::FnCall, env: &TypeEnv) -> Result<(), String> {
         let PlumType::TNamed(mangled_receiver) = self.inferConcrete(object, env) else { return Ok(()) };
         let Some((template_name, class_bindings)) = self.class_specialization_info.get(&mangled_receiver).cloned() else { return Ok(()) };
-        let method = self.methods_generic_on.get(template_name.as_str())
+        let method = self.methods_generic_on_enum.get(template_name.as_str())
-            .or_else(|| self.methods_generic_on_enum.get(template_name.as_str()))
             .and_then(|methods| methods.iter().find(|m| m.name == call.name).copied());
         let Some(method) = method else { return Ok(()) };
         let owner_params: Vec<String> = class_bindings.keys().cloned().collect();
@@ -1394,22 +1329,7 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
-    /// Eagerly computes and registers (into `self.methods`) the `(mangled,
-    /// method_name) -> TFun` signature of every method declared on `class`,
-    /// for the specialization named `mangled` under `bindings` — without
-    /// producing the actual `ast::Fn` items (that still only happens once the
-    /// worklist entry for this specialization is popped, avoiding duplicate
-    /// emission). Needed so a call site that appears in a function processed
-    /// BEFORE the worklist runs (see callers) can still resolve a method call
-    /// against this specialization immediately.
-    fn registerClassMethodSignatures(&mut self, class: &'a ast::Class, mangled: &str, bindings: &BTreeMap<String, PlumType>) {
-        let Some(methods) = self.methods_generic_on.get(class.name.as_str()).cloned() else { return };
-        let owner_params = classGenericParams(class);
-        self.registerMethodSignatures(&class.name, mangled, methods, &owner_params, bindings);
-    }
-    /// The enum counterpart to `registerClassMethodSignatures` — see its doc
-    /// comment. Without this, a method call chained directly onto a FRESH
+    /// Without this, a method call chained directly onto a FRESH
     /// enum construction in the same statement (`Some(4).filter(...)`, or
     /// any `SomeVariant(...).method(...)` one-liner for a generic enum) could
     /// never resolve: the receiver's specialization is only ENQUEUED here,
@@ -1606,9 +1526,8 @@ impl<'a> Monomorphizer<'a> {
         if template_name != &declared.name {
             return;
         }
-        let owner_params: Vec<String> = self.classes_generic.get(template_name.as_str())
+        let owner_params: Vec<String> = self.enums_generic_by_name.get(template_name.as_str())
-            .map(|c| classGenericParams(c))
+            .map(|e| enumGenericParams(e))
-            .or_else(|| self.enums_generic_by_name.get(template_name.as_str()).map(|e| enumGenericParams(e)))
             .unwrap_or_default();
         for (declared_arg, owner_param) in declared.generics.iter().zip(owner_params.iter()) {
             if let Some(bound) = class_bindings.get(owner_param) {
@@ -1707,7 +1626,7 @@ impl<'a> Monomorphizer<'a> {
                 continue;
             }
             let n = &t.name;
-            if (self.classes_generic.contains_key(n.as_str()) || self.enums_generic_by_name.contains_key(n.as_str()))
+            if self.enums_generic_by_name.contains_key(n.as_str())
                 && !names.iter().any(|x| x == n)
             {
                 names.push(n.clone());
@@ -1824,24 +1743,25 @@ impl<'a> Monomorphizer<'a> {
         Ok(())
     }
-    /// `Type(1, 2, 3)` — a bare-positional-args call on a GENERIC class name that
+    /// `Type(1, 2, 3)` — a bare-positional-args call on a GENERIC record-shaped
-    /// declares an `init` method (e.g. `List`'s own `init(values: ...T)`) — is sugar
+    /// enum name that declares an `init` method (e.g. `List`'s own
+    /// `init(values: ...T)`) — is sugar for `Type.init(1, 2, 3)` (see
-    /// for `Type.init(1, 2, 3)` (see `plum-checker`'s `inferExpr` / `plum-wasm-codegen`'s
+    /// `plum-checker`'s `inferExpr` / `plum-wasm-codegen`'s matching `FnCall`
-    /// matching `FnCall` handling, which run AFTER monomorphization and only ever see
+    /// handling, which run AFTER monomorphization and only ever see concrete,
-    /// concrete, mangled class names). Infers `init`'s own generic bindings from
+    /// mangled names). Infers `init`'s own generic bindings from `call.args`'
-    /// `call.args`' types (mirroring `resolveEnumInstantiation`'s args-based
+    /// types (mirroring `resolveEnumInstantiation`'s args-based inference for
-    /// inference for a variant's fields), specializes the class for them, and
+    /// a variant's fields), specializes the enum for them, and rewrites
-    /// rewrites `call.name` to the mangled class name — same rewrite target
+    /// `call.name` to the mangled name — same rewrite target
-    /// `resolveClassInstantiation` uses for the named `Type(field: value, ...)` call
+    /// `resolveClassInstantiation` uses for the named `Type(field: value, ...)`
-    /// shape, just reached from a differently-shaped call site.
+    /// call shape, just reached from a differently-shaped call site.
     fn resolveClassInitInstantiation(&mut self, call: &mut ast::FnCall, env: &TypeEnv) -> Result<(), String> {
-        let Some(class) = self.classes_generic.get(call.name.as_str()).copied() else { return Ok(()) };
+        let Some(e) = self.enums_generic_by_name.get(call.name.as_str()).copied() else { return Ok(()) };
-        let Some(init_fn) = self.methods_generic_on.get(call.name.as_str())
+        let Some(init_fn) = self.methods_generic_on_enum.get(call.name.as_str())
             .and_then(|methods| methods.iter().find(|f| f.name == "init").copied())
         else {
             return Ok(());
         };
-        let params = classGenericParams(class);
+        let params = enumGenericParams(e);
         let mut bindings: BTreeMap<String, PlumType> = BTreeMap::new();
         for (i, arg) in call.args.iter().enumerate() {
             let Some(param) = init_fn.params.get(i).or_else(|| init_fn.params.last()) else { break };
@@ -1879,21 +1799,7 @@ impl<'a> Monomorphizer<'a> {
         if bindings.len() != params.len() {
             return Ok(());
         }
-        let type_args: Vec<PlumType> = params.iter().map(|p| bindings[p].clone()).collect();
-        let mangled = mangle(&call.name, &type_args);
+        let mangled = self.ensureEnumSpecialized(e, &params, bindings);
-        self.class_specialization_info.entry(mangled.clone()).or_insert_with(|| (call.name.clone(), bindings.clone()));
-        if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-            self.enqueued.insert(mangled.clone());
-            self.worklist.push(PendingSpecialization::Class { base: class, subst: Substitution(bindings.clone()), mangled: mangled.clone() });
-        }
-        if !self.classes.contains_key(&mangled) {
-            let spec_class = specializeClass(class, &Substitution(bindings.clone()), &mangled);
-            let field_types: Vec<(String, PlumType)> = spec_class.fields.iter()
-                .map(|f| (f.name.clone(), crate::plumTypeFromAst(&self.resolveFieldType(&f.ty))))
-                .collect();
-            self.classes.insert(mangled.clone(), field_types);
-        }
-        self.registerClassMethodSignatures(class, &mangled, &bindings);
         call.name = mangled;
         Ok(())
     }
@@ -1913,6 +1819,16 @@ impl<'a> Monomorphizer<'a> {
         let mangled = mangle(&e.name, &type_args);
         self.class_specialization_info.entry(mangled.clone()).or_insert_with(|| (e.name.clone(), bindings.clone()));
         if !self.enum_variant_mangling.contains_key(&mangled) {
+            // Insert a placeholder table BEFORE recursively resolving any variant's
+            // own field types below — a self-referential generic enum (e.g. a
+            // linked-list `Node[T]`'s own `next: Option[Node[T]]` field) would
+            // otherwise recurse right back into specializing itself here before
+            // this specialization is even marked as in-progress, infinitely. The
+            // recursive re-entry only ever needs this specialization's MANGLED
+            // NAME back (see `resolveFieldType`'s `ast::Type { name: mangled, ...
+            // }` return), not its fully-resolved variant table — that gets
+            // overwritten with the real one below once the recursion unwinds.
+            self.enum_variant_mangling.insert(mangled.clone(), BTreeMap::new());
             let mut table = BTreeMap::new();
             for (tag, v) in e.variants.iter().enumerate() {
                 let mangled_variant = mangle(&v.name, &type_args);
@@ -1955,7 +1871,7 @@ impl<'a> Monomorphizer<'a> {
     }
     /// Fully resolves a FIELD's declared type into something that will actually
-    /// exist after monomorphization. `specializeClass`'s own field substitution
+    /// exist after monomorphization. `specializeEnum`'s own field substitution
     /// only replaces a bare generic-param NAME (`T` -> `Int`) — a field declared
     /// `Option[Node[T]]` becomes `Option[Node[Int]]` this way, which is now
     /// fully CONCRETE but still names the generic TEMPLATES `Option`/`Node`
@@ -1963,16 +1879,16 @@ impl<'a> Monomorphizer<'a> {
     /// their mangled specializations, e.g. `Node$Int`, survive). Recursively
     /// resolves any nested generic arguments first (so `Node[Int]` inside
     /// `Option[Node[Int]]` becomes `Node$Int` before `Option[...]` itself is
-    /// resolved), then — if the type names a known generic class/enum applied
+    /// resolved), then — if the type names a known generic enum applied to
-    /// to arguments — mangles it to that specialization's real name and
+    /// arguments — mangles it to that specialization's real name and enqueues
-    /// enqueues the specialization if it hasn't been already (via the same
+    /// the specialization if it hasn't been already, via the same
-    /// `ensureEnumSpecialized` used for enum construction sites, for enums; classes
+    /// `ensureEnumSpecialized` used for enum construction sites. A field
-    /// don't have an equivalent shared helper, so that half is inlined here).
-    /// A field that's already concrete (no generics), or whose name isn't a
+    /// that's already concrete (no generics), or whose name isn't a known
-    /// known generic template, is returned unchanged (or with just its nested
+    /// generic template, is returned unchanged (or with just its nested
-    /// generics resolved) — this is ALSO called on every ordinary (non-generic)
+    /// generics resolved) — this is ALSO called on every ordinary
-    /// class's fields, not just specialized ones, since a plain class can
+    /// (non-generic) enum's fields, not just specialized ones, since a plain
-    /// perfectly well have a field like `items: List[Int]`.
+    /// record-shaped enum can perfectly well have a field like `items:
+    /// List[Int]`.
     fn resolveFieldType(&mut self, ty: &ast::Type) -> ast::Type {
         if ty.generics.is_empty() {
             return ty.clone();
@@ -1992,45 +1908,6 @@ impl<'a> Monomorphizer<'a> {
         }
         let type_args: Vec<PlumType> = resolved_args.iter().map(crate::plumTypeFromAst).collect();
-        if let Some(class) = self.classes_generic.get(ty.name.as_str()).copied() {
-            let params = classGenericParams(class);
-            if params.len() == type_args.len() {
-                let bindings: BTreeMap<String, PlumType> = params.into_iter().zip(type_args.iter().cloned()).collect();
-                let mangled = mangle(&ty.name, &type_args);
-                self.class_specialization_info.entry(mangled.clone()).or_insert_with(|| (ty.name.clone(), bindings.clone()));
-                if !self.specialized.contains(&mangled) && !self.enqueued.contains(&mangled) {
-                    self.enqueued.insert(mangled.clone());
-                    self.worklist.push(PendingSpecialization::Class { base: class, subst: Substitution(bindings.clone()), mangled: mangled.clone() });
-                }
-                // Register this specialization's field types right now, even
-                // though its actual `Item::Class`/method output is only pushed
-                // to `m.produced` once the worklist entry above is popped —
-                // another method being rewritten in THIS SAME worklist round
-                // (e.g. a sibling method on the class currently being
-                // specialized) may need to resolve a field access against it
-                // immediately, well before that later worklist entry runs.
-                if !self.classes.contains_key(&mangled) {
-                    // Insert a placeholder BEFORE recursing into the fields below —
-                    // a self-referential class (`Node[T]`'s own `prev`/`next` fields
-                    // point back to `Option[Node[T]]`) would otherwise recurse into
-                    // resolving its own not-yet-registered specialization forever.
-                    // The recursive re-entry only needs this specialization's
-                    // MANGLED NAME to build its own field's type, not its fields —
-                    // those get filled in for real below once the recursion unwinds.
-                    self.classes.insert(mangled.clone(), vec![]);
-                    let mut spec_class = specializeClass(class, &Substitution(bindings.clone()), &mangled);
-                    for f in &mut spec_class.fields {
-                        f.ty = self.resolveFieldType(&f.ty);
-                    }
-                    self.classes.insert(
-                        mangled.clone(),
-                        spec_class.fields.iter().map(|f| (f.name.clone(), crate::plumTypeFromAst(&f.ty))).collect(),
-                    );
-                    self.registerClassMethodSignatures(class, &mangled, &bindings);
-                }
-                return ast::Type { name: mangled, generics: vec![] };
-            }
-        }
         if let Some(e) = self.enums_generic_by_name.get(ty.name.as_str()).copied() {
             let params = enumGenericParams(e);
             if params.len() == type_args.len() {
@@ -2150,16 +2027,14 @@ impl<'a> Monomorphizer<'a> {
                 // "union" enum field (`Wrapper(value: 5)` where `value:
                 // Number`) or a named-payload enum variant field (`Circle
                 // (radius: 5)`, though there `radius: Int` already matches so
-                // this is a no-op) — neither an ordinary class's nor a named
+                // this is a no-op) — a named variant's OWN field types don't
-                // variant's OWN field types depend on generic specialization,
+                // depend on generic specialization, so this can run
-                // so this can run unconditionally here regardless of whether
+                // unconditionally here regardless of whether `call.type_name`
-                // `call.type_name` turns out to be generic or not below.
+                // turns out to be generic or not below.
                 for fa in &mut call.fields {
-                    let expected_ty = self.classes.get(call.type_name.as_str())
-                        .and_then(|fields| fields.iter().find(|(n, _)| n == &fa.name).map(|(_, t)| t.clone()))
-                        .or_else(|| self.enum_variants.get(call.type_name.as_str()).and_then(|info| {
+                    let expected_ty = self.enum_variants.get(call.type_name.as_str()).and_then(|info| {
-                            info.field_names.iter().position(|n| n == &fa.name).map(|i| info.field_types[i].clone())
+                        info.field_names.iter().position(|n| n == &fa.name).map(|i| info.field_types[i].clone())
-                        }));
+                    });
                     if let Some(expected) = expected_ty {
                         self.wrapPrimitiveAgainstExpected(&mut fa.value, &expected, env);
                     }
@@ -2167,7 +2042,7 @@ impl<'a> Monomorphizer<'a> {
                 // Runs next (before the generic per-field rewrite below): a
                 // bare payload-free variant field value (`Node(..., next:
                 // None)`) carries no type of its own to infer a generic
-                // param from, and needs the class's OWN (about-to-be-
+                // param from, and needs the enum's OWN (about-to-be-
                 // specialized) field type to resolve which specialization it
                 // actually means — `resolveClassInstantiation` handles that
                 // internally once it knows the full binding set.
@@ -2388,20 +2263,17 @@ impl<'a> Monomorphizer<'a> {
 /// result has no generic syntax left in it — `checkSource`/`compileSource` run
 /// on it completely unmodified.
 pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
-    let (global_env, classes, methods, enum_variants, enum_params) = crate::buildGlobalTables(source);
+    let (global_env, methods, enum_variants, enum_params) = crate::buildGlobalTables(source);
     let min_required = crate::buildMinRequiredArgs(source);
     let mut m = Monomorphizer {
-        classes_generic: BTreeMap::new(),
         fns_generic: BTreeMap::new(),
-        methods_generic_on: BTreeMap::new(),
         methods_generic_on_enum: BTreeMap::new(),
         enums_generic_by_variant: BTreeMap::new(),
         enums_generic_by_name: BTreeMap::new(),
         enum_variant_mangling: BTreeMap::new(),
         fns_bare_generic: BTreeMap::new(),
         global_env,
-        classes,
         methods,
         enum_variants,
         enum_params,
@@ -2418,38 +2290,33 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
     };
     for item in &source.items {
-        match item {
+        if let ast::Item::Enum(e) = item {
-            ast::Item::Class(c) if !c.generics.is_empty() => { m.classes_generic.insert(c.name.clone(), c); }
-            ast::Item::Enum(e) if !enumGenericParams(e).is_empty() => {
+            if !enumGenericParams(e).is_empty() {
                 m.enums_generic_by_name.insert(e.name.clone(), e);
                 for v in &e.variants {
                     m.enums_generic_by_variant.insert(v.name.clone(), e);
                 }
             }
-            _ => {}
         }
     }
-    // Classifies every method by its receiver (generic class/enum, or neither),
+    // Classifies every method by its receiver (generic enum, or neither),
-    // populating `methods_generic_on`/`methods_generic_on_enum` — MUST run
+    // populating `methods_generic_on_enum` — MUST run before the
-    // before the `fn_return_generic_enum` loop below, which calls
+    // `fn_return_generic_enum` loop below, which calls `resolveFieldType` and
-    // `resolveFieldType` and can therefore trigger `registerClassMethodSignatures`
+    // can therefore trigger `registerEnumMethodSignatures` for a generic enum
-    // for a generic class as a SIDE EFFECT (e.g. resolving a nested `List[Str]`
+    // as a SIDE EFFECT (e.g. resolving a nested `List[Str]` inside some other
-    // inside some other function's `-> Result[List[Str], Str]` return type).
+    // function's `-> Result[List[Str], Str]` return type).
-    // `registerClassMethodSignatures` looks up `methods_generic_on` and, finding
+    // `registerEnumMethodSignatures` looks up `methods_generic_on_enum` and,
-    // it not yet populated, silently registers ZERO methods for that
+    // finding it not yet populated, silently registers ZERO methods for that
     // specialization (`Some(methods) = ... else { return }`) — and because the
-    // specialization is marked done at that point (`self.classes` already has
+    // specialization is marked done at that point (`self.enum_variant_mangling`
-    // the mangled name), no later call ever retries it, permanently leaving
+    // already has the mangled name), no later call ever retries it, permanently
-    // e.g. `List$Str.reject` unresolvable for the rest of this pass (surfacing
+    // leaving e.g. `List$Str.reject` unresolvable for the rest of this pass
-    // much later, and confusingly, as a chained method call inferring to `TVar`
+    // (surfacing much later, and confusingly, as a chained method call
-    // deep inside some unrelated enum-construction site).
+    // inferring to `TVar` deep inside some unrelated enum-construction site).
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
-            let receiver_is_generic_class = f.type_param.as_deref().map(|r| m.classes_generic.contains_key(r)).unwrap_or(false);
             let receiver_is_generic_enum = f.type_param.as_deref().map(|r| m.enums_generic_by_name.contains_key(r)).unwrap_or(false);
-            if receiver_is_generic_class {
+            if receiver_is_generic_enum {
-                m.methods_generic_on.entry(f.type_param.clone().unwrap()).or_default().push(f);
-            } else if receiver_is_generic_enum {
                 m.methods_generic_on_enum.entry(f.type_param.clone().unwrap()).or_default().push(f);
             } else if f.type_param.is_none() && !fnGenericParams(f).is_empty() {
                 m.fns_generic.insert(f.name.clone(), f);
@@ -2516,7 +2383,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
     for item in &source.items {
         if let ast::Item::Fn(f) = item {
             let receiver_is_generic = f.type_param.as_deref()
-                .map(|r| m.classes_generic.contains_key(r) || m.enums_generic_by_name.contains_key(r))
+                .map(|r| m.enums_generic_by_name.contains_key(r))
                 .unwrap_or(false);
             let is_generic_fn = f.type_param.is_none() && !fnGenericParams(f).is_empty();
             let is_bare_generic_fn = f.type_param.is_none() && m.fns_bare_generic.contains_key(f.name.as_str());
@@ -2548,29 +2415,6 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
     for item in &source.items {
         match item {
-            ast::Item::Class(c) if c.generics.is_empty() => {
-                let mut c2 = c.clone();
-                for f in &mut c2.fields {
-                    f.ty = m.resolveFieldType(&f.ty);
-                }
-                // `self.classes` was seeded from the ORIGINAL, pre-monomorphization
-                // source (see `buildGlobalTables`, which — like `plumTypeFromAst`
-                // generally — doesn't resolve a field's own nested generics), so a
-                // field like `items: List[Int]` is still recorded there as bare
-                // `List`, not `List$Int`. Refresh it now that `resolveFieldType`
-                // has produced the real, resolved (and, for a generic field,
-                // mangled) type — otherwise any LATER inference of a `ClassCall`
-                // against this class (e.g. `self.infer` on a nested constructor
-                // call, during another item's own monomorphization) unifies the
-                // stale `List` against an actual `List$Int` value and fails, and
-                // that failure then gets silently swallowed by `infer`'s
-                // `unwrap_or(TVar("_"))` fallback further up the call chain.
-                m.classes.insert(
-                    c2.name.clone(),
-                    c2.fields.iter().map(|f| (f.name.clone(), crate::plumTypeFromAst(&f.ty))).collect(),
-                );
-                m.produced.push(ast::Item::Class(c2));
-            }
             ast::Item::Enum(e) if enumGenericParams(e).is_empty() => {
                 let mut e2 = e.clone();
                 for v in &mut e2.variants {
@@ -2579,20 +2423,33 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
                     }
                 }
                 // Refresh `self.enum_variants` with the resolved field types —
-                // same staleness reason as the `Class` arm above: a variant field
+                // `self.enum_variants` was seeded from the ORIGINAL,
-                // like `List[Json]` was recorded there (from `buildGlobalTables`)
+                // pre-monomorphization source (see `buildGlobalTables`, which —
-                // as bare `List`, not `List$Json`, and a later `self.infer` on a
+                // like `plumTypeFromAst` generally — doesn't resolve a field's
-                // construction site for this variant would otherwise unify that
+                // own nested generics), so a variant field like `List[Json]` is
+                // still recorded there as bare `List`, not `List$Json`.
+                // Otherwise any LATER inference of a construction site for this
+                // variant (e.g. `self.infer` during another item's own
+                // monomorphization) unifies that stale name against the real,
-                // stale name against the real, specialized value's type and fail.
+                // specialized value's type and fails, and that failure then
+                // gets silently swallowed by `infer`'s `unwrap_or(TVar("_"))`
+                // fallback further up the call chain.
                 for v in &e2.variants {
+                    let existing = m.enum_variants.get(v.name.as_str());
-                    let tag = m.enum_variants.get(v.name.as_str()).map(|info| info.tag).unwrap_or(0);
+                    let tag = existing.map(|info| info.tag).unwrap_or(0);
                     // Bare-type variant sugar (see `buildGlobalTables`): `v.fields`
-                    // is empty in the AST for `| FantasyBook`, but its resolved
+                    // is empty in the AST for `| Cat` or `| Int`, but its resolved
-                    // field type was already recorded there as a single
+                    // field type was already recorded there (by the initial
+                    // `buildGlobalTables` seeding, before this loop runs) as a
-                    // self-wrap `TNamed(v.name)` — recompute that same shape here
+                    // single self-wrap `TNamed(v.name)` (a record-shaped enum) or
+                    // primitive bare-wrap (`Int`/`Float`) — reuse that same shape
-                    // instead of clobbering it back to an empty vec.
+                    // here instead of clobbering it back to an empty vec.
-                    let (field_types, field_names) = if v.fields.is_empty() && m.classes.contains_key(v.name.as_str()) {
+                    let existing_field_types = existing.map(|info| info.field_types.clone()).unwrap_or_default();
+                    let is_bare_wrap = v.fields.is_empty()
-                        (vec![PlumType::TNamed(v.name.clone())], Vec::new())
+                        && (existing_field_types == [PlumType::TNamed(v.name.clone())]
+                            || existing_field_types == [crate::plumTypeFromName(&v.name)]);
+                    let (field_types, field_names) = if is_bare_wrap {
+                        (existing_field_types, Vec::new())
                     } else {
                         (v.fields.iter().map(crate::plumTypeFromAst).collect(), v.field_names.clone())
                     };
@@ -2618,7 +2475,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
             }
             ast::Item::Fn(f) => {
                 let receiver_is_generic = f.type_param.as_deref()
-                    .map(|r| m.classes_generic.contains_key(r) || m.enums_generic_by_name.contains_key(r))
+                    .map(|r| m.enums_generic_by_name.contains_key(r))
                     .unwrap_or(false);
                 let is_generic_fn = f.type_param.is_none() && !fnGenericParams(f).is_empty();
                 let is_bare_generic_fn = f.type_param.is_none() && m.fns_bare_generic.contains_key(f.name.as_str());
@@ -2630,7 +2487,7 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
                     m.produced.push(ast::Item::Fn(f2));
                 }
             }
-            _ => {} // generic Class/Enum declarations dropped here — templates only
+            _ => {} // generic Enum declarations dropped here — templates only
         }
     }
@@ -2641,83 +2498,6 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
             return Err("monomorphize: exceeded specialization limit (possible unbounded generic recursion)".to_string());
         }
         match pending {
-            PendingSpecialization::Class { base, subst, mangled } => {
-                if !m.specialized.insert(mangled.clone()) { continue; }
-                let mut spec_class = specializeClass(base, &subst, &mangled);
-                // `specializeClass` only substitutes a field's bare generic-param
-                // NAME (`T` -> `Int`) — a field like `Option[Node[T]]` becomes
-                // `Option[Node[Int]]`, still a generic instantiation, not yet a
-                // real (mangled) type. Resolve those the rest of the way now.
-                for f in &mut spec_class.fields {
-                    f.ty = m.resolveFieldType(&f.ty);
-                }
-                // Register the specialized class's fields so inference inside its
-                // own (and other items') bodies can resolve `receiver.field` on the
-                // mangled type — `self.classes` was built from the ORIGINAL source
-                // and would otherwise not know this freshly-minted class.
-                m.classes.insert(
-                    mangled.clone(),
-                    spec_class.fields.iter().map(|f| (f.name.clone(), crate::plumTypeFromAst(&f.ty))).collect(),
-                );
-                m.produced.push(ast::Item::Class(spec_class));
-                // Same self-nesting landmine as `registerMethodSignatures` —
-                // if THIS specialization is itself already nested
-                // (`isSelfNested`), skips (only) a method whose return type
-                // would construct yet another nested specialization
-                // (`methodMentionsTemplate`; see `isSelfNested`'s doc
-                // comment). Without this, `List.chunk() -> List[List[T]]`
-                // would recurse into producing an unbounded chain of
-                // ever-more-nested `List` specializations via THIS SAME
-                // loop — and since this loop runs once per separate
-                // WORKLIST pop rather than recursively, a guard scoped to a
-                // single call stack isn't enough on its own.
-                {
-                    let already_nested = m.isSelfNested(&base.name, &subst.0);
-                    if let Some(methods) = m.methods_generic_on.get(base.name.as_str()).cloned() {
-                        let owner_params = classGenericParams(base);
-                        for method in methods {
-                            // A method with generic param(s) of its OWN (e.g. `map`'s
-                            // `U`, beyond `List[T]`'s own `T`) can't be produced HERE —
-                            // `U` is only known at a particular CALL SITE, not at class-
-                            // specialization time. `resolveMethodOwnGenerics` queues a
-                            // `PendingSpecialization::Fn` for each concrete `U` it
-                            // actually sees used, instead.
-                            if !methodOwnGenericParams(method, &owner_params).is_empty() {
-                                continue;
-                            }
-                            if already_nested && Monomorphizer::methodMentionsTemplate(method, &base.name) {
-                                continue;
-                            }
-                            let mut specialized_method = specializeFn(method, &subst, &method.name, Some(mangled.clone()));
-                            // Params (not returns — see `resolveFnParamTypes`'s doc
-                            // comment) must run before `rewriteFnBody`/registration
-                            // below: both read the signature's types directly off
-                            // this AST, and the real checker later rebuilds its own
-                            // tables from this exact (post-monomorphize) AST too.
-                            m.resolveFnParamTypes(&mut specialized_method);
-                            m.rewriteFnBody(&mut specialized_method, true)?;
-                            m.resolveFnReturnType(&mut specialized_method);
-                            // Register the specialized method's signature under its
-                            // (mangled receiver, method name) key so any later body that
-                            // dispatches to it can resolve its concrete return type.
-                            let param_types: Vec<PlumType> = specialized_method.params.iter().map(|p| match &p.ty {
-                                ast::ParamType::Type(t) => crate::plumTypeFromAst(t),
-                                ast::ParamType::Variadic(t) => PlumType::TVariadic(Box::new(crate::plumTypeFromAst(t))),
-                                ast::ParamType::Fn(params, ret) => {
-                                    let param_types = params.iter().map(crate::plumTypeFromAst).collect();
-                                    let ret_ty = ret.as_ref().map(|r| crate::plumTypeFromAst(r)).unwrap_or(PlumType::TUnit);
-                                    PlumType::TFun(param_types, Box::new(ret_ty))
-                                }
-                            }).collect();
-                            let ret = specialized_method.returns.as_ref()
-                                .map(crate::plumTypeFromAst)
-                                .unwrap_or(PlumType::TUnit);
-                            m.methods.insert((mangled.clone(), specialized_method.name.clone()), PlumType::TFun(param_types, Box::new(ret)));
-                            m.produced.push(ast::Item::Fn(specialized_method));
-                        }
-                    }
-                }
-            }
             PendingSpecialization::Fn { base, subst, mangled, new_receiver } => {
                 if !m.specialized.insert(mangled.clone()) { continue; }
                 let mut specialized_fn = specializeFn(base, &subst, &mangled, new_receiver);
@@ -2747,21 +2527,32 @@ pub fn monomorphizeSource(source: &ast::Source) -> Result<ast::Source, String> {
                 // `specializeEnum` only substitutes a bare generic-param NAME —
                 // a field like `List[T]` becomes `List[Int]`, still a generic
                 // instantiation, not yet a real (mangled) type. Resolve those
-                // the rest of the way now, same as the `Class` arm above.
+                // the rest of the way now.
                 for v in &mut spec_enum.variants {
                     for f in &mut v.fields {
                         *f = m.resolveFieldType(f);
                     }
                 }
                 m.produced.push(ast::Item::Enum(spec_enum));
-                // Guarded against the same self-nesting landmine as the
+                // Guarded against the self-nesting landmine documented on
-                // `Class` arm above — see `isSelfNested`'s doc comment.
+                // `isSelfNested` — without this, `List.chunk() -> List[List[T]]`
+                // would recurse into producing an unbounded chain of
+                // ever-more-nested `List` specializations via THIS SAME loop —
+                // and since this loop runs once per separate WORKLIST pop
+                // rather than recursively, a guard scoped to a single call
+                // stack isn't enough on its own.
                 {
                     let already_nested = m.isSelfNested(&base.name, &subst.0);
                     if let Some(methods) = m.methods_generic_on_enum.get(base.name.as_str()).cloned() {
                         let owner_params = enumGenericParams(base);
                         for method in methods {
-                            // See the matching comment in the `Class` arm above.
+                            // A method with generic param(s) of its OWN (e.g.
+                            // `map`'s `U`, beyond `List[T]`'s own `T`) can't be
+                            // produced HERE — `U` is only known at a particular
+                            // CALL SITE, not at enum-specialization time.
+                            // `resolveMethodOwnGenerics` queues a
+                            // `PendingSpecialization::Fn` for each concrete `U`
+                            // it actually sees used, instead.
                             if !methodOwnGenericParams(method, &owner_params).is_empty() {
                                 continue;
                             }

plum-checker/tests/checker_tests.rs CHANGED Viewed

@@ -6,13 +6,11 @@ use plum_core::{ast::*, AstParser};
 fn emptyCtx() -> CheckCtx<'static> {
     use std::sync::OnceLock;
-    static CLASSES: OnceLock<plum_checker::ClassEnv> = OnceLock::new();
     static METHODS: OnceLock<plum_checker::MethodEnv> = OnceLock::new();
     static ENUM_VARIANTS: OnceLock<plum_checker::EnumVariants> = OnceLock::new();
     static ENUM_PARAMS: OnceLock<plum_checker::EnumParams> = OnceLock::new();
     static MIN_REQUIRED: OnceLock<plum_checker::MinRequiredArgs> = OnceLock::new();
     CheckCtx {
-        classes: CLASSES.get_or_init(Default::default),
         methods: METHODS.get_or_init(Default::default),
         enum_variants: ENUM_VARIANTS.get_or_init(Default::default),
         enum_params: ENUM_PARAMS.get_or_init(Default::default),
@@ -147,7 +145,7 @@ fn boolLiteralWrongReturnTypeIsError() {
 #[test]
 fn methodSelfFieldAccessPasses() {
-    let src = "type Cat =\n  name: Str\n  age: Int\n\n  fun getName() -> Str =\n    self.name\n";
+    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\n  fun getName() -> Str =\n    self.name\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
@@ -155,7 +153,7 @@ fn methodSelfFieldAccessPasses() {
 #[test]
 fn methodSelfUnknownFieldIsError() {
-    let src = "type Cat =\n  name: Str\n\n  fun getAge() -> Int =\n    self.age\n";
+    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun getAge() -> Int =\n    self.age\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_err());
@@ -163,14 +161,14 @@ fn methodSelfUnknownFieldIsError() {
 #[test]
 fn nestedMethodTypeChecks() {
-    let src = "type Cat =\n  name: Str\n  age: Int\n\n  fun getName(self) -> Str =\n    self.name\n";
+    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\n  fun getName(self) -> Str =\n    self.name\n";
     let result = checkSource(&parse(src));
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
 }
 #[test]
 fn nestedMethodUnknownFieldIsError() {
-    let src = "type Cat =\n  name: Str\n\n  fun getAge(self) -> Int =\n    self.age\n";
+    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun getAge(self) -> Int =\n    self.age\n";
     assert!(checkSource(&parse(src)).is_err());
 }
@@ -184,7 +182,7 @@ fn selfOutsideMethodIsError() {
 #[test]
 fn classCallChecksFieldTypes() {
-    let src = "type Cat =\n  name: Str\n  age: Int\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
+    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
@@ -192,7 +190,7 @@ fn classCallChecksFieldTypes() {
 #[test]
 fn classCallWrongFieldTypeIsError() {
-    let src = "type Cat =\n  name: Str\n  age: Int\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: \"y\")\n";
+    let src = "enum Cat =\n  | Cat(name: Str, age: Int)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: \"y\")\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_err());
@@ -200,7 +198,7 @@ fn classCallWrongFieldTypeIsError() {
 #[test]
 fn classCallUnknownFieldIsError() {
-    let src = "type Cat =\n  name: Str\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
+    let src = "enum Cat =\n  | Cat(name: Str)\n\nfun makeCat() -> Cat =\n  Cat(name: \"x\", age: 1)\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_err());
@@ -208,7 +206,7 @@ fn classCallUnknownFieldIsError() {
 #[test]
 fn methodCallViaAttributeTypeChecksArgs() {
-    let src = "type Cat =\n  name: Str\n\n  fun rename(n: Str) -> Str =\n    n\n\nfun use(c: Cat) -> Str =\n  c.rename(\"x\")\n";
+    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun rename(n: Str) -> Str =\n    n\n\nfun use(c: Cat) -> Str =\n  c.rename(\"x\")\n";
     let source = parse(src);
     let result = checkSource(&source);
     assert!(result.is_ok(), "expected Ok, got {:?}", result.err());
@@ -435,42 +433,16 @@ fun bad(s: Shape) -> Float =
 }
 #[test]
-fn classNameCollidingWithNonSelfWrapEnumVariantIsAClearError() {
-    // `Cat(...)` is ambiguous when `Cat` is both a class and an enum variant
-    // whose payload ISN'T that same class (`Cat[Int]`, not bare `Cat`):
-    // downstream code consults `enum_variants` first, so the class
-    // constructor would otherwise be silently shadowed with no diagnostic.
-    // Compare `bareTypeEnumVariantSugarWrapsTheSameNamedClass` below, where
+fn bareTypeEnumVariantSugarWrapsTheSameNamedRecordShapedEnum() {
-    // `Cat` bare (no `[...]`) is deliberately allowed.
+    // `| Cat` (bare, no `[...]`) naming an already-declared record-shaped enum
+    // (the `type Cat = ...` replacement) is sugar for wrapping that whole
+    // record as the variant's single payload field — shorthand for `| Cat[Cat]`
+    // under a separate tag name. This is the DOP-friendly form: a sealed union
+    // of plain records, matching Java's "sealed interface implemented directly
+    // by records" shape.
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str)
-enum Animal =
-  | Cat(Int)
-  | Dog
-";
-    let source = parse(src);
-    let result = checkSource(&source);
-    assert!(result.is_err(), "expected Err");
-    let errs = result.unwrap_err();
-    assert!(
-        errs.iter().any(|e| e.message.contains("is declared as both a class and an enum variant")),
-        "got: {:?}",
-        errs
-    );
-}
-#[test]
-fn bareTypeEnumVariantSugarWrapsTheSameNamedClass() {
-    // `| Cat` (bare, no `[...]`) naming an already-declared `type Cat` is
-    // sugar for wrapping that whole class as the variant's single payload
-    // field — shorthand for `| Cat[Cat]` under a separate tag name. This is
-    // the DOP-friendly form: a sealed union of plain records, matching
-    // Java's "sealed interface implemented directly by records" shape.
-    let src = "\
-type Cat =
-  name: Str
 enum Animal =
   | Cat
@@ -491,8 +463,8 @@ fun catName(a: Animal) -> Str =
 #[test]
 fn genericClassInstantiatedAtTwoConcreteTypesTypeChecks() {
     let src = "\
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
 fun makeIntBox() -> Box =
   Box(value: 5)
@@ -653,8 +625,8 @@ fun useStr() -> Str =
 #[test]
 fn genericMethodOnGenericClassTypeChecks() {
     let src = "\
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
   fun getValue() -> T =
     self.value
@@ -679,8 +651,8 @@ fn unboundedRecursiveGenericInstantiationIsAClearError() {
     // declaration, which is never itself a call site and so never reaches the
     // worklist at all) and must fail with a clear, bounded error rather than hang.
     let src = "\
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
 fun recurse(v: T) -> Int =
   b = Box(value: v)
@@ -736,8 +708,8 @@ fn ordinaryFunctionWithBareGenericClassParamTypeChecks() {
     // now, but the identical root cause: `Box` is dropped from the monomorphized
     // output, so a bare `Box`-typed param would otherwise reference nothing.
     let src = "\
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
   fun getBoxValue() -> T =
     self.value
@@ -784,9 +756,8 @@ fun each(cb: fn(Int) -> Bool) -> Bool =
 #[test]
 fn fieldAssignmentTargetWithMatchingTypePasses() {
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun haveBirthday() =
     self.age = self.age + 1
@@ -798,9 +769,8 @@ type Cat =
 #[test]
 fn fieldAssignmentTargetWithMismatchedTypeIsError() {
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun breakCat() =
     self.age = \"oops\"
@@ -813,9 +783,8 @@ type Cat =
 #[test]
 fn fieldAssignmentTargetUnknownFieldIsError() {
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun breakCat() =
     self.nope = 1
@@ -981,8 +950,8 @@ fn classImplementingTraitWithMatchingMethodPasses() {
 trait Greeter =
   greet(name: Str) -> Str
-type Robot(Greeter) =
+enum Robot(Greeter) =
-  id: Int
+  | Robot(id: Int)
   fun greet(self, name: Str) -> Str =
     \"beep {name}\"
@@ -997,8 +966,8 @@ fn classClaimingTraitButMissingMethodIsError() {
 trait Greeter =
   greet(name: Str) -> Str
-type Robot(Greeter) =
+enum Robot(Greeter) =
-  id: Int
+  | Robot(id: Int)
 ";
     let source = parse(src);
     let result = checkSource(&source);
@@ -1013,8 +982,8 @@ fn classClaimingTraitWithWrongParamCountIsError() {
 trait Greeter =
   greet(name: Str) -> Str
-type Robot(Greeter) =
+enum Robot(Greeter) =
-  id: Int
+  | Robot(id: Int)
   fun greet(self) -> Str =
     \"beep\"
@@ -1032,8 +1001,8 @@ fn classClaimingTraitWithWrongParamTypeIsError() {
 trait Greeter =
   greet(name: Str) -> Str
-type Robot(Greeter) =
+enum Robot(Greeter) =
-  id: Int
+  | Robot(id: Int)
   fun greet(self, name: Int) -> Str =
     \"beep\"
@@ -1051,8 +1020,8 @@ fn classClaimingTraitWithWrongReturnTypeIsError() {
 trait Greeter =
   greet(name: Str) -> Str
-type Robot(Greeter) =
+enum Robot(Greeter) =
-  id: Int
+  | Robot(id: Int)
   fun greet(self, name: Str) -> Int =
     0
@@ -1070,8 +1039,8 @@ fn classClaimingUndeclaredTraitNameIsNotEnforced() {
     // never declared as a real `trait` anywhere — silently unenforced, not an
     // error, since there is nothing real to check it against.
     let src = "\
-type Robot(NotARealTrait) =
+enum Robot(NotARealTrait) =
-  id: Int
+  | Robot(id: Int)
 ";
     let source = parse(src);
     assert!(checkSource(&source).is_ok(), "expected Ok, got: {:?}", checkSource(&source));
@@ -1091,8 +1060,8 @@ enum Option[T] =
 trait Err =
   cause() -> Option
-type MyErr(Err) =
+enum MyErr(Err) =
-  pos: Int
+  | MyErr(pos: Int)
   fun cause(self) -> Option[MyErr] =
     None
@@ -1104,9 +1073,8 @@ type MyErr(Err) =
 #[test]
 fn matchDestructuresPlainClassAndBindsFieldTypes() {
     let src = "\
-type Point =
+enum Point =
-  x: Int
+  | Point(x: Int, y: Int)
-  y: Int
 fun sumPoint(p: Point) -> Int =
   match p
@@ -1119,9 +1087,8 @@ fun sumPoint(p: Point) -> Int =
 #[test]
 fn matchClassPatternWrongFieldCountIsError() {
     let src = "\
-type Point =
+enum Point =
-  x: Int
+  | Point(x: Int, y: Int)
-  y: Int
 fun sumPoint(p: Point) -> Int =
   match p

plum-checker/tests/monomorphize_tests.rs CHANGED Viewed

@@ -13,17 +13,6 @@ fn isGenericParamNameAcceptsSingleUppercaseLettersOnly() {
     assert!(!isGenericParamName(""));
 }
-#[test]
-fn classGenericParamsReadsDeclaredGenericsList() {
-    let c = ast::Class {
-        name: "Box".to_string(),
-        implements: vec![],
-        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
-        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
-    };
-    assert_eq!(classGenericParams(&c), vec!["T".to_string()]);
-}
 #[test]
 fn fnGenericParamsDetectsImplicitUppercaseLetterTypesInOrder() {
     let f = ast::Fn {
@@ -45,6 +34,7 @@ fn enumGenericParamsDetectsImplicitUppercaseLetterVariantFields() {
     let e = ast::Enum {
         name: "Option".to_string(),
         generics: vec![],
+        implements: vec![],
         params: vec![],
         variants: vec![
             ast::EnumVariant { name: "Some".to_string(), fields: vec![ast::Type { name: "T".to_string(), generics: vec![] }], field_names: vec![], values: vec![] },
@@ -61,22 +51,6 @@ fn mangleJoinsBaseNameAndTypeArgs() {
     assert_eq!(mangle("Green", &[]), "Green");
 }
-#[test]
-fn specializeClassSubstitutesGenericFieldTypesAndClearsGenericsList() {
-    let c = ast::Class {
-        name: "Box".to_string(),
-        implements: vec![],
-        generics: vec![ast::GenericParam { name: "T".to_string(), bounds: vec![] }],
-        fields: vec![ast::Field { name: "value".to_string(), ty: ast::Type { name: "T".to_string(), generics: vec![] } }],
-    };
-    let mut bindings = std::collections::BTreeMap::new();
-    bindings.insert("T".to_string(), PlumType::TInt);
-    let specialized = specializeClass(&c, &Substitution(bindings), "Box$Int");
-    assert_eq!(specialized.name, "Box$Int");
-    assert!(specialized.generics.is_empty());
-    assert_eq!(specialized.fields[0].ty.name, "Int");
-}
 #[test]
 fn specializeFnSubstitutesGenericParamAndReturnTypes() {
     let f = ast::Fn {
@@ -121,6 +95,7 @@ fn specializeEnumSubstitutesGenericVariantFieldNames() {
     let e = ast::Enum {
         name: "Option".to_string(),
         generics: vec![],
+        implements: vec![],
         params: vec![],
         variants: vec![
             ast::EnumVariant { name: "Some".to_string(), fields: vec![ast::Type { name: "T".to_string(), generics: vec![] }], field_names: vec![], values: vec![] },

plum-core/src/ast.rs CHANGED Viewed

@@ -65,7 +65,6 @@ pub struct Import {
 #[derive(Debug, Clone, PartialEq)]
 pub enum Item {
-    Class(Class),
     Trait(Trait),
     Enum(Enum),
     Fn(Fn),
@@ -75,26 +74,12 @@ pub enum Item {
 // ---------- Type definitions ----------
-#[derive(Debug, Clone, PartialEq)]
-pub struct Class {
-    pub name: String,
-    pub implements: Vec<String>,
-    pub generics: Vec<GenericParam>,
-    pub fields: Vec<Field>,
-}
 #[derive(Debug, Clone, PartialEq)]
 pub struct GenericParam {
     pub name: String,
     pub bounds: Vec<String>,
 }
-#[derive(Debug, Clone, PartialEq)]
-pub struct Field {
-    pub name: String,
-    pub ty: Type,
-}
 #[derive(Debug, Clone, PartialEq)]
 pub struct Trait {
     pub name: String,
@@ -113,8 +98,13 @@ pub struct TraitMethod {
 pub struct Enum {
     pub name: String,
     /// The enum's OWN declared generic type parameters (`enum Option[T] =
-    /// ...`) — mirrors `Class::generics`. Empty for a non-generic enum.
+    /// ...`). Empty for a non-generic enum.
     pub generics: Vec<GenericParam>,
+    /// Trait names this enum claims to implement (`enum Cat(ToStr) = ...`).
+    /// Mutually exclusive with `params` at the grammar level (see
+    /// `grammar.js`'s `enum` rule) — a discriminant enum's shared per-variant
+    /// values and a plain enum's trait conformance never coexist.
+    pub implements: Vec<String>,
     pub params: Vec<EnumParam>,
     pub variants: Vec<EnumVariant>,
 }

plum-core/src/builtin_usage.rs CHANGED Viewed

@@ -24,11 +24,6 @@ pub fn usedBuiltinTypeNames(source: &Source) -> HashSet<String> {
     let mut names = HashSet::new();
     for item in &source.items {
         match item {
-            Item::Class(c) => {
-                for f in &c.fields {
-                    walkType(&f.ty, &mut names);
-                }
-            }
             Item::Trait(t) => {
                 for m in &t.methods {
                     for p in &m.params {

plum-core/src/loader.rs CHANGED Viewed

@@ -85,15 +85,16 @@ fn checkBuiltinImports(path: &Path, source: &Source) -> Result<(), String> {
         if !used.contains(name) {
             continue;
         }
-        // A file can also "declare itself" by giving `Int`/`Float` as a bare,
+        // A file can also "declare itself" either as an ordinary enum sharing
-        // payload-free variant name of one of its OWN enums (a "union" enum's
-        // primitive bare-wrap sugar, e.g. `enum Number = | Int | Float` — see
+        // this exact name (e.g. `enum Str = | Str(data: Buffer) ...`, the
+        // record-shaped form `type Str = ...` used to be) or by giving
+        // `Int`/`Float` as a bare, payload-free variant name of one of its OWN
+        // enums (a "union" enum's primitive bare-wrap sugar, e.g. `enum Number
-        // `plum-checker`'s `buildGlobalTables`) instead of the older `type
+        // = | Int | Float` — see `plum-checker`'s `buildGlobalTables`) —
-        // Int = ...` class form — either way, the file is the one DECLARING
+        // either way, the file is the one DECLARING the type, not merely
-        // the type, not merely using it.
+        // using it.
         let declares_self = source.items.iter().any(|i| match i {
-            Item::Class(c) => c.name == name,
-            Item::Enum(e) => e.variants.iter().any(|v| v.name == name && v.fields.is_empty()),
+            Item::Enum(e) => e.name == name || e.variants.iter().any(|v| v.name == name && v.fields.is_empty()),
             _ => false,
         });
         if declares_self {
@@ -205,11 +206,10 @@ fn mergeItems(
 /// A collision key that mirrors `plum-checker`'s own separation of
 /// namespaces: methods are keyed by `(receiver, name)` (so `length<Cat>` and
 /// `length<Box>` never collide, exactly like `plum_checker::MethodEnv`),
-/// while classes/traits/enums/consts/free-functions are each their own
+/// while traits/enums/consts/free-functions are each their own flat,
-/// flat, kind-qualified namespace.
+/// kind-qualified namespace.
 fn itemNameKey(item: &Item) -> String {
     match item {
-        Item::Class(c) => format!("class::{}", c.name),
         Item::Trait(t) => format!("trait::{}", t.name),
         Item::Enum(e) => format!("enum::{}", e.name),
         Item::Const(c) => format!("const::{}", c.name),

plum-core/src/parser.rs CHANGED Viewed

@@ -65,16 +65,6 @@ impl<'a> AstParser<'a> {
                     imports.push(self.parseImport(child));
                     topLevelOrder.push(TopLevelKind::Import);
                 }
-                "class" => {
-                    let c = self.parseClass(child);
-                    let nested = self.collectNestedFns(child, &c.name);
-                    items.push(Item::Class(c));
-                    topLevelOrder.push(TopLevelKind::Other);
-                    for f in nested {
-                        items.push(Item::Fn(f));
-                        topLevelOrder.push(TopLevelKind::Other);
-                    }
-                }
                 "trait" => {
                     items.push(Item::Trait(self.parseTrait(child)));
                     topLevelOrder.push(TopLevelKind::Other);
@@ -139,34 +129,6 @@ impl<'a> AstParser<'a> {
             .collect()
     }
-    fn parseClass(&self, node: Node) -> Class {
-        // class: "type" type_identifier generics? ("(" type_identifier,* ")")? "=" body
-        // Named children in order: type_identifier (name), generics? (declaration), type_identifier* (implements), field*
-        let named: Vec<Node> = self.namedChildren(node);
-        let name = named.first().map(|n| self.text(*n)).unwrap_or_default();
-        // Skip the optional `generics` declaration node before looking for implements.
-        let after_generics = if named.get(1).map(|n| n.kind()) == Some("generics") { 2 } else { 1 };
-        // implements = type_identifiers that appear before any `field` node
-        let implements: Vec<String> = named[after_generics..]
-            .iter()
-            .take_while(|n| n.kind() == "type_identifier")
-            .map(|n| self.text(*n))
-            .collect();
-        let generics = self.parseGenericsField(node);
-        let fields: Vec<Field> = named
-            .iter()
-            .filter(|n| n.kind() == "field")
-            .map(|n| self.parseField(*n))
-            .collect();
-        Class { name, implements, generics, fields }
-    }
     fn parseGenericsField(&self, node: Node) -> Vec<GenericParam> {
         // generics: "[" generic_type,* "]"  where  generic_type: generic (":" sep1(type_identifier, "+"))?
         //
@@ -197,16 +159,6 @@ impl<'a> AstParser<'a> {
         params
     }
-    fn parseField(&self, node: Node) -> Field {
-        // class_field (aliased to field): var_identifier ":" type
-        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
-        let ty = node
-            .named_child(1)
-            .map(|n| self.parseType(n))
-            .unwrap_or(Type { name: String::new(), generics: vec![] });
-        Field { name, ty }
-    }
     fn parseTrait(&self, node: Node) -> Trait {
         // trait: "trait" type_identifier generics? "=" body
         let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
@@ -238,7 +190,20 @@ impl<'a> AstParser<'a> {
     }
     fn parseEnum(&self, node: Node) -> Enum {
+        // enum: "enum" type_identifier generics? (implements | params)? "=" body
+        // `implements` (bare `type_identifier`,*) and `params` (`enum_param`,*) are
+        // mutually exclusive at the grammar level — same comment-safe positional
+        // technique `parseClass` used to use for its own `implements` list, since
+        // `implements`'s items are bare `type_identifier` nodes, the same kind as
+        // the enum's own name at position 0.
+        let named: Vec<Node> = self.namedChildren(node);
-        let name = node.named_child(0).map(|n| self.text(n)).unwrap_or_default();
+        let name = named.first().map(|n| self.text(*n)).unwrap_or_default();
+        let after_generics = if named.get(1).map(|n| n.kind()) == Some("generics") { 2 } else { 1 };
+        let implements: Vec<String> = named[after_generics..]
+            .iter()
+            .take_while(|n| n.kind() == "type_identifier")
+            .map(|n| self.text(*n))
+            .collect();
         let generics = self.parseGenericsField(node);
         let params = self.childrenOfKind(node, "enum_param")
             .into_iter()
@@ -248,7 +213,7 @@ impl<'a> AstParser<'a> {
             .into_iter()
             .map(|f| self.parseEnumVariant(f))
             .collect();
-        Enum { name, generics, params, variants }
+        Enum { name, generics, implements, params, variants }
     }
     fn parseEnumParam(&self, node: Node) -> EnumParam {

plum-core/tests/formatter_test.rs CHANGED Viewed

@@ -41,9 +41,8 @@ fn keywordsGetSpacedCorrectly() {
 module test
 import std/os
-type Cat(IAnimal) =
+enum Cat(IAnimal) =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun speak(self) -> Str =
     \"meow\"
@@ -69,7 +68,7 @@ fun main() =
     let once = formatSource(input).expect("first pass");
     assert!(once.contains("module test"), "got: {once}");
     assert!(once.contains("import std/os"), "got: {once}");
-    assert!(once.contains("type Cat"), "got: {once}");
+    assert!(once.contains("enum Cat"), "got: {once}");
     assert!(once.contains("fun speak"), "got: {once}");
     assert!(once.contains("if x < 0"), "got: {once}");
     assert!(once.contains("else if x == 0"), "got: {once}");

plum-core/tests/loader_test.rs CHANGED Viewed

@@ -114,8 +114,8 @@ fn sameMethodNameOnDifferentReceiversAcrossFilesIsNotACollision() {
     writeLibFile(&lib_path, "cat", "\
 module fixtures
-type Cat =
+enum Cat =
-  age: Unit
+  | Cat(age: Unit)
   fun length(self) -> Unit =
     self.age
@@ -125,8 +125,8 @@ module fixtures
 import cat
-type Box =
+enum Box =
-  items: Unit
+  | Box(items: Unit)
   fun length(self) -> Unit =
     self.items

plum-core/tests/parser_test.rs CHANGED Viewed

@@ -26,8 +26,8 @@ fn onlyEnum(source: &Source) -> &Enum {
 #[test]
 fn nestedClassMethodsBecomeTopLevelFnItemsWithTypeParamSet() {
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str)
   fun getName(self) -> Str =
     self.name
@@ -36,8 +36,8 @@ type Cat =
     todo
 ";
     let source = parse(src);
-    assert_eq!(source.items.len(), 3, "class + 2 nested methods, in order");
+    assert_eq!(source.items.len(), 3, "class-shaped enum + 2 nested methods, in order");
-    let Item::Class(class) = &source.items[0] else { panic!("expected a Class item first") };
+    let Item::Enum(class) = &source.items[0] else { panic!("expected an Enum item first") };
     assert_eq!(class.name, "Cat");
     let Item::Fn(get_name) = &source.items[1] else { panic!("expected getName immediately after the class") };
     assert_eq!(get_name.name, "getName");
@@ -87,8 +87,8 @@ enum Step(n: Int) =
 #[test]
 fn classAndEnumWithNoNestedMethodsProduceNoExtraFnItems() {
     let src = "\
-type Dog =
+enum Dog =
-  name: Str
+  | Dog(name: Str)
 enum Bool =
   | True
@@ -96,7 +96,7 @@ enum Bool =
 ";
     let source = parse(src);
     assert_eq!(source.items.len(), 2, "no nested methods means no extra Item::Fn entries");
-    assert!(matches!(source.items[0], Item::Class(_)));
+    assert!(matches!(source.items[0], Item::Enum(_)));
     assert!(matches!(source.items[1], Item::Enum(_)));
 }
@@ -144,7 +144,7 @@ fn fnWithoutReceiverButWithReturnTypeHasNoTypeParam() {
 #[test]
 fn nestedMethodWithReturnTypeHasCorrectTypeParam() {
-    let src = "type Cat =\n  name: Str\n\n  fun toStr() -> Str =\n    \"x\"\n";
+    let src = "enum Cat =\n  | Cat(name: Str)\n\n  fun toStr() -> Str =\n    \"x\"\n";
     let source = parse(src);
     let f = onlyFn(&source);
     assert_eq!(f.type_param, Some("Cat".to_string()));

plum-examples/closures.plum CHANGED Viewed

@@ -30,8 +30,8 @@ fun useFloatClosure() -> Float =
     offset + v
   eachF(floatCb)
-type ClosureCat =
+enum ClosureCat =
-  age: Int
+  | ClosureCat(age: Int)
 fun eachCat(cb: fn(ClosureCat) -> Int) -> Int =
   cb(ClosureCat(age: 7))

plum-examples/functions.plum CHANGED Viewed

@@ -43,8 +43,8 @@ fun factorial(x: Int) -> Int =
 fun double(n: Int) -> Int =
   n * 2
-type GenericBox[T] =
+enum GenericBox[T] =
-  value: T
+  | GenericBox(value: T)
   fun getIntValue() -> Int =
     self.value
@@ -56,8 +56,8 @@ fun useGenericBox() -> Int =
 fun identity(value: T) -> T =
   value
-type GenericBox2[T] =
+enum GenericBox2[T] =
-  value: T
+  | GenericBox2(value: T)
   fun getValue() -> Int =
     self.value
@@ -87,8 +87,8 @@ fun unwrapFnOptionStrOr(o: FnOption, default: Int) -> Int =
     FnSome(v) => 4
     FnNone => default
-type GenericBox3[T] =
+enum GenericBox3[T] =
-  value: T
+  | GenericBox3(value: T)
   fun getBoxValue() -> Int =
     self.value

plum-examples/match.plum CHANGED Viewed

@@ -138,9 +138,8 @@ fun bothOptions(a: Option, b: Option) -> Int =
     Some(x), Some(y) => x + y
     _, _ => 0
-type Point =
+enum Point =
-  x: Int
+  | Point(x: Int, y: Int)
-  y: Int
   fun sum(self) -> Int =
     match self

plum-examples/methods.plum CHANGED Viewed

@@ -2,9 +2,8 @@ import std/Str
 import std/Bool
 import std/Number
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun getAge(self) -> Int =
     self.age
@@ -12,9 +11,8 @@ type Cat =
   fun birthday(self) -> Int =
     self.age + 1
-type Wrapper =
+enum Wrapper =
-  inner: Cat
+  | Wrapper(inner: Cat, tag: Int)
-  tag: Int
   fun innerAge(self) -> Int =
     self.inner.age

plum-examples/oop_visitor.plum CHANGED Viewed

@@ -41,10 +41,8 @@ enum Rating =
 trait Book =
   collectInterestingInfo() -> Str
-type FantasyBook(Book) =
+enum FantasyBook(Book) =
-  title: Str
-  pages: Int
-  hasMythicalCreatures: Bool
+  | FantasyBook(title: Str, pages: Int, hasMythicalCreatures: Bool)
   fun collectInterestingInfo(self) -> Str =
     if self.hasMythicalCreatures
@@ -52,10 +50,8 @@ type FantasyBook(Book) =
     else
       "Fantasy book \"{self.title}\" has no mythical creatures"
-type ScifiBook(Book) =
+enum ScifiBook(Book) =
-  title: Str
+  | ScifiBook(title: Str, pages: Int, theme: Str)
-  pages: Int
-  theme: Str
   fun collectInterestingInfo(self) -> Str =
     if self.theme == "space exploration"
@@ -63,10 +59,8 @@ type ScifiBook(Book) =
     else
       "Scifi book \"{self.title}\" has theme {self.theme}"
-type ChildrensTaleBook(Book) =
+enum ChildrensTaleBook(Book) =
-  title: Str
-  pages: Int
-  moralLesson: Str
+  | ChildrensTaleBook(title: Str, pages: Int, moralLesson: Str)
   fun collectInterestingInfo(self) -> Str =
     if self.pages == 0
@@ -74,11 +68,8 @@ type ChildrensTaleBook(Book) =
     else
       "Childrens book \"{self.title}\" teaches: {self.moralLesson}"
-type NonFictionBook(Book) =
+enum NonFictionBook(Book) =
-  title: Str
-  pages: Int
-  rating1: Rating
+  | NonFictionBook(title: Str, pages: Int, rating1: Rating, rating2: Rating)
-  rating2: Rating
   fun collectInterestingInfo(self) -> Str =
     match self.rating1, self.rating2

plum-examples/types.plum CHANGED Viewed

@@ -3,18 +3,17 @@ import std/Bool
 import std/Str
 import std/Number
-type Point =
+enum Point =
-  x: Int
+  | Point(x: Int, y: Int)
-  y: Int
-type Named(ToStr) =
+enum Named(ToStr) =
-  name: Str
+  | Named(name: Str)
   fun toStr(self) -> Str =
     self.name
-type Box[T] =
+enum Box[T] =
-  value: T
+  | Box(value: T)
 trait Shape =
   area() -> Float
@@ -47,32 +46,28 @@ fun makeIntBox() -> Box =
 fun makeStrBox() -> Box =
   Box(value: "x")
-# ---- class and enum regression tests ----
+# ---- record-shaped and sum-type enum regression tests ----
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun getAge() -> Int =
     self.age
-type Dog =
+enum Dog =
-  name: Str
+  | Dog(name: Str, age: Int)
-  age: Int
   fun getAge(self) -> Int =
     self.age
-type Pair =
+enum Pair =
-  a: Int
+  | Pair(a: Int, b: Int)
-  b: Int
-type Wrapper =
+enum Wrapper =
-  inner: Pair
+  | Wrapper(inner: Pair, tag: Int)
-  tag: Int
-type LoopBox =
+enum LoopBox =
-  v: Int
+  | LoopBox(v: Int)
 fun sumLoopBoxes() -> Int =
   total := 0
@@ -121,8 +116,8 @@ enum ShapeWithFields =
 fun numberKind(n: Number) -> Str =
   n.kind()
-type OptionBox =
+enum OptionBox =
-  value: Option[Int]
+  | OptionBox(value: Option[Int])
   fun unwrap(default: Int) -> Int =
     match self.value

plum-std/Array.plum CHANGED Viewed

@@ -33,7 +33,9 @@ import std/Number
 # hood — so `get` on an index that was never `set` traps rather than
 # returning some default `T` value (there is no way to conjure a default `T`
 # generically).
-type Array[T] =
+enum Array[T] =
+  | Array
   # A new, empty array.
   fun init() -> Array[T] =
     todo

plum-std/Buffer.plum CHANGED Viewed

@@ -14,9 +14,8 @@ import std/Number
 # `bytes.Buffer`'s asymptotic behavior — unlike the previous `Str`-backed
 # version of this type, which recopied everything written so far on every
 # write.
-type Buffer(ToStr) =
+enum Buffer(ToStr) =
-  data: []Byte
+  | Buffer(data: []Byte, len: Int)
-  len: Int
   # A no-param `init` nested in the type is `Buffer()`'s constructor — a
   # zero-arg `Buffer()` call desugars to `Buffer.init()` (see `plum-checker`'s

plum-std/Byte.plum CHANGED Viewed

@@ -9,7 +9,9 @@ import std/Str
 # recognized conversion, not an ordinary function call, exactly like
 # `Int(x)`/`Float(x)` (see `plum-checker`/`plum-wasm-codegen`'s special-cased
 # handling of these three names).
-type Byte =
+enum Byte =
+  | Byte
   fun toInt(self) -> Int =
     Int(self)

plum-std/ByteSlice.plum CHANGED Viewed

@@ -14,7 +14,9 @@ import std/Number
 # — there's no way to express raw array length/indexing/construction/copying
 # in Plum source itself; `copyStrToBytes`/`bytesToStr` build on top of them
 # instead of needing intrinsics of their own.
-type ByteSlice =
+enum ByteSlice =
+  | ByteSlice
   # Number of bytes in the slice.
   fun length(self) -> Int =
     todo

plum-std/Http.plum CHANGED Viewed

@@ -12,10 +12,8 @@ import std/Number
 # An HTTP response: status code, response headers, and the raw response
 # body as a `Str` (a byte array, so binary bodies round-trip intact).
-type Response =
+enum Response =
-  status: Int
-  headers: Map[Str, Str]
+  | Response(status: Int, headers: Map[Str, Str], body: Str)
-  body: Str
   # 2xx status codes are success; everything else (redirects, 4xx, 5xx) is
   # surfaced here rather than as an `Err` from `request` — a non-2xx

plum-std/Json.plum CHANGED Viewed

@@ -84,9 +84,8 @@ enum Json =
 # message — implements the shared `Err` trait (`libs/std/err.plum`) rather
 # than being a plain `Str`, so a caller that wants the position can get it
 # without re-parsing the message.
-type JsonParseError(Err) =
+enum JsonParseError(Err) =
-  pos: Int
-  text: Str
+  | JsonParseError(pos: Int, text: Str)
   fun code(self) -> Int =
     1
@@ -107,9 +106,8 @@ type JsonParseError(Err) =
 # but `Readable` is an undefined trait with no methods anywhere in `libs/std`
 # — there is nothing to call on it — so this reads directly from a `Str`
 # instead, the same way every other stdlib parser, e.g. `Int.fromStr`, does.)
-type JsonParser =
+enum JsonParser =
-  src: Str
+  | JsonParser(src: Str, pos: Int)
-  pos: Int
   fun fail(self, text: Str) -> JsonParseError =
     JsonParseError(pos: self.pos, text: text)

plum-std/List.plum CHANGED Viewed

@@ -7,17 +7,13 @@ import std/Bool
 import std/Str
 # A node stores the data in a list and contains pointers to the previous and next sibling nodes
-type Node[T] =
+enum Node[T] =
-  value: T
-  prev: Option[Node[T]]
+  | Node(value: T, prev: Option[Node[T]], next: Option[Node[T]])
-  next: Option[Node[T]]
 # A list is a data structure describing a contiguous section of an array stored separately from the slice variable itself.
 # It contains the pointers to the start and end nodes (head, tail) and maintains the size as well
-type List[T: ToStr](ToStr) =
+enum List[T: ToStr](ToStr) =
-  head: Option[Node[T]]
+  | List(head: Option[Node[T]], tail: Option[Node[T]], size: Int)
-  tail: Option[Node[T]]
-  size: Int
   # `List[T](1, 2, 3)` (or, for an empty list, `List[T]()` — explicit
   # generics required either way, since nothing else in a call this shape

plum-std/Map.plum CHANGED Viewed

@@ -29,9 +29,8 @@ trait Hashable =
 # so a `Pair` used as a `List` element always has `K`/`V: ToStr` too,
 # and `List`'s own eagerly-compiled `join`/`toStr` (which call `.toStr()` on
 # every element) need this to exist for every `Map` specialization anyway.
-type Pair[K, V](ToStr) =
+enum Pair[K, V](ToStr) =
-  key: K
+  | Pair(key: K, val: V)
-  val: V
   fun toStr(self) -> Str =
     return "{self.key.toStr()}: {self.val.toStr()}"
@@ -48,9 +47,8 @@ BUCKET_COUNT = 16
 # `get`/`set`/`remove` (versus the single, whole-map linear scan a plain
 # association list costs), degrading to O(n) only if many keys collide into
 # the same bucket.
-type Map[K: Hashable, V] =
+enum Map[K: Hashable, V] =
-  buckets: Array[List[Pair[K, V]]]
+  | Map(buckets: Array[List[Pair[K, V]]], size: Int)
-  size: Int
   # `Map[Str, Int]()` — explicit generics required (nothing in a no-arg call
   # pins down `K`/`V`), builds `BUCKET_COUNT` empty bucket lists up front via

plum-std/Str.plum CHANGED Viewed

@@ -26,8 +26,8 @@ trait ToStr =
 # means constructing a brand new `Str`/`Buffer` pair (`Buffer.write`'s own
 # callers are always building up a FRESH buffer before wrapping it, never
 # mutating an already-published `Str`'s backing storage).
-type Str(Comparable, ToStr, Readable, Writable) =
+enum Str(Comparable, ToStr, Readable, Writable) =
-  data: Buffer
+  | Str(data: Buffer)
   # Number of bytes in the string — `self.data` (a `Buffer`) already tracks
   # this, so unlike `byteAt`/`byteToStr` this needs no compiler intrinsic of

plum-std/Time.plum CHANGED Viewed

@@ -7,8 +7,8 @@ import std/Bool
 extern fun rawNowMillis() -> Int
 # A single point in time, stored as milliseconds since the Unix epoch.
-type Time(ToStr) =
+enum Time(ToStr) =
-  value: Int
+  | Time(value: Int)
   fun toMillis(self) -> Int =
     return self.value
@@ -78,10 +78,8 @@ fun now() -> Time =
   return Time(value: rawNowMillis())
 # A Gregorian calendar date, decomposed from a day count by `civilFromDays`.
-type Civil =
+enum Civil =
-  year: Int
-  month: Int
+  | Civil(year: Int, month: Int, day: Int)
-  day: Int
 MILLIS_PER_DAY = 86400000
@@ -116,8 +114,8 @@ fun floorMod(a: Int, b: Int) -> Int =
 # A span of time, stored as milliseconds. Negative values are meaningful
 # (e.g. the result of `Time.since` when `self` is earlier than `other`).
-type Duration =
+enum Duration =
-  value: Int
+  | Duration(value: Int)
   fun millis(n: Int) -> Duration =
     return Duration(value: n)

plum-std/Uuid.plum CHANGED Viewed

@@ -6,8 +6,8 @@ import std/Bool
 # A UUID, stored as its canonical 36-character
 # `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` text form.
-type Uuid(ToStr) =
+enum Uuid(ToStr) =
-  value: Str
+  | Uuid(value: Str)
   fun toStr(self) -> Str =
     return self.value

plum-tooling/tree-sitter-plum/grammar.js CHANGED Viewed

@@ -78,7 +78,7 @@ module.exports = grammar({
       seq(
         optional($.module),
         repeat($.import),
-        repeat(choice($.class, $.trait, $.enum, $.fn, $.const, $.test)),
+        repeat(choice($.trait, $.enum, $.fn, $.const, $.test)),
       ),
     module: ($) => seq("module", $.mod_identifier),
@@ -119,20 +119,6 @@ module.exports = grammar({
       ),
     variadic_type: ($) => seq("...", $.type),
-    class: ($) =>
-      seq(
-        "type",
-        field("name", $.type_identifier),
-        field("generics", optional($.generics)),
-        field("implements", optional(seq("(", commaSep1($.type_identifier), ")"))),
-        "=",
-        $._indent,
-        field("fields", optional(repeat(alias($.class_field, $.field)))),
-        field("methods", optional(repeat($.fn))),
-        $._dedent,
-      ),
-    class_field: ($) => seq(field("name", $.var_identifier), ":", field("type", $.type)),
     trait: ($) =>
       seq(
         "trait",
@@ -173,7 +159,16 @@ module.exports = grammar({
         "enum",
         field("name", $.type_identifier),
         field("generics", optional($.generics)),
+        // Mutually exclusive with each other (an enum is either a plain sum
+        // type possibly claiming trait conformance, OR a discriminant enum
+        // with shared per-variant values — never both) — disambiguated by
+        // content, not just position: `implements` holds bare type names
+        // (`ToStr`), `params` holds `name: Type` pairs (`n: Int`), and
+        // `var_identifier`/`type_identifier` are distinct tokens.
+        optional(choice(
+          field("implements", seq("(", commaSep1($.type_identifier), ")")),
-        field("params", optional(seq("(", commaSep1($.enum_param), ")"))),
+          field("params", seq("(", commaSep1($.enum_param), ")")),
+        )),
         "=",
         $._indent,
         optional(repeat(alias($.enum_field, $.field))),

plum-tooling/tree-sitter-plum/queries/plum/format.scm CHANGED Viewed

@@ -9,9 +9,6 @@
 (source
   (fn) @allow_blank_line_before)
-(source
-  (class) @allow_blank_line_before)
 (source
   (enum) @allow_blank_line_before)
@@ -96,8 +93,6 @@
 (import "import" @append_space)
-(class "type" @append_space)
 (trait "trait" @append_space)
 (enum "enum" @append_space)
@@ -158,35 +153,13 @@
 ":" @append_space
 ; ============================================================
-; class/trait/enum bodies — unlike a `fn`'s body, these have no
+; trait/enum bodies — unlike a `fn`'s body, these have no
 ; wrapping `(body ...)` node of their own (the grammar puts their
-; `field`/`fn` children directly under `class`/`trait`/`enum`), so
+; `field`/`fn` children directly under `trait`/`enum`), so
 ; they need their own hardline + indent rules instead of reusing
 ; the `(body)` rule below.
 ; ============================================================
-(class
-  (field) @prepend_hardline)
-(class
-  (fn) @prepend_hardline)
-; A blank line between two fields/methods (or a field and a method) inside a
-; `type` body is preserved if the source already had one — same as top-level
-; items — rather than always being collapsed to a single hardline.
-(class
-  (field) @allow_blank_line_before)
-(class
-  (fn) @allow_blank_line_before)
-(class
-  "=" @append_indent_start)
-(class
-  (_) @append_indent_end
-  .)
 (trait
   (field) @prepend_hardline)
@@ -203,7 +176,9 @@
 (enum
   (fn) @prepend_hardline)
+; A blank line between two fields/methods (or a field and a method) inside an
+; `enum` body is preserved if the source already had one — same as top-level
-; Same blank-line preservation as `class` above.
+; items — rather than always being collapsed to a single hardline.
 (enum
   (field) @allow_blank_line_before)
@@ -218,13 +193,13 @@
   .)
 ; `enum_field` (a variant like `| Some[T]`) is ALIASED to the same visible
-; node kind ("field") as class_field/trait_field, but only it has a literal
+; node kind ("field") as trait_field, but only it has a literal
 ; "|" — safe to target unscoped by parent.
 (field
   "|" @append_space)
 ; ============================================================
-; match — same situation as class/trait/enum: `case`/`guard_case`
+; match — same situation as trait/enum: `case`/`guard_case`
 ; children sit directly under `match`, no wrapping `(body ...)`.
 ; ============================================================

plum-tooling/tree-sitter-plum/queries/plum/highlights.scm CHANGED Viewed

@@ -59,6 +59,7 @@
   "||"
   "&&"
   "..."
+  ".."
 ] @operator
 [
@@ -71,7 +72,6 @@
 [
   "import"
   "module"
-  "type"
   "enum"
   "trait"
   "fun"

plum-tooling/tree-sitter-plum/queries/plum/indents.scm CHANGED Viewed

@@ -1,7 +1,6 @@
 [
   (enum)
   (trait)
-  (class)
   (fn)
   (for)
   (while)
@@ -16,7 +15,6 @@
   (for)
   (while)
   (fn)
-  (class)
   (enum)
   (trait)
 ] @extend

plum-tooling/tree-sitter-plum/queries/plum/tags.scm CHANGED Viewed

@@ -1,6 +1,3 @@
-(class
-  name: (type_identifier) @name) @definition.class
 (enum
   name: (type_identifier) @name) @definition.class

plum-tooling/tree-sitter-plum/queries/plum/textobjects.scm CHANGED Viewed

@@ -1,9 +1,6 @@
 (fn
   body: (_) @function.inside) @function.around
-(class
-  fields: (field) @class.inside) @class.around
 (trait
   fields: (field) @class.inside) @class.around

plum-tooling/tree-sitter-plum/src/grammar.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/node-types.json CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/src/parser.c CHANGED Viewed

Binary file

plum-tooling/tree-sitter-plum/test/corpus/type.txt CHANGED Viewed

@@ -2,13 +2,11 @@
 type
 ================================================================================
-type Dog =
+enum Dog =
-  name: Str
+  | Dog(name: Str, age: B)
-  age: B
-type Cat(ToStr) =
+enum Cat(ToStr) =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun init(name: Str) -> Cat =
     Cat(name: name, age: 0)
@@ -25,27 +23,31 @@ type Cat(ToStr) =
 --------------------------------------------------------------------------------
 (source
-  (class
+  (enum
     (type_identifier)
     (field
+      (type_identifier)
+      (enum_named_field
-      (var_identifier)
+        (var_identifier)
-      (type
+        (type
-        (type_identifier)))
+          (type_identifier)))
-    (field
+      (enum_named_field
-      (var_identifier)
+        (var_identifier)
-      (type
+        (type
-        (generic))))
+          (generic)))))
-  (class
+  (enum
     (type_identifier)
     (type_identifier)
     (field
+      (type_identifier)
+      (enum_named_field
-      (var_identifier)
+        (var_identifier)
-      (type
+        (type
-        (type_identifier)))
+          (type_identifier)))
-    (field
+      (enum_named_field
-      (var_identifier)
+        (var_identifier)
-      (type
+        (type
-        (type_identifier)))
+          (type_identifier))))
     (fn
       (fn_identifier)
       (param
@@ -60,14 +62,16 @@ type Cat(ToStr) =
             (class_call
               (type_identifier)
               (class_argument_list
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (var_identifier)))
+                      (var_identifier))))
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (integer)))))))))
+                      (integer))))))))))
     (fn
       (fn_identifier)
       (param
@@ -82,14 +86,16 @@ type Cat(ToStr) =
             (class_call
               (type_identifier)
               (class_argument_list
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (var_identifier)))
+                      (var_identifier))))
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (integer)))))))))
+                      (integer))))))))))
     (fn
       (fn_identifier)
       (param
@@ -104,16 +110,18 @@ type Cat(ToStr) =
             (class_call
               (type_identifier)
               (class_argument_list
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (string
+                      (string
-                      (string_start)
+                        (string_start)
-                      (string_end))))
+                        (string_end)))))
+                (field_argument
-                (var_identifier)
+                  (var_identifier)
-                (expression
+                  (expression
-                  (primary_expression
+                    (primary_expression
-                    (var_identifier)))))))))
+                      (var_identifier))))))))))
     (fn
       (fn_identifier)
       (type
@@ -146,8 +154,8 @@ type Cat(ToStr) =
 type - nested method declaration
 ================================================================================
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str)
   fun getName(self) -> Str =
     self.name
@@ -155,12 +163,14 @@ type Cat =
 --------------------------------------------------------------------------------
 (source
-  (class
+  (enum
     (type_identifier)
     (field
+      (type_identifier)
+      (enum_named_field
-      (var_identifier)
+        (var_identifier)
-      (type
+        (type
-        (type_identifier)))
+          (type_identifier))))
     (fn
       (fn_identifier)
       (self)

plum-tooling/tree-sitter-plum/test/highlight/sample.plum CHANGED Viewed

@@ -1,8 +1,7 @@
 module std
-type Cat(ToStr) =
+enum Cat(ToStr) =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun withName(name: Str) -> Cat =
     Cat(name: name, age: self.age)

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

@@ -7,7 +7,7 @@ use std::cell::{Cell, RefCell};
 use std::collections::{HashMap, HashSet};
 use plum_core::ast;
 use plum_checker::types::{PlumType, TypeEnv, TypeScheme};
-use plum_checker::{ClassEnv, MethodEnv, EnumVariants, EnumVariantInfo, EnumParams};
+use plum_checker::{MethodEnv, EnumVariants, EnumVariantInfo, EnumParams};
 /// One entry in the module's type section. Wasm's type section is a SINGLE shared
 /// index space for function types AND (once wasm-gc is in play) composite
@@ -328,7 +328,6 @@ type ClosureSigKey = (Vec<ValType>, Option<ValType>);
 pub struct CompileCtx<'a> {
     pub func_ids: HashMap<String, u32>,
     pub func_sigs: HashMap<String, FuncSig>,
-    pub classes: ClassEnv,
     pub methods: MethodEnv,
     pub enum_variants: EnumVariants,
     pub enum_params: EnumParams,
@@ -358,7 +357,7 @@ pub struct CompileCtx<'a> {
     /// Shared runtime helper `(n: i64) -> ref Str`: allocates a new `array<i8>`
     /// holding `n`'s decimal representation, for interpolating an `Int`.
     pub int_to_string_func: u32,
-    /// wasm-gc type-section indices for this program's classes/enums/Str/closures —
+    /// wasm-gc type-section indices for this program's enums/Str/closures —
     /// every value's real representation (see `docs/superpowers/plans/2026-07-25-wasm-gc-migration.md`).
     pub gc_types: GcTypeRegistry,
     /// Payload-free variant name (True/False/None/...) -> the global index holding
@@ -401,7 +400,6 @@ struct LocalCtx<'a> {
     string_concat_func: u32,
     string_eq_func: u32,
     int_to_string_func: u32,
-    classes: &'a ClassEnv,
     methods: &'a MethodEnv,
     enum_variants: &'a EnumVariants,
     enum_params: &'a EnumParams,
@@ -506,13 +504,14 @@ 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
+/// other spot a pattern's own concrete GC type index is needed) is always an enum
-/// variant or a plain class — see `compileClassDestructureArm`. Checks both
+/// variant — falls back to `class_type_idx` only for the record-shaped alias case
+/// (see `buildGcTypeRegistry`'s own alias comment), which `variant_type_idx` should
-/// registries so a scratch local narrows correctly either way.
+/// already cover directly; kept as a defensive second lookup.
 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))
+        .unwrap_or_else(|| panic!("internal codegen error: '{}' missing from the GC type registry", name))
 }
 /// Resolves an `ast::Type`/`ast::ParamType`'s bare name (e.g. from a function
@@ -677,8 +676,8 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
         PlumType::TByteSlice => ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(registry.byte_array_type_idx) }),
         PlumType::TNamed(name) => match registry.class_type_idx.get(name).or_else(|| registry.enum_super_type_idx.get(name)) {
             Some(idx) => ValType::Ref(RefType { nullable: true, heap_type: HeapType::Concrete(*idx) }),
-            // A field typed as a generic enum/class (e.g. `Node.next: Option[Node]`)
+            // A field typed as a generic enum (e.g. `Node.next: Option[Node]`)
-            // resolves here to the BARE generic name — `ClassEnv`'s `plumTypeFromAst`
+            // resolves here to the BARE generic name — `plumTypeFromAst`
             // has no representation for type arguments, so it can't know this means
             // `Option$Int` once monomorphization specializes (and removes the
             // unspecialized) `Option` — same permissive `anyref` fallback as
@@ -696,24 +695,22 @@ fn plumTypeToGcValtype(t: &PlumType, registry: &GcTypeRegistry) -> ValType {
     }
 }
-/// Builds the wasm-gc type registry for every concrete class/enum actually declared
+/// Builds the wasm-gc type registry for every concrete enum actually declared in
-/// in `source` (`Bool`/`Str`/etc included, but only if imported — no builtin is
+/// `source` (`Bool`/`Str`/etc included, but only if imported — no builtin is
 /// hardcoded here), plus the shared raw byte-array type, and declares them all as
 /// ONE `rec` group via `module.addGcTypes` — a single group sidesteps every ordering
-/// question about mutual/self-references (a class field of another class's type, an
+/// question about mutual/self-references (a record-shaped enum's field naming
-/// enum variant field referencing its own enum, `Node.next: Option[Node]`, etc.),
+/// another such enum's type, an enum variant field referencing its own enum,
-/// since within one `rec` group members may reference each other regardless of
+/// `Node.next: Option[Node]`, etc.), since within one `rec` group members may
-/// declaration order.
+/// reference each other regardless of declaration order.
 fn buildGcTypeRegistry(
     module: &mut WasmModule,
     source: &ast::Source,
-    classes: &ClassEnv,
     enum_variants: &EnumVariants,
     enum_params: &EnumParams,
 ) -> GcTypeRegistry {
     enum Slot {
         Str,
-        Class(String),
         EnumSuper(String),
         Variant(String),
         /// The single shared `array<anyref>` type every `Array[T]`
@@ -729,22 +726,6 @@ fn buildGcTypeRegistry(
     let mut variant_type_idx: HashMap<String, u32> = HashMap::new();
     let mut array_ref_slot: Option<u32> = None;
-    for item in &source.items {
-        if let ast::Item::Class(c) = item {
-            if isArraySpecialization(&c.name) {
-                let idx = *array_ref_slot.get_or_insert_with(|| {
-                    let idx = slots.len() as u32;
-                    slots.push(Slot::ArrayRef);
-                    idx
-                });
-                class_type_idx.insert(c.name.clone(), idx);
-            } else {
-                class_type_idx.insert(c.name.clone(), slots.len() as u32);
-                slots.push(Slot::Class(c.name.clone()));
-            }
-        }
-    }
     // `Bool` is an ordinary enum now (`type Bool = | True | False` in
     // `libs/std/Bool.plum`) — registered exactly like any other enum
     // declared in `source.items`, present only if actually imported.
@@ -755,12 +736,42 @@ fn buildGcTypeRegistry(
         }
     }
     for (enum_name, variant_names) in &enum_decls {
+        // `Array`/`Array$T` is a RECORD-shaped enum (single variant sharing the
+        // enum's own name — the `type Array[T] = ...` replacement) whose values
+        // are ALL represented by the one shared `array<anyref>` type regardless
+        // of `T` (see `isArraySpecialization`'s own doc comment) — alias its
+        // enum/variant/class names onto that single existing slot instead of
+        // giving it (and every OTHER `Array$...` specialization) its own real
+        // struct type.
+        if isArraySpecialization(enum_name) {
+            let idx = *array_ref_slot.get_or_insert_with(|| {
+                let idx = slots.len() as u32;
+                slots.push(Slot::ArrayRef);
+                idx
+            });
+            enum_super_type_idx.insert(enum_name.clone(), idx);
+            class_type_idx.insert(enum_name.clone(), idx);
+            for vname in variant_names {
+                variant_type_idx.insert(vname.clone(), idx);
+            }
+            continue;
+        }
         enum_super_type_idx.insert(enum_name.clone(), slots.len() as u32);
         slots.push(Slot::EnumSuper(enum_name.clone()));
         for vname in variant_names {
             variant_type_idx.insert(vname.clone(), slots.len() as u32);
             slots.push(Slot::Variant(vname.clone()));
         }
+        // A RECORD-shaped enum (the `type X = ...` replacement, e.g. `enum Cat =
+        // | Cat(name: Str)`) also gets a `class_type_idx` alias onto its one
+        // variant's real struct slot — `plumTypeToValtype`'s `TNamed(name)` arm
+        // resolves a value of this type via `class_type_idx` (checked first,
+        // falling back to `enum_super_type_idx`), and every OTHER codegen site
+        // that already looks up a "class" by this exact name (field access,
+        // construction, pattern destructuring, ...) keeps working unchanged.
+        if variant_names.len() == 1 && variant_names[0] == *enum_name {
+            class_type_idx.insert(enum_name.clone(), variant_type_idx[&variant_names[0]]);
+        }
     }
     // The registry is fully index-complete after pass 1 (every name has an assigned
@@ -787,18 +798,6 @@ fn buildGcTypeRegistry(
                 shared: false,
             },
         },
-        Slot::Class(name) => {
-            let fields = classes.get(name).cloned().unwrap_or_default();
-            let field_types: Vec<FieldType> = fields.iter().map(|(_, ty)| FieldType {
-                element_type: StorageType::Val(plumTypeToGcValtype(ty, &registry)),
-                mutable: true,
-            }).collect();
-            SubType {
-                is_final: true,
-                supertype_idx: None,
-                composite_type: CompositeType { inner: CompositeInnerType::Struct(StructType { fields: field_types.into() }), shared: false },
-            }
-        }
         // An ORDINARY enum's supertype declares zero fields (each variant adds its
         // own distinct payload fields below it). A DISCRIMINANT enum (`enum
         // Foo(n: Int) = ...`) is different: every variant shares the EXACT SAME
@@ -903,14 +902,13 @@ fn initCallableWithNoArgs(params: &[PlumType]) -> bool {
 }
 fn checkCtxOf<'a>(
-    ctx_classes: &'a ClassEnv,
     ctx_methods: &'a MethodEnv,
     ctx_enum_variants: &'a EnumVariants,
     ctx_enum_params: &'a EnumParams,
     ctx_min_required: &'a plum_checker::MinRequiredArgs,
 ) -> plum_checker::CheckCtx<'a> {
     plum_checker::CheckCtx {
-        classes: ctx_classes, methods: ctx_methods, enum_variants: ctx_enum_variants,
+        methods: ctx_methods, enum_variants: ctx_enum_variants,
         enum_params: ctx_enum_params, min_required: ctx_min_required,
     }
 }
@@ -921,7 +919,7 @@ fn checkCtxOf<'a>(
 /// codegen is being driven directly on unchecked input (as some tests do).
 fn inferLocalType(expr: &ast::Expr, ctx: &LocalCtx) -> PlumType {
     let env = ctx.type_env.borrow();
-    let cctx = checkCtxOf(ctx.classes, ctx.methods, ctx.enum_variants, ctx.enum_params, ctx.min_required);
+    let cctx = checkCtxOf(ctx.methods, ctx.enum_variants, ctx.enum_params, ctx.min_required);
     plum_checker::inferExpr(expr, &env, &cctx).unwrap_or(PlumType::TInt)
 }
@@ -1080,12 +1078,12 @@ fn desugarAssertStmt(stmt: &ast::Stmt) -> ast::Stmt {
 fn compileSourceInner(source: &ast::Source, extra_exports: &[(String, String)]) -> Result<Vec<u8>, String> {
     let source = &plum_checker::monomorphize::monomorphizeSource(source)?;
-    let (global_env, classes, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
+    let (global_env, methods, enum_variants, enum_params) = plum_checker::buildGlobalTables(source);
     let min_required = plum_checker::buildMinRequiredArgs(source);
     let mut module = WasmModule::new();
-    let mut gc_types = buildGcTypeRegistry(&mut module, source, &classes, &enum_variants, &enum_params);
+    let mut gc_types = buildGcTypeRegistry(&mut module, source, &enum_variants, &enum_params);
     CURRENT_GC_TYPES.with(|c| *c.borrow_mut() = Some(gc_types.clone()));
     CURRENT_CONSTS.with(|c| {
@@ -1169,6 +1167,15 @@ fn compileSourceInner(source: &ast::Source, extra_exports: &[(String, String)])
         if !info.field_types.is_empty() {
             continue;
         }
+        // `Array`/`Array$T`'s bare payload-free variant is aliased onto the
+        // ONE shared `array<anyref>` type every specialization reuses (see
+        // `buildGcTypeRegistry`'s `isArraySpecialization` handling), not a
+        // real struct type — it's never actually instantiated this way
+        // (construction goes through the `init`/`push` compiler intrinsics
+        // instead), so it must not get a singleton global here.
+        if isArraySpecialization(name) {
+            continue;
+        }
         let variant_idx = *gc_types.variant_type_idx.get(name)
             .unwrap_or_else(|| panic!("internal codegen error: payload-free variant '{}' missing from GC type registry", name));
         let mut init = Vec::new();
@@ -1258,7 +1265,7 @@ fn compileSourceInner(source: &ast::Source, extra_exports: &[(String, String)])
         }
         let mut walker = ClosureWalker {
             env,
-            cctx: checkCtxOf(&classes, &methods, &enum_variants, &enum_params, &min_required),
+            cctx: checkCtxOf(&methods, &enum_variants, &enum_params, &min_required),
             fn_decls: &fn_decls,
             found: Vec::new(),
             locals,
@@ -1400,7 +1407,7 @@ fn compileSourceInner(source: &ast::Source, extra_exports: &[(String, String)])
     let int_to_string_func = registerIntToStringHelper(&mut module, gc_types.byte_array_type_idx);
     let ctx = CompileCtx {
-        func_ids, func_sigs, classes, methods, enum_variants, enum_params, min_required, global_env,
+        func_ids, func_sigs, methods, enum_variants, enum_params, min_required, global_env,
         closures, closure_asts, closure_call_types, named_fn_values,
         string_concat_func, string_eq_func, int_to_string_func, gc_types, singleton_globals,
     };
@@ -2442,14 +2449,15 @@ fn scanExprForParamTypes(
         }
         ast::Expr::Attribute(a) => {
             // `c.field` on a bare, unresolved param implies `c`'s type is whichever
-            // class declares that field name — ambiguous if more than one class has
+            // enum declares a variant with that field name — ambiguous if more than
-            // a field by that name, but resolvable in the common case.
+            // one variant has a field by that name, but resolvable in the common case.
             if let ast::AttrKind::Field(field_name) = &a.attr {
                 if let ast::Expr::Var(n) = &a.object {
                     if params.contains(n) && !resolved.contains_key(n) {
+                        let mut matches = cctx.enum_variants.values()
-                        let mut matches = cctx.classes.iter().filter(|(_, fields)| fields.iter().any(|(fname, _)| fname == field_name));
+                            .filter(|info| info.field_names.iter().any(|fname| fname == field_name));
-                        if let (Some((class_name, _)), None) = (matches.next(), matches.next()) {
+                        if let (Some(info), None) = (matches.next(), matches.next()) {
-                            resolved.insert(n.clone(), PlumType::TNamed(class_name.clone()));
+                            resolved.insert(n.clone(), PlumType::TNamed(info.enum_name.clone()));
                         }
                     }
                 }
@@ -2763,11 +2771,6 @@ 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);
-                    }
                 }
             }
             _ => {}
@@ -2952,7 +2955,7 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
     let mut collector = Collector {
         env: base_env.clone(),
-        cctx: checkCtxOf(&ctx.classes, &ctx.methods, &ctx.enum_variants, &ctx.enum_params, &ctx.min_required),
+        cctx: checkCtxOf(&ctx.methods, &ctx.enum_variants, &ctx.enum_params, &ctx.min_required),
         named: Vec::new(),
         named_set: Default::default(),
         match_scratch: HashMap::new(),
@@ -3044,7 +3047,6 @@ fn compileFnBody(f: &ast::Fn, ctx: &CompileCtx, state: &mut ModuleState) -> Resu
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
         int_to_string_func: ctx.int_to_string_func,
-        classes: &ctx.classes,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,
@@ -3307,47 +3309,36 @@ fn compileStmt(stmt: &ast::Stmt, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         // struct.set expects [(ref null $t) value] on the stack (ref
                         // pushed first/deeper, value second/on top) — same push order
                         // this already used for the old memory store. Mirrors the read
-                        // side's class / discriminant-enum-param / single-owning-variant
+                        // side's discriminant-enum-param / single-owning-variant
-                        // fallback chain (`AttrKind::Field` below) so a named-payload
+                        // fallback chain (`AttrKind::Field` below) — this also covers a
-                        // enum variant's own field can be mutated too, not just a class's.
+                        // record-shaped enum's own field (the `type X = ...`
+                        // replacement), whose one variant is trivially its own unique
+                        // owner of every field it declares.
-                        match ctx.classes.get(&class_name) {
+                        match ctx.enum_params.get(&class_name) {
-                            Some(fields) => {
+                            Some(params) => {
-                                let field_idx = fields
+                                let field_idx = params
                                     .iter()
                                     .position(|(n, _)| n == field_name)
-                                    .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))?;
-                                let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
+                                let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
-                                    .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
+                                    .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
                                 compileExpr(object, body, ctx, state)?;
                                 compileExpr(value, body, ctx, state)?;
-                                Instruction::StructSet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
+                                Instruction::StructSet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
+                            }
+                            None => {
+                                let (variant_name, info) = ctx.enum_variants.iter()
+                                    .find(|(_, info)| info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name))
+                                    .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+                                let field_idx = info.field_names.iter().position(|n| n == field_name)
+                                    .expect("just found by this field name");
+                                let variant_type_idx = *ctx.gc_types.variant_type_idx.get(variant_name)
+                                    .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
+                                compileExpr(object, body, ctx, state)?;
+                                Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
+                                compileExpr(value, body, ctx, state)?;
+                                Instruction::StructSet { struct_type_index: variant_type_idx, field_index: field_idx as u32 }.encode(body);
                             }
-                            None => match ctx.enum_params.get(&class_name) {
-                                Some(params) => {
-                                    let field_idx = params
-                                        .iter()
-                                        .position(|(n, _)| n == field_name)
-                                        .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-                                    let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
-                                        .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
-                                    compileExpr(object, body, ctx, state)?;
-                                    compileExpr(value, body, ctx, state)?;
-                                    Instruction::StructSet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
-                                }
-                                None => {
-                                    let (variant_name, info) = ctx.enum_variants.iter()
-                                        .find(|(_, info)| info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name))
-                                        .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-                                    let field_idx = info.field_names.iter().position(|n| n == field_name)
-                                        .expect("just found by this field name");
-                                    let variant_type_idx = *ctx.gc_types.variant_type_idx.get(variant_name)
-                                        .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
-                                    compileExpr(object, body, ctx, state)?;
-                                    Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
-                                    compileExpr(value, body, ctx, state)?;
-                                    Instruction::StructSet { struct_type_index: variant_type_idx, field_index: field_idx as u32 }.encode(body);
-                                }
-                            },
                         }
                     }
                 }
@@ -3780,11 +3771,7 @@ 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)
-            }
         }
     }
 }
@@ -3891,51 +3878,6 @@ 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
@@ -4021,8 +3963,9 @@ 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 } if ctx.enum_variants.contains_key(name) => {
+        ast::CasePattern::Class { name, fields: inner_fields } => {
-            let info = ctx.enum_variants.get(name).expect("just checked contains_key");
+            let info = ctx.enum_variants.get(name)
+                .ok_or_else(|| format!("codegen: unknown enum variant '{}'", name))?;
             if !matches!(plumTypeToValtype(field_ty), ValType::Ref(_)) {
                 return Err(format!("codegen: constructor pattern '{}' against a non-enum field", name));
             }
@@ -4059,42 +4002,6 @@ 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)
-            })
-        }
     }
 }
@@ -4307,18 +4214,22 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                 }
             } else if is_closure_call {
                 compileClosureCall(call, body, ctx, state)?;
-            } else if let Some(info) = ctx.enum_variants.get(&call.name) {
-                compileVariantConstruction(info, call, expr, body, ctx, state)?;
-            } else if ctx.classes.contains_key(&call.name) && ctx.methods.contains_key(&(call.name.clone(), "init".to_string())) {
-                // `Type(1, 2, 3)` — mirrors `plum-checker`'s own `inferExpr` handling
+            // `Type(1, 2, 3)` — mirrors `plum-checker`'s own `inferExpr` handling of
-                // of the same case: sugar for `Type.init(1, 2, 3)`, desugared to that
+            // the same case: sugar for `Type.init(1, 2, 3)`, desugared to that
-                // equivalent static method-call expression so the existing
+            // equivalent static method-call expression so the existing
-                // `AttrKind::Method` codegen (below) handles it without duplication.
+            // `AttrKind::Method` codegen (below) handles it without duplication.
+            // Checked BEFORE the ordinary positional-variant-construction case just
+            // below — see the matching comment in `plum-checker`'s `inferExpr` for
+            // why a record-shaped enum's own name needs this precedence.
+            } else if ctx.enum_variants.get(&call.name).is_some_and(|info| info.enum_name == call.name)
+                && ctx.methods.contains_key(&(call.name.clone(), "init".to_string())) {
                 let synthetic = ast::Expr::Attribute(Box::new(ast::AttributeExpr {
                     object: ast::Expr::TypeName(call.name.clone()),
                     attr: ast::AttrKind::Method(ast::FnCall { name: "init".to_string(), args: call.args.clone() }),
                 }));
                 compileExpr(&synthetic, body, ctx, state)?;
+            } else if let Some(info) = ctx.enum_variants.get(&call.name) {
+                compileVariantConstruction(info, call, expr, body, ctx, state)?;
             } else {
                 fn argExprOf(arg: &ast::Arg) -> &ast::Expr {
                     match arg {
@@ -4423,13 +4334,13 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
         // A NAMED-payload enum variant construction (`Circle(radius: 5)`, as
         // opposed to the positional/generic-payload form `Some[T]` — constructed
         // via `Expr::FnCall` instead, elsewhere) — mirrors `plum-checker`'s own
-        // `inferClassCallRaw` handling of the same call shape. Same field-pushing
+        // `inferClassCallRaw` handling of the same call shape. Against the
-        // shape as the plain-class arm just below, but against the variant's own
-        // GC struct type (`gc_types.variant_type_idx`), matched by NAME (recorded
+        // variant's own GC struct type (`gc_types.variant_type_idx`), matched by
-        // only for this named-payload form — see `EnumVariantInfo::field_names`)
+        // NAME (recorded only for this named-payload form — see
-        // instead of position.
+        // `EnumVariantInfo::field_names`) instead of position. This ALSO covers a
-        ast::Expr::ClassCall(call) if !ctx.classes.contains_key(&call.type_name)
+        // record-shaped enum's own construction (the `type X = ...` replacement,
+        // e.g. `Cat(name: "x")`) — its one variant always has named fields too.
-            && ctx.enum_variants.get(&call.type_name).is_some_and(|info| !info.field_names.is_empty()) =>
+        ast::Expr::ClassCall(call) if ctx.enum_variants.get(&call.type_name).is_some_and(|info| !info.field_names.is_empty()) =>
         {
             let info = ctx.enum_variants.get(&call.type_name).expect("just checked is_some");
             let variant_idx = *ctx.gc_types.variant_type_idx.get(&call.type_name)
@@ -4458,32 +4369,12 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
             }
             Instruction::StructNew(variant_idx).encode(body);
         }
+        // Every named-payload construction now goes through the variant-construction
+        // arm above (record-shaped or not) — reaching here means `call.type_name`
+        // is genuinely unmodeled, which the checker already permits (`inferExpr`'s
+        // "unmodeled type: allow, codegen will catch" case) — a real compile error.
         ast::Expr::ClassCall(call) => {
-            // struct.new needs every field value pushed in DECLARATION order (not
-            // `call.fields`'s written order) immediately before the single
-            // construction instruction — no intermediate scratch pointer needed at
-            // all, unlike the old bump-pointer-then-store approach.
-            let fields = ctx
-                .classes
-                .get(&call.type_name)
-                .ok_or_else(|| format!("codegen: unknown class '{}'", call.type_name))?
+            return Err(format!("codegen: unknown class or enum variant '{}'", call.type_name));
-                .clone();
-            let class_type_idx = *ctx.gc_types.class_type_idx.get(&call.type_name)
-                .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", call.type_name))?;
-            for (field_idx, (field_name, _)) in fields.iter().enumerate() {
-                match call.fields.iter().find(|fa| &fa.name == field_name) {
-                    Some(fa) => compileExpr(&fa.value, body, ctx, state)?,
-                    // See the matching comment in the variant-construction arm above.
-                    None => {
-                        let spread = call.spread.as_ref()
-                            .ok_or_else(|| format!("codegen: class '{}' missing field '{}'", call.type_name, field_name))?;
-                        compileExpr(spread, body, ctx, state)?;
-                        Instruction::StructGet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
-                    }
-                }
-            }
-            Instruction::StructNew(class_type_idx).encode(body);
         }
         ast::Expr::Attribute(attr) => {
             let obj_ty = inferLocalType(&attr.object, ctx);
@@ -4497,57 +4388,48 @@ fn compileExpr(expr: &ast::Expr, body: &mut Vec<u8>, ctx: &LocalCtx, state: &mut
                         PlumType::TStr => "Str".to_string(),
                         other => return Err(format!("codegen: cannot access field '{}' on non-class type {}", field_name, other)),
                     };
+                    // Fall back to a discriminant enum's shared params, declared
+                    // directly on the enum's SUPERTYPE (see `buildGcTypeRegistry`'s
+                    // `EnumSuper` arm) — no `ref.cast` to any particular variant
+                    // needed, since every variant has the exact same field list as
+                    // the supertype itself. This ALSO covers a record-shaped enum's
+                    // own field (the `type X = ...` replacement) via the unique-
+                    // owning-variant fallback below, since its one variant is
+                    // trivially its own unique owner of every field it declares.
-                    match ctx.classes.get(&class_name) {
+                    match ctx.enum_params.get(&class_name) {
-                        Some(fields) => {
+                        Some(params) => {
-                            let field_idx = fields
+                            let field_idx = params
                                 .iter()
                                 .position(|(n, _)| n == field_name)
-                                .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))?;
-                            let class_type_idx = *ctx.gc_types.class_type_idx.get(&class_name)
+                            let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
-                                .ok_or_else(|| format!("codegen: class '{}' missing from the GC type registry", class_name))?;
+                                .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
                             compileExpr(&attr.object, body, ctx, state)?;
-                            Instruction::StructGet { struct_type_index: class_type_idx, field_index: field_idx as u32 }.encode(body);
+                            Instruction::StructGet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
+                        }
+                        // Not a discriminant enum either: `class_name` is an
+                        // ordinary enum, and `plum-checker`'s `inferExpr` already
+                        // verified exactly ONE of its variants declares a field
+                        // with this name (ambiguity across sibling variants is a
+                        // checker error, never reaches codegen). Compile `.field`
+                        // as a checked downcast to that one variant's own
+                        // concrete struct type (same `ref.cast` idiom `match`
+                        // pattern-matching already uses, e.g. `compileCasePositions`),
+                        // then read the field off it — traps at runtime if the
+                        // value turns out to be a different variant, so no static
+                        // proof the value IS that variant is required here.
+                        None => {
+                            let (variant_name, info) = ctx.enum_variants.iter()
+                                .find(|(_, info)| info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name))
+                                .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
+                            let field_idx = info.field_names.iter().position(|n| n == field_name)
+                                .expect("just found by this field name");
+                            let variant_type_idx = *ctx.gc_types.variant_type_idx.get(variant_name)
+                                .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
+                            compileExpr(&attr.object, body, ctx, state)?;
+                            Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
+                            Instruction::StructGet { struct_type_index: variant_type_idx, field_index: field_idx as u32 }.encode(body);
                         }
-                        // Not a class: fall back to a discriminant enum's shared params,
-                        // declared directly on the enum's SUPERTYPE (see
-                        // `buildGcTypeRegistry`'s `EnumSuper` arm) — no `ref.cast` to any
-                        // particular variant needed, since every variant has the exact
-                        // same field list as the supertype itself.
-                        None => match ctx.enum_params.get(&class_name) {
-                            Some(params) => {
-                                let field_idx = params
-                                    .iter()
-                                    .position(|(n, _)| n == field_name)
-                                    .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-                                let super_type_idx = *ctx.gc_types.enum_super_type_idx.get(&class_name)
-                                    .ok_or_else(|| format!("codegen: enum '{}' missing from the GC type registry", class_name))?;
-                                compileExpr(&attr.object, body, ctx, state)?;
-                                Instruction::StructGet { struct_type_index: super_type_idx, field_index: field_idx as u32 }.encode(body);
-                            }
-                            // Not a discriminant enum either: `class_name` is an
-                            // ordinary enum, and `plum-checker`'s `inferExpr` already
-                            // verified exactly ONE of its variants declares a field
-                            // with this name (ambiguity across sibling variants is a
-                            // checker error, never reaches codegen). Compile `.field`
-                            // as a checked downcast to that one variant's own
-                            // concrete struct type (same `ref.cast` idiom `match`
-                            // pattern-matching already uses, e.g. `compileCasePositions`),
-                            // then read the field off it — traps at runtime if the
-                            // value turns out to be a different variant, so no static
-                            // proof the value IS that variant is required here.
-                            None => {
-                                let (variant_name, info) = ctx.enum_variants.iter()
-                                    .find(|(_, info)| info.enum_name == class_name && info.field_names.iter().any(|n| n == field_name))
-                                    .ok_or_else(|| format!("codegen: no field '{}' on enum '{}'", field_name, class_name))?;
-                                let field_idx = info.field_names.iter().position(|n| n == field_name)
-                                    .expect("just found by this field name");
-                                let variant_type_idx = *ctx.gc_types.variant_type_idx.get(variant_name)
-                                    .ok_or_else(|| format!("codegen: variant '{}' missing from the GC type registry", variant_name))?;
-                                compileExpr(&attr.object, body, ctx, state)?;
-                                Instruction::RefCastNonNull(HeapType::Concrete(variant_type_idx)).encode(body);
-                                Instruction::StructGet { struct_type_index: variant_type_idx, field_index: field_idx as u32 }.encode(body);
-                            }
-                        },
                     }
                 }
                 ast::AttrKind::Method(call) => {
@@ -4972,7 +4854,7 @@ fn compileClosureBody(
     let mut collector = Collector {
         env: base_env.clone(),
-        cctx: checkCtxOf(&ctx.classes, &ctx.methods, &ctx.enum_variants, &ctx.enum_params, &ctx.min_required),
+        cctx: checkCtxOf(&ctx.methods, &ctx.enum_variants, &ctx.enum_params, &ctx.min_required),
         named: Vec::new(),
         named_set: Default::default(),
         match_scratch: HashMap::new(),
@@ -5074,7 +4956,6 @@ fn compileClosureBody(
         string_concat_func: ctx.string_concat_func,
         string_eq_func: ctx.string_eq_func,
         int_to_string_func: ctx.int_to_string_func,
-        classes: &ctx.classes,
         methods: &ctx.methods,
         enum_variants: &ctx.enum_variants,
         enum_params: &ctx.enum_params,

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

@@ -208,9 +208,8 @@ fn floatArithmeticAndNegationCompile() {
 #[test]
 fn classFieldAndMethodCompile() {
     let src = "\
-type Cat =
+enum Cat =
-  name: Str
+  | Cat(name: Str, age: Int)
-  age: Int
   fun getAge() -> Int =
     self.age
@@ -225,13 +224,11 @@ fun makeCat() -> Int =
 #[test]
 fn nestedClassCallCompiles() {
     let src = "\
-type Pair =
+enum Pair =
-  a: Int
+  | Pair(a: Int, b: Int)
-  b: Int
-type Wrapper =
+enum Wrapper =
-  inner: Pair
+  | Wrapper(inner: Pair, tag: Int)
-  tag: Int
 fun make() -> Int =
   w = Wrapper(inner: Pair(a: 1, b: 2), tag: 9)