@scriptc/compiler 0.1.6 → 0.1.7

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

@@ -1,8 +1,10 @@
 import * as ts from "../ts7/adapter.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
 import type { Lowerer } from "./lowerer.js";
 import { IrExpr, IrFunction, IrStmt, IrType, SrcLoc } from "../../ir/ir.js";
 import type { ScrDiagnostic } from "../../diagnostics/diagnostic.js";
 import { type ClassInfo } from "./lower-classes.js";
+export { bodyReadsArguments };
 /** How a parameter participates in CALL-SITE COMPLETION (the frontend
  * completes every call to the one full signature, so the IR and backends
  * stay count-exact — see docs/ir.md). `required` params must be passed;
@@ -423,15 +425,6 @@ export declare function lambdaSignature(lowerer: Lowerer, node: ts.ArrowFunction
         kind: "func";
     };
 };
-/** Does this function's OWN body read `arguments`? Nested plain functions
-   * and methods have their own `arguments` (the walk skips them); arrows
-   * see the enclosing one (the walk descends). Exported for the lowerer's
-   * dynFallbackType: tsgo does not synthesize the `arguments` rest
-   * parameter into inferred signatures (5.9.3 did — its param-count
-   * mismatch was the detector), so the 7 world asks the BODY directly. */
-export declare function bodyReadsArguments(fn: {
-    body?: ts.Node | undefined;
-}): boolean;
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */

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

@@ -4,6 +4,7 @@ import { InternalCompilerError } from "../../errors.js";
  * function/lambda lowering and signature collection, and monomorphizing
  * generic instantiation (bounded by MAX_GENERIC_INSTANCES). */
 import * as ts from "../ts7/adapter.js";
+import { bodyReadsArguments } from "../arguments-usage.js";
 import { lowerGenMethodCall } from "./lower-generators.js";
 import { BIGINT_T, BOOL, CAUGHT, DYN, F64, JSVAL, STRING, SYMBOL_T, UNDEFINED_T, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, canDynCheckTo, canMarshalTypedFuncIntoIsland, ffiClassType, ffiSourceParamTypes, funcOf, isFfiCallbackParam, isFfiContextParam, isFfiReleaseParam, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
 import { isJsSourceFile, isNodeEsmFile, locOf } from "../program.js";
@@ -33,6 +34,7 @@ import { countedFor, varRef } from "../../ir/build.js";
 import { rejectStaticThis } from "./static-this.js";
 import { fenceNodeModuleMutationCall, lowerRequireCacheKeys } from "./lower-node-module.js";
 import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, positionNumber } from "./optional-arguments.js";
+export { bodyReadsArguments };
 /** The one func-type projection of completed parameter shapes. Typed rest
  * parameters keep their packed array as the trailing native ABI slot and
  * mark the value variadic so indirect call sites run completeArgs before
@@ -6349,31 +6351,6 @@ export function lambdaSignature(lowerer, node) {
         funcType.rest = true;
     return { shapes, funcType };
 }
-/** Does this function's OWN body read `arguments`? Nested plain functions
-   * and methods have their own `arguments` (the walk skips them); arrows
-   * see the enclosing one (the walk descends). Exported for the lowerer's
-   * dynFallbackType: tsgo does not synthesize the `arguments` rest
-   * parameter into inferred signatures (5.9.3 did — its param-count
-   * mismatch was the detector), so the 7 world asks the BODY directly. */
-export function bodyReadsArguments(fn) {
-    let found = false;
-    if (fn.body === undefined)
-        return false;
-    // Iterative walk (walkPreorder): function bodies can hold pathologically
-    // deep expression chains that a recursive visit would die on.
-    ts.walkPreorder(fn.body, (n) => {
-        if (ts.isIdentifier(n) && n.text === "arguments" && !(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n)) {
-            found = true;
-            return "stop";
-        }
-        if ((ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n) || ts.isMethodDeclaration(n)) &&
-            n !== fn) {
-            return "skip"; // own `arguments` scope
-        }
-        return undefined;
-    });
-    return found;
-}
 /** Lifts an arrow function / function expression / nested declaration /
    * object-literal shorthand method to a module-level function and yields
    * the `closure` expression creating it. */
