@scriptc/compiler 0.0.21 → 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,83 +5414,180 @@ 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));
 }
-/** The WHATWG encoder pair, COMPOSED: `new TextDecoder().decode(bytes)`
-   * and `new TextEncoder().encode(s)` — the encoder object between the two
-   * calls never exists (the crypto/Date precedent; bare construction is
-   * fenced in lowerNew with the composed hint). decode is the runtime's
-   * WHATWG utf-8 decode with the leading BOM stripped; a zero-argument
-   * decode() is "" like the spec's. encode IS Buffer.from(s, "utf8") —
-   * ScrStr storage is well-formed UTF-8, so the bytes are identical (lone
+/** A direct construction of THE stdlib TextEncoder/TextDecoder, through
+   * type-only wrappers. Name alone is never enough: a user class with the
+   * same spelling keeps the ordinary class lowering. */
+function directTextCodecCtorOf(L, expr) {
+    const ctor = stripTypeCasts(expr);
+    if (!ts.isNewExpression(ctor))
+        return null;
+    const callee = stripTypeCasts(ctor.expression);
+    if (!ts.isIdentifier(callee))
+        return null;
+    if (callee.text !== "TextDecoder" && callee.text !== "TextEncoder")
+        return null;
+    const sym = L.resolveValueSymbol(callee);
+    if (!sym || !L.isStdlibSymbol(sym))
+        return null;
+    if (sym.name !== "TextDecoder" && sym.name !== "TextEncoder")
+        return null;
+    return { cls: sym.name, ctor };
+}
+/** True when construction itself is effect-free and inside the already
+   * lowered codec slice, so a const binding can be erased and calls can
+   * resolve back to the initializer. TextDecoder's explicit label must be
+   * an actual literal here: accepting an arbitrary expression merely typed
+   * as "utf-8" would move or repeat its effects when the binding is erased. */
+function erasableTextCodecCtor(info) {
+    const args = info.ctor.arguments ?? [];
+    if (info.cls === "TextEncoder")
+        return args.length === 0;
+    if (args.length === 0)
+        return true;
+    if (args.length !== 1)
+        return false;
+    const label = stripTypeCasts(args[0]);
+    return ts.isStringLiteralLike(label) && (label.text === "utf-8" || label.text === "utf8");
+}
+/** `const encoder = new TextEncoder()` / the default TextDecoder twin:
+   * compile-time alias plumbing with no runtime object. Calls through the
+   * stable binding are recognized by textCodecReceiverOf below; any other
+   * reached value use keeps the ordinary SC2020 representation fence. Both
+   * declaration walks call this and independently gate on constness. */
+export function textCodecBindingClassOf(L, nameNode, init) {
+    if (!ts.isIdentifier(nameNode) || init === undefined)
+        return null;
+    const decl = nameNode.parent;
+    if (!ts.isVariableDeclaration(decl) || !ts.isVariableDeclarationList(decl.parent) ||
+        !ts.isVariableStatement(decl.parent.parent)) {
+        return null;
+    }
+    const info = directTextCodecCtorOf(L, init);
+    return info !== null && erasableTextCodecCtor(info) ? info.cls : null;
+}
+export function textCodecBindingDecl(L, nameNode, init) {
+    return textCodecBindingClassOf(L, nameNode, init) !== null;
+}
+/** The inline composed receiver, or a const identifier whose initializer
+   * is an erasable codec construction in the same execution scope and
+   * after that declaration. Following the declaration instead of
+   * materializing the value is honest for the supported slice: receiver
+   * reads are pure, construction has no effects, and every non-call use
+   * fences because there is deliberately no general value lowering. */
+function textCodecReceiverOf(L, expr) {
+    const direct = directTextCodecCtorOf(L, expr);
+    if (direct !== null)
+        return direct;
+    const receiver = stripTypeCasts(expr);
+    if (!ts.isIdentifier(receiver))
+        return null;
+    const sym = L.resolveValueSymbol(receiver);
+    const decl = sym ? L.checker.valueDeclarationOf(sym) : undefined;
+    if (!decl || !ts.isVariableDeclaration(decl) || decl.initializer === undefined ||
+        !ts.isVariableDeclarationList(decl.parent) || (decl.parent.flags & ts.NodeFlags.Const) === 0 ||
+        !textCodecBindingDecl(L, decl.name, decl.initializer)) {
+        return null;
+    }
+    // A closure can run before the const initializes (TDZ), and an
+    // imported binding can be observed during a module cycle; both need
+    // real runtime storage rather than this deliberately trivial rewrite.
+    const executionScope = (node) => {
+        let child = node;
+        for (let cur = node.parent;; child = cur, cur = cur.parent) {
+            if (ts.isFunctionLike(cur) || ts.isSourceFile(cur))
+                return cur;
+            // An instance field initializer runs when an object is constructed,
+            // not when its enclosing class expression evaluates. Treat it like
+            // a closure boundary: a later source position does not prove the
+            // codec declaration ran (a switch can enter a following case and
+            // instantiate the class while the binding is still in its TDZ).
+            if (ts.isPropertyDeclaration(cur) && cur.initializer === child &&
+                (ts.getCombinedModifierFlags(cur) & ts.ModifierFlags.Static) === 0) {
+                return cur;
+            }
+        }
+    };
+    if (executionScope(receiver) !== executionScope(decl) || receiver.getStart() < decl.end)
+        return null;
+    // All switch clauses share one lexical environment, but dispatch can
+    // enter a later clause without executing a const in an earlier one.
+    // TypeScript normally diagnoses the direct read; an @ts-expect-error
+    // can deliberately retain the runtime TDZ shape, so source order alone
+    // is not a sufficient proof. A codec declared in a clause is erasable
+    // only for uses inside that exact clause's subtree (nested switches are
+    // fine; closures and instance initializers already fail executionScope).
+    const switchClauseOf = (node) => {
+        for (let cur = node.parent; cur !== undefined; cur = cur.parent) {
+            if (ts.isCaseClause(cur) || ts.isDefaultClause(cur))
+                return cur;
+            if (ts.isFunctionLike(cur) || ts.isSourceFile(cur))
+                return null;
+        }
+        return null;
+    };
+    const declClause = switchClauseOf(decl);
+    if (declClause !== null) {
+        let insideDeclClause = false;
+        for (let cur = receiver; cur !== undefined; cur = cur.parent) {
+            if (cur === declClause) {
+                insideDeclClause = true;
+                break;
+            }
+        }
+        if (!insideDeclClause)
+            return null;
+    }
+    return directTextCodecCtorOf(L, decl.initializer);
+}
+/** The WHATWG encoder pair, COMPOSED or through an erasable const binding:
+   * `new TextDecoder().decode(bytes)`, `new TextEncoder().encode(s)`, and
+   * the idiomatic store-then-call equivalents. The codec object never
+   * exists (the crypto/Date precedent); bare construction and value uses
+   * are fenced with the composed hint. decode is the runtime's WHATWG
+   * utf-8 decode with the leading BOM stripped; a zero-argument decode()
+   * is "" like the spec's. encode IS Buffer.from(s, "utf8") — ScrStr
+   * storage is well-formed UTF-8, so the bytes are identical (lone
    * surrogates became U+FFFD at string construction, exactly what the
-   * spec's encoder emits). Null when this is neither composed form. */
+   * spec's encoder emits). Null when this is neither supported form. */
 export function lowerTextCodecCall(L, call, access) {
     if (call.questionDotToken || access.questionDotToken)
         return null;
     const member = access.name.text;
     if (member !== "decode" && member !== "encode")
         return null;
-    const recv = access.expression;
-    if (!ts.isNewExpression(recv) || !ts.isIdentifier(recv.expression))
-        return null;
-    const sym = L.resolveValueSymbol(recv.expression);
-    const cls = sym?.name;
-    if (!sym || !L.isStdlibSymbol(sym))
+    const info = textCodecReceiverOf(L, access.expression);
+    if (info === null || !L.isStdlibMember(access))
         return null;
+    const { cls, ctor: recv } = info;
     if (!(cls === "TextDecoder" && member === "decode") && !(cls === "TextEncoder" && member === "encode")) {
         return null;
     }