@scriptc/compiler 0.4.0 → 0.4.2

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

@@ -1,3 +1,4 @@
+import { keyedHelperName } from "./stable-names.js";
 import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -9,6 +10,7 @@ import { InternalCompilerError } from "../../errors.js";
  * (FieldTarget). */
 import * as ts from "../ts7/adapter.js";
 import { checkedPrivateReceiver, localPrivateBrandClass } from "./private-brands.js";
+import { staticCondition } from "./static-typeof.js";
 import { constituentTypes } from "../ts7/checker.js";
 import { lowerMaybePromiseAwait, maybePromiseUnionOf } from "./maybe-promise.js";
 import { checkedClassUnionAssertion } from "./class-assertions.js";
@@ -45,6 +47,8 @@ export { ensureString, lowerBinary, lowerCompoundValueToTarget, lowerElementComp
 export { jsHoldsDynObject, lowerArrayLiteral } from "./expressions/array-literals.js";
 export { lowerElementAccess, lowerElementWrite, lowerEnvironmentKey, lowerRecordKeyRead, } from "./expressions/element-access.js";
 export { fieldSetStmt, lowerIncDec, lowerIncDecTarget, lowerPrefixUnary, } from "./expressions/updates.js";
+import { awaitDynThenable, programMayDefineThenables } from "./thenables.js";
+import { awaitsChildThenable } from "./handle-properties.js";
 export { lowerInstanceOf } from "./expressions/relational.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
  * characters). 7's client AST ships no rawText at runtime (the typing
@@ -475,8 +479,14 @@ function lowerExprInner(lowerer, expr) {
             // and answers itself. Thenable adoption stays unmodeled
             // (SEMANTICS.md).
             if (value.type.kind === "dyn") {
+                // A program that can define thenables adopts them (thenables.ts).
+                if (programMayDefineThenables(lowerer))
+                    return awaitDynThenable(lowerer, value, loc);
                 return { kind: "libCall", fn: "async.awaitDyn", args: [value], type: DYN, loc };
             }
+            if (awaitsChildThenable(lowerer, expr, value)) {
+                return awaitDynThenable(lowerer, lowerer.coerceToExpected(value, DYN), loc);
+            }
             // A TYPED non-promise operand (`await 42`, an awaited record):
             // JS awaits non-thenables through exactly one microtask turn and
             // yields the value itself — evaluate the operand, hop, answer it.
@@ -839,7 +849,15 @@ export function lowerCondition(lowerer, expr) {
         });
         if (presence !== null)
             return presence;
