@scriptc/compiler 0.4.1 → 0.4.2

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

@@ -136,6 +136,11 @@ export interface ClassInfo {
      * lower-event-target.ts over any class rooted here. Subclass structs
      * embed the runtime prefix. */
     builtinEventTarget?: "target" | "event";
+    /** A class declared `extends Date` (builtins/date-classes.ts): its first
+     * field is the hidden `%time` value, super() sets it with the Date
+     * constructor's rules, and the Date methods it does not declare lower
+     * over that value. Subclasses inherit the field. */
+    extendsDate?: true;
     /** The synthetic LifetimeRegion class (@scriptc/experimental,
      * lifetime-regions.ts): its constructor is synthesized with the class,
      * and its methods lower at their call sites. */
@@ -265,6 +270,9 @@ export interface ClassInfo {
         path: InstantiationPath;
         family: ClassInfo;
         bindings: Map<ts.Symbol, IrType>;
+        /** The type arguments as checker types, for the resolutions that need
+         * literal identity (a conditional type over a literal argument). */
+        tsBindings: Map<ts.Symbol, ts.Type>;
         typeArgsText: string;
         ordinal: number;
     };
@@ -354,6 +362,9 @@ export interface GenericClassInfo {
         info: ClassInfo | null;
         poisoned?: boolean;
     }>;
+    /** The type parameters a conditional type in the class depends on
+     * (literalSensitiveTypeParams), computed on first instantiation. */
+    literalSensitive?: Set<ts.Symbol>;
 }
 /** The builtin Error hierarchy
  * as eagerly-registered ClassInfos: mapType names them the moment a lib
@@ -438,6 +449,7 @@ export declare function collectClassShapeInner(lowerer: Lowerer, decl: ts.ClassL
     family: ClassInfo;
     name: string;
     bindings: Map<ts.Symbol, IrType>;
+    tsBindings: Map<ts.Symbol, ts.Type>;
     typeArgsText: string;
     ordinal: number;
 }, 
@@ -777,6 +789,12 @@ export declare function throwingSetterFn(lowerer: Lowerer, info: ClassInfo, prop
  * order) — a base constructor's prologue, a derived constructor's
  * super()-return continuation. */
 export declare function fieldInitStmts(lowerer: Lowerer, info: ClassInfo, thisLocal: IrLocal): IrStmt[];
+/** The comma chain of an `if` condition whose leading operands hold a
+ * super() call (`if (super(), r === 0) throw ...`, as minifiers join a
+ * super statement with the next test), or null. The if statement runs the
+ * chain's left operand as a statement first and tests its right operand,
+ * which is what the comma evaluates. */
+export declare function superConditionLead(cond: ts.Expression): ts.BinaryExpression | null;
 /** Super statements initialize the base and then the derived fields on
  * whichever control-flow path executes. Repeated calls are explicitly
  * refused until native layouts can allocate a second receiver. */

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

@@ -1,3 +1,6 @@
+import { DATE_TIME_FIELD, dateRootOf, dateSuperCall, isDatePrototypeMethod, lowerDateSuperMethodCall, } from "./builtins/date-classes.js";
+import { lowerDateStaticCall } from "./builtins/dates.js";
+import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
 import { adaptPromiseExecutor } from "./promise-executor-adapter.js";
 import { dynUndefinedExpr, nodeThrowExpr, varRef } from "../../ir/build.js";
@@ -29,7 +32,7 @@ import { bodyReadsArguments } from "../arguments-usage.js";
 import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
 import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
-import { isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
+import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, } from "../type-mapper.js";
 import { canonicalBuiltinModule, cjsClassExprWholeExportOf, isCjsJsFile, isJsSourceFile, isModuleExportsAccess, locOf, requireSpecOf, } from "../program.js";
 import { PoisonError, dynFallbackType, jsFuncNameOf, newFnCtx, own } from "./lowerer.js";
 import { isAssertClassNew } from "./assert-instances.js";
