@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -1,4 +1,6 @@
+import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
 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";
@@ -24,7 +26,7 @@ import { lowerZlibStreamNew, zlibClassName, zlibStreamModeOf } from "./builtins/
 import { everyStmtList } from "../../ir/traverse.js";
 import { builtinClassAliasOf, builtinClassRefOf, } from "./builtins/class-values.js";
 import { inlineNamespaceRequireOf, lowerWithInlineRequireInit } from "./cjs-inline-require.js";
-import { BOOL, canDynCheckTo, DATE_T, DYN, F64, bytesOf, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
+import { BOOL, canDynCheckTo, DATE_T, DYN, F64, RUNTIME_EMITTER_CLASS, RUNTIME_ERROR_CLASSES, RUNTIME_STREAM_CLASSES, STRING, classValueConstructor, UNDEFINED_T, VOID, arrayOf, isSupportedMapKey, isSupportedMapValue, isSupportedSetElem, isUnitType, typeEquals, } from "../../ir/ir.js";
 import { genericCallInstance, implicitAnyParamSymbolsOf, implicitCallInstance, implicitMonoFile, genericLocalClassResult, } from "./generic-functions.js";
 import { extendInstantiationPath, MAX_INSTANTIATION_RECURSION, } from "./instantiation-path.js";
 import { appendImplicitUndefinedReturn, hasExplicitJsDocReturn } from "./function-returns.js";
@@ -40,13 +42,12 @@ import { isCjsRequireGlobal } from "./lower-node-module.js";
 import { lowerArrayConstructor } from "./containers/array-construction.js";
 import { lowerMapSeedNew, lowerSetSeedNew } from "./containers/collection-methods.js";
 import { lowerObjectConstructor } from "./containers/indexed-objects.js";
-import { knownBufEncoding, lowerNodeModulesBufferConstruct } from "./containers/bytes.js";
-import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
+import { knownBufEncoding, lowerBufferConstruct } from "./containers/bytes.js";
 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;
@@ -889,7 +891,7 @@ function undefArmedFieldType(lowerer, p) {
     const byKey = new Map();
     const arms = mapped.kind === "union" ? (lowerer.unions.get(mapped.unionId)?.arms ?? []) : [mapped];
     for (const a of arms) {
-        if (a.kind === "map" || a.kind === "regex" || a.kind === "date" || a.kind === "generator") {
+        if (a.kind === "map" || a.kind === "regex" || a.kind === "generator") {
             return null;
         }
         byKey.set(typeKey(a), a);
@@ -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) {
@@ -3039,7 +3042,6 @@ mixin) {
                     declared.kind !== "union" &&
                     declared.kind !== "dyn" &&
                     declared.kind !== "map" &&
-                    declared.kind !== "date" &&
                     declared.kind !== "generator" &&
                     declared.kind !== "void" &&
                     declared.kind !== "caught";
@@ -3167,7 +3169,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 +3197,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 +3274,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 +4431,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 +4925,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 +4957,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 +4976,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 +5044,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 +5077,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 +5093,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 +5132,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 +5479,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 +5548,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 +6003,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 +7783,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 = {
@@ -8032,9 +8246,9 @@ function isCollectionOrErrorClass(ref) {
 }
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
-    // A dependency's deprecated `new Buffer(...)` fallback (containers/bytes.ts).
+    // The deprecated `new Buffer(...)` (containers/bytes.ts).
     {
-        const buffer = lowerNodeModulesBufferConstruct(lowerer, expr);
+        const buffer = lowerBufferConstruct(lowerer, expr);
         if (buffer)
             return buffer;
     }
@@ -8610,8 +8824,10 @@ export function lowerNew(lowerer, expr) {
             if (arg.type.kind === "string") {
                 return { kind: "libCall", fn: "date.newString", args: [arg], type: DATE_T, loc };
             }
+            // new Date(date): a new Date object with the same time value.
             if (arg.type.kind === "date") {
-                return arg;
+                const time = { kind: "libCall", fn: "date.getTime", args: [arg], type: F64, loc };
+                return { kind: "libCall", fn: "date.newMs", args: [time], type: DATE_T, loc };
             }
             lowerer.noLowering(`new Date of '${lowerer.fmt(arg.type)}' values`, args[0], "pass milliseconds, a date string, or another Date value", symbol);
         }
@@ -8790,7 +9006,7 @@ export function lowerNew(lowerer, expr) {
             if (targs[1]) {
                 lowerer.unsupported("SC1090", expr, `Map values of type '${lowerer.checker.typeToString(targs[1])}' ` +
                     `(Map values must be number, string, boolean, records, class instances, functions, ` +
-                    `typed arrays, arrays, promises, Maps, Sets, or supported unions and checked values)`);
+                    `typed arrays, arrays, promises, Dates, Maps, Sets, or supported unions and checked values)`);
             }
             lowerer.badType(expr, tsType);
         }
@@ -8810,6 +9026,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")) {
@@ -8874,15 +9124,21 @@ export function lowerNew(lowerer, expr) {
             lowerer.badType(expr, tsType);
         }
         // `new AsyncLocalStorage()` (node:async_hooks): a fresh store id —
-        // an f64 handle (type-mapper.ts), the Channel story. Construction options
-        // ({ defaultValue, name }) have no lowering yet.
+        // an f64 handle (type-mapper.ts), the Channel story. The options form
+        // ({ defaultValue, name }) passes the options object as a dyn value.
         if (symbol !== null &&
             ts.symbolName(symbol) === "AsyncLocalStorage" &&
             lowerer.isStdlibSymbol(symbol)) {
-            if ((expr.arguments?.nodes.length ?? 0) > 0) {
-                lowerer.noLowering("new AsyncLocalStorage(options)", expr, "the zero-argument constructor is the supported form (defaultValue/name options have no lowering yet)");
-            }
-            return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
+            const options = expr.arguments?.nodes[0];
+            if (options === undefined)
+                return { kind: "libCall", fn: "als.new", args: [], type: F64, loc };
+            return {
+                kind: "libCall",
+                fn: "als.newOptions",
+                args: [lowerAsyncLocalStorageOptions(lowerer, options)],
+                type: F64,
+                loc,
+            };
         }
         // `new Promise<T>((resolve) => ...)`: the ambient Promise constructor.
         if (symbol !== null && ts.symbolName(symbol) === "Promise" && lowerer.isStdlibSymbol(symbol)) {
@@ -8952,45 +9208,12 @@ export function lowerNew(lowerer, expr) {
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
         if (lowerer.isStdlibSymbol(symbol ?? undefined)) {
-            // The deprecated `new Buffer(string, encoding?)` ctor's string arm
-            // with a NON-STRING first argument and a string second: Node
-            // throws ERR_INVALID_ARG_TYPE synchronously (and DEP0005 never
-            // fires on this throwing path, so the compiled silence matches).
-            // Every other new Buffer form keeps the fence below — the
-            // constructing forms would owe the deprecation warning.
-            if (expr.expression.text === "Buffer" &&
-                expr.arguments?.nodes.length === 2 &&
-                !expr.arguments.nodes.some(ts.isSpreadElement) &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[0]))?.kind !== "string" &&
-                lowerer.mapTypeOf(lowerer.typeOf(expr.arguments.nodes[1]))?.kind === "string") {
-                const first = lowerer.lowerExpr(expr.arguments.nodes[0]);
-                if (first.kind === "unitLit" ||
-                    first.type.kind === "dyn" ||
-                    lowerer.dynConvertible(first.type)) {
-                    const got = first.type.kind === "dyn" ? first : { kind: "dynFrom", value: first, type: DYN, loc };
-                    // The encoding argument still evaluates in Node before the
-                    // throw only via the ctor body's later reads — it does NOT
-                    // observe it before throwing, so dropping it is exact for
-                    // effect-free operands; effectful ones keep the fence.
-                    const enc = lowerer.lowerExpr(expr.arguments.nodes[1]);
-                    if (enc.kind === "strLit" || isSafeToRepeat(enc)) {
-                        return {
-                            kind: "libCall",
-                            fn: "buffer.newStringFail",
-                            args: [got],
-                            type: bytesOf("u8"),
-                            loc,
-                        };
-                    }
-                }
-            }
             const ctorHints = {
                 RegExp: "use a regex literal (/pattern/flags) — constructed regexes have no lowering",
                 String: "boxed wrapper objects have no lowering — use the string primitive (the box is only distinguishable via typeof/identity, which nothing here can honor)",
                 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 +9502,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