@scriptc/compiler 0.0.15 → 0.0.17

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

@@ -458,10 +458,10 @@ export declare function lowerDefaultToStringCall(L: Lowerer, call: ts.CallExpres
    * member spellings (`x.hasOwnProperty(...)` and `x['hasOwnProperty'](...)`
    * — JS resolves the two identically, so the element spelling routes here
    * from lowerCall's element-access hook):
-   *   - `n.toExponential()` / `n.toFixed()` with the fraction digits
-   *     OMITTED — the static runtime formatters (num.toExponential's
-   *     shortest-mantissa form, num.toFixed0's ties-up integer). The
-   *     explicit-digits forms keep their island/fence story.
+   *   - `n.toExponential()` and both `n.toFixed()` forms — the static
+   *     runtime formatters (num.toExponential's shortest-mantissa form,
+   *     num.toFixed0's ties-up integer fast path, and num.toFixed's exact
+   *     binary-value rounding for an explicit fractionDigits).
    *   - `hasOwnProperty(lit)` on number/boolean receivers — the boxes own
    *     NOTHING, so any key answers false (a compile-time constant; the
    *     receiver must be effect-free since the constant elides it).

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

@@ -3583,13 +3583,11 @@ export function lowerCall(L, expr) {
             // Object.prototype.toString's default answer on records and
             // override-free program classes — "[object Object]", folded.
             lowerDefaultToStringCall(L, expr, expr.expression) ??
-            // The remaining primitive prototype statics — toExponential()/
-            // toFixed() digit-free, hasOwnProperty over literal keys. Before
-            // the island path (its table claims the explicit-digits forms);
-            // optional-chain spellings keep the chain machinery's paths.
-            (expr.expression.questionDotToken
-                ? null
-                : lowerPrimitiveProtoCall(L, expr, expr.expression.expression, expr.expression.name.text, L.checker.getSymbolAtLocation(expr.expression.name))) ??
+            // The remaining primitive prototype statics — toExponential(),
+            // both toFixed() forms, hasOwnProperty over literal keys. Before
+            // the island path. Optional-chain spellings first enter the chain
+            // machinery above, then re-enter here with a narrowed chainRecv.
+            lowerPrimitiveProtoCall(L, expr, expr.expression.expression, expr.expression.name.text, L.checker.getSymbolAtLocation(expr.expression.name)) ??
             // hasOwnProperty on a program class CONSTRUCTOR — own statics are
             // compile-time-known, so a literal key folds to a constant.
             lowerClassHasOwnPropertyCall(L, expr, expr.expression) ??
@@ -4413,10 +4411,10 @@ function pureReceiverNode(node) {
    * member spellings (`x.hasOwnProperty(...)` and `x['hasOwnProperty'](...)`
    * — JS resolves the two identically, so the element spelling routes here
    * from lowerCall's element-access hook):
-   *   - `n.toExponential()` / `n.toFixed()` with the fraction digits
-   *     OMITTED — the static runtime formatters (num.toExponential's
-   *     shortest-mantissa form, num.toFixed0's ties-up integer). The
-   *     explicit-digits forms keep their island/fence story.
+   *   - `n.toExponential()` and both `n.toFixed()` forms — the static
+   *     runtime formatters (num.toExponential's shortest-mantissa form,
+   *     num.toFixed0's ties-up integer fast path, and num.toFixed's exact
+   *     binary-value rounding for an explicit fractionDigits).
    *   - `hasOwnProperty(lit)` on number/boolean receivers — the boxes own
    *     NOTHING, so any key answers false (a compile-time constant; the
    *     receiver must be effect-free since the constant elides it).
@@ -4452,6 +4450,33 @@ export function lowerPrimitiveProtoCall(L, call, recv, name, memberSym) {
         const fn = name === "toExponential" ? "num.toExponential" : "num.toFixed0";
         return { kind: "libCall", fn, args: [operand], type: STRING, loc };
     }
+    if (name === "toFixed" && recvKind === "f64" && call.arguments.length === 1) {
+        const operand = L.lowerExpr(recv);
+        let digits = L.lowerExpr(call.arguments[0]);
+        // The optional parameter also admits undefined. A standalone,
+        // side-effect-free undefined value is exactly the default 0; an
+        // optional number preserves its evaluation and selects 0 at runtime
+        // through the same narrowed nullish IR used by `digits ?? 0`.
+        const zero = { kind: "numLit", value: 0, type: F64, loc: digits.loc };
+        if ((digits.type.kind === "undefinedT" || digits.type.kind === "void") &&
+            droppableStatic(digits)) {
+            digits = zero;
+        }
+        else if (digits.type.kind === "union") {
+            const def = L.unions.get(digits.type.unionId);
+            if (def?.arms.every(isUnitType) && droppableStatic(digits)) {
+                digits = zero;
+            }
+            else if (def?.arms.length === 2 &&
+                def.arms.some((arm) => arm.kind === "f64") &&
+                def.arms.some((arm) => arm.kind === "undefinedT")) {
+                digits = { kind: "nullish", left: digits, right: zero, type: F64, loc: digits.loc };
+            }
+        }
+        if (operand.type.kind !== "f64" || digits.type.kind !== "f64")
+            return null;
+        return { kind: "libCall", fn: "num.toFixed", args: [operand, digits], type: STRING, loc };
+    }
     // Number.prototype.toLocaleString("en-US") — the spec makes it
     // NumberFormat(locale).format(this), so the en-US embedded formatter
     // answers exactly. The unlowered forms fence by NAME: no locale (the