@@ -48,7 +51,7 @@ import { builtinEventTargetBaseOf, eventTargetApiMembers, eventTargetApiMethod,
 import { emitOverrideShapeReason, emitSpecSuperForward, emitterRooted, lowerEmitterSuperCall, } from "./lower-event-emitter.js";
 import { declSymbolOf } from "./lower-modules.js";
 import { classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
-import { lowerHttpAgentNew, lowerHttpServerNew } from "./lower-server.js";
+import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
@@ -493,8 +496,10 @@ export function registerBuiltinErrorClasses(lowerer) {
             throwingSetters: [],
             staticFields: [],
         };
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(irName, info);
     }
 }
@@ -575,8 +580,10 @@ export function registerBuiltinStreamClasses(lowerer) {
             throwingSetters: [],
             staticFields: [],
         };
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(irName, info);
     }
 }
@@ -1358,6 +1365,7 @@ mixin) {
                 : (computedBase?.classInfo ?? null);
         let genericBase;
         let callableBase;
+        let extendsDate = false;
         let factoryBaseExpression;
         const adoptCallableBase = (expression) => {
             if (familyMode || inst || mixin)
@@ -1538,6 +1546,12 @@ mixin) {
                     continue;
                 lowerer.unsupported("SC1090", clause, "extending computed expressions");
             }
+            if (!familyMode && !inst && !mixin && lowerer.isStdlibGlobal(t.expression, "Date")) {
+                if (t.typeArguments?.nodes)
+                    lowerer.unsupported("SC1090", t, "extending generic classes");
+                extendsDate = true;
+                continue;
+            }
             const symbol = lowerer.resolveValueSymbol(t.expression);
             // Extending a REBINDABLE decorated class (analysis already ran —
             // this collection is a class expression or a generic
@@ -1738,7 +1752,8 @@ mixin) {
         };
         for (const member of decl.members.nodes) {
             if ((functionLocalClass(decl) || checkedStatics) &&
-                isJsSourceFile(ts.getSourceFileOfNode(decl)) &&
+                (isJsSourceFile(ts.getSourceFileOfNode(decl)) ||
+                    (functionLocalClass(decl) && ts.isMethodDeclaration(member))) &&
                 (ts.isClassStaticBlockDeclaration(member) ||
                     ts
                         .getModifiers(member)
@@ -3394,7 +3409,8 @@ mixin) {
         // synthesized constructor forwards the same params to super).
         const ctorParams = ctor && !mixinForwarding
             ? lowerer.paramShapes(ctor.parameters.nodes)
-            : (base?.ctorParams ?? (callableBase ? [{ type: DYN, mode: "dynRest" }] : []));
+            : (base?.ctorParams ??
+                (callableBase || extendsDate ? [{ type: DYN, mode: "dynRest" }] : []));
         if (ctor &&
             !mixinForwarding &&
             isJsSourceFile(ts.getSourceFileOfNode(ctor)) &&
@@ -3421,6 +3437,7 @@ mixin) {
                 // Redeclared INHERITED fields contribute no slot (their
                 // initializers assign the prefix slot).
                 fields: [
+                    ...(extendsDate ? [{ name: DATE_TIME_FIELD, type: DATE_T }] : []),
                     ...(base?.def.fields ?? []),
                     ...fieldOrder
                         .filter((f) => f.redeclared !== true)
@@ -3452,6 +3469,7 @@ mixin) {
             base,
             ...(genericBase ? { genericBase } : {}),
             ...(callableBase ? { callableBase } : {}),
+            ...(extendsDate ? { extendsDate: true } : {}),
             ...(factoryBaseExpression ? { factoryBaseExpression } : {}),
             subclasses: [],
             throwingSetters,
@@ -3492,6 +3510,7 @@ mixin) {
                 path: inst.path,
                 family: inst.family,
                 bindings: inst.bindings,
+                tsBindings: inst.tsBindings,
                 typeArgsText: inst.typeArgsText,
                 ordinal: inst.ordinal,
             };
@@ -3522,8 +3541,10 @@ mixin) {
             };
             lowerer.genericClassByDecl.set(decl, info.generic);
         }
-        if (base)
+        if (base) {
             base.subclasses.push(info);
+            lowerer.subclassLinks++;
+        }
         lowerer.classes.set(className, info);
         if (computedBase && !functionLocalClass(decl)) {
             info.def.baseValueGlobal = `%g.${className}.computedBase`;
@@ -3625,8 +3646,10 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         .getTypeArguments(ref)
         .slice(0, gci.typeParams.length);
     const mapped = [];
+    const tsArgs = [];
     if (args.length === gci.typeParams.length) {
         for (const a of args) {
+            tsArgs.push(lowerer.typeParamTsResolver(a) ?? a);
             const m = lowerer.mapTypeOf(a, mapArgument);
             if (!m || m.kind === "void") {
                 // An UNBOUND type parameter argument (`Box<T>` outside any
@@ -3647,9 +3670,34 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             if (!b)
                 return null;
             mapped.push(b);
-        }
-    }
-    const key = mapped.map(typeKey).join(",");
+            const bound = lowerer.typeParamTsBindings?.get(tp);
+            if (bound)
+                tsArgs.push(bound);
+        }
+    }
+    // A type parameter that a conditional type in the class depends on
+    // (`K extends "required" ? T : T | undefined`) is bound to its checker
+    // type for the members, and that type keys the instance: mapType alone
+    // widens a literal, so Field<string, "required"> and Field<string,
+    // "optional"> would otherwise share one layout. The other parameters get
+    // no checker binding, so nothing in the members depends on a literal
+    // the key does not carry.
+    gci.literalSensitive ??= literalSensitiveTypeParams(lowerer, gci);
+    const sensitive = (i) => tsArgs.length === gci.typeParams.length && gci.literalSensitive.has(gci.typeParams[i]);
+    const checkerKey = gci.typeParams
+        .map((_, i) => (sensitive(i) ? `#${tsArgs[i].id}` : "*"))
+        .join(",");
+    const key = mapped.map(typeKey).join(",") + (gci.literalSensitive.size > 0 ? `@${checkerKey}` : "");
+    const literalText = (i) => {
+        const arg = sensitive(i) ? tsArgs[i] : undefined;
+        if (arg?.isStringLiteralType())
+            return JSON.stringify(arg.value);
+        if (arg?.isNumberLiteralType())
+            return String(arg.value);
+        if (arg && arg.flags & ts.TypeFlags.BooleanLiteral)
+            return lowerer.checker.typeToString(arg);
+        return null;
+    };
     const existing = gci.instances.get(key);
     if (existing) {
         if (existing.info)
@@ -3663,18 +3711,40 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         lowerer.unsupported("SC1090", decl, `unbounded generic class instantiation ('${gci.baseName}' exceeded ${MAX_INSTANTIATION_RECURSION} recursive specializations on one demand path)`);
     }
     const ordinal = gci.instances.size;
-    const name = `${gci.family.def.name}%${ordinal}`;
+    // The name does not take the checker type ids of the key: a literal
+    // argument is named by its text, another checker type by its
+    // description. Two keys that still describe alike number the later one.
+    const nameKey = mapped.map(typeKey).join(",") +
+        (gci.literalSensitive.size > 0
+            ? `@${gci.typeParams
+                .map((_, i) => sensitive(i)
+                ? (literalText(i) ?? checkerTypeDescription(tsArgs[i], lowerer.typeCtx))
+                : "*")
+                .join(",")}`
+            : "");
+    const prefix = `${gci.family.def.name}%`;
+    const taken = new Set([...gci.instances.values()].map((instance) => instance.name));
+    let name = keyedHelperName(lowerer, prefix, nameKey, "");
+    for (let n = 1; taken.has(name); n++)
+        name = keyedHelperName(lowerer, prefix, `${nameKey}#${n}`, "");
     const entry = { name, info: null };
     gci.instances.set(key, entry);
     const bindings = new Map();
     gci.typeParams.forEach((tp, i) => bindings.set(tp, mapped[i]));
-    const rendered = mapped.map((m) => lowerer.fmt(m)).join(", ");
+    const tsBindings = new Map();
+    gci.typeParams.forEach((tp, i) => {
+        if (sensitive(i))
+            tsBindings.set(tp, tsArgs[i]);
+    });
+    const rendered = mapped.map((m, i) => literalText(i) ?? lowerer.fmt(m)).join(", ");
     const typeArgsText = `<${rendered.length > 80 ? rendered.slice(0, 77) + "..." : rendered}>`;
     const prevBindings = lowerer.typeParamBindings;
+    const prevTsBindings = lowerer.typeParamTsBindings;
     const prevContext = lowerer.instantiationContext;
     const previousPath = lowerer.genericInstantiationPath;
     lowerer.genericInstantiationPath = path;
     lowerer.typeParamBindings = bindings;
+    lowerer.typeParamTsBindings = tsBindings;
     lowerer.instantiationContext = `instantiating class '${gci.baseName}' with ${typeArgsText}`;
     try {
         lowerer.collectClassShapeInner(decl, undefined, {
@@ -3682,6 +3752,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
             family: gci.family,
             name,
             bindings,
+            tsBindings,
             typeArgsText,
             ordinal,
         });
@@ -3696,6 +3767,7 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     }
     finally {
         lowerer.typeParamBindings = prevBindings;
+        lowerer.typeParamTsBindings = prevTsBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.genericInstantiationPath = previousPath;
     }
@@ -3710,6 +3782,65 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
     lowerer.onLateClassCollected?.(info);
     return { kind: "object", className: name };
 }
+/** The class's type parameters that a conditional type inside it depends
+ * on: the parameters named within a type node that is a conditional type
+ * or reaches one through the type aliases and interfaces it refers to
+ * (`get(): Value<T, K>` with `type Value<T, K> = K extends "required" ? T
+ * : T | undefined`, also when the alias wraps the conditional in a union
+ * or another alias). Their arguments pick the conditional's branch. */
+function literalSensitiveTypeParams(lowerer, gci) {
+    const params = new Set(gci.typeParams);
+    const found = new Set();
+    const reaches = new Map();
+    const declarationsReach = (symbol) => {
+        const target = symbol.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(symbol) : symbol;
+        const known = reaches.get(target);
+        if (known !== undefined)
+            return known;
+        reaches.set(target, false); // a recursive alias reaches through its other parts
+        const result = target.declarations.some((d) => ts.isTypeAliasDeclaration(d)
+            ? reachesConditional(d.type)
+            : ts.isInterfaceDeclaration(d)
+                ? d.members.nodes.some(reachesConditional)
+                : false);
+        reaches.set(target, result);
+        return result;
+    };
+    const reachesConditional = (node) => {
+        if (ts.isConditionalTypeNode(node))
+            return true;
+        if (ts.isTypeReferenceNode(node)) {
+            const name = ts.isIdentifier(node.typeName) ? node.typeName : node.typeName.right;
+            const symbol = lowerer.checker.getSymbolAtLocation(name);
+            if (symbol && !params.has(symbol) && declarationsReach(symbol))
+                return true;
+        }
+        let found = false;
+        ts.forEachChild(node, (child) => {
+            if (!found && reachesConditional(child))
+                found = true;
+        });
+        return found;
+    };
+    const collect = (node) => {
+        if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(node.typeName);
+            if (symbol && params.has(symbol))
+                found.add(symbol);
+        }
+        ts.forEachChild(node, collect);
+    };
+    const visit = (node) => {
+        if (ts.isTypeNode(node) && reachesConditional(node)) {
+            collect(node);
+            return;
+        }
+        ts.forEachChild(node, visit);
+    };
+    for (const member of gci.decl.members.nodes)
+        visit(member);
+    return found;
+}
 /** Runs a member-lowering thunk under an INSTANTIATION's type-parameter
  * bindings (the generic-fn typeParamResolver mechanism) — the checker
  * keeps reporting the unsubstituted `T`s inside the shared body AST.
@@ -3745,11 +3876,13 @@ function withInstanceBindings(lowerer, info, fn) {
         }
     }
     const prevBindings = lowerer.typeParamBindings;
+    const prevTsBindings = lowerer.typeParamTsBindings;
     const prevContext = lowerer.instantiationContext;
     const prevSuppress = lowerer.suppressStats;
     const previousPath = lowerer.genericInstantiationPath;
     lowerer.genericInstantiationPath = gi.path;
     lowerer.typeParamBindings = gi.bindings;
+    lowerer.typeParamTsBindings = gi.tsBindings;
     lowerer.instantiationContext = `instantiating class '${gi.family.generic?.baseName ?? info.def.jsName ?? ""}' with ${gi.typeArgsText}`;
     lowerer.suppressStats = prevSuppress || gi.ordinal > 0;
     try {
@@ -3757,6 +3890,7 @@ function withInstanceBindings(lowerer, info, fn) {
     }
     finally {
         lowerer.typeParamBindings = prevBindings;
+        lowerer.typeParamTsBindings = prevTsBindings;
         lowerer.instantiationContext = prevContext;
         lowerer.suppressStats = prevSuppress;
         lowerer.genericInstantiationPath = previousPath;
@@ -4484,6 +4618,13 @@ export function lowerStaticFieldRead(lowerer, expr) {
         return null;
     const loc = locOf(expr);
     const found = findStaticOn(lowerer, info, expr.name.text);
+    // A Date static read as a value through a class declared `extends Date`:
+    // the statics lower only as calls.
+    if (!found &&
+        dateRootOf(info) &&
+        ["now", "parse", "UTC"].includes(expr.name.text) &&
+        !(ts.isCallExpression(expr.parent) && expr.parent.expression === expr))
+        lowerer.noLowering(`Date.${expr.name.text} read through a class that extends Date`, expr);
     if (hasRuntimeStatics(info) && !found?.field)
         return {
             kind: "dynKeyGet",
@@ -4687,9 +4828,10 @@ export function lowerClassExpressionInfo(lowerer, expr) {
             expr.members.nodes.some((member) => decoratorNodesOf(member).length ||
                 (!isJsSourceFile(ts.getSourceFileOfNode(expr)) &&
                     (ts.isClassStaticBlockDeclaration(member) ||
-                        ts
-                            .getModifiers(member)
-                            ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword))) ||
+                        (!ts.isMethodDeclaration(member) &&
+                            ts
+                                .getModifiers(member)
+                                ?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword)))) ||
                 (ts.isMethodDeclaration(member) && member.typeParameters?.nodes.length)))) {
         lowerer.unsupported("SC1090", expr, "function-local classes with statics, decorators, or generic members");
     }
@@ -4932,9 +5074,49 @@ export function lowerClassExpression(lowerer, expr) {
             loc,
         });
     }
-    return info.localClass
-        ? initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value)
-        : value;
+    if (!info.localClass)
+        return value;
+    const classValue = initializeRuntimeStatics(lowerer, info, value.kind === "classRef" ? { ...value, captures: info.localClass.captureSources } : value);
+    // The base resolves statically here, but Node still evaluates the
+    // heritage expression each time the class definition runs, first.
+    const heritage = heritageWithEffects(expr);
+    if (heritage === undefined)
+        return classValue;
+    return {
+        kind: "seqExpr",
+        stmts: [lowerer.lowerExprStatement(heritage)],
+        result: classValue,
+        type: classValue.type,
+        loc: classValue.loc,
+    };
+}
+/** The `extends` expression of `decl` when evaluating it can have effects
+ * (a call, construction, assignment, update, delete, await or yield
+ * outside nested functions). */
+function heritageWithEffects(decl) {
+    const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
+    if (heritage === undefined)
+        return undefined;
+    const effects = (node) => {
+        if (ts.isFunctionLike(node) || ts.isClassDeclaration(node) || ts.isClassExpression(node))
+            return false;
+        if (ts.isCallExpression(node) ||
+            ts.isNewExpression(node) ||
+            ts.isTaggedTemplateExpression(node) ||
+            ts.isDeleteExpression(node) ||
+            ts.isAwaitExpression(node) ||
+            ts.isYieldExpression(node) ||
+            (ts.isPrefixUnaryExpression(node) &&
+                (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                    node.operator === ts.SyntaxKind.MinusMinusToken)) ||
+            ts.isPostfixUnaryExpression(node) ||
+            (ts.isBinaryExpression(node) &&
+                node.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastAssignment))
+            return true;
+        return ts.forEachChild(node, (child) => effects(child) || undefined) ?? false;
+    };
+    return effects(heritage) ? heritage : undefined;
 }
 /** The EXACT class a receiver expression is statically known to BE (not
  * merely be typed by): the class name itself, or a `const` binding
@@ -5195,6 +5377,13 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
     const runtimeStatic = directRuntimeStaticCall(lowerer, call, access, info, throughValue);
     if (runtimeStatic)
         return runtimeStatic;
+    // Date's statics through a class declared `extends Date`
+    // (`Moment.UTC(...)`), which inherits them.
+    if (dateRootOf(info) && !findStaticOn(lowerer, info, access.name.text)) {
+        const date = lowerDateStaticCall(lowerer, call, access.name.text);
+        if (date)
+            return date;
+    }
     if ((hasRuntimeStatics(info) && !findStaticOn(lowerer, info, access.name.text)?.field) ||
         (info.callableBase &&
             !findStaticOn(lowerer, info, access.name.text) &&
@@ -6288,7 +6477,7 @@ function lowerClassCtorInner(lowerer, info) {
                 lowerer.ctx.argumentsLocal = local;
             }
             body.push(...declared.prologue);
-            if (!ctorBase && !info.callableBase) {
+            if (!ctorBase && !info.callableBase && !info.extendsDate) {
                 // Node's base-class order: field initializers run at the start
                 // of construction, the parameter-property assignments open the
                 // constructor body (probed — a field initializer reading a
@@ -6303,7 +6492,7 @@ function lowerClassCtorInner(lowerer, info) {
             }
         }
         else {
-            if (ctorBase || info.callableBase) {
+            if (ctorBase || info.callableBase || info.extendsDate) {
                 // Synthetic forwarding params (the inherited ABI signature).
                 // Nothing references them by symbol — only the super call below,
                 // which forwards the already-completed values UNCHANGED (defaults
@@ -6486,7 +6675,7 @@ export function classIteratorDrainCall(lowerer, src, loc, elemT) {
     const key = `${cit.className}:${typeKey(outElem)}`;
     let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        name = keyedHelperName(lowerer, "%iter.drain", key);
         lowerer.iterDrainHelpers.set(key, name);
         const recvT = { kind: "object", className: cit.className };
         const recvRef = { kind: "varRef", localId: "r.0", type: recvT, loc };
@@ -6594,7 +6783,7 @@ export function classIteratorRestDrainCall(lowerer, cit, itVal, loc) {
     const key = `it:${cit.iterT.className}`;
     let name = lowerer.iterDrainHelpers.get(key);
     if (!name) {
-        name = `%iter.drain.${lowerer.iterDrainHelpers.size}`;
+        name = keyedHelperName(lowerer, "%iter.drain", key);
         lowerer.iterDrainHelpers.set(key, name);
         const itRef = { kind: "varRef", localId: "it.0", type: cit.iterT, loc };
         const outRef = { kind: "varRef", localId: "out.0", type: outT, loc };
@@ -7089,12 +7278,39 @@ function superCallInStatementPosition(call) {
         const parent = node.parent;
         if (ts.isExpressionStatement(parent))
             return true;
+        if (ts.isIfStatement(parent)) {
+            const lead = superConditionLead(parent.expression);
+            return lead !== null && call.pos >= lead.left.pos && call.end <= lead.left.end;
+        }
         const comma = ts.isBinaryExpression(parent) && parent.operatorToken.kind === ts.SyntaxKind.CommaToken;
         if (!comma && !ts.isParenthesizedExpression(parent))
             return false;
         node = parent;
     }
 }
+/** The comma chain of an `if` condition whose leading operands hold a
+ * super() call (`if (super(), r === 0) throw ...`, as minifiers join a
+ * super statement with the next test), or null. The if statement runs the
+ * chain's left operand as a statement first and tests its right operand,
+ * which is what the comma evaluates. */
+export function superConditionLead(cond) {
+    let expr = cond;
+    while (ts.isParenthesizedExpression(expr))
+        expr = expr.expression;
+    if (!ts.isBinaryExpression(expr) || expr.operatorToken.kind !== ts.SyntaxKind.CommaToken)
+        return null;
+    const holdsSuperCall = (operand) => {
+        let e = operand;
+        while (ts.isParenthesizedExpression(e))
+            e = e.expression;
+        if (ts.isCallExpression(e))
+            return e.expression.kind === ts.SyntaxKind.SuperKeyword;
+        return (ts.isBinaryExpression(e) &&
+            e.operatorToken.kind === ts.SyntaxKind.CommaToken &&
+            (holdsSuperCall(e.left) || holdsSuperCall(e.right)));
+    };
+    return holdsSuperCall(expr.left) ? expr : null;
+}
 /** Super statements initialize the base and then the derived fields on
  * whichever control-flow path executes. Repeated calls are explicitly
  * refused until native layouts can allocate a second receiver. */
