@scriptc/compiler 0.0.22 → 0.0.23

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

@@ -785,6 +785,41 @@ export function lowerBuiltinModuleCall(L, expr, bi, fn, loc) {
     if (bi.module === "fs" && bi.member === "watch") {
         return lowerFsWatchCall(L, expr, loc);
     }
+    // fs.readSync(fd, buffer, offset, length[, position]) — normalize the
+    // current-offset forms to Node/libuv's -1 sentinel so the IR and native
+    // ABI stay fixed-width. A real numeric position is a positioned read
+    // and therefore must not advance the descriptor. Literal null is the
+    // documented current-offset spelling; richer nullable expressions must
+    // narrow first so no effectful evaluation is silently discarded.
+    if (bi.module === "fs" && bi.member === "readSync") {
+        const supported = "use readSync(fd, buffer, offset, length[, position]) with a numeric position or literal null; options objects and bigint positions have no lowering";
+        if ((expr.arguments.length !== 4 && expr.arguments.length !== 5) ||
+            expr.arguments.some(ts.isSpreadElement)) {
+            L.noLowering(`readSync with ${expr.arguments.length} argument${expr.arguments.length === 1 ? "" : "s"}`, expr, supported);
+        }
+        const args = [
+            L.lowerExprExpecting(expr.arguments[0], F64),
+            L.lowerExprExpecting(expr.arguments[1], BYTES_U8),
+            L.lowerExprExpecting(expr.arguments[2], F64),
+            L.lowerExprExpecting(expr.arguments[3], F64),
+        ];
+        const positionNode = expr.arguments[4];
+        let positionValueNode = positionNode;
+        while (positionValueNode && ts.isParenthesizedExpression(positionValueNode)) {
+            positionValueNode = positionValueNode.expression;
+        }
+        if (positionNode === undefined || positionValueNode.kind === ts.SyntaxKind.NullKeyword) {
+            args.push({ kind: "numLit", value: -1, type: F64, loc });
+        }
+        else {
+            const positionType = L.mapTypeOf(L.typeOf(positionNode));
+            if (positionType?.kind !== "f64") {
+                L.noLowering(`readSync with a '${positionType ? L.fmt(positionType) : L.checker.typeToString(L.typeOf(positionNode))}' position`, positionNode, supported);
+            }
+            args.push(L.lowerExprExpecting(positionNode, F64));
+        }
+        return { kind: "libCall", fn: "fs.readSync", args, type: F64, loc };
+    }
     if (bi.module === "child_process" &&
         (bi.member === "execFileSync" || bi.member === "execSync")) {
         return L.lowerExecSyncCall(expr, bi.member === "execSync", loc);
@@ -5326,13 +5361,29 @@ export function lowerNumberStaticCall(L, call, access) {
     }
     return null; // other Number statics land on the member fence
 }
-/** The Date slice: `Date.now()` and the COMPOSED
-   * `new Date(ms?).toISOString()` — the Date object between the two calls
-   * never exists (the crypto randomBytes(n).toString(enc) precedent). An
-   * omitted constructor argument completes with date.now; a one-argument
-   * form takes the milliseconds. String parsing, Y/M/D fields (local-time
-   * semantics), and Date VALUES stay fenced — lowerNew carries the hint.
-   * Null when this is neither form. */
+const DATE_GETTER_FNS = {
+    getFullYear: "date.getFullYear",
+    getUTCFullYear: "date.getUTCFullYear",
+    getMonth: "date.getMonth",
+    getUTCMonth: "date.getUTCMonth",
+    getDate: "date.getDate",
+    getUTCDate: "date.getUTCDate",
+    getDay: "date.getDay",
+    getUTCDay: "date.getUTCDay",
+    getHours: "date.getHours",
+    getUTCHours: "date.getUTCHours",
+    getMinutes: "date.getMinutes",
+    getUTCMinutes: "date.getUTCMinutes",
+    getSeconds: "date.getSeconds",
+    getUTCSeconds: "date.getUTCSeconds",
+    getMilliseconds: "date.getMilliseconds",
+    getUTCMilliseconds: "date.getUTCMilliseconds",
+    getTimezoneOffset: "date.getTimezoneOffset",
+};
+const DATE_METHOD_HINT = "getTime(), valueOf(), toISOString(), the local/UTC calendar getters, and getTimezoneOffset() are supported; Date setters and locale/string formatters have no lowering";
+/** The Date slice: statics plus read-only Date values backed by one
+   * TimeClip'd millisecond scalar. Construction lives in lowerNew;
+   * identity and mutating methods remain fenced. */
 export function lowerDateCall(L, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
@@ -5363,60 +5414,34 @@ export function lowerDateCall(L, call, access) {
         }
         return { kind: "libCall", fn: "date.utc", args, type: F64, loc };
     }
-    if (access.name.text !== "toISOString" && access.name.text !== "getTime")
+    if (L.mapTypeOf(L.typeOf(access.expression))?.kind !== "date")
         return null;
-    const recv = access.expression;
-    if (!ts.isNewExpression(recv) || !ts.isIdentifier(recv.expression))
-        return null;
-    const sym = L.resolveValueSymbol(recv.expression);
-    if (!sym || sym.name !== "Date" || !L.isStdlibSymbol(sym))
-        return null;
-    if (access.name.text === "getTime") {
-        // The composed `new Date(x).getTime()` read — the Date value
-        // between the two never materializes (the toISOString precedent).
-        // new Date().getTime() IS Date.now(); the STRING form parses the
-        // bounded date-string grammar (the X509 validity shape portless's
-        // cert-expiry check reads, plus ECMA's own date-time format) and
-        // answers NaN elsewhere — a documented divergence from V8's wider
-        // parser. The ms form is pointless composition; the fence points at
-        // the value.
-        if (call.arguments.length !== 0) {
-            L.noLowering("getTime with arguments", call);
-        }
-        const ctorArgs = recv.arguments ?? [];
-        if (ctorArgs.length === 0) {
-            return { kind: "libCall", fn: "date.now", args: [], type: F64, loc };
-        }
-        if (ctorArgs.length !== 1) {
-            L.noLowering("new Date with year/month/day arguments", recv, "the field constructor is local-time; only new Date() and new Date(dateString) compose with .getTime()");
-        }
-        const arg = L.lowerExpr(ctorArgs[0]);
-        if (arg.type.kind !== "string") {
-            L.noLowering(`new Date of '${L.fmt(arg.type)}' values composed with .getTime()`, ctorArgs[0], arg.type.kind === "f64"
-                ? "new Date(ms).getTime() is the ms value — use it directly (or Date.now())"
-                : "the composed form parses date STRINGS — narrow unions first");
-        }
-        return { kind: "libCall", fn: "date.parseGetTime", args: [arg], type: F64, loc };
-    }
+    if (!L.isStdlibMember(access))
+        return null;
+    const name = access.name.text;
     if (call.arguments.length !== 0) {
-        L.noLowering("toISOString with arguments", call);
+        L.noLowering(`Date.prototype.${name} with arguments`, call, DATE_METHOD_HINT);
     }
-    const ctorArgs = recv.arguments ?? [];
-    let ms;
-    if (ctorArgs.length === 0) {
-        ms = { kind: "libCall", fn: "date.now", args: [], type: F64, loc };
+    const receiver = L.lowerExpr(access.expression);
+    if (receiver.type.kind !== "date")
+        L.badType(access.expression, L.typeOf(access.expression));
+    if (name === "getTime" || name === "valueOf") {
+        return {
+            kind: "libCall",
+            fn: name === "getTime" ? "date.getTime" : "date.valueOf",
+            args: [receiver],
+            type: F64,
+            loc,
+        };
     }
-    else if (ctorArgs.length === 1) {
-        const arg = L.lowerExpr(ctorArgs[0]);
-        if (arg.type.kind !== "f64") {
-            L.noLowering(`new Date of '${L.fmt(arg.type)}' values`, ctorArgs[0], "only the milliseconds form composes — new Date(ms).toISOString(); date-string parsing has no lowering");
-        }
-        ms = arg;
+    if (name === "toISOString") {
+        return { kind: "libCall", fn: "date.toISOStringValue", args: [receiver], type: STRING, loc };
     }
-    else {
-        L.noLowering("new Date with year/month/day arguments", recv, "the field constructor is local-time; only new Date() and new Date(ms) compose with .toISOString()");
+    const fn = DATE_GETTER_FNS[name];
+    if (fn !== undefined) {
+        return { kind: "libCall", fn, args: [receiver], type: F64, loc };
     }
-    return { kind: "libCall", fn: "date.toISOString", args: [ms], type: STRING, loc };
+    L.noLowering(`Date.prototype.${name}`, call, DATE_METHOD_HINT, L.checker.getSymbolAtLocation(access.name));
 }
 /** A direct construction of THE stdlib TextEncoder/TextDecoder, through
    * type-only wrappers. Name alone is never enough: a user class with the