@@ -6569,9 +6546,8 @@ export function lowerLambda(lowerer, node) {
    * becomes the catch binding, and a handler VALUE would need a
    * caught-typed closure parameter, which cannot exist. finally takes
    * any () => void closure (its callback sees no arguments). then takes
-   * exactly one FULFILLMENT handler (any closure value of the settled
-   * value's type — the two-argument onRejected form stays fenced toward
-   * .catch); a promise-returning handler flattens through the async
+   * a fulfillment handler and optionally a rejection handler; a
+   * promise-returning handler flattens through the async
    * return path, a receiver rejection passes through untouched (the
    * wrapper's await re-throws it), and a handler throw rejects the
    * result — the spec's onFulfilled rules by construction. Null for
@@ -6670,9 +6646,9 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
     };
     const passthrough = call.arguments.length === 0 ||
         (call.arguments.length === 1 && isAbsentHandler(call.arguments[0]));
-    if (call.arguments.length !== 1 && !passthrough) {
+    if (call.arguments.length !== 1 && !passthrough && !(member === "then" && call.arguments.length === 2)) {
         lowerer.noLowering(`${member} with ${call.arguments.length} arguments`, call, member === "then"
-            ? "the supported form takes exactly one fulfillment handler — chain .catch(...) for the rejection half"
+            ? "the supported form takes a fulfillment handler and an optional rejection handler"
             : `the supported form takes exactly one ${member === "catch" ? "inline handler" : "callback"}`);
     }
     // The receiver evaluates FIRST, in the enclosing function, like JS.
@@ -6744,6 +6720,140 @@ export function lowerPromiseMethodCall(lowerer, call, access) {
         }
     }
     if (member === "then") {
+        if (call.arguments.length === 2) {
+            const fulfilledNode = call.arguments[0];
+            const rejectedNode = call.arguments[1];
+            const fulfilledAbsent = isAbsentHandler(fulfilledNode);
+            const rejectedAbsent = isAbsentHandler(rejectedNode);
+            const resultT = lowerer.mapTypeOf(lowerer.typeOf(call));
+            if (resultT?.kind !== "promise") {
+                lowerer.noLowering("then with these handlers", call, "the result must be a representable promise");
+            }
+            const R = resultT.inner;
+            if (!fulfilledAbsent && inner.kind === "jsval")
+                markJsvalHandlerParams(lowerer, fulfilledNode);
+            if (!fulfilledAbsent && inner.kind === "moduleNs")
+                markModuleNsHandlerParams(lowerer, fulfilledNode, inner);
+            const boxHandler = (node, allowDirect) => {
+                const value = lowerer.lowerExpr(node);
+                if (allowDirect && value.type.kind === "func" && value.type.params.length <= 1 &&
+                    (value.type.params.length === 0 || (inner.kind !== "void" && typeEquals(value.type.params[0], inner)))) {
+                    return { value, direct: true, returnsPromise: value.type.ret.kind === "promise" };
+                }
+                if (value.type.kind === "dyn")
+                    return { value, direct: false, returnsPromise: false };
+                if (value.type.kind === "func" && value.type.params.length <= 1 &&
+                    canBoxFuncIntoDyn(value.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))) {
+                    return { value: { kind: "dynFrom", value, type: DYN, loc }, direct: false, returnsPromise: value.type.ret.kind === "promise" };
+                }
+                lowerer.unsupported("SC1090", node, "then handlers that cannot be called with one value");
+            };
+            // Evaluate both callback expressions before the wrapper runs, in source order.
+            const fulfilled = fulfilledAbsent ? null : boxHandler(fulfilledNode, true);
+            const rejected = rejectedAbsent ? null : boxHandler(rejectedNode, false);
+            const fnName = `%fn${lowerer.lambdaCounter++}_then2`;
+            const paramTypes = [promT, ...(fulfilled ? [fulfilled.value.type] : []), ...(rejected ? [DYN] : [])];
+            const funcType = { kind: "func", params: paramTypes, ret: resultT };
+            const fnCtx = newFnCtx(true, null, funcType, R);
+            fnCtx.isAsync = true;
+            lowerer.fnStack.push(fnCtx);
+            try {
+                const pLocal = lowerer.declareHiddenLocal("p", promT);
+                const fLocal = fulfilled ? lowerer.declareHiddenLocal("f", fulfilled.value.type) : null;
+                const rLocal = rejected ? lowerer.declareHiddenLocal("r", DYN) : null;
+                const eLocal = lowerer.declareHiddenLocal("e", CAUGHT);
+                const vLocal = inner.kind === "void" ? null : lowerer.declareHiddenLocal("v", inner);
+                const awaitE = {
+                    kind: "awaitExpr",
+                    value: { kind: "varRef", localId: pLocal.id, type: promT, loc },
+                    type: inner,
+                    loc,
+                };
+                const tryBody = vLocal
+                    ? [{ kind: "varDecl", localId: vLocal.id, init: awaitE, loc }]
+                    : [{ kind: "exprStmt", expr: awaitE, loc }];
+                const resultOf = (value, returnsPromise = false) => {
+                    const settled = value.type.kind === "promise"
+                        ? { kind: "awaitExpr", value, type: value.type.inner, loc }
+                        : returnsPromise
+                            ? { kind: "libCall", fn: "async.awaitDyn", args: [value], type: DYN, loc }
+                            : value;
+                    return R.kind === "void"
+                        ? [{ kind: "exprStmt", expr: settled, loc }, { kind: "return", value: null, loc }]
+                        : [{ kind: "return", value: lowerer.coerceInto(call, settled, R), loc }];
+                };
+                const rejectedCall = rLocal ? {
+                    kind: "dynCall",
+                    callee: { kind: "varRef", localId: rLocal.id, type: DYN, loc },
+                    calleeName: jsFuncNameOf(rejectedNode) ?? "onRejected",
+                    args: [{ kind: "caughtToDyn", value: { kind: "varRef", localId: eLocal.id, type: CAUGHT, loc }, type: DYN, loc }],
+                    type: DYN,
+                    loc,
+                } : null;
+                const catchBody = rejectedCall
+                    ? resultOf(rejectedCall, rejected?.returnsPromise)
+                    : [{ kind: "rethrow", localId: eLocal.id, loc }];
+                const body = [{ kind: "tryCatch", tryBody, catchBody, catchLocalId: eLocal.id, finallyBody: null, loc }];
+                // The fulfillment callback sits after the catch so a throw from it
+                // rejects the result instead of reaching onRejected.
+                if (fLocal) {
+                    const settled = vLocal
+                        ? { kind: "varRef", localId: vLocal.id, type: inner, loc }
+                        : dynUndefinedExpr(loc);
+                    if (fulfilled.direct && fLocal.type.kind === "func") {
+                        body.push(...resultOf({
+                            kind: "callValue",
+                            callee: { kind: "varRef", localId: fLocal.id, type: fLocal.type, loc },
+                            args: fLocal.type.params.length === 0 ? [] : [settled],
+                            type: fLocal.type.ret,
+                            loc,
+                        }));
+                    }
+                    else {
+                        const arg = settled.type.kind === "dyn" ? settled
+                            : canConvertToDyn(settled.type, (id) => lowerer.shapes.get(id), (id) => lowerer.unions.get(id))
+                                ? { kind: "dynFrom", value: settled, type: DYN, loc }
+                                : lowerer.unsupported("SC1090", fulfilledNode, "then fulfillment values that cannot cross the checked-dynamic boundary");
+                        body.push(...resultOf({
+                            kind: "dynCall",
+                            callee: { kind: "varRef", localId: fLocal.id, type: DYN, loc },
+                            calleeName: jsFuncNameOf(fulfilledNode) ?? "onFulfilled",
+                            args: [arg], type: DYN, loc,
+                        }, fulfilled?.returnsPromise));
+                    }
+                }
+                else if (vLocal) {
+                    body.push(...resultOf({ kind: "varRef", localId: vLocal.id, type: inner, loc }));
+                }
+                else if (R.kind === "void") {
+                    body.push({ kind: "return", value: null, loc });
+                }
+                else {
+                    body.push({ kind: "return", value: lowerer.coerceInto(call, dynUndefinedExpr(loc), R), loc });
+                }
+                const ctx = lowerer.ctx;
+                const lifted = {
+                    name: fnName,
+                    params: [
+                        { localId: pLocal.id, name: pLocal.name, type: promT },
+                        ...(fLocal ? [{ localId: fLocal.id, name: fLocal.name, type: fLocal.type }] : []),
+                        ...(rLocal ? [{ localId: rLocal.id, name: rLocal.name, type: DYN }] : []),
+                    ],
+                    returnType: R,
+                    locals: ctx.locals,
+                    captures: ctx.captures,
+                    body,
+                    loc,
+                    async: true,
+                };
+                lowerer.liftedFns.push(lifted);
+                const closure = { kind: "closure", fnName, captures: ctx.captureSources, type: funcType, loc };
+                return { kind: "callValue", callee: closure, args: [receiver, ...(fulfilled ? [fulfilled.value] : []), ...(rejected ? [rejected.value] : [])], type: resultT, loc };
+            }
+            finally {
+                lowerer.fnStack.pop();
+            }
+        }
         // The settled value is an island HANDLE: an inline handler's
         // unannotated parameter binds it as jsval, whatever the checker's
         // contextual type spelled (a module-namespace type has no mapping —