@scriptc/compiler 0.1.4 → 0.1.6

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

@@ -18,7 +18,7 @@ import { builtinModuleFnOf, FS_READDIR_DOCUMENTED_OPTIONS, FS_WATCH_DOCUMENTED_O
 import { lowerAbsenceProbe } from "./lower-exprs.js";
 import { conditionalSpreadOf, lowerDynObjectLiteral } from "./expressions/object-literals.js";
 import { isSafeToDiscard } from "./expressions/evaluation-safety.js";
-import { defaultAfterUndefined, lowerStaticallyUndefinedArgument } from "./optional-arguments.js";
+import { defaultAfterUndefined, lowerOptionalArgument, lowerStaticallyUndefinedArgument, lowerStringSearchArgument } from "./optional-arguments.js";
 import { HTTP2_CONSTANTS } from "./http2-constants.js";
 import { CRYPTO_CIPHERS, CRYPTO_CONSTANTS, CRYPTO_CURVES, CRYPTO_HASHES } from "./crypto-tables.js";
 import { generatorMeta, timerStyleCallback } from "./lower-calls.js";
@@ -4206,6 +4206,9 @@ export function lowerJsonMethodCall(lowerer, call, access) {
     }
     if (member === "stringify") {
         const indent = stringifySpaceIndent(lowerer, call);
+        if (call.arguments.length === 0) {
+            return lowerer.wrappedUndefined(lowerer.withUndefinedArm(STRING), loc);
+        }
         const argNode = call.arguments[0];
         const value = lowerer.lowerExpr(argNode);
         const optionalString = lowerOptionalStringifyRoot(lowerer, value, indent, loc);
@@ -6037,7 +6040,7 @@ export function lowerFsConstantsProperty(lowerer, expr) {
 /** `process.stdin/stdout/stderr.isTTY` → isatty(3) on the stream's fd
    * (a REAL boolean: Node's non-TTY streams expose `undefined` here — the
    * documented divergence; truthiness tests, the actual usage, agree), and
-   * `process.stdout/stderr.columns` → ioctl(TIOCGWINSZ) on the fd, with
+   * `process.stdout/stderr.columns/rows` → ioctl(TIOCGWINSZ) on the fd, with
    * Node's non-TTY answer intact: the read is `number | undefined` and a
    * non-TTY (or ioctl-refusing) stream yields the undefined arm. The
    * receiver match sees through parens and as-casts to the SYMBOL —
@@ -6052,7 +6055,7 @@ export function lowerProcessStreamProperty(lowerer, expr) {
     if (expr.questionDotToken)
         return null;
     const member = expr.name.text;
-    if (member !== "isTTY" && member !== "columns")
+    if (member !== "isTTY" && member !== "columns" && member !== "rows")
         return null;
     let recv = expr.expression;
     while (ts.isParenthesizedExpression(recv) || ts.isAsExpression(recv) || ts.isTypeAssertion(recv))
@@ -6086,17 +6089,17 @@ export function lowerProcessStreamProperty(lowerer, expr) {
         return { kind: "libCall", fn: "process.isTTY", args: [fd], type: BOOL, loc };
     }
     if (stream === "stdin")
-        return null; // no columns on a ReadStream — generic fences apply
+        return null; // no geometry on a ReadStream — generic fences apply
     const declared = lowerer.mapTypeOf(lowerer.typeOf(expr));
     const want = lowerer.withUndefinedArm(F64);
     // JS files skip the annotation fence: there is no annotation to fix —
     // the read IS Node's `number | undefined` and lowers to exactly that
     // (commander's `isTTY ? columns : undefined` help-width probes).
     if ((!declared || typeKey(declared) !== typeKey(want)) && !isJsSourceFile(expr.getSourceFile())) {
-        lowerer.noLowering(`process.${stream}.columns as a plain number`, expr, "on a non-TTY stream Node's .columns is undefined — type the read to admit it: " +
-            `(process.${stream} as typeof process.${stream} & { columns?: number }).columns`);
+        lowerer.noLowering(`process.${stream}.${member} as a plain number`, expr, `on a non-TTY stream Node's .${member} is undefined — type the read to admit it: ` +
+            `(process.${stream} as typeof process.${stream} & { ${member}?: number }).${member}`);
     }
-    return { kind: "libCall", fn: "process.columns", args: [fd], type: want, loc };
+    return { kind: "libCall", fn: member === "rows" ? "process.rows" : "process.columns", args: [fd], type: want, loc };
 }
 /** `process.argv` / `process.platform` / `process.pid` property READS
    * lower to zero-arg libCalls (argv returns +1 on one interned array —
@@ -7467,7 +7470,7 @@ export function lowerDateCall(lowerer, call, access) {
     if (name === "toISOString") {
         return { kind: "libCall", fn: "date.toISOStringValue", args: [receiver], type: STRING, loc };
     }
-    const fn = DATE_GETTER_FNS[name];
+    const fn = own(DATE_GETTER_FNS, name);
     if (fn !== undefined) {
         return { kind: "libCall", fn, args: [receiver], type: F64, loc };
     }
@@ -7828,11 +7831,10 @@ export function lowerStringStaticCall(lowerer, call, access) {
     const packed = { kind: "arrayLit", elems, type: arrayOf(F64), loc };
     return { kind: "libCall", fn: "string.fromCharCode", args: [packed], type: STRING, loc };
 }
-/** `s.lastIndexOf(needle)` on string receivers — a libCall rather than a
-   * strIntrinsic, but the same UTF-16 index semantics as
-   * indexOf. The lib's fromIndex parameter has no lowering (Node clamps
-   * it with ToIntegerOrInfinity; nothing in the corpus wants it) and
-   * fences per site. Null for non-string receivers / other members. */
+/** `s.lastIndexOf(searchValue?, position?)` on string receivers, using UTF-16
+   * indices. An omitted search value searches for "undefined". Omitted or undefined positions clamp to the string's end;
+   * MAX_SAFE_INTEGER has the same effect for every representable string.
+   * Null for non-string receivers and other members. */
 export function lowerStringLastIndexOfCall(lowerer, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -7843,12 +7845,18 @@ export function lowerStringLastIndexOfCall(lowerer, call, access) {
     if (!lowerer.isStdlibMember(access))
         return null;
     const loc = locOf(call);
-    if (call.arguments.length !== 1) {
-        lowerer.noLowering("lastIndexOf with a fromIndex argument", call, "the one-argument form lowers");
+    if (call.arguments.length > 2 || call.arguments.some(ts.isSpreadElement)) {
+        lowerer.noLowering("lastIndexOf with this argument shape", call, "pass no arguments, or a search value with an optional numeric position");
     }
     const receiver = lowerer.lowerExprExpecting(access.expression, STRING);
+    const positionNode = call.arguments[1];
+    if (!positionNode) {
+        const needle = lowerStringSearchArgument(lowerer, call.arguments[0], loc);
+        return { kind: "libCall", fn: "string.lastIndexOf", args: [receiver, needle], type: F64, loc };
+    }
     const needle = lowerer.lowerExprExpecting(call.arguments[0], STRING);
-    return { kind: "libCall", fn: "string.lastIndexOf", args: [receiver, needle], type: F64, loc };
+    const position = lowerOptionalArgument(lowerer, positionNode, F64, numLit(Number.MAX_SAFE_INTEGER, loc));
+    return { kind: "libCall", fn: "string.lastIndexOfFrom", args: [receiver, needle, position], type: F64, loc };
 }
 /** `Promise.race([...])` on THE Promise global: the entries lower
    * individually (the array never materializes — promise-element arrays