@scriptc/compiler 0.2.7 → 0.2.8

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

@@ -5,6 +5,7 @@ import { lowerArrayCallbackCall } from "./containers/array-callback-call.js";
  * own owners; this module selects the applicable call path. */
 import { dynUndefinedExpr, nodeThrowExpr, countedFor, numLit, varRef } from "../../ir/build.js";
 import { lowerBuiltinCall } from "./builtin-calls.js";
+import { threadsImportOf } from "../threads-import.js";
 import { adaptZeroArgTimerCallback, lowerTimersMemberCall, TIMER_MODULE_MEMBERS, } from "./lower-timers.js";
 import { objectEnumerationReceiver } from "./object-enumeration-receiver.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -335,7 +336,7 @@ export function lowerCall(lowerer, expr) {
             // inspect distinction, per arm), Maps/Sets, plain undefined/null,
             // regexes, symbols, error values, Buffers. Shapes inspect cannot
             // render fence honestly with the reason.
-            return lowerConsoleInspectArg(lowerer, a, lowered, surface, loc);
+            return lowerConsoleInspectArg(lowerer, a, lowerer.deferredFieldSlot(lowered) ?? lowered, surface, loc);
         });
         return withReceiver({
             kind: "intrinsic",
@@ -795,6 +796,14 @@ export function lowerCall(lowerer, expr) {
             if (rf)
                 return lowerHttpClientFnCall(lowerer, expr, rf, loc);
         }
+        if (threadsImportOf(lowerer.program, expr.expression) === "publish") {
+            // @scriptc/threads publish(value): the same value, its graph made
+            // immortal and immutable (backend/llvm/publish.ts).
+            if (expr.arguments.length !== 1 || ts.isSpreadElement(expr.arguments[0]))
+                lowerer.noLowering(`publish with ${expr.arguments.length} arguments`, expr);
+            const value = lowerer.lowerExpr(expr.arguments[0]);
+            return { kind: "intrinsic", name: "threads.publish", args: [value], type: value.type, loc };
+        }
         const bi = lowerer.builtinImportOf(expr.expression);
         if (bi)
             return lowerBuiltinCall(lowerer, expr, bi, loc);
@@ -850,138 +859,14 @@ export function lowerCall(lowerer, expr) {
         // checker-pinned (or checked) to number, where the global's ToNumber
         // coercion is the identity and the tests are Number.isNaN /
         // Number.isFinite exactly (ms's `isFinite(val)` guard).
-        if ((expr.expression.text === "parseInt" || expr.expression.text === "isNaN") &&
+        if ((expr.expression.text === "parseInt" ||
+            expr.expression.text === "isNaN" ||
+            expr.expression.text === "parseFloat" ||
+            expr.expression.text === "isFinite") &&
             lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            const name = expr.expression.text;
-            const maxArgs = name === "parseInt" ? 2 : 1;
-            if (expr.arguments.length < 1 || expr.arguments.length > maxArgs) {
-                lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
-            }
-            if (name === "isNaN") {
-                const x = lowerer.lowerExprExpecting(expr.arguments[0], F64);
-                return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
-            }
-            const radix = expr.arguments[1]
-                ? lowerer.lowerExprExpecting(expr.arguments[1], F64)
-                : { kind: "numLit", value: 0, type: F64, loc };
-            const optional = optionalCallValue(lowerer, expr.arguments[0]);
-            if (optional?.type.kind === "union") {
-                const def = lowerer.unions.get(optional.type.unionId);
-                const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
-                if (def &&
-                    stringTag >= 0 &&
-                    def.arms.every((arm) => arm.kind === "string" || isUnitType(arm))) {
-                    const unionT = optional.type;
-                    const key = `parseInt.optional:${unionT.unionId}`;
-                    let helper = lowerer.valueHelpers.get(key);
-                    if (!helper) {
-                        helper = `%parseInt.optional.${lowerer.valueHelpers.size}`;
-                        lowerer.valueHelpers.set(key, helper);
-                        const value = { kind: "varRef", localId: "value.0", type: unionT, loc };
-                        const radixRef = { kind: "varRef", localId: "radix.0", type: F64, loc };
-                        const body = def.arms.flatMap((arm, tag) => isUnitType(arm)
-                            ? [
-                                {
-                                    kind: "if",
-                                    cond: {
-                                        kind: "unionIsTag",
-                                        unionId: unionT.unionId,
-                                        tag,
-                                        negated: false,
-                                        value,
-                                        type: BOOL,
-                                        loc,
-                                    },
-                                    then: [
-                                        {
-                                            kind: "return",
-                                            value: { kind: "numLit", value: NaN, type: F64, loc },
-                                            loc,
-                                        },
-                                    ],
-                                    else_: null,
-                                    loc,
-                                },
-                            ]
-                            : []);
-                        body.push({
-                            kind: "return",
-                            value: {
-                                kind: "libCall",
-                                fn: "num.parseInt",
-                                args: [
-                                    {
-                                        kind: "unionNarrow",
-                                        unionId: unionT.unionId,
-                                        tag: stringTag,
-                                        value,
-                                        type: STRING,
-                                        loc,
-                                    },
-                                    radixRef,
-                                ],
-                                type: F64,
-                                loc,
-                            },
-                            loc,
-                        });
-                        lowerer.liftedFns.push({
-                            name: helper,
-                            params: [
-                                { localId: "value.0", name: "value", type: unionT },
-                                { localId: "radix.0", name: "radix", type: F64 },
-                            ],
-                            returnType: F64,
-                            locals: [
-                                { id: "value.0", name: "value", type: unionT, mutable: true },
-                                { id: "radix.0", name: "radix", type: F64, mutable: true },
-                            ],
-                            body,
-                            loc,
-                        });
-                    }
-                    return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
-                }
-            }
-            const s = lowerer.lowerExprExpecting(expr.arguments[0], STRING);
-            return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
-        }
-        // STATIC parseFloat/isFinite over exactly-typed arguments —
-        // parseInt's siblings (num.parseFloat is ECMA 19.2.4's decimal-
-        // literal prefix parse in scr_string.c; a number-typed isFinite IS
-        // Number.isFinite — the global's ToNumber coercion is the identity
-        // there, ms's `isFinite(val)` guard). Other argument types fall
-        // through to today's island path (--dynamic) or its SC2012 fence:
-        // the ToNumber/ToString coercions on arbitrary values stay engine
-        // territory. The probe never emits — lowering is IR construction.
-        if ((expr.expression.text === "parseFloat" || expr.expression.text === "isFinite") &&
-            expr.arguments.length === 1 &&
-            lowerer.isStdlibSymbol(lowerer.resolveValueSymbol(expr.expression) ?? undefined)) {
-            const name = expr.expression.text;
-            if (name === "parseFloat") {
-                const optional = optionalCallValue(lowerer, expr.arguments[0]);
-                if (optional) {
-                    const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
-                    if (parsed)
-                        return parsed;
-                }
-            }
-            const probed = tryLowerExpression(lowerer, expr.arguments[0]);
-            if (name === "parseFloat" && probed?.type.kind === "string") {
-                return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
-            }
-            if (name === "parseFloat" && probed?.type.kind === "dyn") {
-                return {
-                    kind: "libCall",
-                    fn: "num.parseFloat",
-                    args: [{ kind: "libCall", fn: "dyn.toStringCoerce", args: [probed], type: STRING, loc }],
-                    type: F64,
-                    loc,
-                };
-            }
-            if (name === "isFinite" && probed?.type.kind === "f64") {
-                return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
-            }
+            const parsed = lowerStaticNumberGlobal(lowerer, expr.expression.text, expr, expr.arguments, loc);
+            if (parsed !== null)
+                return parsed;
         }
         // STATIC encodeURIComponent/encodeURI/decodeURIComponent
         // (str.encodeUriComponent / str.encodeUri / str.decodeUriComponent —
@@ -1074,7 +959,16 @@ export function lowerCall(lowerer, expr) {
             lowerer.noLowering(`${name} with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr);
         }
         if (islFn && expr.arguments.length === islFn.args.length) {
-            lowerer.requireDynamicApi(`'${expr.expression.text}'`, expr);
+            // The static forms above already took the exactly-typed argument
+            // (a string for parseFloat, a number for isFinite): name the
+            // argument type that sent this call to the engine, so the message
+            // states the condition rather than reading as if the global itself
+            // were unsupported.
+            const argText = lowerer.dynamic ? "" : loweredArgumentText(lowerer, expr.arguments[0]);
+            const exact = expr.expression.text === "isFinite" ? "number" : "string";
+            lowerer.requireDynamicApi(`'${expr.expression.text}' with a '${argText}' argument (only a ${exact} argument compiles statically)`, expr, exact === "string"
+                ? "convert the argument explicitly first (for example String(x), or narrow the union), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)"
+                : "narrow the argument to a number first (isFinite over a number compiles statically), or build with --dynamic to run the coercing call in the embedded engine (adds ~620KB to the binary)");
             const callee = {
                 kind: "jsOp",
                 op: "globalGet",
@@ -1889,13 +1783,7 @@ function lowerBufferStaticCallWithNarrowedArg(lowerer, call, access) {
     }
     const narrowedValue = {
         ...lowered,
-        source: {
-            kind: "call",
-            callee: helper,
-            args: [lowered.source],
-            type: narrowed,
-            loc: lowered.source.loc,
-        },
+        source: lowerer.checkedNarrowCall(helper, lowered.source, narrowed, lowered.source.loc),
     };
     return branded ? { ...branded, args: [narrowedValue] } : narrowedValue;
 }
@@ -4286,7 +4174,7 @@ function reconcileOverloadReturn(lowerer, expr, call) {
     if (call.type.kind === "union" && rt.kind !== "union") {
         const helper = lowerer.narrowedArmHelper(call.type.unionId, rt, call.loc);
         if (helper)
-            return { kind: "call", callee: helper, args: [call], type: rt, loc: call.loc };
+            return lowerer.checkedNarrowCall(helper, call, rt, call.loc);
     }
     return lowerer.coerceInto(expr, call, rt);
 }
@@ -7115,9 +7003,12 @@ function lowerObjectStaticCall(lowerer, call, access) {
         return lowerObjectIterOverIndexShape(lowerer, call, member, argIr, shape);
     }
     const loc = locOf(call);
-    const resultT = lowerer.irTypeOf(call);
-    if (resultT.kind !== "array")
+    const checkedT = lowerer.irTypeOf(call);
+    if (checkedT.kind !== "array")
         lowerer.badType(call, lowerer.typeOf(call)); // defensive
+    const resultT = member === "entries" && consumesEntryPairs(call)
+        ? runtimeOptionalEntriesType(lowerer, argIr, checkedT)
+        : checkedT;
     const receiver = objectEnumerationReceiver(lowerer, lowerer.lowerExpr(argNode), argIr, loc);
     if (member === "keys") {
         // The keys walk is shared with for-in (which iterates exactly the
@@ -7337,6 +7228,53 @@ function lowerObjectStaticCall(lowerer, call, access) {
     }
     return { kind: "call", callee: helper, args: [receiver], type: resultT, loc };
 }
+/** An entries array consumed pair by pair right where it is built: a
+ * for-of loop or an array callback method. These consumers bind each pair
+ * from the array's own layout, so the pair's value slot can keep a
+ * runtime-optional field's undefined arm. */
+function consumesEntryPairs(call) {
+    let node = call;
+    while (ts.isParenthesizedExpression(node.parent))
+        node = node.parent;
+    const parent = node.parent;
+    if (ts.isForOfStatement(parent))
+        return parent.expression === node;
+    return (ts.isPropertyAccessExpression(parent) &&
+        parent.expression === node &&
+        ENTRY_PAIR_CALLBACK_METHODS.has(parent.name.text) &&
+        ts.isCallExpression(parent.parent) &&
+        parent.parent.expression === parent);
+}
+const ENTRY_PAIR_CALLBACK_METHODS = new Set([
+    "every",
+    "filter",
+    "find",
+    "findIndex",
+    "flatMap",
+    "forEach",
+    "map",
+    "some",
+]);
+/** The entries array of a record whose runtime-optional fields (unchecked
+ * indexed reads the checker calls present) can hold undefined: the pair's
+ * value slot gains the undefined arm, so such an entry is listed with its
+ * undefined value as Node lists it. Reads of the slot follow the
+ * runtime-optional field rules. */
+function runtimeOptionalEntriesType(lowerer, record, resultT) {
+    const shape = lowerer.shapes.get(record.shapeId);
+    if (resultT.elem.kind !== "record" || !shape)
+        return resultT;
+    const pair = lowerer.shapes.get(resultT.elem.shapeId);
+    const slot = pair?.tuple ? pair.fields.find((f) => f.name === "1") : undefined;
+    if (!slot)
+        return resultT;
+    const optional = shape.fields.find((f) => lowerer.isRuntimeOptionalField(record.shapeId, f.name) &&
+        lowerer.runtimeOptionalWidening(f.type, slot.type) !== null);
+    if (!optional)
+        return resultT;
+    const widened = lowerer.runtimeOptionalWidening(optional.type, slot.type);
+    return { kind: "array", elem: lowerer.runtimeOptionalRecordField(resultT.elem, "1", widened) };
+}
 /** `r.f(args)` where `r` is a record and `f` a func-typed field: an
  * ordinary indirect call through the field's closure value. Deliberately
  * record-only — calling a func-typed CLASS field stays rejected (the
@@ -7922,13 +7860,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
         if (receiver.type.kind === "union") {
             const helper = lowerer.narrowedArmHelper(receiver.type.unionId, receiverIr, locOf(access.expression));
             if (helper !== null)
-                return {
-                    kind: "call",
-                    callee: helper,
-                    args: [receiver],
-                    type: receiverIr,
-                    loc: locOf(access.expression),
-                };
+                return lowerer.checkedNarrowCall(helper, receiver, receiverIr, locOf(access.expression));
         }
         return receiver.type.kind === "dyn"
             ? lowerer.coerceInto(access.expression, receiver, receiverIr)
@@ -8008,13 +7940,7 @@ export function lowerObjectMethodCall(lowerer, call, access) {
             if (callee?.type.kind === "union" && callableType !== null) {
                 const helper = lowerer.narrowedArmHelper(callee.type.unionId, callableType, locOf(access));
                 if (helper !== null) {
-                    callee = {
-                        kind: "call",
-                        callee: helper,
-                        args: [callee],
-                        type: callableType,
-                        loc: locOf(access),
-                    };
+                    callee = lowerer.checkedNarrowCall(helper, callee, callableType, locOf(access));
                 }
             }
             if (callee?.type.kind === "func") {
@@ -8453,4 +8379,147 @@ function unionObjectMethodHelper(lowerer, sourceCall, receiverT, method, plans,
     lowerer.liftedFns.push({ name, params, returnType: resultT, locals, body, loc });
     return name;
 }
+/** The argument's lowered type for a message (what the static form saw),
+ * or the checker's text when the argument itself does not lower. */
+function loweredArgumentText(lowerer, arg) {
+    const probed = tryLowerExpression(lowerer, arg);
+    return probed !== null
+        ? lowerer.fmt(probed.type)
+        : lowerer.checker.typeToString(lowerer.checker.getTypeAtLocation(arg));
+}
+/** The static global number parsers (parseInt/parseFloat/isNaN/isFinite),
+ * shared by the globals and their Number.* aliases. `call` blames arity
+ * fences; null when the argument shape needs the engine (the caller keeps
+ * its island path or SC2012 fence). */
+export function lowerStaticNumberGlobal(lowerer, name, call, args, loc) {
+    if (name === "parseInt" || name === "isNaN") {
+        const maxArgs = name === "parseInt" ? 2 : 1;
+        if (args.length < 1 || args.length > maxArgs) {
+            lowerer.noLowering(`${name} with ${args.length} argument${args.length === 1 ? "" : "s"}`, call);
+        }
+        if (name === "isNaN") {
+            const x = lowerer.lowerExprExpecting(args[0], F64);
+            return { kind: "libCall", fn: "num.isNaN", args: [x], type: BOOL, loc };
+        }
+        const radix = args[1]
+            ? lowerer.lowerExprExpecting(args[1], F64)
+            : { kind: "numLit", value: 0, type: F64, loc };
+        const optional = optionalCallValue(lowerer, args[0]);
+        if (optional?.type.kind === "union") {
+            const def = lowerer.unions.get(optional.type.unionId);
+            const stringTag = def?.arms.findIndex((arm) => arm.kind === "string") ?? -1;
+            if (def &&
+                stringTag >= 0 &&
+                def.arms.every((arm) => arm.kind === "string" || isUnitType(arm))) {
+                const unionT = optional.type;
+                const key = `parseInt.optional:${unionT.unionId}`;
+                let helper = lowerer.valueHelpers.get(key);
+                if (!helper) {
+                    helper = `%parseInt.optional.${lowerer.valueHelpers.size}`;
+                    lowerer.valueHelpers.set(key, helper);
+                    const value = { kind: "varRef", localId: "value.0", type: unionT, loc };
+                    const radixRef = { kind: "varRef", localId: "radix.0", type: F64, loc };
+                    const body = def.arms.flatMap((arm, tag) => isUnitType(arm)
+                        ? [
+                            {
+                                kind: "if",
+                                cond: {
+                                    kind: "unionIsTag",
+                                    unionId: unionT.unionId,
+                                    tag,
+                                    negated: false,
+                                    value,
+                                    type: BOOL,
+                                    loc,
+                                },
+                                then: [
+                                    {
+                                        kind: "return",
+                                        value: { kind: "numLit", value: NaN, type: F64, loc },
+                                        loc,
+                                    },
+                                ],
+                                else_: null,
+                                loc,
+                            },
+                        ]
+                        : []);
+                    body.push({
+                        kind: "return",
+                        value: {
+                            kind: "libCall",
+                            fn: "num.parseInt",
+                            args: [
+                                {
+                                    kind: "unionNarrow",
+                                    unionId: unionT.unionId,
+                                    tag: stringTag,
+                                    value,
+                                    type: STRING,
+                                    loc,
+                                },
+                                radixRef,
+                            ],
+                            type: F64,
+                            loc,
+                        },
+                        loc,
+                    });
+                    lowerer.liftedFns.push({
+                        name: helper,
+                        params: [
+                            { localId: "value.0", name: "value", type: unionT },
+                            { localId: "radix.0", name: "radix", type: F64 },
+                        ],
+                        returnType: F64,
+                        locals: [
+                            { id: "value.0", name: "value", type: unionT, mutable: true },
+                            { id: "radix.0", name: "radix", type: F64, mutable: true },
+                        ],
+                        body,
+                        loc,
+                    });
+                }
+                return { kind: "call", callee: helper, args: [optional, radix], type: F64, loc };
+            }
+        }
+        const s = lowerer.lowerExprExpecting(args[0], STRING);
+        return { kind: "libCall", fn: "num.parseInt", args: [s, radix], type: F64, loc };
+    }
+    // STATIC parseFloat/isFinite over exactly-typed arguments —
+    // parseInt's siblings (num.parseFloat is ECMA 19.2.4's decimal-
+    // literal prefix parse in scr_string.c; a number-typed isFinite IS
+    // Number.isFinite — the global's ToNumber coercion is the identity
+    // there, ms's `isFinite(val)` guard). Other argument types fall
+    // through to today's island path (--dynamic) or its SC2012 fence:
+    // the ToNumber/ToString coercions on arbitrary values stay engine
+    // territory. The probe never emits — lowering is IR construction.
+    if ((name === "parseFloat" || name === "isFinite") && args.length === 1) {
+        if (name === "parseFloat") {
+            const optional = optionalCallValue(lowerer, args[0]);
+            if (optional) {
+                const parsed = lowerOptionalStringNumber(lowerer, optional, loc, "num.parseFloat", "parseFloat");
+                if (parsed)
+                    return parsed;
+            }
+        }
+        const probed = tryLowerExpression(lowerer, args[0]);
+        if (name === "parseFloat" && probed?.type.kind === "string") {
+            return { kind: "libCall", fn: "num.parseFloat", args: [probed], type: F64, loc };
+        }
+        if (name === "parseFloat" && probed?.type.kind === "dyn") {
+            return {
+                kind: "libCall",
+                fn: "num.parseFloat",
+                args: [{ kind: "libCall", fn: "dyn.toStringCoerce", args: [probed], type: STRING, loc }],
+                type: F64,
+                loc,
+            };
+        }
+        if (name === "isFinite" && probed?.type.kind === "f64") {
+            return { kind: "libCall", fn: "number.isFinite", args: [probed], type: BOOL, loc };
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=lower-calls.js.map