@@ -7126,9 +7342,11 @@ export function lowerDerivedCtorBody(lowerer, info, thisLocal, forward) {
                 loc,
             },
         ];
-        if (info.callableBase) {
+        if (info.callableBase || info.extendsDate) {
             if (superCall.arguments.nodes.some(ts.isSpreadElement))
-                lowerer.unsupported("SC1090", superCall, "spreading explicit super arguments into an ordinary constructor");
+                lowerer.unsupported("SC1090", superCall, info.extendsDate
+                    ? "spreading super arguments into the Date constructor"
+                    : "spreading explicit super arguments into an ordinary constructor");
             const pack = {
                 kind: "dynArrLit",
                 elems: superCall.arguments.nodes.map((arg) => lowerer.lowerExprExpecting(arg, DYN)),
@@ -7271,6 +7489,8 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         type: { kind: "object", className: info.def.name },
         loc,
     };
+    if (info.extendsDate)
+        return dateSuperCall(thisRef, info, args[0], loc);
     if (info.callableBase)
         return {
             kind: "exprStmt",
@@ -7373,6 +7593,22 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
  * super dispatch is static in JS too, never through the dynamic class. */
 export function lowerSuperMethodCall(lowerer, call, access) {
     const cls = lowerer.currentClass;
+    // `super.toISOString()` in a class declared `extends Date`.
+    if (cls?.extendsDate && !cls.base) {
+        const thisL = lowerer.resolveThis();
+        if (!thisL)
+            lowerer.unsupported("SC1080", access);
+        const thisRef = {
+            kind: "varRef",
+            localId: thisL.id,
+            type: thisL.type,
+            loc: locOf(call),
+        };
+        const date = lowerDateSuperMethodCall(lowerer, call, access.name.text, cls, thisRef);
+        if (date)
+            return date;
+        lowerer.unsupported("SC1090", access, `'super.${access.name.text}' (Date.prototype does not declare it)`);
+    }
     if (!cls?.base) {
         // tsc rejects super outside derived-class bodies first; defensive.
         lowerer.unsupported("SC1090", access, "'super' outside a derived class");
@@ -7420,6 +7656,18 @@ export function lowerSuperMethodCall(lowerer, call, access) {
         // `super.dispatchEvent(e)`, `super.preventDefault()`: the inherited
         // runtime members over this method's own `this` (subclasses cannot
         // override them, so the static answer is the runtime's).
+        if (dateRootOf(cls.base) && isDatePrototypeMethod(access.name.text)) {
+            const thisL = lowerer.resolveThis();
+            if (!thisL)
+                lowerer.unsupported("SC1080", access);
+            const thisRef = {
+                kind: "varRef",
+                localId: thisL.id,
+                type: thisL.type,
+                loc: locOf(call),
+            };
+            return lowerDateSuperMethodCall(lowerer, call, access.name.text, cls.base, thisRef);
+        }
         if (eventTargetApiMethod(cls.base, access.name.text)) {
             const thisL = lowerer.resolveThis();
             if (!thisL)
@@ -8057,6 +8305,13 @@ export function lowerNew(lowerer, expr) {
         if (httpServer)
             return httpServer;
     }
+    // `new tls.TLSSocket(socket, options)` — the server-mode wrap of an open
+    // socket (lower-server).
+    {
+        const tlsSocket = lowerTlsSocketNew(lowerer, expr);
+        if (tlsSocket)
+            return tlsSocket;
+    }
     // `new http.Agent(opts?)` / `new https.Agent(opts?)` — the Agent
     // handle (lower-server): getName/destroy/counters through the dyn
     // handle ops, requests thread it via the agent option.
@@ -8782,7 +9037,7 @@ export function lowerNew(lowerer, expr) {
             const key = `x509.record:${isBytes ? "bytes" : "str"}`;
             let helper = lowerer.valueHelpers.get(key);
             if (!helper) {
-                helper = `%x509.record.${lowerer.valueHelpers.size}`;
+                helper = keyedHelperName(lowerer, "%x509.record", key);
                 lowerer.valueHelpers.set(key, helper);
                 const dataT = data.type;
                 const dRef = { kind: "varRef", localId: "d.0", type: dataT, loc };