perry-hir: class expressions hoisted to a single shared class — no per-evaluation identity or static-field state (blocks effect Schema #1758)

[proggeramlug]

Summary

Perry hoists a class expression to a single shared class, so every evaluation of the same class { ... } expression returns the same class object. This breaks the "factory function returns a class" pattern — most importantly each returned class cannot have its own static field state. This is the root blocker behind effect's Schema.ts failing to initialize (#1758): effect's make(ast) returns class SchemaClass { static ast = ast }, so every schema ends up sharing one class with an undefined (or last-write-wins) .ast.

Minimal repros

(1) Class identity — a class expression evaluated twice should yield distinct classes:

function make(ast: any) { return class C { static ast = ast }; }
const A = make("AAA");
const B = make("BBB");
console.log(A === B);      // node: false   perry: true
console.log((A as any).ast, (B as any).ast);  // node: AAA BBB   perry: undefined undefined

(2) Static field initializers are dropped for class expressions (any context):

const T = class { static x = 77 };
console.log((T as any).x); // node: 77   perry: undefined

(A top-level class declaration class T { static x = 77 } works; only class expressions — and class declarations nested inside a function — lose their static field initializers.)

Root cause

crates/perry-hir/src/lower/lower_expr.rs (the ast::Expr::Class arm, ~line 1280) lowers a class expression by pushing one class into ctx.pending_classes under a single synthetic name and returning a ClassRef to it. Static fields are initialized once via the module's init_static_fields_late phase, against the shared class — at which point any initializer that references the factory's parameters/locals reads undefined (the factory hasn't run; and there is only one class instance to hold the value). #894 added an eager RegisterClassStaticSymbol for computed/Symbol-key static fields (e.g. static [TypeId] = variance) sequenced in front of the ClassRef, but regular-named static fields (static ast = ast) are not handled, and even the symbol path writes to the one shared class.

Properly supporting this needs per-evaluation class identity: each time a class expression evaluates, produce a distinct runtime class object carrying its own static fields (initialized from the enclosing scope at that moment). That's a codegen + runtime change (class objects as first-class per-evaluation values rather than a single hoisted definition).

Impact

Blocks #1758 / Effect Schema end-to-end (#321): import { Effect } from "effect" and import * as S from "effect/Schema" throw TypeError: Cannot read properties of undefined (reading '_tag') during Schema.ts init, because Struct(...) calls AST.typeAST(field.ast) where field.ast is undefined.

Refs #1758, #321.

[proggeramlug]

Implementation in progress (branch fix-1772-class-expr-identity, commit 78f4e36d — NOT merged, has a known regression)

Approach (validated as the right shape): mint a fresh synthetic class_id per class-expression evaluation, parented to the compile-time "template" class, so methods/new/prototype/instanceof resolve through the template via the existing parent-chain walk while the fresh id carries its own per-evaluation static state.

• New Expr::ClassExprFresh { template, named_statics, symbol_statics } (lowered from the ast::Expr::Class arm when the class expression has static fields and no mixin extends).
• Runtime js_class_clone_for_expr(template_id) -> u32: NEXT_SYNTHETIC_CLASS_ID + register_class(fresh, template) + js_register_class_id(fresh).
• Codegen writes per-evaluation statics onto the fresh id (js_class_register_static_field / js_class_register_static_symbol) and yields INT32(fresh).
• Parent-walk added to static-field lookup (class_dynamic_prop_with_parents) and static-Symbol lookup (class_static_symbol_lookup) so subclasses inherit per-evaluation statics.

Works (verified):

• make(a) !== make(b) (distinct identity); make(a).ast !== make(b).ast (distinct per-evaluation statics).
• Static-field init on any class expression; inheritance through class X extends make(a) {} (1- and 2-level); static-Symbol inheritance (isSchema).
• cargo test (runtime/hir/codegen/transform) green; class smoke + 5 class parity tests green; effect/Effect deep import still 42 (no regression).
• import * as S from "effect/Schema" advances well past this issue's _tag-of-undefined (through the DurationValue schemas into TupleTypeClass.annotations).

Known regression — blocks merge: inherited static methods through the fresh-id hop mis-dispatch. class Sub extends make(); Sub.greet() returns a wrong value (1) post-change vs hi pre-change. The directly-named-class StaticMethodCall runtime fallback (and likely the value-read / new paths) don't transparently walk through the vtable-less fresh id. This is also the next effect/Schema blocker (TypeError: value is not a function in SchemaAST reached via TupleTypeClass.annotations).

Remaining work: make the fresh id transparent across the remaining class-dispatch paths (static-method-call runtime fallback, method value-read, new, instanceof) — either by routing them through the parent-walking lookup_class_method_in_chain, or by having js_class_clone_for_expr share the template's vtable/symbol registrations by reference. Then re-validate the full effect/Schema init.

Refs #1758, #321.

[proggeramlug]

Architecturally-correct design: class expressions evaluate to GC-traced "class objects" (supersedes the integer-hack WIP)

Motivated by the #1090 GC overhaul: #1095 (copying nursery — objects move) and #1096 (layout descriptors + precise pointer-mask scanning). The integer-hack WIP (fresh class_id per eval + global side-table walks) would leak (per-eval entries in process-global class tables are never collected) and is a rooting hazard under a moving GC (static-field pointers live in non-root side tables). Both vanish if the class is a real heap object.

What a class is today

• definition = compile-time class_id + global side tables (CLASS_VTABLE_REGISTRY, CLASS_REGISTRY, CLASS_STATIC_SYMBOLS, CLASS_DYNAMIC_PROPS)
• value = INT32(class_id) (a NaN-boxed integer — no heap object)
• instance = heap ObjectHeader { object_type, class_id, parent_class_id, field_count, keys_array } + field slots

Target: class EXPRESSIONS yield a heap "class object"

A class expression evaluates to a heap ObjectHeader with:

• object_type = OBJECT_TYPE_CLASS (new) — marks the value as a class
• class_id = the compile-time template id (instance-side behavior: new, instance methods, instanceof stay on the fast existing path)
• own fields = the per-evaluation static fields (named) — ordinary object properties; static symbols via the existing per-object symbol slot
• prototype = the superclass's class object (static inheritance), reusing the perry-runtime: Effect framework throws TypeError: pipe is not a function during Schema.ts module init (Effect end-to-end blocker, post-#685) #711/perry-codegen: object literal with computed-key props + computed-key methods + cross-module spread drops keys & mis-resolves methods — Effect HashRing.ts blocker (post-#740) #809 CLASS_PROTOTYPE_OBJECTS prototype-chain resolution

Shared static methods (pipe, annotations, …) + constant symbol statics live on a per-template static-base object created once; every fresh class object's prototype reaches it. So:

• make(a) → fresh class object C: proto = static_base(template), own ast = a, class_id = template
• class Sub extends make(a) {} → Sub's class object proto = C

One uniform mechanism for the static side (the whole point)

op	becomes
make(a) !== make(b)	distinct heap allocations → distinct pointers
C.ast, C.pipe, C[TypeId], and inherited Sub.ast/Sub.pipe	ordinary property get walking the prototype chain (#711/#809) — same path for fields, methods, symbols
class Sub extends C {}	set Sub's class object prototype = C
new C() / x instanceof C	read class_id from the class object → existing class_id machinery
C === D	pointer compare

No per-lookup parent-walks; the integer-hack's whack-a-mole disappears.

Value representation

Class expressions produce a POINTER (NaN-boxed) class object instead of INT32(class_id). Top-level class declarations keep INT32(class_id) (no per-eval identity needed). Consumers must accept both forms — much of the codebase already does (js_register_class_parent_dynamic already reads class_id from a POINTER's ObjectHeader).

GC integration

The class object is a normal traced heap object. Register a #1096 layout descriptor: pointer-bearing slots = static-field slots + the prototype slot; scalar = class_id. It then moves correctly under evacuation/the #1095 copying nursery and is collected when unreachable → no leak, no rooting hazard.

Reuse from the WIP branch

Keep: Expr::ClassExprFresh + walker plumbing + the lowering that collects named/symbol statics. Replace: runtime js_class_clone_for_expr → js_class_object_new(template_id) (allocate object + link static-base); global-table parent-walks → prototype-chain walks; codegen yields a POINTER.

Milestones (stageable PRs)

1. Class object alloc + per-template static-base + static field/method/symbol resolution via prototype chain (static side). Validate: make(a)!==make(b), .ast, .pipe, [TypeId].
2. extends <class object> (set prototype). Validate: class Sub extends make() static inheritance.
3. new / instanceof / typeof on a class-object value.
4. GC scanning: add layout descriptors and pointer masks #1096 layout descriptor + GC stress / leak verification.
5. Full effect/Schema + effect/Effect + class-suite regression.

Refs #1090, #1095, #1096, #1758, #321.

[proggeramlug]

Object-model foundation landed (WIP branch) + next layer pinned

Implemented the object model's foundation (commit on fix-1772-class-expr-identity): a class expression allocates a real heap class object (regular object + class_id = template + per-evaluation static fields as own properties; value = the object POINTER).

Verified working: make(a) !== make(b) (distinct heap identities) and make(a).ast / make(b).ast are distinct own fields — the core #1772 property. Static-method dispatch works (a no-this static method returns correctly). GC-traced + collectible (no leak). No method regression.

Next layer (pinned): static-method this-binding. A.konst() on a class-object value resolves statically to the template at compile time, and the class_id vtable dispatch path passes this = undefined (static methods have a different this convention than instance methods). So typeof this is undefined inside the static method, and this.ast (effect's annotations/pipe read this) throws. Fix needed: a method call whose receiver is a class-object value must dispatch dynamically and bind this to that value.

Remaining layers, in order:

1. Static-method this-binding (above) — method calls on a class-object value pass the value as this; this.field inside resolves dynamically on the receiver.
2. extends-inheritance of own static fields (class Sub extends make(a); Sub.ast).
3. new / instanceof on a class-object value.
4. GC scanning: add layout descriptors and pointer masks #1096 layout descriptor for the class object + GC stress/leak verification.
5. Full effect/Schema + effect/Effect + class-suite regression.

Each is well-scoped but real codegen/lowering work; layers 3–4 touch the GC subsystem (#1090) and are worth coordinating with @andrewtdiz. The architecture is settled and the foundation is correct; this is a staged multi-PR effort from here.

[proggeramlug]

Implementation is now tracked as an epic with sequenced, self-contained subtickets so it can land across sessions: #1785 (→ #1786 foundation, #1787 this-binding, #1788 extends-inheritance, #1789 new/instanceof, #1790 GC layout, #1791 integration which closes this). The verified foundation lives on branch fix-1772-class-expr-identity.