-    }
+        if (isTimerMethodPresence(lowerer, e))
+            return { kind: "boolLit", value: true, type: BOOL, loc: locOf(e) };
+    }
+    // Global detection (`typeof window < "u"`, `typeof self !==
+    // "undefined" && …`): a condition whose typeof answers are static
+    // folds, so the untaken arm never lowers (static-typeof.ts).
+    const folded = staticCondition(lowerer, e);
+    if (folded !== null)
+        return { kind: "boolLit", value: folded, type: BOOL, loc: locOf(e) };
     if (ts.isBinaryExpression(e)) {
         const op = e.operatorToken.kind;
         if (op === ts.SyntaxKind.AmpersandAmpersandToken || op === ts.SyntaxKind.BarBarToken) {
@@ -925,6 +943,20 @@ function maybePromiseThenPresence(lowerer, access, result) {
         loc,
     };
 }
+/** `if (t.unref)` over a Node timer handle: the guard libraries write for
+ * runtimes whose timers lack the method (execa's kill timeout). Node's
+ * Timeout and Immediate always have it. */
+function isTimerMethodPresence(lowerer, access) {
+    if (access.questionDotToken || !ts.isIdentifier(access.expression))
+        return false;
+    if (!["ref", "unref", "hasRef", "refresh"].includes(access.name.text))
+        return false;
+    const symbol = lowerer.checker.getSymbolAtLocation(access.name);
+    if (!symbol || !lowerer.isStdlibSymbol(symbol))
+        return false;
+    const owner = lowerer.typeOf(access.expression).getSymbol();
+    return owner !== undefined && ["Timeout", "Immediate"].includes(ts.symbolName(owner));
+}
 export function lowerPromiseThenPresence(lowerer, access, result) {
     if (access.name.text !== "then")
         return null;
@@ -1135,10 +1167,67 @@ export function lowerOptionalNumber(lowerer, operand, loc, narrowedNode) {
  * out-of-range read, a local or field holding one, or a hole — converts to
  * NaN instead of trusting the checker's number type. */
 export function lowerToNumberArgument(lowerer, node) {
+    const operand = numberOperand(lowerer, node);
+    return operand.convert ? operand.convert(operand.value) : operand.value;
+}
+/** The ToNumber arguments of one call (the Math functions,
+ * String.fromCharCode): Node evaluates every argument before it converts
+ * any. When an argument's conversion can run program code (valueOf or
+ * toString on a dynamic value) and a later argument follows, the arguments
+ * evaluate into temporaries first and convert in order after. `lowerOther`
+ * lowers an argument that takes no conversion (a spread's array), or returns
+ * null for a ToNumber argument; with temporaries, such an array is copied
+ * where it is evaluated, since JavaScript reads a spread's elements then,
+ * before a later conversion's valueOf could change them. Returns the
+ * temporaries' statements (empty when none are needed) and the converted
+ * values. */
+export function lowerToNumberArguments(lowerer, nodes, lowerOther) {
+    const operands = nodes.map((node) => {
+        const other = lowerOther?.(node);
+        return other
+            ? { value: other, convert: null, runsCode: false, spread: true }
+            : numberOperand(lowerer, node);
+    });
+    const late = operands.slice(0, -1).some((operand) => operand.runsCode);
+    if (!late) {
+        const values = operands.map((o) => (o.convert ? o.convert(o.value) : o.value));
+        return { stmts: [], values };
+    }
+    const stmts = [];
+    const values = operands.map((operand) => {
+        if (operand.value.kind === "numLit")
+            return operand.value;
+        const temp = lowerer.declareHiddenLocal("%numberArgument", operand.value.type);
+        const loc = operand.value.loc;
+        const init = operand.spread && operand.value.type.kind === "array"
+            ? {
+                kind: "arrIntrinsic",
+                method: "slice",
+                receiver: operand.value,
+                args: [numLit(0, loc), numLit(Infinity, loc)],
+                type: operand.value.type,
+                loc,
+            }
+            : operand.value;
+        stmts.push({ kind: "varDecl", localId: temp.id, init, loc });
+        const read = varRef(temp.id, operand.value.type, loc);
+        return operand.convert ? operand.convert(read) : read;
+    });
+    return { stmts, values };
+}
+function numberOperand(lowerer, node) {
     let inner = node;
     while (ts.isParenthesizedExpression(inner))
         inner = inner.expression;
     const loc = locOf(inner);
+    const number = (value) => ({ value, convert: null, runsCode: false });
+    const dynToNumber = (value) => ({
+        kind: "libCall",
+        fn: "dyn.toNumberCoerce",
+        args: [value],
+        type: F64,
+        loc,
+    });
     const isOptionalNumber = (value) => value.type.kind === "union" &&
         lowerer.armTag(value.type.unionId, UNDEFINED_T) >= 0 &&
         lowerer.stripUndefinedArm(value.type).kind === "f64";
@@ -1148,14 +1237,55 @@ export function lowerToNumberArgument(lowerer, node) {
             ? lowerAbsenceProbe(lowerer, inner)
             : null;
     if (optional && isOptionalNumber(optional))
-        return lowerOptionalNumber(lowerer, optional, loc, inner);
-    // A conditional builds each branch for the destination.
-    if (ts.isConditionalExpression(inner))
-        return lowerer.lowerExprExpecting(node, F64);
+        return number(lowerOptionalNumber(lowerer, optional, loc, inner));
+    // A conditional with number branches builds each branch as a number;
+    // other branches box, and the value converts like any dynamic value.
+    if (ts.isConditionalExpression(inner)) {
+        const branch = (b) => lowerer.mapTypeOf(lowerer.typeOf(b))?.kind;
+        if (branch(inner.whenTrue) === "f64" && branch(inner.whenFalse) === "f64")
+            return number(lowerer.lowerExprExpecting(node, F64));
+        return { value: lowerer.lowerExprExpecting(node, DYN), convert: dynToNumber, runsCode: true };
+    }
     const value = lowerer.lowerExpr(node);
     if (isOptionalNumber(value))
-        return lowerOptionalNumber(lowerer, value, loc, inner);
-    return lowerer.coerceInto(node, value, F64);
+        return number(lowerOptionalNumber(lowerer, value, loc, inner));
+    // Other values convert with ToNumber: strings parse as numeric literals,
+    // booleans and null are numbers, and checked-dynamic values call
+    // valueOf/toString or throw Node's TypeError for a Symbol or BigInt.
+    const num = (n) => ({ kind: "numLit", value: n, type: F64, loc });
+    const pure = (convert) => ({
+        value,
+        convert,
+        runsCode: false,
+    });
+    switch (value.type.kind) {
+        case "string":
+            return pure((v) => ({ kind: "libCall", fn: "num.fromString", args: [v], type: F64, loc }));
+        case "bool":
+            return pure((v) => ({
+                kind: "ternary",
+                cond: v,
+                then: num(1),
+                else_: num(0),
+                type: F64,
+                loc,
+            }));
+        case "nullT":
+            return pure((v) => defaultAfterUndefined(v, num(0)));
+        case "undefinedT":
+            return pure((v) => defaultAfterUndefined(v, num(NaN)));
+        case "dyn":
+            return { value, convert: dynToNumber, runsCode: true };
+        case "union":
+            if (lowerer.dynConvertible(value.type))
+                return {
+                    value: lowerer.coerceToExpected(value, DYN),
+                    convert: dynToNumber,
+                    runsCode: true,
+                };
+            break;
+    }
+    return number(lowerer.coerceInto(node, value, F64));
 }
 /** The stored value of an identifier whose storage holds an undefined arm
  * that the checker's type at this use has dropped. An assignment from an
@@ -1819,7 +1949,11 @@ export function cjsAccessorSnapshotOf(lowerer, getter) {
     const call = cjsAccessorCall(lowerer, getter, locOf(getter));
     if (call === null)
         return null;
-    const snapshot = { id: `%g.cjsSnapshot.${lowerer.cjsAccessorSnapshots.size}`, type: call.type };
+    const at = locOf(getter);
+    const snapshot = {
+        id: keyedHelperName(lowerer, "%g.cjsSnapshot", `${at.file}:${at.start}:${at.end}`),
+        type: call.type,
+    };
     lowerer.globalsList.push({
         id: snapshot.id,
         name: "%cjsSnapshot",
@@ -1840,7 +1974,7 @@ export function cjsAccessorSnapshotStores(lowerer, dep, loc) {
         return [];
     let readyId = lowerer.cjsSnapshotReady.get(dep);
     if (readyId === undefined) {
-        readyId = `%g.cjsSnapshotReady.${lowerer.cjsSnapshotReady.size}`;
+        readyId = keyedHelperName(lowerer, "%g.cjsSnapshotReady", dep.fileName);
         lowerer.globalsList.push({ id: readyId, name: "%cjsSnapshotReady", type: BOOL, mutable: true });
         lowerer.cjsSnapshotReady.set(dep, readyId);
     }
@@ -2514,8 +2648,10 @@ export function lowerFieldCompound(lowerer, access, op, rhsNode, loc) {
  * returns the zero-capture closure over it. Typed sources use the mapped
  * `(value: string) => primitive` signature; a recognized JavaScript
  * concise-arrow selector (`() => String`, the picocolors fallback) takes
- * dyn so its ordinary coercion signature survives inference residue. The
- * dyn bodies run exact ToString/ToNumber/ToBoolean, including object hooks.
+ * dyn so its ordinary coercion signature survives inference residue, and a
+ * boxed constructor value takes dyn too (coerceToExpected). The dyn bodies
+ * run what the constructors do for any argument: String() (a symbol's
+ * description form included), ToNumber and ToBoolean, with object hooks.
  * Interning makes every reference under one ABI the SAME immortal closure,
  * so `opt.type === String` compares like JS function identity. */
 export function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
@@ -2532,7 +2668,7 @@ export function primitiveCtorClosure(lowerer, name, loc, dynamicInput) {
             ? name === "BigInt"
                 ? { kind: "libCall", fn: "dyn.bigintConstructor", args: [v], type: BIGINT_T, loc }
                 : name === "String"
-                    ? { kind: "libCall", fn: "dyn.toStringCoerce", args: [v], type: STRING, loc }
+                    ? { kind: "libCall", fn: "dyn.stringConstructor", args: [v], type: STRING, loc }
                     : name === "Number"
                         ? { kind: "libCall", fn: "dyn.numberConstructor", args: [v], type: F64, loc }
                         : { kind: "dynTest", test: "truthy", value: v, type: BOOL, loc }