@scriptc/compiler 0.4.7 → 0.4.8

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

@@ -1,3 +1,4 @@
+import { isJsIteratorGlobal, iteratorPrototypeExpr, lowerIteratorNew, } from "./iterator-prototype.js";
 import { lowerWrapperNew } from "./primitive-wrappers.js";
 import { lowerAsyncLocalStorageOptions } from "./builtins/async-context.js";
 import { shapeOverlayAnnotated } from "../shape-inference/index.js";
@@ -9,7 +10,8 @@ import { keyedHelperName } from "./stable-names.js";
 import { lowerValueReturningConstructorNew } from "./js-dynamic-objects.js";
 import { adaptPromiseExecutor } from "./promise-executor-adapter.js";
 import { dynUndefinedExpr, nodeThrowExpr, strLit, varRef } from "../../ir/build.js";
-import { constructedFromValue, constructedValue, superIntoResultSlot, } from "./constructor-returns.js";
+import { isBuiltinIdentityToken, isPrimitiveValueType, staticallyPrimitive, throwAfterEach, throwTypeError, } from "./primitive-throws.js";
+import { constructedFromValue, constructedValue, constructorPrimitiveFlag, superIntoResultSlot, } from "./constructor-returns.js";
 import { checkedIterableSpread } from "./checked-iterable-spread.js";
 import { lowerReadlineInterfaceNew, lowerReadlineUiNew } from "./builtins/readline.js";
 import { builtinMemberBindingTarget, builtinMemberRequireDecl, } from "./builtins/module-bindings.js";
@@ -29,15 +31,15 @@ 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, BYTES_U8, 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 { BIGINT_BYTES_NAMES, BOOL, BYTES_U8, 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";
 import { bodyReadsArguments } from "../arguments-usage.js";
 import { errorNameAfterField, errorViewFields } from "./error-name-order.js";
-import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, } from "./call-signatures.js";
+import { checkedJsDocumentedParameter, documentedParameter, generatorMeta, generatorParamsBindAtCall, } from "./call-signatures.js";
 import { omittedArgFor } from "./call-arguments.js";
-import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, typeKey, withUnitArm, X509_DER_FIELD, X509_PUBLIC_KEY_FIELD, } from "../type-mapper.js";
+import { checkerTypeDescription, isGenericCallableMemberType, jsOpenObjectType, noteScopeSensitiveMapping, typeKey, withUnitArm, X509_DER_FIELD, X509_PUBLIC_KEY_FIELD, } 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 { islandValueOrigin } from "../node-api-import.js";
@@ -62,6 +64,7 @@ import { declSymbolOf } from "./lower-modules.js";
 import { INSPECT_CUSTOM_MEMBER, classSymbolKeyOf, classSymbolKeyOfSymbol, symbolFieldDisplayName, } from "./symbol-fields.js";
 import { lowerHttpAgentNew, lowerHttpServerNew, lowerTlsSocketNew } from "./lower-server.js";
 import { ambientNsRootOf, ambientUndefReadType, ambientUndefVarRootOf, ambientUndefinedFnSymbolOf, contextualUndefReadType, fenceEarlyAliasUse, fenceEarlyNsMemberRef, nsMemberIdentOf, nsUndefRead, } from "./lower-namespaces.js";
+import { hostGlobalNameOfRead } from "./host-globals.js";
 import { mixinResultBindingClassOf } from "./lower-mixins.js";
 import { hasLexicalPrivateReference, hasStaticThis, rejectStaticThis } from "./static-this.js";
 import { lowerUrlNew } from "./lower-url.js";
@@ -73,8 +76,8 @@ import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { lowerInstanceConstructorNew } from "./class-instance-constructor.js";
 import { classPrototypeData, reflectClassPrototype } from "./class-prototypes.js";
 import { constructionEscape } from "./construction-escapes.js";
-import { checkedClassConstruction, checkedClassConstructionPacked } from "./class-construction.js";
-import { initializeRuntimeStatics, hasRuntimeStatics } from "./class-runtime-statics.js";
+import { checkedClassConstruction, checkedClassConstructionPacked, primitiveCheckedConstruction, } from "./class-construction.js";
+import { initializeRuntimeStatics, hasRuntimeStatics, runtimeStaticDefines, } from "./class-runtime-statics.js";
 import { reflectedClassMethodValue, reflectedClassStaticMethodValue, } from "./class-method-values.js";
 import { identifierReadSymbol } from "./surfaces.js";
 export function returnsOnlyThis(member) {
@@ -167,6 +170,59 @@ function perInstanceMember(node) {
         return false;
     return !ts.getModifiers(node)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword);
 }
