@scriptc/compiler 0.4.1 → 0.4.3

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

@@ -1,4 +1,7 @@
+import { keyedHelperName } from "./stable-names.js";
+import { isNewTarget, lowerNewTarget, lowerNewTargetComparison, lowerNewTargetName, } from "./new-target.js";
 import { lowerWebAssemblyValue, refuseWebAssemblyUse } from "./builtins/webassembly.js";
+import { lowerAwaitedUniformPromiseAll } from "./builtins/promises.js";
 import { dynUndefinedExpr, nodeThrowExpr, numLit, strLit, varRef } from "../../ir/build.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Expression lowering: the expression dispatch (lowerExpr), literals
@@ -419,6 +422,9 @@ function lowerExprInner(lowerer, expr) {
             // boundary for malformed/upstream ASTs.
             lowerer.unsupported("SC1090", expr, "top-level await (await outside async functions)");
         }
+        const uniformAll = lowerAwaitedUniformPromiseAll(lowerer, expr);
+        if (uniformAll)
+            return uniformAll;
         const value = lowerer.lowerExpr(expr.expression);
         // A promise-or-absent union (`Promise<T> | undefined` values, calls
         // of `(...) => Promise<void> | void` callbacks): the await handles
@@ -552,7 +558,7 @@ function lowerExprInner(lowerer, expr) {
     if (ts.isPostfixUnaryExpression(expr))
         return lowerIncDec(lowerer, expr, false);
     if (ts.isBinaryExpression(expr))
-        return lowerer.lowerBinary(expr);
+        return lowerNewTargetComparison(lowerer, expr) ?? lowerer.lowerBinary(expr);
     if (ts.isCallExpression(expr)) {
         // `h.return?.()` on a helper object: the method exists, so the
         // optional call is the call.
@@ -574,12 +580,14 @@ function lowerExprInner(lowerer, expr) {
     if (ts.isConditionalExpression(expr))
         return lowerTernary(lowerer, expr);
     if (ts.isPropertyAccessExpression(expr))
-        return lowerPropertyAccessExpr(lowerer, expr, loc);
+        return lowerNewTargetName(lowerer, expr) ?? lowerPropertyAccessExpr(lowerer, expr, loc);
     // Meta-properties, named: `new.target` reflects HOW a function was
     // invoked (compiled functions are never constructors of themselves —
     // no runtime invocation record exists), and `import.meta`/
     // `import.defer` are module-loader surface a native binary does not
     // carry.
+    if (isNewTarget(expr))
+        return lowerNewTarget(lowerer, expr);
     if (ts.isMetaProperty(expr)) {
         const name = expr.keywordToken === ts.SyntaxKind.NewKeyword ? "new.target" : `import.${expr.name.text}`;
         lowerer.unsupported("SC1090", expr, name === "new.target"
@@ -1166,10 +1174,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";
@@ -1179,14 +1244,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
@@ -1663,6 +1769,7 @@ export function typeofAnswer(arm) {
         case "array":
         case "map":
         case "set":
+        case "generator":
         case "regex":
         case "bytes":
         case "url":
@@ -1850,7 +1957,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",
@@ -1871,7 +1982,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);
     }
@@ -2545,8 +2656,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) {
@@ -2563,7 +2676,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 }