@scriptc/compiler 0.0.22 → 0.0.24

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

@@ -971,7 +971,7 @@ export function fenceUnsupportedFetchConstructorMember(L, access) {
     const member = members.find((candidate) => fetchInventoryStatus("Response", candidate, "static") === "unsupported");
     if (member === undefined)
         return null;
-    L.noLowering(`Response.${member}`, access, "Response constructor-object operations have no compiler lowering in either tier");
+    L.noLowering(`Response.${member}`, access, "Response static constructor-object operations have no compiler lowering in either tier");
 }
 function hasLiveWebMutableArm(L, type) {
     if (type.kind === "record" ||
@@ -988,8 +988,8 @@ function hasLiveWebMutableArm(L, type) {
  * this capsule is deliberately limited to records/arrays/bytes (including
  * those selected at runtime from a union) that the live materializer can
  * snapshot and commit. */
-function lowerLiveWebValue(L, node) {
-    const value = L.lowerExpr(node);
+function lowerLiveWebValue(L, node, lowered) {
+    const value = lowered ?? L.lowerExpr(node);
     if (hasLiveWebMutableArm(L, value.type) &&
         canConvertToDyn(value.type, (id) => L.shapes.get(id), (id) => L.unions.get(id))) {
         return {
@@ -1069,6 +1069,22 @@ export function fenceStaticHeadersMember(L, access, use) {
     }
     L.noLowering(`Headers.${member} in a static build`, access, "the native static Headers surface is append/delete/get/getSetCookie/has/set/forEach; use keys()/values()/entries() or symbol-keyed iteration with --dynamic, while construction remains unsupported", sym);
 }
+/** The native AbortController handle dispatches `abort()` directly and
+ * exposes `.signal` as data, but it has no first-class function value for
+ * the prototype method. Fence method extraction before the checked-dynamic
+ * keyed-read fallback can silently answer `undefined`. Dynamic builds use
+ * the engine's real AbortController object and retain ordinary method reads. */
+export function fenceStaticAbortControllerMemberRead(L, access) {
+    if (L.dynamic)
+        return null;
+    const symbol = isStdlibFetchInterface(L, access.expression, "AbortController");
+    if (!symbol)
+        return null;
+    const members = fetchAccessMemberNames(L, access);
+    if (members === null || !members.includes("abort"))
+        return null;
+    L.noLowering("AbortController.abort through method extraction in a static build", access, "call controller.abort(...) directly; the native AbortController handle does not expose abort as a first-class function value", symbol);
+}
 function isStdlibFetchInterface(L, node, owner) {
     const type = L.checker.getBaseTypeOfLiteralType(L.typeOf(node));
     for (const symbol of [type.getSymbol(), type.getAliasSymbol()]) {
@@ -1525,17 +1541,17 @@ export function fenceStaticReadableStreamMember(L, access, use) {
  * ambient globals have no first-class constructor-object representation;
  * claim the direct calls by declaration provenance before the general
  * member-call path tries to lower the receiver as a value. */
-function staticCallWithSurplusArgs(L, call, first, result) {
+function staticFirstArgWithSurplusArgs(L, call, first) {
     const loc = locOf(call);
-    if (call.arguments.length === 1)
-        return result(first);
+    if (call.arguments.length <= 1)
+        return first;
     const firstLocal = L.declareHiddenLocal("%fetchArg", first.type);
-    const firstRef = () => ({
+    const firstRef = {
         kind: "varRef",
         localId: firstLocal.id,
         type: first.type,
         loc,
-    });
+    };
     const stmts = [
         { kind: "varDecl", localId: firstLocal.id, init: first, loc },
     ];
@@ -1551,8 +1567,16 @@ function staticCallWithSurplusArgs(L, call, first, result) {
             : L.lowerExpr(argument);
         stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
     }
-    const answer = result(firstRef());
-    return { kind: "seqExpr", stmts, result: answer, type: answer.type, loc };
+    return {
+        kind: "seqExpr",
+        stmts,
+        result: firstRef,
+        type: first.type,
+        loc,
+    };
+}
+function staticCallWithSurplusArgs(L, call, first, result) {
+    return result(staticFirstArgWithSurplusArgs(L, call, first));
 }
 export function lowerStaticFetchCompanionCall(L, call) {
     if (L.dynamic ||
@@ -1668,6 +1692,46 @@ export function lowerStaticFetchCompanionCall(L, call) {
     }
     return null;
 }
+/** `AbortController.abort(reason?)` mutates the native signal shared with
+ * `.signal` and fetch. Preserve a mutable reason's identity just like
+ * `AbortSignal.abort(reason)`; surplus arguments still evaluate in order and
+ * are ignored by the runtime operation. */
+export function lowerStaticAbortControllerCall(L, call) {
+    const access = call.expression;
+    if (L.dynamic ||
+        call.questionDotToken ||
+        call.arguments.some((argument) => ts.isSpreadElement(argument)) ||
+        (!ts.isPropertyAccessExpression(access) &&
+            !ts.isElementAccessExpression(access)) ||
+        access.questionDotToken ||
+        staticResponseMemberName(L, access) !== "abort") {
+        return null;
+    }
+    const receiverTs = L.checker.getBaseTypeOfLiteralType(L.typeOf(access.expression));
+    const symbol = receiverTs.getAliasSymbol() ?? receiverTs.getSymbol();
+    if (symbol?.name !== "AbortController" ||
+        !L.checker.declarationsOf(symbol).some((d) => ts.isInterfaceDeclaration(d) &&
+            L.isStdlibFile(d.getSourceFile()))) {
+        return null;
+    }
+    const receiver = L.lowerExpr(access.expression);
+    if (receiver.type.kind !== "dyn")
+        return null;
+    const loc = locOf(call);
+    const first = call.arguments[0]
+        ? lowerLiveWebValue(L, call.arguments[0])
+        : dynUndefinedExpr(loc);
+    const args = [staticFirstArgWithSurplusArgs(L, call, first)];
+    return lowerStaticFixedFetchMethodCall(L, call, access, "abort", receiver, args, (receiverRef, argumentRefs) => ({
+        kind: "dynInvoke",
+        recv: receiverRef,
+        method: "abort",
+        calleeName: access.getText(),
+        args: argumentRefs,
+        type: DYN,
+        loc,
+    }));
+}
 /** Controller chunks and error reasons are dyn-handle calls, but unlike a
  * general checked-dynamic boundary the Web Streams contract preserves their
  * object identity for the reader/source callbacks that observe them. */
@@ -1792,6 +1856,60 @@ export function lowerStaticAbortSignalListenerCall(L, call) {
         loc,
     }));
 }
+/** `new AbortController()`. Static builds create a native controller handle
+ * over the same signal state consumed by fetch; dynamic builds construct the
+ * island Web object. JavaScript accepts surplus constructor arguments, so
+ * both tiers evaluate them even though AbortController ignores their values. */
+export function lowerAbortControllerNew(L, expr) {
+    if (!ts.isIdentifier(expr.expression) ||
+        expr.expression.text !== "AbortController") {
+        return null;
+    }
+    const symbol = L.resolveValueSymbol(expr.expression);
+    if (!symbol || !L.isStdlibSymbol(symbol))
+        return null;
+    const args = expr.arguments ?? [];
+    if (args.some((argument) => ts.isSpreadElement(argument)))
+        return null;
+    const loc = locOf(expr);
+    if (L.dynamic) {
+        const ctor = {
+            kind: "jsOp",
+            op: "globalGet",
+            name: "AbortController",
+            args: [],
+            type: JSVAL,
+            loc,
+        };
+        return {
+            kind: "jsOp",
+            op: "construct",
+            args: [ctor, ...args.map((argument) => L.jsvalIn(L.lowerExpr(argument), argument))],
+            type: JSVAL,
+            loc,
+        };
+    }
+    const result = {
+        kind: "libCall",
+        fn: "fetch.abortControllerNew",
+        args: [],
+        type: DYN,
+        loc,
+    };
+    if (args.length === 0)
+        return result;
+    return {
+        kind: "seqExpr",
+        stmts: args.map((argument) => ({
+            kind: "exprStmt",
+            expr: L.lowerExpr(argument),
+            loc: locOf(argument),
+        })),
+        result,
+        type: DYN,
+        loc,
+    };
+}
 /** `new ReadableStream(source?)`. Static builds box the source record into
  * the checked-dynamic tree; dynamic builds construct the island's Web
  * stream directly so the returned handle composes with dynamic fetch. */
@@ -1842,6 +1960,162 @@ export function lowerStaticReadableStreamNew(L, expr) {
         loc,
     };
 }
+/** `new Response(body?, init?)`. Dynamic builds construct the island's
+ * Web Response directly. Static builds hand a checked-dynamic BodyInit and
+ * ResponseInit snapshot to the native fetch runtime, which returns the same
+ * opaque Response handle as fetch(). */
+export function lowerResponseNew(L, expr) {
+    if (!ts.isIdentifier(expr.expression) ||
+        expr.expression.text !== "Response") {
+        return null;
+    }
+    const symbol = L.resolveValueSymbol(expr.expression);
+    if (!symbol || !L.isStdlibSymbol(symbol))
+        return null;
+    const args = expr.arguments ?? [];
+    if (args.some(ts.isSpreadElement))
+        return null;
+    const loc = locOf(expr);
+    if (L.dynamic) {
+        const ctor = {
+            kind: "jsOp",
+            op: "globalGet",
+            name: "Response",
+            args: [],
+            type: JSVAL,
+            loc,
+        };
+        const lowered = args.map((arg) => ts.isObjectLiteralExpression(arg)
+            ? lowerIslandObjectLiteral(L, arg)
+            : L.jsvalIn(L.lowerExpr(arg), arg));
+        return {
+            kind: "jsOp",
+            op: "construct",
+            args: [ctor, ...lowered],
+            type: JSVAL,
+            loc,
+        };
+    }
+    const toDyn = (node, value, what) => {
+        if (node === undefined)
+            return dynUndefinedExpr(loc);
+        if (value.type.kind === "dyn")
+            return value;
+        /* 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
+         * deliberately declines accessors/methods, whose observable reads
+         * cannot be moved into the runtime WebIDL conversion phase. */
+        if (what === "an init value" && value.type.kind === "object") {
+            const sourceType = L.typeOf(node);
+            const fields = [];
+            for (const name of ["headers", "status", "statusText"]) {
+                const property = L.checker.getPropertyOfType(sourceType, name);
+                if (!property)
+                    continue;
+                const propertyType = L.checker.getTypeOfSymbolAtLocation(property, node);
+                const mapped = L.mapTypeOf(propertyType);
+                if (!mapped || mapped.kind === "void") {
+                    L.noLowering(`new Response with ${what} of type '${L.fmt(value.type)}'`, node, `the '${name}' field does not have a checked-dynamic representation`);
+                }
+                fields.push({ name, type: mapped });
+            }
+            const recordType = {
+                kind: "record",
+                shapeId: L.shapes.intern(fields, false, undefined, fields.map((field) => field.name)),
+            };
+            const projected = L.widthCoerce(value, recordType);
+            if (projected && L.dynConvertible(projected.type)) {
+                return {
+                    kind: "dynFrom",
+                    value: projected,
+                    liveRef: true,
+                    type: DYN,
+                    loc: value.loc,
+                };
+            }
+        }
+        if (value.kind === "unitLit" || L.dynConvertible(value.type)) {
+            if (what === "an init value" &&
+                hasLiveWebMutableArm(L, value.type)) {
+                return {
+                    kind: "dynFrom",
+                    value,
+                    liveRef: true,
+                    type: DYN,
+                    loc: value.loc,
+                };
+            }
+            return {
+                kind: "dynFrom",
+                value,
+                type: DYN,
+                loc: value.loc,
+            };
+        }
+        L.noLowering(`new Response with ${what} of type '${L.fmt(value.type)}'`, node, "the static constructor accepts string, Uint8Array, ReadableStream, null, and the declared ResponseInit dictionary");
+    };
+    const bodyNode = args[0];
+    const body = bodyNode === undefined
+        ? { kind: "unitLit", unit: "undefined", type: { kind: "undefinedT" }, loc }
+        : L.lowerExpr(bodyNode);
+    const initNode = args[1];
+    const init = initNode === undefined
+        ? { kind: "unitLit", unit: "undefined", type: { kind: "undefinedT" }, loc }
+        : ts.isObjectLiteralExpression(initNode)
+            ? lowerDynObjectLiteral(L, initNode, (node, value) => lowerLiveWebValue(L, node, value))
+            : L.lowerExpr(initNode);
+    /* JavaScript evaluates every argument expression before WebIDL starts
+     * converting either BodyInit or ResponseInit. Capture the raw values in
+     * source order; only the final libCall boxes the body and gives typed init
+     * values a live capsule for the runtime's later dictionary reads. This is
+     * observable when argument evaluation or BodyInit coercion mutates a
+     * Uint8Array body or a typed ResponseInit record. Unit-valued expressions
+     * still execute, then contribute the corresponding undefined/null literal. */
+    const stmts = [];
+    const capture = (value, name) => {
+        if (isUnitType(value.type) || value.type.kind === "void") {
+            if (value.kind !== "unitLit") {
+                stmts.push({ kind: "exprStmt", expr: value, loc: value.loc });
+            }
+            return value.type.kind === "nullT"
+                ? { kind: "unitLit", unit: "null", type: value.type, loc: value.loc }
+                : {
+                    kind: "unitLit",
+                    unit: "undefined",
+                    type: { kind: "undefinedT" },
+                    loc: value.loc,
+                };
+        }
+        const local = L.declareHiddenLocal(name, value.type);
+        stmts.push({ kind: "varDecl", localId: local.id, init: value, loc: value.loc });
+        return {
+            kind: "varRef",
+            localId: local.id,
+            type: local.type,
+            loc: value.loc,
+        };
+    };
+    const bodyRef = capture(body, "%responseBody");
+    const initRef = capture(init, "%responseInit");
+    for (const argument of args.slice(2)) {
+        const discarded = ts.isVoidExpression(argument)
+            ? L.lowerExpr(argument.expression)
+            : L.lowerExpr(argument);
+        stmts.push({ kind: "exprStmt", expr: discarded, loc: discarded.loc });
+    }
+    const result = {
+        kind: "libCall",
+        fn: "fetch.responseNew",
+        args: [
+            toDyn(bodyNode, bodyRef, "a body"),
+            toDyn(initNode, initRef, "an init value"),
+        ],
+        type: DYN,
+        loc,
+    };
+    return { kind: "seqExpr", stmts, result, type: DYN, loc };
+}
 /** A static default reader's read() exits the native checked-dynamic
  * transport into the checker's concrete chunk type. An exact chunk type
  * preserves ReadableStream.from(array)'s element identity; structural