+/** `Symbol.hasInstance` over the standard global. */
+export function isSymbolHasInstanceKey(lowerer, key) {
+    let e = key;
+    while (ts.isParenthesizedExpression(e))
+        e = e.expression;
+    return (ts.isPropertyAccessExpression(e) &&
+        !e.questionDotToken &&
+        ts.isIdentifier(e.expression) &&
+        lowerer.isStdlibGlobal(e.expression, "Symbol") &&
+        ts.isIdentifier(e.name) &&
+        e.name.text === "hasInstance");
+}
+/** The static members keyed by `Symbol.hasInstance`
+ * (`static [Symbol.hasInstance](v) { … }`): defining them on the class
+ * value's own-property table gives `instanceof` its hook (the runtime
+ * consults that table, scr_dyn_has_instance_hook). */
+export function staticHasInstanceHookMembers(lowerer, decl) {
+    return decl.members.nodes.filter((member) => {
+        const name = member.name;
+        return (name !== undefined &&
+            ts.isComputedPropertyName(name) &&
+            ts.getModifiers(member)?.some((modifier) => modifier.kind === ts.SyntaxKind.StaticKeyword) ===
+                true &&
+            isSymbolHasInstanceKey(lowerer, name.expression));
+    });
+}
+/** Whether `info` or an ancestor declares a static `Symbol.hasInstance`
+ * member. Node's `instanceof` asks the hook on the constructor (inherited
+ * through the static prototype chain) and uses OrdinaryHasInstance only
+ * when no hook exists. */
+export function classDeclaresHasInstanceHook(info) {
+    for (let current = info; current; current = current.base) {
+        if (current.hasInstanceHook === true)
+            return true;
+    }
+    return false;
+}
+/** Whether `expression` reads an element of a JavaScript array whose
+ * compiled storage is checked-dynamic (`const classes = [A, B]`; the
+ * array literal of several class constructors lowers as the checked
+ * array, and an unannotated file-scope binding keeps that layout). */
+function jsCheckedDynamicArrayElement(lowerer, expression) {
+    if (!ts.isElementAccessExpression(expression))
+        return false;
+    if (!isJsSourceFile(ts.getSourceFileOfNode(expression)))
+        return false;
+    if (!ts.isIdentifier(expression.expression))
+        return false;
+    const stored = lowerer.peekLocal(expression.expression) ?? lowerer.globalOf(expression.expression);
+    if (!stored)
+        return false;
+    return (stored.type.kind === "dyn" || (stored.type.kind === "array" && stored.type.elem.kind === "dyn"));
+}
 export function storedClassValueType(lowerer, expression, visiting = new Set()) {
     if (visiting.has(expression))
         return null;
@@ -212,6 +268,12 @@ export function storedClassValueType(lowerer, expression, visiting = new Set())
     }
     const type = lowerer.typeOf(expression);
     const mapped = lowerer.mapTypeOf(type);
