@scriptc/compiler 0.4.2 → 0.4.3

package/dist/frontend/lowering/lower-classes.d.ts

@@ -13,6 +13,7 @@ export declare function returnsOnlyThis(member: ts.MethodDeclaration): boolean;
  * claim setters). Used only to narrow a call's result back to the
  * receiver's class. */
 export declare function returnsOnlyThisValue(member: ts.MethodDeclaration): boolean;
+export declare function functionLocalClass(decl: ts.ClassLikeDeclaration): boolean;
 export declare function storedClassValueType(lowerer: Lowerer, expression: ts.Expression, visiting?: Set<import("../ts7/ast-node.js").AstNode>): IrType | null;
 export interface ClassMethodSignature {
     params: ParamShape[];
@@ -33,6 +34,10 @@ export interface ClassInfo {
     prototypeMethodValues?: Map<string, IrExpr>;
     prototypeReflectionReady?: true;
     prototypeObservedMethodsReady?: true;
+    /** The globals holding each observed method's original prototype value
+     * (set when the prototype data is built), by method name. A typed call
+     * whose slot still holds that value calls the method natively. */
+    prototypeOriginals?: Map<string, string>;
     prototypeReflectionRefusal?: string;
     localClass?: {
         context: FnCtx | null;
@@ -582,8 +587,12 @@ export declare function lowerClassExpressionInfo(lowerer: Lowerer, expr: ts.Clas
  * mints a class at all: evaluating the expression IS the
  * ReferenceError, so it lowers to exactly that read — every evaluation
  * throws identically, which is why the once-evaluated restriction and
- * the member fences don't apply. */
-export declare function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassLikeDeclaration): IrExpr;
+ * the member fences don't apply.
+ *
+ * `binding` is the local of a function-local class declaration's name,
+ * declared without a value; the class value assigns it before the class's
+ * static members are defined (see initializeRuntimeStatics). */
+export declare function lowerClassExpression(lowerer: Lowerer, expr: ts.ClassLikeDeclaration, binding?: IrLocal): IrExpr;
 /** The EXACT class a receiver expression is statically known to BE (not
  * merely be typed by): the class name itself, or a `const` binding
  * whose initializer is a class expression / class name. Such receivers

package/dist/frontend/lowering/lower-classes.js

@@ -1,4 +1,5 @@
 import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
+import { predeclareForwardClass } from "./lower-stmts.js";
 import { lowerDateStaticCall } from "./builtins/dates.js";
 import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
@@ -46,7 +47,7 @@ import { lowerSearchParamsNew } from "./builtins/url.js";
 import { lowerTextCodecNew } from "./builtins/text-codecs.js";
 import { lowerBroadcastChannelNew, lowerMessageChannelNew, lowerWorkerNew, } from "./builtins/workers.js";
 import { unsupportedPackageValueDiag, unsupportedDiag, } from "../../diagnostics/diagnostic.js";
-import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_INDEX, UNDERSCORE_METHODS, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
+import { STREAM_API_MEMBERS, STREAM_PROP_MEMBERS, STREAM_COMPLETION_CALLBACK_INDEX, UNDERSCORE_METHODS, streamExtraCallbacks, lowerStreamNew, lowerStreamSuperCall, streamCtorShape, } from "./lower-stream.js";
 import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod, eventTargetRootOf, eventTargetSuperCall, lowerEventTargetMethodCall, } from "./lower-event-target.js";
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall, } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
@@ -58,7 +59,7 @@ import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./s
 import { lowerUrlNew } from "./lower-url.js";
 import { isNativeProxyInitializer, lowerNativeProxy } from "./expressions/native-proxy.js";
 import { classStaticDataFor } from "./class-static-data.js";
-import { construction, constructionPrefix } from "./js-class-fields.js";
+import { accessorInterceptsBase, accessorNames, construction, constructionPrefix, } from "./js-class-fields.js";
 import { lowerObjectFactoryNew } from "./object-factory-new.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
@@ -67,6 +68,7 @@ import { constructionEscape } from "./construction-escapes.js";
 import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js";
 import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
 import { reflectedClassStaticMethodValue } from "./class-method-values.js";
+import { identifierReadSymbol } from "./surfaces.js";
 export function returnsOnlyThis(member) {
     const body = member.body;
     const last = body?.statements?.nodes.at(-1);
@@ -122,7 +124,7 @@ export function returnsOnlyThisValue(member) {
     ts.forEachChild(body, visit);
     return valid;
 }
-function functionLocalClass(decl) {
+export function functionLocalClass(decl) {
     for (let parent = decl.parent; parent && !ts.isSourceFile(parent); parent = parent.parent) {
         if (ts.isFunctionLike(parent))
             return true;
@@ -1693,6 +1695,7 @@ mixin) {
         // receiver-sensitive getters and setters inherited by subclasses.
         const checkedStatics = isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
             ((base && hasRuntimeStatics(base)) ||
+                definedThroughReflection(lowerer, decl) ||
                 decl.members.nodes.some((member) => ts.isAccessor(member) &&
                     !ts.isPrivateIdentifier(member.name) &&
                     member.modifiers?.nodes.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) &&
@@ -2007,8 +2010,8 @@ mixin) {
             // state, so an override or shadowing field would split-brain.
             // Underscore methods are the SUPPORTED override form — but only
             // the ones the class's own base consumes (a `_read` on a
-            // Transform, or `_writev`/`_construct` anywhere, would be consumed
-            // by Node machinery that has no lowering here).
+            // Transform, or `_writev` on a Readable, would be consumed by Node
+            // machinery that has no lowering here).
             if (memberName && ts.isIdentifier(memberName)) {
                 const streamBase = (() => {
                     for (let c = base; c; c = c.base)
@@ -2021,8 +2024,8 @@ mixin) {
                     if (STREAM_API_MEMBERS.has(name) || STREAM_PROP_MEMBERS.has(name)) {
                         lowerer.unsupported("SC1090", memberName, `overriding the stream member '${name}' (the runtime owns the stream surface)`);
                     }
-                    if (name === "_writev" || name === "_construct") {
-                        lowerer.unsupported("SC1090", memberName, `declaring '${name}' on a stream subclass (${name === "_writev" ? "batched writes are" : "deferred construction is"} not lowered — writes deliver one chunk at a time)`);
+                    if (name === "_writev" && !streamExtraCallbacks(streamBase.def.name).includes("writev")) {
+                        lowerer.unsupported("SC1090", memberName, `declaring '_writev' on a ${streamBase.def.name.slice(1)} subclass (a Readable has no writable side)`);
                     }
                     const accepted = streamCtorShape(streamBase.def.name).accepted;
                     for (const [option, methodName] of UNDERSCORE_METHODS) {
@@ -3167,7 +3170,7 @@ mixin) {
             }
             // A subclass field created before anything can observe the instance
             // keeps its type: super() cannot run code that reads it earlier.
-            const baseConstruction = base && ![...methods.keys()].some((m) => m.startsWith("get:") || m.startsWith("set:"))
+            const baseConstruction = base && !accessorInterceptsBase(accessorNames(methods.keys()), base)
                 ? construction(base)
                 : null;
             const sealedPrefix = baseConstruction
@@ -3195,7 +3198,7 @@ mixin) {
                             // An own JS callable shadows its prototype declaration.
                             // Keep the method in the prototype and store the assigned
                             // value in the instance property bag.
-                            lowerer.prototypeMethodAccesses.set(name, assign);
+                            lowerer.noteMethodAccess(name, assign);
                             continue;
                         }
                         const sym = lowerer.checker.getSymbolAtLocation(assign);
@@ -3272,7 +3275,7 @@ mixin) {
                         if (!key && (fields.has(fieldName) || hasAccessor(fieldName)))
                             continue;
                         if (!key && (methods.has(fieldName) || lowerer.findMethodOn(base, fieldName))) {
-                            lowerer.prototypeMethodAccesses.set(fieldName, lhs);
+                            lowerer.noteMethodAccess(fieldName, lhs);
                             continue;
                         }
                         // A key already declared (own or inherited) makes later
@@ -4429,7 +4432,13 @@ export function classValueRef(lowerer, info, blame) {
     const display = info.def.name.replace(/^%|^%m\d+\./, "");
     fenceDecorationThrows(lowerer, info, blame);
     if (info.localClass && ts.isIdentifier(blame)) {
-        const stored = lowerer.resolveLocal(blame);
+        let stored = lowerer.resolveLocal(blame);
+        // A reference from a function hoisted above the class statement.
+        if (!stored) {
+            const symbol = lowerer.resolveValueSymbol(blame);
+            if (symbol && predeclareForwardClass(lowerer, symbol))
+                stored = lowerer.resolveLocal(blame);
+        }
         if (stored)
             return lowerer.coerceToExpected({ kind: "varRef", localId: stored.id, type: stored.type, loc: locOf(blame) }, { kind: "classval", className: info.def.name });
     }
@@ -4917,6 +4926,31 @@ export function lowerClassExpressionInfo(lowerer, expr) {
     }
     return info;
 }
+/** True when a named class expression's body refers to the class value by
+ * its own name (`class Box { static of() { return new Box(); } }`, a
+ * shorthand property `{ Box }` included); type annotations naming it
+ * (`again(): Box`) do not count. */
+function classExpressionNamesItself(lowerer, expr) {
+    const name = expr.name;
+    if (!name)
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(name);
+    if (!symbol)
+        return false;
+    let found = false;
+    for (const member of expr.members.nodes) {
+        ts.walkPreorder(member, (n) => {
+            if (found || ts.isTypeNode(n))
+                return "skip";
+            if (ts.isIdentifier(n) && n.text === name.text && identifierReadSymbol(lowerer, n) === symbol)
+                found = true;
+            return undefined;
+        });
+        if (found)
+            return true;
+    }
+    return false;
+}
 /** `class {…}` in expression position: a class definition bound to no
  * statement — once the static side is a value, the expression IS the
  * definition plus a classRef over it. A DECORATED class expression
@@ -4924,8 +4958,12 @@ export function lowerClassExpressionInfo(lowerer, expr) {
  * mints a class at all: evaluating the expression IS the
  * ReferenceError, so it lowers to exactly that read — every evaluation
  * throws identically, which is why the once-evaluated restriction and
- * the member fences don't apply. */
-export function lowerClassExpression(lowerer, expr) {
+ * the member fences don't apply.
+ *
+ * `binding` is the local of a function-local class declaration's name,
+ * declared without a value; the class value assigns it before the class's
+ * static members are defined (see initializeRuntimeStatics). */
+export function lowerClassExpression(lowerer, expr, binding) {
     if (decoratorNodesOf(expr).length > 0 ||
         expr.members.nodes.some((m) => decoratorNodesOf(m).length > 0)) {
         if (!isJsSourceFile(ts.getSourceFileOfNode(expr)) && expr.typeParameters === undefined) {
@@ -4939,6 +4977,28 @@ export function lowerClassExpression(lowerer, expr) {
         }
     }
     const info = lowerClassExpressionInfo(lowerer, expr);
+    // A function-local class expression's own name is a binding of its body:
+    // declared before the members lower, so their references to the name
+    // resolve to it. The class value captures it before it is assigned, as
+    // it captures a class declaration's binding.
+    if (!binding &&
+        info.localClass &&
+        ts.isClassExpression(expr) &&
+        expr.name &&
+        classExpressionNamesItself(lowerer, expr)) {
+        const own = lowerer.declareLocal(expr.name, expr.name.text, { kind: "classval", className: info.def.name }, true);
+        const value = lowerClassValue(lowerer, expr, info, own);
+        return {
+            kind: "seqExpr",
+            stmts: [{ kind: "varDecl", localId: own.id, init: null, loc: value.loc }],
+            result: value,
+            type: value.type,
+            loc: value.loc,
+        };
+    }
+    return lowerClassValue(lowerer, expr, info, binding);
+}
+function lowerClassValue(lowerer, expr, info, binding) {
     if (!info.localClass &&
         !info.expressionInitializationEmitted &&
         (info.callableBase ||
@@ -4985,7 +5045,7 @@ export function lowerClassExpression(lowerer, expr) {
         const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
         const boxed = { kind: "dynFrom", value: clsRef, type: DYN, loc };
         info.localPrototypeData = true;
-        return initializeRuntimeStatics(lowerer, info, {
+        const built = {
             kind: "seqExpr",
             stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
@@ -5018,7 +5078,8 @@ export function lowerClassExpression(lowerer, expr) {
             result: clsRef,
             type: value.type,
             loc,
-        });
+        };
+        return initializeRuntimeStatics(lowerer, info, built, binding);
     }
     if (info.localClass?.baseExpression && info.base && value.kind === "classRef") {
         const loc = locOf(expr);
@@ -5033,7 +5094,7 @@ export function lowerClassExpression(lowerer, expr) {
         const clsRef = { kind: "varRef", localId: clsLocal.id, type: value.type, loc };
         const basePrototype = classPrototypeData(lowerer, info.base, loc, baseRef);
         info.localPrototypeData = true;
-        return initializeRuntimeStatics(lowerer, info, {
+        const built = {
             kind: "seqExpr",
             stmts: [
                 { kind: "varDecl", localId: baseLocal.id, init: base, loc },
@@ -5072,11 +5133,12 @@ export function lowerClassExpression(lowerer, expr) {
             result: clsRef,
             type: value.type,
             loc,
-        });
+        };
+        return initializeRuntimeStatics(lowerer, info, built, binding);
     }
     if (!info.localClass)
         return value;
-    const classValue = initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value);
+    const classValue = initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value, binding);
     // The base resolves statically here, but Node still evaluates the
     // heritage expression each time the class definition runs, first.
     const heritage = heritageWithEffects(expr);
@@ -5418,7 +5480,7 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         // through-a-VALUE shadowing fence as plain statics.
         const gfound = findGenericStaticOn(lowerer, info, access.name.text);
         if (!gfound)
-            return null;
+            return classConstructorCall(lowerer, call, access, info);
         if (throughValue && staticShadowBelow(info, access.name.text)) {
             lowerer.unsupported("SC1090", call, `calling the static member '${access.name.text}' through a class value (a subclass of '${info.def.name.replace(/^%|^%m\d+\./, "")}' redeclares it, so the runtime class decides which declaration answers)`);
         }
@@ -5487,6 +5549,74 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
     const args = lowerer.completeArgs(call.arguments.nodes, found.method.params, loc, call);
     return { kind: "call", callee: fnName, args, type: found.method.ret, loc };
 }
+/** `C.call(thisArg, ...)` / `C.apply(thisArg, args)` on a program class that
+ * declares no such static: Function.prototype.call/apply invoke the class
+ * constructor without `new`, which throws Node's TypeError "Class
+ * constructor C cannot be invoked without 'new'" after the arguments are
+ * evaluated (and, for apply, after the argument list is read). The boxed
+ * class value's call path throws exactly that. Neither expando statics nor
+ * writes through untyped values can give a class an own `call` or `apply`.
+ * A receiver that may hold a subclass at run time (a class value, `this` in
+ * a static method) needs every subclass to lack such a static too. The
+ * receiver must be one the caller does not evaluate again (a name, `this`,
+ * or a namespace member). Null otherwise. */
+function classConstructorCall(lowerer, call, access, info) {
+    const name = access.name.text;
+    const receiver = access.expression;
+    if ((name !== "call" && name !== "apply") ||
+        !info.decl ||
+        info.def.runtime ||
+        info.builtinError ||
+        info.builtinEmitter ||
+        info.builtinStream ||
+        info.builtinEventTarget ||
+        info.runtimeStatics?.length ||
+        declaresStaticAbove(info, name) ||
+        (exactClassOfReceiver(lowerer, receiver) !== info &&
+            info.subclasses.some((subclass) => declaresStaticBelow(subclass, name))) ||
+        call.arguments.nodes.some(ts.isSpreadElement) ||
+        !(ts.isIdentifier(receiver) ||
+            receiver.kind === ts.SyntaxKind.ThisKeyword ||
+            (ts.isPropertyAccessExpression(receiver) && nsMemberIdentOf(lowerer, receiver) !== null)))
+        return null;
+    return {
+        kind: "dynInvoke",
+        recv: lowerer.lowerExprExpecting(receiver, DYN),
+        method: name,
+        calleeName: ts.getTextOfNode(access),
+        args: call.arguments.nodes.map((argument) => lowerer.lowerExprExpecting(argument, DYN)),
+        type: DYN,
+        loc: locOf(call),
+    };
+}
+/** Whether `info`'s declaration has a static member that may be named `name`
+ * (a method, field or accessor of that name, or a computed name), or `info`
+ * has no declaration to tell. */
+function declaresStatic(info, name) {
+    if (!info.decl)
+        return true;
+    return info.decl.members.nodes.some((member) => member.name !== undefined &&
+        ts.canHaveModifiers(member) &&
+        ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ===
+            true &&
+        (ts.isComputedPropertyName(member.name) ||
+            ((ts.isIdentifier(member.name) || ts.isStringLiteral(member.name)) &&
+                member.name.text === name)));
+}
+/** declaresStatic over `info` and its bases, which it inherits statics from. */
+function declaresStaticAbove(info, name) {
+    for (let c = info; c; c = c.base)
+        if (declaresStatic(c, name))
+            return true;
+    return false;
+}
+/** declaresStatic over `info` and its subclasses, or runtime statics, which a
+ * function-local JavaScript class defines at run time. */
+function declaresStaticBelow(info, name) {
+    return (declaresStatic(info, name) ||
+        !!info.runtimeStatics?.length ||
+        info.subclasses.some((subclass) => declaresStaticBelow(subclass, name)));
+}
 /** `C.m(...)` where `m` is a static method that a function-local
  * JavaScript class defines at runtime (a factory's `class extends base`),
  * inherited by `C` through its statically known base chain. When the body
@@ -5874,11 +6004,94 @@ export function inHierarchy(lowerer, info) {
  * dynamically. Abstract re-declarations don't count (they carry no
  * implementation; the concrete ones below them do, via the recursion). */
 export function overrideBelow(lowerer, info, name) {
+    if (info.decl !== null && localOverrideBelow(lowerer, info.decl, name))
+        return true;
     return info.subclasses.some((s) => {
         const m = s.methods.get(name);
         return (m !== undefined && m.abstract !== true) || lowerer.overrideBelow(s, name);
     });
 }
+/** The class node an `extends` clause names: a class declaration, or the
+ * class expression a variable is initialized with. */
+function extendedClassNode(lowerer, decl) {
+    const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
+    if (!heritage || !ts.isIdentifier(heritage))
+        return null;
+    let symbol = lowerer.checker.getSymbolAtLocation(heritage);
+    if (symbol && symbol.flags & ts.SymbolFlags.Alias)
+        symbol = lowerer.checker.getAliasedSymbol(symbol);
+    const target = symbol?.valueDeclaration;
+    if (!target)
+        return null;
+    if (ts.isClassDeclaration(target) || ts.isClassExpression(target))
+        return target;
+    if (ts.isVariableDeclaration(target) && target.initializer) {
+        let init = target.initializer;
+        while (ts.isParenthesizedExpression(init))
+            init = init.expression;
+        if (ts.isClassExpression(init))
+            return init;
+    }
+    return null;
+}
+/** The function-local classes that extend the class node `base`. Function
+ * bodies lower on demand, after code that may already call methods of a
+ * class their local classes extend, so such a subclass is not yet in its
+ * base's `subclasses` when those calls lower. */
+function localSubclassesOf(lowerer, base) {
+    let index = lowerer.localSubclassIndex;
+    if (index === null) {
+        index = new Map();
+        const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
+        for (const sf of files) {
+            if (!sf.text.includes("extends"))
+                continue;
+            ts.walkPreorder(sf, (node) => {
+                if ((ts.isClassDeclaration(node) || ts.isClassExpression(node)) &&
+                    node.heritageClauses !== undefined &&
+                    functionLocalClass(node)) {
+                    const extended = extendedClassNode(lowerer, node);
+                    if (extended) {
+                        const list = index.get(extended);
+                        if (list)
+                            list.push(node);
+                        else
+                            index.set(extended, [node]);
+                    }
+                }
+                return undefined;
+            });
+        }
+        lowerer.localSubclassIndex = index;
+    }
+    return index.get(base) ?? [];
+}
+/** True when a function-local class below the class node `base` declares
+ * a concrete instance method or accessor `name` (accessors are keyed
+ * `get:x` and `set:x`). A call on `base`'s class then dispatches on the
+ * receiver; devirtualization turns it back into a direct call when no such
+ * override is reachable. */
+function localOverrideBelow(lowerer, base, name, visited) {
+    const subclasses = localSubclassesOf(lowerer, base);
+    if (subclasses.length === 0)
+        return false;
+    visited ??= new Set();
+    if (visited.has(base))
+        return false;
+    visited.add(base);
+    const accessor = name.startsWith("get:") ? "get" : name.startsWith("set:") ? "set" : null;
+    const member = accessor ? name.slice(4) : name;
+    return subclasses.some((sub) => sub.members.nodes.some((m) => (accessor === null
+        ? ts.isMethodDeclaration(m)
+        : accessor === "get"
+            ? ts.isGetAccessorDeclaration(m)
+            : ts.isSetAccessorDeclaration(m)) &&
+        m.body !== undefined &&
+        m.name !== undefined &&
+        (ts.isIdentifier(m.name) || ts.isStringLiteral(m.name)) &&
+        m.name.text === member &&
+        !ts.getModifiers(m)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)) || localOverrideBelow(lowerer, sub, name, visited));
+}
 /** The nearest GENERIC-method declaration of `name` at/above `info` —
  * findMethodOn's twin over the genericMethods tables. */
 export function findGenericMethodOn(lowerer, info, name) {
@@ -7571,8 +7784,10 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         // The SYNTHESIZED constructor of a ctor-less stream subclass:
         // super() with default options (underscore methods still bind; a
         // construction passing options requires a declared constructor —
-        // lowerNew fences that). Zero options ⇒ exactly one init stmt.
-        return lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor)[0];
+        // lowerNew fences that). Zero options ⇒ the init stmt, then the
+        // class's _writev/_construct follow-ups.
+        const stmts = lowerStreamSuperCall(lowerer, info, base, [], thisLocal, loc, info.decl ?? info.ctor);
+        return stmts.length === 1 ? stmts[0] : { kind: "block", body: stmts, loc };
     }
     lowerer.noteSuperConstructorEdge(`%${base.def.name}.constructor`);
     const call = {
@@ -8810,6 +9025,40 @@ export function lowerNew(lowerer, expr) {
                 loc,
             };
         }
+        // A FinalizationRegistry construction: register and unregister keep
+        // their bookkeeping, and the cleanup callback never runs, which
+        // ECMAScript allows (scr_finalization_registry_new).
+        if (symbol !== null &&
+            ts.symbolName(symbol) === "FinalizationRegistry" &&
+            lowerer.isStdlibSymbol(symbol)) {
+            const args = expr.arguments?.nodes ?? [];
+            if (args.some(ts.isSpreadElement)) {
+                lowerer.unsupported("SC1090", expr, "FinalizationRegistry construction with spread arguments");
+            }
+            const cleanup = args[0] ? lowerer.lowerExprExpecting(args[0], DYN) : dynUndefinedExpr(loc);
+            const surplus = args.slice(1).map((arg) => lowerer.lowerExpr(arg));
+            const created = {
+                kind: "libCall",
+                fn: "finalizationRegistry.new",
+                args: [cleanup],
+                type: DYN,
+                loc,
+            };
+            if (surplus.length === 0)
+                return created;
+            // Surplus arguments evaluate after the cleanup argument and are ignored.
+            const local = lowerer.declareHiddenLocal("%finalizationCleanup", DYN);
+            return {
+                kind: "seqExpr",
+                stmts: [
+                    { kind: "varDecl", localId: local.id, init: cleanup, loc },
+                    ...surplus.map((value) => ({ kind: "exprStmt", expr: value, loc })),
+                ],
+                result: { ...created, args: [varRef(local.id, DYN, loc)] },
+                type: DYN,
+                loc,
+            };
+        }
         // `new Set<T>()`: construct + bulk add from supported values,
         // including live collection cursors. Duplicates collapse in insertion order.
         if (ts.isIdentifier(identifier) && lowerer.isStdlibGlobal(identifier, "Set")) {
@@ -8990,7 +9239,6 @@ export function lowerNew(lowerer, expr) {
                 Number: "boxed wrapper objects have no lowering — use the number primitive",
                 Boolean: "boxed wrapper objects have no lowering — use the boolean primitive",
                 WeakRef: "deref()-after-collect exposes GC timing — genuinely dynamic; hold a strong reference instead",
-                FinalizationRegistry: "finalization callbacks expose GC timing — genuinely dynamic; release resources explicitly instead",
                 SharedArrayBuffer: "no shared-memory threads exist in a compiled program — Uint8Array is the byte storage",
                 ArrayBuffer: "native ArrayBuffer construction supports fixed-length storage; resizable buffers remain unsupported",
                 Proxy: "native Proxy construction requires checked-native plain targets and handlers",
@@ -9279,4 +9527,36 @@ function genericFieldFnNodeOf(member) {
     }
     return null;
 }
+/** Whether a JavaScript class's own binding is the target of
+ * `Object.defineProperty`/`defineProperties` in its file
+ * (`Object.defineProperty(Definition, "name", { value })`): its constructor
+ * then needs a live own-property table. */
+function definedThroughReflection(lowerer, decl) {
+    const name = decl.name;
+    const sf = ts.getSourceFileOfNode(decl);
+    if (name === undefined || !sf.text.includes("definePropert"))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(name);
+    if (symbol === undefined)
+        return false;
+    let found = false;
+    ts.walkPreorder(sf, (node) => {
+        if (found)
+            return "stop";
+        if (ts.isCallExpression(node) &&
+            ts.isPropertyAccessExpression(node.expression) &&
+            (node.expression.name.text === "defineProperty" ||
+                node.expression.name.text === "defineProperties") &&
+            lowerer.stdlibGlobalMember(node.expression, "Object") !== null) {
+            const target = node.arguments.nodes[0];
+            if (target !== undefined &&
+                ts.isIdentifier(target) &&
+                target.text === name.text &&
+                lowerer.checker.getSymbolAtLocation(target) === symbol)
+                found = true;
+        }
+        return undefined;
+    });
+    return found;
+}
 //# sourceMappingURL=lower-classes.js.map