@scriptc/compiler 0.3.6 → 0.4.1

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

@@ -2,6 +2,7 @@ import { dynUndefinedExpr, nodeThrowExpr } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { lowerToNumberArgument } from "./lower-exprs.js";
+import { isDeclaredInAmbientNamespace } from "../type-mapper.js";
 import { arrayOf, BOOL, BYTES_U8, DYN, F64, STRING, VOID, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
 import { STDLIB_SURFACE, STATIC_MATH_FNS, STATIC_MATH_PROPS, stdlibGlobalNameOf, } from "./surfaces.js";
 import { unsupportedNativeApiDiag, unsupportedPackageValueDiag, } from "../../diagnostics/diagnostic.js";
@@ -10,6 +11,8 @@ import { foldedStringKeyOf, lowerDynObjectLiteral } from "./expressions/object-l
 import { noteEventListeners } from "./lower-event-target.js";
 import { PoisonError, newFnCtx, own } from "./lowerer.js";
 import { NODE24_FETCH_COMPAT_PROFILE, STATIC_HEADERS_CALLS, STATIC_READABLE_STREAM_CALLS, STATIC_READABLE_STREAM_READS, STATIC_RESPONSE_CALLS, STATIC_RESPONSE_READS, } from "../../compat/fetch-profile.js";
+import { classGeneratorIterable } from "./class-iterables.js";
+import { generatorDrain } from "./iterator-adapters.js";
 export function refuseUnsupportedApi(lowerer, feature, node, hint) {
     lowerer.pushDiag(unsupportedNativeApiDiag(feature, locOf(node), hint));
     throw new PoisonError();
@@ -132,9 +135,7 @@ function requestInitConstBacked(lowerer, value, seen) {
     if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return false;
     seen.add(symbol);
-    const declarations = lowerer.checker
-        .declarationsOf(symbol)
-        .filter((declaration) => ts.isVariableDeclaration(declaration) &&
+    const declarations = symbol.declarations.filter((declaration) => ts.isVariableDeclaration(declaration) &&
         declaration.initializer !== undefined &&
         ts.isVariableDeclarationList(declaration.parent) &&
         (declaration.parent.flags & ts.NodeFlags.Const) !== 0);
@@ -151,8 +152,8 @@ function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, vis
         // a statically traced spread) hides earlier values exactly as it does at
         // runtime; a conditional/missing spread keeps the earlier contributor
         // in the possible-value set.
-        for (let i = expr.properties.length - 1; i >= 0; i--) {
-            const property = expr.properties[i];
+        for (let i = expr.properties.nodes.length - 1; i >= 0; i--) {
+            const property = expr.properties.nodes[i];
             if (ts.isSpreadAssignment(property)) {
                 const defines = visitRequestInitConstSelectedValues(lowerer, property.expression, selector, new Set(seen), visit);
                 if (defines)
@@ -172,7 +173,7 @@ function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, vis
         return false;
     }
     if (selector.kind === "index" && ts.isArrayLiteralExpression(expr)) {
-        const element = expr.elements[selector.index];
+        const element = expr.elements.nodes[selector.index];
         if (element === undefined || ts.isOmittedExpression(element) || ts.isSpreadElement(element)) {
             return false;
         }
@@ -214,7 +215,7 @@ function visitRequestInitConstSelectedValues(lowerer, value, selector, seen, vis
     seen.add(symbol);
     let sawDeclaration = false;
     let defines = true;
-    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
+    for (const declaration of symbol.declarations) {
         if (ts.isVariableDeclaration(declaration) &&
             declaration.initializer !== undefined &&
             ts.isVariableDeclarationList(declaration.parent) &&
@@ -243,7 +244,7 @@ function requestInitConstBindingSource(lowerer, declaration) {
         else if (ts.isArrayBindingPattern(pattern)) {
             if (current.dotDotDotToken)
                 return null;
-            const index = pattern.elements.indexOf(current);
+            const index = pattern.elements.nodes.indexOf(current);
             if (index < 0)
                 return null;
             selectors.unshift({ kind: "index", index });
@@ -295,7 +296,7 @@ function fenceRequestInitProperty(lowerer, access, seen) {
     if (!symbol || seen.has(symbol))
         return;
     seen.add(symbol);
-    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
+    for (const declaration of symbol.declarations) {
         if (ts.isPropertyAssignment(declaration)) {
             fenceRequestInitValueInner(lowerer, declaration.initializer, seen);
         }
@@ -333,8 +334,8 @@ function fenceRequestInitObject(lowerer, init, seen) {
     // effective contributor for each dictionary member; a definite later
     // `cache: undefined`, for example, suppresses an earlier unsupported
     // cache value just as WebIDL observes at runtime.
-    for (let index = init.properties.length - 1; index >= 0; index--) {
-        const prop = init.properties[index];
+    for (let index = init.properties.nodes.length - 1; index >= 0; index--) {
+        const prop = init.properties.nodes[index];
         if (ts.isSpreadAssignment(prop)) {
             for (const row of rows) {
                 if (shadowed.has(row.member))
@@ -399,7 +400,7 @@ function fenceRequestInitValueInner(lowerer, value, seen) {
     if (requestInitPropMutatedSymbols(lowerer).has(symbol))
         return;
     seen.add(symbol);
-    for (const declaration of lowerer.checker.declarationsOf(symbol)) {
+    for (const declaration of symbol.declarations) {
         if (ts.isBindingElement(declaration)) {
             const source = requestInitConstBindingSource(lowerer, declaration);
             if (source !== null) {
@@ -428,14 +429,14 @@ export function lowerFetchCall(lowerer, call) {
     const symbol = lowerer.resolveValueSymbol(callee);
     if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
-    if (call.arguments.length < 1)
+    if (call.arguments.nodes.length < 1)
         return null;
     const loc = locOf(call);
-    const initNode = call.arguments[1];
+    const initNode = call.arguments.nodes[1];
     if (initNode !== undefined)
         fenceRequestInitValue(lowerer, initNode);
     {
-        const inputNode = call.arguments[0];
+        const inputNode = call.arguments.nodes[0];
         const input = lowerer.lowerExpr(inputNode);
         let init;
         if (initNode === undefined) {
@@ -470,7 +471,7 @@ export function lowerFetchCall(lowerer, call) {
             { kind: "varDecl", localId: inputLocal.id, init: input, loc },
             { kind: "varDecl", localId: initLocal.id, init, loc },
         ];
-        for (const argument of call.arguments.slice(2)) {
+        for (const argument of call.arguments.nodes.slice(2)) {
             if (ts.isSpreadElement(argument)) {
                 lowerer.noLowering("spread surplus arguments on static fetch()", argument, "pass surplus arguments without spread syntax");
             }
@@ -479,6 +480,18 @@ export function lowerFetchCall(lowerer, call) {
                 : lowerer.lowerExpr(argument);
             stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
         }
+        // A union input holding a URL arm (`string | URL`) converts through the
+        // checked-dynamic input path, which reads the URL's href at the call
+        // like the bare-URL arm below; narrowing it to a string would throw on
+        // the URL arm.
+        const unionWithUrl = input.type.kind === "union" &&
+            (lowerer.unions.get(input.type.unionId)?.arms.some((arm) => arm.kind === "url") ?? false) &&
+            lowerer.dynConvertible(input.type);
+        const dynInput = input.type.kind === "dyn"
+            ? inputRef
+            : unionWithUrl
+                ? { kind: "dynFrom", value: inputRef, type: DYN, loc: locOf(inputNode) }
+                : null;
         const url = input.type.kind === "url"
             ? {
                 kind: "libCall",
@@ -487,13 +500,13 @@ export function lowerFetchCall(lowerer, call) {
                 type: STRING,
                 loc: locOf(inputNode),
             }
-            : input.type.kind === "dyn"
-                ? inputRef
+            : dynInput !== null
+                ? dynInput
                 : lowerer.coerceInto(inputNode, inputRef, STRING);
         const answer = {
             kind: "libCall",
-            fn: input.type.kind === "dyn" ? "fetch.input" : "fetch.start",
-            args: [input.type.kind === "dyn" ? inputRef : url, initRef],
+            fn: dynInput !== null ? "fetch.input" : "fetch.start",
+            args: [url, initRef],
             type: { kind: "promise", inner: DYN },
             loc,
         };
@@ -513,12 +526,12 @@ export function lowerStaticResponseCall(lowerer, call) {
     const member = staticResponseMemberName(lowerer, access);
     if (access.questionDotToken ||
         (member !== "json" && member !== "text" && member !== "bytes" && member !== "arrayBuffer") ||
-        call.arguments.length !== 0) {
+        call.arguments.nodes.length !== 0) {
         return null;
     }
     const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Response" || !lowerer.isStdlibSymbol(sym))
+    if (!sym || ts.symbolName(sym) !== "Response" || !lowerer.isStdlibSymbol(sym))
         return null;
     const recv = lowerer.lowerExpr(access.expression);
     if (recv.type.kind !== "dyn")
@@ -591,7 +604,7 @@ function lowerStaticFixedFetchMethodCall(lowerer, call, access, member, receiver
             loc,
         },
         then: answer,
-        else_: nodeThrowExpr(1, "", `${access.getText()} is not a function`, answer.type, loc),
+        else_: nodeThrowExpr(1, "", `${ts.getTextOfNode(access)} is not a function`, answer.type, loc),
         type: answer.type,
         loc,
     };
@@ -721,7 +734,7 @@ function fetchMethodArgumentIsLive(owner, members, index) {
 export function fenceStaticResponseMember(lowerer, access, use) {
     const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Response" || !lowerer.isStdlibSymbol(sym))
+    if (!sym || ts.symbolName(sym) !== "Response" || !lowerer.isStdlibSymbol(sym))
         return null;
     const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
@@ -744,7 +757,7 @@ export function fenceStaticResponseMember(lowerer, access, use) {
 export function fenceStaticHeadersMember(lowerer, access, use) {
     const recvType = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const sym = recvType.getAliasSymbol() ?? recvType.getSymbol();
-    if (!sym || sym.name !== "Headers" || !lowerer.isStdlibSymbol(sym))
+    if (!sym || ts.symbolName(sym) !== "Headers" || !lowerer.isStdlibSymbol(sym))
         return null;
     const members = fetchAccessMemberNames(lowerer, access);
     if (members === null)
@@ -775,7 +788,11 @@ export function fenceStaticAbortControllerMemberRead(lowerer, access) {
 function isStdlibFetchInterface(lowerer, node, owner) {
     const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node));
     for (const symbol of [type.getSymbol(), type.getAliasSymbol()]) {
-        if (symbol?.name === owner && lowerer.isStdlibSymbol(symbol))
+        // NodeJS.ReadableStream shares the WHATWG interface's name.
+        if (symbol !== undefined &&
+            ts.symbolName(symbol) === owner &&
+            lowerer.isStdlibSymbol(symbol) &&
+            !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && isDeclaredInAmbientNamespace(d, "NodeJS")))
             return symbol;
     }
     return null;
@@ -829,9 +846,9 @@ function fetchObjectAssignmentMemberName(lowerer, property) {
 function fetchInterfaceInventoryOwner(lowerer, node) {
     const type = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(node));
     const symbol = [type.getSymbol(), type.getAliasSymbol()].find((candidate) => candidate !== undefined &&
-        NODE24_FETCH_COMPAT_PROFILE.inventory.interfaces.includes(candidate.name) &&
+        NODE24_FETCH_COMPAT_PROFILE.inventory.interfaces.includes(ts.symbolName(candidate)) &&
         lowerer.isStdlibSymbol(candidate));
-    return symbol ? { owner: symbol.name, symbol } : null;
+    return symbol ? { owner: ts.symbolName(symbol), symbol } : null;
 }
 function fenceFetchObjectMembers(lowerer, ownerNode, members) {
     const resolved = fetchInterfaceInventoryOwner(lowerer, ownerNode);
@@ -858,7 +875,7 @@ function fenceFetchObjectMembers(lowerer, ownerNode, members) {
     }
 }
 export function fenceFetchObjectBinding(lowerer, pattern) {
-    fenceFetchObjectMembers(lowerer, pattern, pattern.elements.flatMap((element) => {
+    fenceFetchObjectMembers(lowerer, pattern, pattern.elements.nodes.flatMap((element) => {
         if (element.dotDotDotToken)
             return [];
         const member = fetchObjectBindingMemberName(lowerer, element);
@@ -869,7 +886,7 @@ export function fenceFetchObjectBinding(lowerer, pattern) {
  * a binding pattern, but its source type lives on the right-hand expression
  * instead of the target AST. */
 export function fenceFetchObjectAssignment(lowerer, target, source) {
-    fenceFetchObjectMembers(lowerer, source, target.properties.flatMap((property) => {
+    fenceFetchObjectMembers(lowerer, source, target.properties.nodes.flatMap((property) => {
         const member = fetchObjectAssignmentMemberName(lowerer, property);
         return member === null ? [] : [{ member, node: property }];
     }));
@@ -901,7 +918,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     if (call.questionDotToken ||
         !ts.isElementAccessExpression(call.expression) ||
         call.expression.questionDotToken ||
-        call.arguments.some((argument) => ts.isSpreadElement(argument))) {
+        call.arguments.nodes.some((argument) => ts.isSpreadElement(argument))) {
         return null;
     }
     const access = call.expression;
@@ -929,7 +946,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     const loc = locOf(call);
     const receiverLocal = lowerer.declareHiddenLocal("%fetchReceiver", DYN);
     const keyLocal = lowerer.declareHiddenLocal("%fetchMember", STRING);
-    const argumentValues = call.arguments.map((argument, index) => fetchMethodArgumentIsLive(resolved.owner, members, index)
+    const argumentValues = call.arguments.nodes.map((argument, index) => fetchMethodArgumentIsLive(resolved.owner, members, index)
         ? lowerLiveWebValue(lowerer, argument)
         : lowerer.lowerExprExpecting(argument, DYN));
     const argumentLocals = argumentValues.map((argument) => lowerer.declareHiddenLocal("%fetchMethodArg", argument.type));
@@ -963,7 +980,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
         loc,
     }));
     const staticResponsePromise = resolved.owner === "Response" &&
-        call.arguments.length === 0 &&
+        call.arguments.nodes.length === 0 &&
         members.every((member) => member === "text" || member === "bytes")
         ? (() => {
             // The checker spells this call as
@@ -989,7 +1006,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
             kind: "dynInvoke",
             recv: receiverRef,
             method: member,
-            calleeName: access.getText(),
+            calleeName: ts.getTextOfNode(access),
             args: argumentRefs,
             type: DYN,
             loc,
@@ -999,7 +1016,7 @@ export function lowerFetchElementMethodCall(lowerer, call) {
     // throw "is not a function" rather than dispatching every mismatch to the
     // last member.
     const invocationType = staticResponsePromise ?? DYN;
-    let result = nodeThrowExpr(1, "", `${access.getText()} is not a function`, invocationType, loc);
+    let result = nodeThrowExpr(1, "", `${ts.getTextOfNode(access)} is not a function`, invocationType, loc);
     for (let index = members.length - 1; index >= 0; index--) {
         const member = members[index];
         result = {
@@ -1065,7 +1082,7 @@ export function fenceStaticReadableStreamMember(lowerer, access, use) {
  * member-call path tries to lower the receiver as a value. */
 function staticFirstArgWithSurplusArgs(lowerer, call, first) {
     const loc = locOf(call);
-    if (call.arguments.length <= 1)
+    if (call.arguments.nodes.length <= 1)
         return first;
     const firstLocal = lowerer.declareHiddenLocal("%fetchArg", first.type);
     const firstRef = {
@@ -1075,7 +1092,7 @@ function staticFirstArgWithSurplusArgs(lowerer, call, first) {
         loc,
     };
     const stmts = [{ kind: "varDecl", localId: firstLocal.id, init: first, loc }];
-    for (const argument of call.arguments.slice(1)) {
+    for (const argument of call.arguments.nodes.slice(1)) {
         if (ts.isSpreadElement(argument)) {
             lowerer.noLowering("spread surplus arguments on the static fetch companion APIs", argument, "pass surplus arguments without spread syntax");
         }
@@ -1107,18 +1124,18 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
     }
     const root = call.expression.expression;
     const symbol = lowerer.resolveValueSymbol(root);
-    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+    if ((!symbol || !lowerer.isStdlibSymbol(symbol)) && !isStreamWebReadableStream(lowerer, root))
         return null;
     const loc = locOf(call);
     if (root.text === "AbortSignal") {
         noteEventListeners(lowerer, loc);
         switch (call.expression.name.text) {
             case "timeout":
-                if (call.arguments[0] && ts.isSpreadElement(call.arguments[0])) {
+                if (call.arguments.nodes[0] && ts.isSpreadElement(call.arguments.nodes[0])) {
                     return null;
                 }
-                return staticCallWithSurplusArgs(lowerer, call, call.arguments[0]
-                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                return staticCallWithSurplusArgs(lowerer, call, call.arguments.nodes[0]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                     : dynUndefinedExpr(loc), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortTimeout",
@@ -1127,7 +1144,7 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
                     loc,
                 }));
             case "abort":
-                if (call.arguments.length === 0) {
+                if (call.arguments.nodes.length === 0) {
                     return {
                         kind: "libCall",
                         fn: "fetch.abortNow",
@@ -1136,9 +1153,9 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
                         loc,
                     };
                 }
-                if (ts.isSpreadElement(call.arguments[0]))
+                if (ts.isSpreadElement(call.arguments.nodes[0]))
                     return null;
-                return staticCallWithSurplusArgs(lowerer, call, lowerLiveWebValue(lowerer, call.arguments[0]), (first) => ({
+                return staticCallWithSurplusArgs(lowerer, call, lowerLiveWebValue(lowerer, call.arguments.nodes[0]), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortNow",
                     args: [first],
@@ -1146,11 +1163,11 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
                     loc,
                 }));
             case "any":
-                if (call.arguments[0] && ts.isSpreadElement(call.arguments[0])) {
+                if (call.arguments.nodes[0] && ts.isSpreadElement(call.arguments.nodes[0])) {
                     return null;
                 }
-                return staticCallWithSurplusArgs(lowerer, call, call.arguments[0]
-                    ? lowerer.lowerExprExpecting(call.arguments[0], DYN)
+                return staticCallWithSurplusArgs(lowerer, call, call.arguments.nodes[0]
+                    ? lowerer.lowerExprExpecting(call.arguments.nodes[0], DYN)
                     : dynUndefinedExpr(loc), (first) => ({
                     kind: "libCall",
                     fn: "fetch.abortAny",
@@ -1164,8 +1181,8 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
     }
     if (root.text === "ReadableStream" &&
         call.expression.name.text === "from" &&
-        (!call.arguments[0] || !ts.isSpreadElement(call.arguments[0]))) {
-        if (!call.arguments[0]) {
+        (!call.arguments.nodes[0] || !ts.isSpreadElement(call.arguments.nodes[0]))) {
+        if (!call.arguments.nodes[0]) {
             return {
                 kind: "libCall",
                 fn: "fetch.streamFrom",
@@ -1174,7 +1191,7 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
                 loc,
             };
         }
-        let source = lowerer.lowerExpr(call.arguments[0]);
+        let source = lowerer.lowerExpr(call.arguments.nodes[0]);
         // A readonly tuple satisfies the fallback's readonly-array overload,
         // but maps to a monomorphic record in IR. Reuse the ordinary
         // tuple→array width conversion with the resolved generic parameter so
@@ -1196,7 +1213,7 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
                 canConvertToDyn(source.type.elem, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) ||
             source.type.kind === "dyn";
         if (!preserve) {
-            lowerer.noLowering(`ReadableStream.from() over ${lowerer.checker.typeToString(lowerer.typeOf(call.arguments[0]))} iterables`, call.arguments[0], "arrays, Uint8Array, and strings are supported — spread other synchronous iterables into an array first: [...iterable]");
+            lowerer.noLowering(`ReadableStream.from() over ${lowerer.checker.typeToString(lowerer.typeOf(call.arguments.nodes[0]))} iterables`, call.arguments.nodes[0], "arrays, Uint8Array, and strings are supported — spread other synchronous iterables into an array first: [...iterable]");
         }
         return staticCallWithSurplusArgs(lowerer, call, source, (first) => ({
             kind: "libCall",
@@ -1219,7 +1236,7 @@ export function lowerStaticFetchCompanionCall(lowerer, call) {
 export function lowerStaticAbortControllerCall(lowerer, call) {
     const access = call.expression;
     if (call.questionDotToken ||
-        call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
+        call.arguments.nodes.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
         staticResponseMemberName(lowerer, access) !== "abort") {
@@ -1227,25 +1244,24 @@ export function lowerStaticAbortControllerCall(lowerer, call) {
     }
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
-    if (symbol?.name !== "AbortController" ||
-        !lowerer.checker
-            .declarationsOf(symbol)
-            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+    if (symbol === undefined ||
+        ts.symbolName(symbol) !== "AbortController" ||
+        !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return null;
     }
     const receiver = lowerer.lowerExpr(access.expression);
     if (receiver.type.kind !== "dyn")
         return null;
     const loc = locOf(call);
-    const first = call.arguments[0]
-        ? lowerLiveWebValue(lowerer, call.arguments[0])
+    const first = call.arguments.nodes[0]
+        ? lowerLiveWebValue(lowerer, call.arguments.nodes[0])
         : dynUndefinedExpr(loc);
     const args = [staticFirstArgWithSurplusArgs(lowerer, call, first)];
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, "abort", receiver, args, (receiverRef, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiverRef,
         method: "abort",
-        calleeName: access.getText(),
+        calleeName: ts.getTextOfNode(access),
         args: argumentRefs,
         type: DYN,
         loc,
@@ -1257,7 +1273,7 @@ export function lowerStaticAbortControllerCall(lowerer, call) {
 export function lowerStaticReadableStreamControllerCall(lowerer, call) {
     const access = call.expression;
     if (call.questionDotToken ||
-        call.arguments.length > 1 ||
+        call.arguments.nodes.length > 1 ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
@@ -1267,10 +1283,9 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
         return null;
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
-    if (symbol?.name !== "ReadableStreamDefaultController" ||
-        !lowerer.checker
-            .declarationsOf(symbol)
-            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+    if (symbol === undefined ||
+        ts.symbolName(symbol) !== "ReadableStreamDefaultController" ||
+        !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return null;
     }
     const recv = lowerer.lowerExpr(access.expression);
@@ -1278,13 +1293,15 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
         return null;
     const loc = locOf(call);
     const args = [
-        call.arguments[0] ? lowerLiveWebValue(lowerer, call.arguments[0]) : dynUndefinedExpr(loc),
+        call.arguments.nodes[0]
+            ? lowerLiveWebValue(lowerer, call.arguments.nodes[0])
+            : dynUndefinedExpr(loc),
     ];
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiver,
         method: member,
-        calleeName: access.getText(),
+        calleeName: ts.getTextOfNode(access),
         args: argumentRefs,
         type: DYN,
         loc,
@@ -1296,8 +1313,8 @@ export function lowerStaticReadableStreamControllerCall(lowerer, call) {
 export function lowerStaticReadableStreamCancelCall(lowerer, call) {
     const access = call.expression;
     if (call.questionDotToken ||
-        call.arguments.length > 1 ||
-        call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
+        call.arguments.nodes.length > 1 ||
+        call.arguments.nodes.some((argument) => ts.isSpreadElement(argument)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken ||
         staticResponseMemberName(lowerer, access) !== "cancel") {
@@ -1312,13 +1329,15 @@ export function lowerStaticReadableStreamCancelCall(lowerer, call) {
         return null;
     const loc = locOf(call);
     const args = [
-        call.arguments[0] ? lowerLiveWebValue(lowerer, call.arguments[0]) : dynUndefinedExpr(loc),
+        call.arguments.nodes[0]
+            ? lowerLiveWebValue(lowerer, call.arguments.nodes[0])
+            : dynUndefinedExpr(loc),
     ];
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, "cancel", receiver, args, (receiverRef, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiverRef,
         method: "cancel",
-        calleeName: access.getText(),
+        calleeName: ts.getTextOfNode(access),
         args: argumentRefs,
         type: DYN,
         loc,
@@ -1331,8 +1350,8 @@ export function lowerStaticReadableStreamCancelCall(lowerer, call) {
 export function lowerStaticAbortSignalListenerCall(lowerer, call) {
     const access = call.expression;
     if (call.questionDotToken ||
-        call.arguments.length < 2 ||
-        call.arguments.some((arg) => ts.isSpreadElement(arg)) ||
+        call.arguments.nodes.length < 2 ||
+        call.arguments.nodes.some((arg) => ts.isSpreadElement(arg)) ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
@@ -1343,10 +1362,9 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
     }
     const receiverTs = lowerer.checker.getBaseTypeOfLiteralType(lowerer.typeOf(access.expression));
     const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
-    if ((symbol?.name !== "AbortSignal" && symbol?.name !== "EventTarget") ||
-        !lowerer.checker
-            .declarationsOf(symbol)
-            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+    if (((symbol === undefined || ts.symbolName(symbol) !== "AbortSignal") &&
+        (symbol === undefined || ts.symbolName(symbol) !== "EventTarget")) ||
+        !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return null;
     }
     const recv = lowerer.lowerExpr(access.expression);
@@ -1354,12 +1372,12 @@ export function lowerStaticAbortSignalListenerCall(lowerer, call) {
         return null;
     const loc = locOf(call);
     noteEventListeners(lowerer, loc);
-    const args = call.arguments.map((arg, index) => index === 1 ? lowerLiveWebValue(lowerer, arg) : lowerer.lowerExprExpecting(arg, DYN));
+    const args = call.arguments.nodes.map((arg, index) => index === 1 ? lowerLiveWebValue(lowerer, arg) : lowerer.lowerExprExpecting(arg, DYN));
     return lowerStaticFixedFetchMethodCall(lowerer, call, access, member, recv, args, (receiver, argumentRefs) => ({
         kind: "dynInvoke",
         recv: receiver,
         method: member,
-        calleeName: access.getText(),
+        calleeName: ts.getTextOfNode(access),
         args: argumentRefs,
         type: DYN,
         loc,
@@ -1372,7 +1390,7 @@ export function lowerEventTargetNew(lowerer, expr) {
     const name = stdlibGlobalNameOf(lowerer, expr.expression);
     if (name !== "EventTarget" && name !== "Event" && name !== "CustomEvent")
         return null;
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(expr);
@@ -1408,7 +1426,7 @@ export function lowerAbortControllerNew(lowerer, expr) {
     const symbol = lowerer.resolveValueSymbol(expr.expression);
     if (!symbol || !lowerer.isStdlibSymbol(symbol))
         return null;
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.some((argument) => ts.isSpreadElement(argument)))
         return null;
     const loc = locOf(expr);
@@ -1434,14 +1452,20 @@ export function lowerAbortControllerNew(lowerer, expr) {
         loc,
     };
 }
+/** An import binding of node:stream/web's ReadableStream, which IS the
+ * global class (`import { ReadableStream } from "node:stream/web"`). */
+function isStreamWebReadableStream(lowerer, ident) {
+    return ident.text === "ReadableStream" && lowerer.isStdlibGlobal(ident, "ReadableStream");
+}
 export function lowerStaticReadableStreamNew(lowerer, expr) {
     if (!ts.isIdentifier(expr.expression) || expr.expression.text !== "ReadableStream") {
         return null;
     }
     const symbol = lowerer.resolveValueSymbol(expr.expression);
-    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+    if ((!symbol || !lowerer.isStdlibSymbol(symbol)) &&
+        !isStreamWebReadableStream(lowerer, expr.expression))
         return null;
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.length > 1)
         return null;
     const loc = locOf(expr);
@@ -1463,7 +1487,7 @@ export function lowerFetchWebNew(lowerer, expr) {
     const name = stdlibGlobalNameOf(lowerer, expr.expression);
     if (name !== "Request" && name !== "Headers")
         return null;
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.some(ts.isSpreadElement))
         return null;
     const loc = locOf(expr);
@@ -1485,15 +1509,38 @@ export function lowerFetchWebNew(lowerer, expr) {
 export function lowerResponseNew(lowerer, expr) {
     if (stdlibGlobalNameOf(lowerer, expr.expression) !== "Response")
         return null;
-    const args = expr.arguments ?? [];
+    const args = expr.arguments?.nodes ?? [];
     if (args.some(ts.isSpreadElement))
         return null;
-    const loc = locOf(expr);
+    return lowerResponseConstruction(lowerer, args, locOf(expr), false);
+}
+/** Static `Response.json(data, init?)`: the data crosses into the runtime's
+ * checked-dynamic JSON serializer (toJSON hooks included) after ResponseInit
+ * converts, then the response initializes as the constructor does. */
+export function lowerResponseStaticJson(lowerer, call) {
+    if (call.questionDotToken || !ts.isPropertyAccessExpression(call.expression))
+        return null;
+    const access = call.expression;
+    if (access.questionDotToken || access.name.text !== "json")
+        return null;
+    if (!lowerer.isStdlibGlobal(access.expression, "Response"))
+        return null;
+    if (call.arguments.nodes.some(ts.isSpreadElement) || call.arguments.nodes.length === 0)
+        return null;
+    return lowerResponseConstruction(lowerer, call.arguments.nodes, locOf(call), true);
+}
+function lowerResponseConstruction(lowerer, args, loc, json) {
     const toDyn = (node, value, what) => {
         if (node === undefined)
             return dynUndefinedExpr(loc);
         if (value.type.kind === "dyn")
             return value;
+        if (what === "JSON data") {
+            const boxed = lowerer.coerceToExpected(value, DYN);
+            if (boxed.type.kind === "dyn")
+                return boxed;
+            lowerer.noLowering(`Response.json of '${lowerer.fmt(value.type)}' values`, node, "the data must cross the checked-dynamic boundary (number, string, boolean, null, records, arrays, and 'unknown')");
+        }
         /* A user class can satisfy ResponseInit structurally through plain
          * fields. Project just the declared dictionary members into a record,
          * then use the ordinary checked-dynamic copy. objRecordWidthHelper
@@ -1598,8 +1645,11 @@ export function lowerResponseNew(lowerer, expr) {
     }
     const result = {
         kind: "libCall",
-        fn: "fetch.responseNew",
-        args: [toDyn(bodyNode, bodyRef, "a body"), toDyn(initNode, initRef, "an init value")],
+        fn: json ? "fetch.responseJsonStatic" : "fetch.responseNew",
+        args: [
+            toDyn(bodyNode, bodyRef, json ? "JSON data" : "a body"),
+            toDyn(initNode, initRef, "an init value"),
+        ],
         type: DYN,
         loc,
     };
@@ -1612,7 +1662,7 @@ export function lowerResponseNew(lowerer, expr) {
 export function lowerStaticReadableStreamReaderCall(lowerer, call) {
     const access = call.expression;
     if (call.questionDotToken ||
-        call.arguments.length !== 0 ||
+        call.arguments.nodes.length !== 0 ||
         (!ts.isPropertyAccessExpression(access) && !ts.isElementAccessExpression(access)) ||
         access.questionDotToken) {
         return null;
@@ -1622,10 +1672,9 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
         return null;
     const receiverTs = lowerer.typeOf(access.expression);
     const symbol = receiverTs.getSymbol();
-    if (symbol?.name !== "ReadableStreamDefaultReader" ||
-        !lowerer.checker
-            .declarationsOf(symbol)
-            .some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(d.getSourceFile()))) {
+    if (symbol === undefined ||
+        ts.symbolName(symbol) !== "ReadableStreamDefaultReader" ||
+        !symbol.declarations.some((d) => ts.isInterfaceDeclaration(d) && lowerer.isStdlibFile(ts.getSourceFileOfNode(d)))) {
         return null;
     }
     const type = lowerer.mapTypeOf(lowerer.typeOf(call));
@@ -1644,15 +1693,15 @@ export function lowerStaticReadableStreamReaderCall(lowerer, call) {
 export function lowerDynamicImportCall(lowerer, call) {
     if (call.expression.kind !== ts.SyntaxKind.ImportKeyword)
         return null;
-    const arg = call.arguments[0];
+    const arg = call.arguments.nodes[0];
     if (arg === undefined || !ts.isStringLiteralLike(arg)) {
         lowerer.unsupported("SC1090", call, "dynamic import() of computed specifiers (the module graph resolves at " +
             "build time — the specifier must be a string literal)");
     }
-    if (call.arguments.length !== 1) {
+    if (call.arguments.nodes.length !== 1) {
         lowerer.unsupported("SC1090", call, "dynamic import() with import attributes");
     }
-    const res = lowerer.dynImports.get(`${call.getSourceFile().fileName}\u0000${arg.text}`);
+    const res = lowerer.dynImports.get(`${ts.getSourceFileOfNode(call).fileName}\u0000${arg.text}`);
     if (res === undefined)
         lowerer.refuseUnsupportedApi("'import()'", call);
     if (res.kind === "program-module") {
@@ -1666,7 +1715,7 @@ export function lowerDynamicImportCall(lowerer, call) {
 /** The checker-resolved program source behind one literal import(). */
 function programImportTarget(lowerer, arg) {
     const modSym = lowerer.checker.getSymbolAtLocation(arg);
-    for (const d of modSym ? lowerer.checker.declarationsOf(modSym) : []) {
+    for (const d of modSym ? modSym.declarations : []) {
         if (ts.isSourceFile(d) && !d.isDeclarationFile)
             return d;
     }
@@ -1816,12 +1865,12 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
     {
         const sigMember = lowerer.stdlibGlobalMember(access, "AbortSignal");
         if ((sigMember === "timeout" || sigMember === "abort" || sigMember === "any") &&
-            call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
+            call.arguments.nodes.every((argument) => !ts.isSpreadElement(argument))) {
             lowerer.refuseUnsupportedApi(`'AbortSignal.${sigMember}'`, call);
         }
     }
     if (lowerer.stdlibGlobalMember(access, "ReadableStream") === "from" &&
-        call.arguments.every((argument) => !ts.isSpreadElement(argument))) {
+        call.arguments.nodes.every((argument) => !ts.isSpreadElement(argument))) {
         lowerer.refuseUnsupportedApi("'ReadableStream.from'", call);
     }
     const isMath = lowerer.stdlibGlobalMember(access, "Math") !== null;
@@ -1831,9 +1880,16 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
     // missing read, or the read itself) converts to NaN, ToNumber's answer
     // for undefined, instead of trusting the checker's number type.
     const mathArg = (a) => lowerToNumberArgument(lowerer, a);
-    if (staticMath && name === "hypot") {
-        const elems = call.arguments.map((a) => ts.isSpreadElement(a) ? lowerer.lowerExprExpecting(a.expression, arrayOf(F64)) : mathArg(a));
-        const spreads = call.arguments.flatMap((a, i) => (ts.isSpreadElement(a) ? [i] : []));
+    // Math.hypot, and Math.max/Math.min with a spread among other arguments
+    // (`Math.max(...xs, 5)`): the arguments in order, spreads flattened, as
+    // one number[] the runtime folds.
+    if (staticMath &&
+        (name === "hypot" ||
+            ((name === "max" || name === "min") &&
+                call.arguments.nodes.length > 1 &&
+                call.arguments.nodes.some(ts.isSpreadElement)))) {
+        const elems = call.arguments.nodes.map((a) => ts.isSpreadElement(a) ? lowerer.lowerExprExpecting(a.expression, arrayOf(F64)) : mathArg(a));
+        const spreads = call.arguments.nodes.flatMap((a, i) => (ts.isSpreadElement(a) ? [i] : []));
         const packed = {
             kind: "arrayLit",
             elems,
@@ -1841,9 +1897,10 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
             type: arrayOf(F64),
             loc,
         };
-        return { kind: "libCall", fn: staticMath.fn, args: [packed], type: F64, loc };
+        const fn = name === "max" ? "math.maxArr" : name === "min" ? "math.minArr" : staticMath.fn;
+        return { kind: "libCall", fn, args: [packed], type: F64, loc };
     }
-    if (staticMath && call.arguments.every((a) => !ts.isSpreadElement(a))) {
+    if (staticMath && call.arguments.nodes.every((a) => !ts.isSpreadElement(a))) {
         // Math.max/Math.min at ANY plain arity — Node's are variadic. The
         // spec's reduction is a left fold of the same NaN-poisoning
         // ±0-ordered scalar compare the two-arg form lowers to, so n
@@ -1854,30 +1911,29 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
         // arguments are the fold's seed: -Infinity for max, +Infinity for
         // min, exactly Node.
         if (name === "max" || name === "min") {
-            if (call.arguments.length === 0) {
+            if (call.arguments.nodes.length === 0) {
                 return { kind: "numLit", value: name === "max" ? -Infinity : Infinity, type: F64, loc };
             }
-            const args = call.arguments.map(mathArg);
+            const args = call.arguments.nodes.map(mathArg);
             let acc = args[0];
             for (let i = 1; i < args.length; i++) {
                 acc = { kind: "libCall", fn: staticMath.fn, args: [acc, args[i]], type: F64, loc };
             }
             return acc;
         }
-        if (call.arguments.length === staticMath.arity) {
-            const args = call.arguments.map(mathArg);
+        if (call.arguments.nodes.length === staticMath.arity) {
+            const args = call.arguments.nodes.map(mathArg);
             return { kind: "libCall", fn: staticMath.fn, args, type: F64, loc };
         }
     }
     // `Math.max(...xs)` / `Math.min(...xs)` over a number[]: a STATIC
-    // runtime fold (NaN poisons and ±0 follows JS ordering). This
-    // one-spread form lowers; mixed spread/positional argument lists keep
-    // the nest-calls fence.
+    // runtime fold (NaN poisons and ±0 follows JS ordering). Mixed
+    // spread/positional argument lists pack into one array above.
     if (isMath &&
         (name === "max" || name === "min") &&
-        call.arguments.length === 1 &&
-        ts.isSpreadElement(call.arguments[0])) {
-        const spread = call.arguments[0];
+        call.arguments.nodes.length === 1 &&
+        ts.isSpreadElement(call.arguments.nodes[0])) {
+        const spread = call.arguments.nodes[0];
         let src = lowerer.lowerExpr(spread.expression);
         // JavaScript array call results retain checked storage so aliases stay
         // shared. This read-only fold can extract the inferred numeric array.
@@ -1887,6 +1943,11 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
                 src = lowerer.coerceInto(spread.expression, src, inferred);
             }
         }
+        // A generator, or a class whose [Symbol.iterator] is a generator
+        // method, drains into the number[] the fold reads.
+        src = classGeneratorIterable(lowerer, src) ?? src;
+        if (src.type.kind === "generator")
+            src = generatorDrain(lowerer, src, F64, loc) ?? src;
         if (src.type.kind !== "array" || src.type.elem.kind !== "f64") {
             lowerer.unsupported("SC1090", spread, `spreading '${lowerer.fmt(src.type)}' into Math.${name} (only a number[] spreads)`);
         }
@@ -1899,7 +1960,7 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
         };
     }
     const mathFn = isMath ? own(STDLIB_SURFACE.math.fns, name) : undefined;
-    if (mathFn && call.arguments.length === mathFn.args.length) {
+    if (mathFn && call.arguments.nodes.length === mathFn.args.length) {
         lowerer.refuseUnsupportedApi(`'Math.${name}'`, call);
     }
     const kind = lowerer.mapTypeOf(lowerer.typeOf(access.expression))?.kind;
@@ -1908,7 +1969,7 @@ export function lowerStdlibMethodCall(lowerer, call, access) {
         : kind === "string"
             ? own(STDLIB_SURFACE.string, name)
             : undefined;
-    if (!entry || call.arguments.length !== entry.args.length)
+    if (!entry || call.arguments.nodes.length !== entry.args.length)
         return null;
     if (!lowerer.isStdlibMember(access))
         return null;
@@ -1975,11 +2036,11 @@ export function npmMemberFence(lowerer, access) {
  * npmPackageOf, also asked directly for import-alias bindings (whose
  * aliased symbol is the package's export). */
 export function npmPackageOfSymbol(lowerer, sym) {
-    const decls = sym ? lowerer.checker.declarationsOf(sym) : undefined;
+    const decls = sym ? sym.declarations : undefined;
     if (!decls || decls.length === 0)
         return null;
-    if (!decls.every((d) => lowerer.isNpmFile(d.getSourceFile())))
+    if (!decls.every((d) => lowerer.isNpmFile(ts.getSourceFileOfNode(d))))
         return null;
-    return npmPackageNameOf(decls[0].getSourceFile().fileName);
+    return npmPackageNameOf(ts.getSourceFileOfNode(decls[0]).fileName);
 }
 //# sourceMappingURL=lower-stdlib.js.map