+    // An element of a CHECKED-DYNAMIC JavaScript array (`const classes =
+    // [A, B]`, `both[1]`): the storage holds whichever constructor the array
+    // holds, so tsc's inferred element type — best common type spells the
+    // first — does not name the class the slot holds at run time.
+    if (mapped?.kind === "classval" && jsCheckedDynamicArrayElement(lowerer, expression))
+        return null;
     if (mapped?.kind === "classval" && !lowerer.classes.has(mapped.className)) {
         for (const signature of lowerer.checker.getConstructSignatures(type)) {
             const constructor = signature.declaration;
@@ -1416,6 +1478,15 @@ mixin) {
         const adoptCallableBase = (expression) => {
             if (familyMode || inst || mixin)
                 return false;
+            if (isJsIteratorGlobal(lowerer, expression)) {
+                callableBase = {
+                    expression,
+                    constructorId: `%g.${className}.base`,
+                    prototypeId: `%g.${className}.basePrototype`,
+                    iterator: true,
+                };
+                return true;
+            }
             if (lowerer.computedCallableBases.has(decl)) {
                 callableBase = {
                     expression,
@@ -3537,7 +3608,18 @@ mixin) {
             bodyReadsArguments(ctor)) {
             ctorParams.push({ type: DYN, mode: "arguments" });
         }
+        // A static `Symbol.hasInstance` member of a class that otherwise keeps
+        // its statics in module storage: the hook only exists if the CLASS
+        // VALUE carries it, so the member joins the runtime property table
+        // (initializeRuntimeStatics). Only the hook members are added; every
+        // other static keeps its current representation.
+        const hasInstanceHooks = staticHasInstanceHookMembers(lowerer, decl);
+        for (const member of hasInstanceHooks) {
+            if (!runtimeStatics.includes(member))
+                runtimeStatics.push(member);
+        }
         const info = {
+            ...(hasInstanceHooks.length ? { hasInstanceHook: true } : {}),
             ...(runtimeStatics.length || checkedStatics ? { runtimeStatics } : {}),
             ...(runtimePrototypeMembers.length ? { runtimePrototypeMembers } : {}),
             def: {
@@ -3801,6 +3883,9 @@ export function genericClassInstanceType(lowerer, decl, ref, mapArgument) {
         // body (`this.v = v` types the receiver as `this`, not a reference).
         // Inside an instantiation the CURRENT bindings are the arguments;
         // anywhere else the reference is honestly unmappable.
+        // The current instance's bindings ARE the arguments: the mapping
+        // belongs to that instance.
+        noteScopeSensitiveMapping();
         for (const tp of gci.typeParams) {
             const b = lowerer.typeParamBindings?.get(tp);
             if (!b)
@@ -4134,16 +4219,23 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         }, {
             kind: "assign",
             localId: prototypeId,
-            value: {
-                kind: "libCall",
-                fn: "dyn.classBasePrototype",
-                args: [{ kind: "varRef", localId: constructorId, type: DYN, loc }],
-                type: DYN,
-                loc,
-            },
+            value: info.callableBase.iterator
+                ? iteratorPrototypeExpr(loc)
+                : {
+                    kind: "libCall",
+                    fn: "dyn.classBasePrototype",
+                    args: [{ kind: "varRef", localId: constructorId, type: DYN, loc }],
+                    type: DYN,
+                    loc,
+                },
             loc,
         });
-        const prototype = classPrototypeData(lowerer, info, loc);
+        // An iterator subclass's instances are driven by the runtime's helpers,
+        // which read `next` and `return` (methods or accessors) through the
+        // instance's view: its prototype holds every member.
+        const prototype = info.callableBase.iterator && info.decl
+            ? reflectClassPrototype(lowerer, info, loc, classValueRef(lowerer, info, info.decl))
+            : classPrototypeData(lowerer, info, loc);
         if (prototype)
             out.push({ kind: "exprStmt", expr: prototype, loc });
         out.push({
@@ -4169,10 +4261,14 @@ function lowerStaticFieldInitsInner(lowerer, info) {
         });
     }
     const items = [
-        // A runtime-statics class initializes its private static fields with
-        // its other initializers (initializeRuntimeStatics).
+        // A runtime-statics class initializes the private static fields its
+        // property table carries with its other initializers
+        // (initializeRuntimeStatics). One whose table carries only its
+        // `Symbol.hasInstance` hook keeps its native initializers here.
         ...info.staticFields
-            .filter((f) => !(info.runtimeStatics && f.name.startsWith("#")))
+            .filter((f) => !(info.runtimeStatics &&
+            f.name.startsWith("#") &&
+            runtimeStaticDefines(lowerer, info, f.name)))
             .map((f) => ({
             pos: ts.tokenStartOfNode(f.initializer),
             kind: "field",
@@ -4785,7 +4881,13 @@ export function lowerClassStaticRead(lowerer, info, name, receiver, site) {
         ["now", "parse", "UTC"].includes(name) &&
         !(ts.isCallExpression(site.parent) && site.parent.expression === site))
         lowerer.noLowering(`Date.${name} read through a class that extends Date`, site);
-    if (hasRuntimeStatics(info) && !found?.field && !name.startsWith("#"))
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // reads its own storage, as it would without the hook.
+    if (hasRuntimeStatics(info) &&
+        !found?.field &&
+        !name.startsWith("#") &&
+        (!found || runtimeStaticDefines(lowerer, info, name)))
         return {
             kind: "dynKeyGet",
             value: lowerer.coerceToExpected(classValueRef(lowerer, info, receiver), DYN),
@@ -4887,6 +4989,15 @@ function namedEvaluationName(expr) {
         return p.name.text;
     if (ts.isParameter(p) && ts.isIdentifier(p.name))
         return p.name.text;
+    // A destructuring default: `const [c = class {}] = []` and
+    // `({ c = class {} } = o)` name the class after the bound identifier. An
+    // array-literal element that is not a pattern element stays unnamed.
+    if (ts.isBindingElement(p) && p.initializer !== undefined && ts.isIdentifier(p.name))
+        return p.name.text;
+    if (ts.isShorthandPropertyAssignment(p) &&
+        p.objectAssignmentInitializer !== undefined &&
+        ts.isIdentifier(p.name))
+        return p.name.text;
     return "";
 }
 /** Each evaluation of a function-local class creates fresh private names,
@@ -5225,7 +5336,15 @@ function lowerClassValue(lowerer, expr, info, binding) {
                         fn: "dyn.classPrototype",
                         args: [
                             boxed,
-                            { kind: "libCall", fn: "dyn.classBasePrototype", args: [baseRef], type: DYN, loc },
+                            info.callableBase.iterator
+                                ? iteratorPrototypeExpr(loc)
+                                : {
+                                    kind: "libCall",
+                                    fn: "dyn.classBasePrototype",
+                                    args: [baseRef],
+                                    type: DYN,
+                                    loc,
+                                },
                         ],
                         type: DYN,
                         loc,
@@ -5604,12 +5723,15 @@ function staticCallOn(lowerer, call, access, info, throughValue) {
         if (date)
             return date;
     }
+    const staticMember = findStaticOn(lowerer, info, access.name.text);
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // calls its own function, as it would without the hook.
     if ((hasRuntimeStatics(info) &&
         !access.name.text.startsWith("#") &&
-        !findStaticOn(lowerer, info, access.name.text)?.field) ||
-        (info.callableBase &&
-            !findStaticOn(lowerer, info, access.name.text) &&
-            !findGenericStaticOn(lowerer, info, access.name.text)))
+        !staticMember?.field &&
+        (!staticMember || runtimeStaticDefines(lowerer, info, access.name.text))) ||
+        (info.callableBase && !staticMember && !findGenericStaticOn(lowerer, info, access.name.text)))
         return {
             kind: "dynInvoke",
             recv: lowerer.lowerExprExpecting(access.expression, DYN),
@@ -5797,9 +5919,12 @@ function directRuntimeStaticCall(lowerer, call, access, info, throughValue) {
             c.staticMethods?.has(name) === true ||
             c.genericStatics?.has(name) === true)
             return null;
-        const runtime = c.runtimeStatics?.find((element) => element.name !== undefined &&
-            ts.isIdentifier(element.name) &&
-            element.name.text === name);
+        // A computed name defines the key it folds to, so `static ['m']` in
+        // this class answers for `m` and hides the inherited method.
+        const runtime = c.runtimeStatics?.find((element) => {
+            const elementName = element.name;
+            return elementName !== undefined && classMemberNameOf(lowerer, elementName) === name;
+        });
         if (runtime) {
             if (!ts.isMethodDeclaration(runtime) || !runtime.body)
                 return null;
@@ -5991,11 +6116,16 @@ export function lowerClassValueProperty(lowerer, expr) {
     // its other statics (`Error.stackTraceLimit`) keep their own lowerings.
     if (info?.def.runtime && member !== "name")
         return null;
+    const storedMember = info ? findStaticOn(lowerer, info, member) : undefined;
+    // A statically known member that the class value's table does not carry
+    // (a class whose only runtime static is its `Symbol.hasInstance` hook)
+    // reads its own storage, as it would without the hook.
     if (info &&
         ((hasRuntimeStatics(info) &&
             !member.startsWith("#") &&
-            !findStaticOn(lowerer, info, member)?.field) ||
-            (info.callableBase && !findStaticOn(lowerer, info, member))))
+            !storedMember?.field &&
+            (!storedMember || runtimeStaticDefines(lowerer, info, member))) ||
+            (info.callableBase && !storedMember)))
         return {
             kind: "dynKeyGet",
             value: lowerer.lowerExprExpecting(expr.expression, DYN),
@@ -6837,6 +6967,20 @@ function lowerClassCtorInner(lowerer, info) {
         const thisLocal = lowerer.declareThis(thisType);
         const params = [{ localId: thisLocal.id, name: "this", type: thisType }];
         const body = [];
+        // A derived constructor that can return a primitive records the pending
+        // TypeError for the construction site to raise. Drop a stale record on
+        // entry: a `finally` that throws after the return abandons the
+        // construction before any site reads it.
+        const pendingPrimitive = constructorPrimitiveFlag(lowerer, info);
+        if (pendingPrimitive !== null) {
+            const clearLoc = locOf(info.ctor ?? info.decl);
+            body.push({
+                kind: "assign",
+                localId: pendingPrimitive.id,
+                value: { kind: "boolLit", value: false, type: BOOL, loc: clearLoc },
+                loc: clearLoc,
+            });
+        }
         // The construction-relevant base: generic families are transparent
         // (an instantiation of a base-less generic class IS a base class —
         // its source has no super()).
@@ -7510,7 +7654,16 @@ function lowerClassMethodBody(lowerer, info, fnLike, fnName, sig) {
             if (shape.mode === "arguments")
                 fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(fnLike.body.statements.nodes)];
+        // See lowerFunction: a generator binds its parameters at the CALL
+        // (FunctionDeclarationInstantiation runs before GeneratorStart) exactly
+        // when that is observable — a destructuring or rest pattern, a default
+        // that evaluates anything, or a body that reads `arguments`.
+        const bindsAtCall = genCh !== null && declared.prologue.length > 0 && generatorParamsBindAtCall(fnLike);
+        const body = [
+            ...declared.prologue,
+            ...(bindsAtCall ? [{ kind: "genBindBarrier", loc: locOf(fnLike) }] : []),
+            ...lowerer.lowerStmts(fnLike.body.statements.nodes),
+        ];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(fnLike));
         const fn = {
             name: fnName,
@@ -7524,7 +7677,7 @@ function lowerClassMethodBody(lowerer, info, fnLike, fnName, sig) {
         if (isAsync)
             fn.async = true;
         if (genCh !== null)
-            fn.generator = genCh;
+            fn.generator = bindsAtCall ? { ...genCh, bindAtCall: true } : genCh;
         return fn;
     }
     finally {
@@ -7570,7 +7723,14 @@ export function lowerStaticMethod(lowerer, info, name) {
             declared.params.push({ localId: local.id, name: "%arguments", type: DYN });
             fnCtx.argumentsLocal = local;
         }
-        const body = [...declared.prologue, ...lowerer.lowerStmts(entry.member.body.statements.nodes)];
+        // See lowerFunction: a generator binds its parameters at the CALL
+        // exactly when that is observable.
+        const bindsAtCall = genCh !== null && declared.prologue.length > 0 && generatorParamsBindAtCall(entry.member);
+        const body = [
+            ...declared.prologue,
+            ...(bindsAtCall ? [{ kind: "genBindBarrier", loc: locOf(entry.member) }] : []),
+            ...lowerer.lowerStmts(entry.member.body.statements.nodes),
+        ];
         appendImplicitUndefinedReturn(lowerer, body, bodyReturn, locOf(entry.member));
         const fn = {
             name: `%${info.def.name}.static:${name}`,
@@ -7583,7 +7743,7 @@ export function lowerStaticMethod(lowerer, info, name) {
         if (isAsync)
             fn.async = true;
         if (genCh !== null)
-            fn.generator = genCh;
+            fn.generator = bindsAtCall ? { ...genCh, bindAtCall: true } : genCh;
         return fn;
     }
     catch (e) {
@@ -7988,6 +8148,10 @@ export function superCallStmt(lowerer, info, thisLocal, args, loc) {
         return dateSuperCall(thisRef, info, args[0], loc);
     if (info.extendsArray)
         return arraySuperCall(info, thisRef, args[0], loc);
+    // super() into %Iterator%: NewTarget is the subclass, so the abstract
+    // constructor only creates the receiver the derived constructor made.
+    if (info.callableBase?.iterator)
+        return { kind: "exprStmt", expr: args[0], loc };
     if (info.callableBase)
         return {
             kind: "exprStmt",
@@ -8620,13 +8784,162 @@ function checkedElementConstruction(lowerer, info, narrowed, args, loc) {
         loc,
     };
 }
+/** `new x.someLibMethod(...)`: a built-in method is not a constructor.
+ * Node evaluates the receiver, reads the member, evaluates the arguments,
+ * then throws `TypeError: <callee> is not a constructor` (V8 prints an
+ * anonymous intermediate value as `(intermediate value)`). On a typed
+ * receiver and on %Iterator.prototype% the member is the built-in method.
+ * Any other checked-dynamic receiver may hold any value: the read throws
+ * Node's TypeError for undefined and null before any argument evaluates
+ * and runs an accessor, and a function it answers constructs as for any
+ * dynamic callee. Null otherwise. */
+function lowerNonConstructorNew(lowerer, expr) {
+    let callee = expr.expression;
+    while (ts.isParenthesizedExpression(callee))
+        callee = callee.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.questionDotToken)
+        return null;
+    if (!lowerer.isStdlibMember(callee))
+        return null;
+    const symbol = lowerer.checker.getSymbolAtLocation(callee.name);
+    const method = symbol?.declarations?.some((decl) => ts.isMethodSignatureDeclaration(decl) || ts.isMethodDeclaration(decl));
+    if (!method)
+        return null;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(expr);
+    let receiver = callee.expression;
+    while (ts.isParenthesizedExpression(receiver))
+        receiver = receiver.expression;
+    const left = ts.isClassExpression(receiver) ||
+        ts.isFunctionExpression(receiver) ||
+        ts.isArrowFunction(receiver)
+        ? "(intermediate value)"
+        : ts.getTextOfNode(receiver);
+    const message = `${left}.${callee.name.text} is not a constructor`;
+    const recv = lowerer.lowerExpr(receiver);
+    // %Iterator.prototype% (scr_js_iterator.c) holds the runtime's helpers.
+    const intrinsic = recv.kind === "libCall" && recv.fn === "iterator.prototype";
+    if (intrinsic || (recv.type.kind !== "dyn" && recv.type.kind !== "union")) {
+        const stmts = [
+            { kind: "exprStmt", expr: recv, loc: locOf(receiver) },
+            ...args.map((arg) => ({
+                kind: "exprStmt",
+                expr: lowerer.lowerExpr(arg),
+                loc: locOf(arg),
+            })),
+        ];
+        return {
+            kind: "seqExpr",
+            stmts,
+            result: nodeThrowExpr(1, "", message, DYN, loc),
+            type: DYN,
+            loc,
+        };
+    }
+    const member = lowerer.declareHiddenLocal("%newMember", DYN);
+    const stmts = [
+        {
+            kind: "varDecl",
+            localId: member.id,
+            init: {
+                kind: "dynKeyGet",
+                key: strLit(callee.name.text, loc),
+                value: lowerer.coerceToExpected(recv, DYN),
+                type: DYN,
+                loc: locOf(callee),
+            },
+            loc: locOf(callee),
+        },
+    ];
+    const argRefs = args.map((arg) => {
+        const local = lowerer.declareHiddenLocal("%newArg", DYN);
+        stmts.push({
+            kind: "varDecl",
+            localId: local.id,
+            init: lowerer.coerceToExpected(lowerer.lowerExpr(arg), DYN),
+            loc: locOf(arg),
+        });
+        return varRef(local.id, DYN, loc);
+    });
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: {
+            kind: "ternary",
+            cond: {
+                kind: "dynTest",
+                test: "function",
+                value: varRef(member.id, DYN, loc),
+                type: BOOL,
+                loc,
+            },
+            then: checkedClassConstruction(lowerer, varRef(member.id, DYN, loc), argRefs, loc, `${left}.${callee.name.text}`),
+            else_: nodeThrowExpr(1, "", message, DYN, loc),
+            type: DYN,
+            loc,
+        },
+        type: DYN,
+        loc,
+    };
+}
 /** Map, Set and the error classes construct in lowerNew's identifier
  * branch, which a module member alias of one (`new mod.M()`) also takes. */
 function isCollectionOrErrorClass(ref) {
     return ref?.kind === "collection" || ref?.kind === "error";
 }
+/** `new url.URL(...)` / `new url.URLSearchParams(...)`: the member of a
+ * node:url binding (a namespace import, a require result, or an import=
+ * alias) resolves to the stdlib class symbol the named import binds, so the
+ * construction takes the same lowering. A binding that holds the class
+ * (`const U = url.URL`) follows its initializer to the same symbol. */
+function stdlibUrlClassOf(lowerer, callee) {
+    const classNamed = (sym) => {
+        if (!sym || !lowerer.isStdlibSymbol(sym))
+            return null;
+        const name = ts.symbolName(sym);
+        return name === "URL" || name === "URLSearchParams" ? name : null;
+    };
+    const aliased = (raw) => raw && raw.flags & ts.SymbolFlags.Alias ? lowerer.checker.getAliasedSymbol(raw) : raw;
+    let selected = callee;
+    for (let hops = 0; hops < 4; hops++) {
+        while (ts.isParenthesizedExpression(selected))
+            selected = selected.expression;
+        if (ts.isPropertyAccessExpression(selected) && !selected.questionDotToken) {
+            return classNamed(aliased(lowerer.checker.getSymbolAtLocation(selected.name)));
+        }
+        if (!ts.isIdentifier(selected))
+            return null;
+        const sym = aliased(lowerer.checker.getSymbolAtLocation(selected));
+        if (!sym)
+            return null;
+        const known = classNamed(sym);
+        if (known !== null)
+            return known;
+        const decl = sym.valueDeclaration;
+        if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer)
+            return null;
+        let next = decl.initializer;
+        while (ts.isParenthesizedExpression(next))
+            next = next.expression;
+        if (next === selected)
+            return null;
+        selected = next;
+    }
+    return null;
+}
 export function lowerNew(lowerer, expr) {
     const loc = locOf(expr);
+    // Constructing a Node 24 global the native runtime does not provide
+    // (WebSocket, FormData, …): the value a read answers refuses construction
+    // (host-global-values.ts), so the construction is that refusal — SC2020,
+    // which a JavaScript source defers to the throw at this statement.
+    {
+        const hostGlobal = hostGlobalNameOfRead(lowerer, expr.expression);
+        if (hostGlobal !== null)
+            lowerer.hostGlobalFence(hostGlobal, expr.expression);
+    }
     // The deprecated `new Buffer(...)` (containers/bytes.ts).
     {
         const buffer = lowerBufferConstruct(lowerer, expr);
@@ -8654,9 +8967,25 @@ export function lowerNew(lowerer, expr) {
             return lowerWithInlineRequireInit(lowerer, req, () => lowerNew(lowerer, expr));
         }
     }
+    // `new url.URL(input)` / `new url.URLSearchParams(init?)`: the node:url
+    // member names the same class the named import does, so both take the
+    // class's own lowering (including its argument diagnostics).
+    {
+        const urlClass = stdlibUrlClassOf(lowerer, expr.expression);
+        if (urlClass === "URL")
+            return lowerUrlNew(lowerer, expr);
+        if (urlClass === "URLSearchParams")
+            return lowerSearchParamsNew(lowerer, expr, loc);
+    }
     const wrapper = lowerWrapperNew(lowerer, expr);
     if (wrapper)
         return wrapper;
+    const abstractIterator = lowerIteratorNew(lowerer, expr);
+    if (abstractIterator)
+        return abstractIterator;
+    const nonConstructor = lowerNonConstructorNew(lowerer, expr);
+    if (nonConstructor)
+        return nonConstructor;
     const worker = lowerWorkerNew(lowerer, expr);
     if (worker)
         return worker;
@@ -9177,7 +9506,21 @@ export function lowerNew(lowerer, expr) {
             if (args.some(ts.isSpreadElement))
                 lowerer.noLowering("new RegExp with spread arguments", expr);
             const values = args.map((arg) => lowerer.lowerExpr(arg));
-            if (values.some((value) => value.type.kind === "dyn" || value.type.kind === "regex")) {
+            // The statically spelled form below needs a string or undefined in
+            // each slot. Every other value — a `dyn` or `regex` argument, and
+            // any primitive or object the static form cannot spell, such as a
+            // boolean, number or null flags argument — reaches the runtime's
+            // JavaScript ToString, exactly the coercion the spec's RegExp
+            // builtin performs, so an invalid flags string throws Node's
+            // SyntaxError at construction instead of refusing the build.
+            const stringSlot = (value) => value.type.kind === "string" ||
+                value.type.kind === "undefinedT" ||
+                (value.type.kind === "union" &&
+                    (lowerer.unions
+                        .get(value.type.unionId)
+                        ?.arms.every((arm) => arm.kind === "string" || arm.kind === "undefinedT") ??
+                        false));
+            if (values.some((value) => value.type.kind === "dyn" || value.type.kind === "regex" || !stringSlot(value))) {
                 const checked = [0, 1].map((index) => values[index]
                     ? lowerer.coerceInto(args[index], values[index], DYN)
                     : dynUndefinedExpr(loc));
@@ -9189,7 +9532,9 @@ export function lowerNew(lowerer, expr) {
                     loc,
                 };
             }
-            const strArg = (a, what) => {
+            // Every slot reaches here as a string or a nullish cover of one: the
+            // checked path above took every other value.
+            const strArg = (a) => {
                 if (!a)
                     return { kind: "strLit", value: "", type: STRING, loc };
                 const v = values[args.indexOf(a)];
@@ -9205,19 +9550,13 @@ export function lowerNew(lowerer, expr) {
                         loc,
                     };
                 }
-                if (v.type.kind === "union" &&
-                    lowerer.unions
-                        .get(v.type.unionId)
-                        ?.arms.every((arm) => arm.kind === "string" || arm.kind === "undefinedT")) {
+                if (v.type.kind === "union") {
                     return { kind: "nullish", left: v, right: empty, type: STRING, loc: locOf(a) };
                 }
-                if (v.type.kind !== "string") {
-                    lowerer.noLowering(`new RegExp with a '${lowerer.fmt(v.type)}' ${what}`, a, "string or undefined arguments are the lowered form (a RegExp copy or ToString coercion has no lowering)");
-                }
                 return v;
             };
-            const pattern = strArg(args[0], "pattern");
-            const flags = strArg(args[1], "flags argument");
+            const pattern = strArg(args[0]);
+            const flags = strArg(args[1]);
             // Node accepts the 'd' flag the engine does not have; a literal
             // flags string refuses here like the literal regex form.
             if (flags.kind === "strLit" && args[1] !== undefined && flags.value.includes("d")) {
@@ -9749,7 +10088,16 @@ export function lowerNew(lowerer, expr) {
         // TextEncoder, ...) typechecks and reports SC2020 here. The named
         // families carry pointed hints: each states WHY no honest static
         // lowering exists (or what to use instead).
-        if (lowerer.isStdlibSymbol(symbol ?? undefined)) {
+        // `new BigInt64Array(...)` / `new BigUint64Array(...)` are exempt where
+        // the checked-dynamic tier exists: the typed IR has no BigInt element
+        // kind, so these construct through the typed-array constructor VALUE
+        // (the checked-construction fallback below, whose runtime build reads and
+        // stores BigInt elements). Static code keeps the refusal.
+        const bigintBytesCtor = ts.isIdentifier(identifier) &&
+            symbol != null &&
+            BIGINT_BYTES_NAMES.has(ts.symbolName(symbol)) &&
+            isJsSourceFile(ts.getSourceFileOfNode(expr));
+        if (!bigintBytesCtor && lowerer.isStdlibSymbol(symbol ?? undefined)) {
             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)",
@@ -9990,6 +10338,31 @@ export function lowerNew(lowerer, expr) {
     }
     // Checked construction supports emitted classes and builtin typed arrays.
     const callee = tryLowerExpression(lowerer, expr.expression);
+    // A callee whose VALUE is a primitive (`new (null)()`, `new (5)()`, and a
+    // union whose arms are all primitives): JavaScript's IsConstructor step
+    // throws Node's TypeError, which names the constructed expression. V8
+    // evaluates the callee, then every argument, and only then checks, so the
+    // arguments lower for their effects ahead of the throw.
+    if (callee &&
+        isPrimitiveValueType(callee.type) &&
+        !isBuiltinIdentityToken(lowerer, expr.expression, callee)) {
+        return primitiveCalleeThrow(lowerer, expr, callee, loc);
+    }
+    if (callee && callee.type.kind === "union") {
+        const arms = lowerer.unions.get(callee.type.unionId)?.arms ?? [];
+        if (arms.length > 0 && arms.every(isPrimitiveValueType)) {
+            return primitiveCalleeThrow(lowerer, expr, callee, loc);
+        }
+    }
+    // A callee the CHECKER types as a primitive that still lowers to a
+    // dynamic slot (`const n = null`, or a property whose initializer was
+    // null): the same Node TypeError, but the value decides at run time,
+    // because a JavaScript property keeps its initializer's type through a
+    // later assignment (`reg.ctor = Foo; new reg.ctor()`). A typed
+    // construction site and an `any` callee keep the lowering they had.
+    if (callee && callee.type.kind === "dyn" && staticallyPrimitive(lowerer, expr.expression)) {
+        return primitiveCheckedNew(lowerer, expr, callee, loc);
+    }
     if (callee &&
         (callee.type.kind === "dyn" ||
             ((callee.type.kind === "func" || callee.type.kind === "classval") &&
@@ -10016,6 +10389,57 @@ function lowerCheckedConstructor(lowerer, expr, callee) {
     }
     return checkedClassConstruction(lowerer, callee, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
 }
+/** A checker-primitive callee whose value is a dynamic slot: the callee and
+ * every argument evaluate, then the runtime primitive check throws Node's
+ * "<callee> is not a constructor" — or, when the slot holds something else
+ * after all, constructs it as a dynamic `new` always did. */
+function primitiveCheckedNew(lowerer, expr, callee, loc) {
+    const message = `${constructorSpelling(expr.expression)} is not a constructor`;
+    const args = expr.arguments?.nodes ?? [];
+    if (args.some(ts.isSpreadElement)) {
+        const packed = lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0];
+        return primitiveCheckedConstruction(lowerer, callee, message, [], loc, packed);
+    }
+    return primitiveCheckedConstruction(lowerer, callee, message, args.map((arg) => lowerer.lowerExprExpecting(arg, DYN)), loc);
+}
+/** The always-throwing construction of a provably primitive callee. */
+function primitiveCalleeThrow(lowerer, expr, callee, loc) {
+    const args = expr.arguments?.nodes ?? [];
+    const effects = [callee];
+    if (args.some(ts.isSpreadElement)) {
+        effects.push(lowerer.completeArgs(args, [{ type: DYN, mode: "dynRest" }], loc, expr)[0]);
+    }
+    else {
+        for (const arg of args)
+            effects.push(lowerer.lowerExpr(arg));
+    }
+    return throwAfterEach(effects, throwTypeError(strLit(`${constructorSpelling(expr.expression)} is not a constructor`, loc), DYN, loc), loc);
+}
+/** The constructed expression as V8 names it in "is not a constructor": its
+ * source text, without the parentheses that only group it (`new (null)()`
+ * reports "null is not a constructor") and with a call's argument list
+ * abbreviated to "..." (`new (factory(null))()` reports "factory(...)",
+ * `new (factory(o).f)()` "factory(...).f", `new o["f"]()` "o.f"). A comma
+ * expression keeps V8's own "(a , b)" spelling. */
+function constructorSpelling(node) {
+    let spelled = node;
+    while (ts.isParenthesizedExpression(spelled))
+        spelled = spelled.expression;
+    if (ts.isCallExpression(spelled))
+        return `${constructorSpelling(spelled.expression)}(...)`;
+    if (ts.isPropertyAccessExpression(spelled)) {
+        return `${constructorSpelling(spelled.expression)}.${spelled.name.text}`;
+    }
+    if (ts.isElementAccessExpression(spelled) &&
+        ts.isStringLiteralLike(spelled.argumentExpression) &&
+        /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(spelled.argumentExpression.text)) {
+        return `${constructorSpelling(spelled.expression)}.${spelled.argumentExpression.text}`;
+    }
+    if (ts.isBinaryExpression(spelled) && spelled.operatorToken.kind === ts.SyntaxKind.CommaToken) {
+        return `(${constructorSpelling(spelled.left)} , ${constructorSpelling(spelled.right)})`;
+    }
+    return spelled.getText();
+}
 /** A getter/setter invocation over an accessor target's receiver — the
  * same whole-program devirtualization as method calls: a virtualCall
  * when some strict subclass of the receiver's static class overrides