@scriptc/compiler 0.0.22 → 0.0.24

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

@@ -234,7 +234,7 @@ export declare function foldedStringKeyOf(L: Lowerer, expr: ts.Expression): stri
    * (dynFrom's domain, functions box); a value with no dyn representation
    * fences per property. Spreads copy through dyn.assign in source order;
    * accessors stay fenced. */
-export declare function lowerDynObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
+export declare function lowerDynObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression, boxValue?: (node: ts.Expression, value: IrExpr) => IrExpr): IrExpr;
 export declare function lowerObjectLiteral(L: Lowerer, expr: ts.ObjectLiteralExpression): IrExpr;
 /** A conditional spread's carrier property: `name: value` or shorthand,
    * with an identifier/string-literal name. */

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

@@ -21,7 +21,7 @@ import { lowerSocketInstanceOf, lowerTlsRootCertificates } from "./lower-server.
 import { findGenericMethodOn, lowerStaticFieldRead } from "./lower-classes.js";
 import { bindingNeverReassigned, implicitMonoFile, lowerTaggedTemplate, nullishGenericBindingUnitOf, objLitGenericFnInfoOf, objLitGenericFnNodeOf, requireObjLitGenericReceiver } from "./lower-calls.js";
 import { mixinFnOfCallee } from "./lower-mixins.js";
-import { isConstAssertionTypeNode, isGenericCallableMemberType, underConstAssertion, unitOnlyUnion } from "../types.js";
+import { isConstAssertionTypeNode, isGenericCallableMemberType, isParseArgsDynTypeName, underConstAssertion, unitOnlyUnion } from "../types.js";
 import { lowerYield } from "./lower-generators.js";
 import { lowerStreamProperty, lowerStreamStateProperty, streamSidesOf } from "./lower-stream.js";
 /** A template piece's RAW text (String.raw's contract: escapes stay
@@ -63,6 +63,30 @@ export function abstractPropertyDeclOf(L, expr) {
         .some((d) => ts.isPropertyDeclaration(d) &&
         ts.getModifiers(d)?.some((m) => m.kind === ts.SyntaxKind.AbstractKeyword) === true);
 }
+/** A field declared by node:util's parseArgs checked-dynamic type family.
+ * Narrowing a ParseArgsToken exposes one anonymous union arm, so its alias
+ * identity no longer reaches mapType; declaration ancestry is the stable
+ * provenance check. */
+function isParseArgsDynProperty(L, expr) {
+    const sym = L.checker.getSymbolAtLocation(expr.name);
+    if (!sym)
+        return false;
+    return L.checker.declarationsOf(sym).some((d) => {
+        if (!L.isStdlibFile(d.getSourceFile()))
+            return false;
+        let inParseArgsType = false;
+        for (let node = d.parent; node; node = node.parent) {
+            if ((ts.isTypeAliasDeclaration(node) || ts.isInterfaceDeclaration(node)) &&
+                isParseArgsDynTypeName(node.name.text)) {
+                inParseArgsType = true;
+            }
+            if (ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name)) {
+                return inParseArgsType && (node.name.text === "util" || node.name.text === "node:util");
+            }
+        }
+        return false;
+    });
+}
 export function lowerExpr(L, expr) {
     if (lowerExprDepth >= LOWER_EXPR_MAX_DEPTH) {
         L.unsupported("SC1090", expr, `expressions nested deeper than ${LOWER_EXPR_MAX_DEPTH} levels`);
@@ -1600,6 +1624,32 @@ function lowerExprInner(L, expr) {
                     return nsUndefRead(L, ambientRoot.text, expr, t);
             }
         }
+        // parseArgs results/tokens live in the checked-dynamic tree. A token
+        // discriminant check narrows its checker type to one anonymous arm,
+        // whose ambient property symbols would otherwise hit SC2020 before
+        // the generic dyn receiver path below. Provenance is limited to the
+        // node:util parseArgs family; every other stdlib member keeps its
+        // ordinary surface fence.
+        if (isParseArgsDynProperty(L, expr)) {
+            const recv = L.lowerExpr(expr.expression);
+            if (recv.type.kind === "dyn") {
+                const key = {
+                    kind: "strLit",
+                    value: expr.name.text,
+                    type: STRING,
+                    loc: locOf(expr.name),
+                };
+                const opt = chainGuardedByQuestionDot(expr.expression);
+                return L.maybeNarrow({
+                    kind: "dynKeyGet",
+                    key,
+                    ...(opt ? { optional: true } : {}),
+                    value: recv,
+                    type: DYN,
+                    loc,
+                }, expr);
+            }
+        }
         // A member read through a NULLISH generic binding (`const i: I<A &
         // B> = null as any; const _i: I<A> = i.something` — the receiver
         // provably holds null/undefined forever): the read throws Node's
@@ -1614,6 +1664,7 @@ function lowerExprInner(L, expr) {
         // The lib fence's PROPERTY chokepoint: a stdlib-declared member that
         // no lowering above claimed ([1,2].entries, Math.SQRT2, Promise.all,
         // re.exec as a value, ...) reports SC2020 here.
+        L.fenceStaticAbortControllerMemberRead(expr);
         L.fenceStaticResponseMember(expr, "read");
         L.fenceStaticHeadersMember(expr, "read");
         L.fenceStaticReadableStreamMember(expr, "read");
@@ -2911,7 +2962,7 @@ export function lowerIntrinsicProperty(L, expr) {
         if (probe.type.kind === "array")
             kind = "array";
     }
-    if (kind !== "string" && kind !== "array" && kind !== "map" && kind !== "set" && kind !== "f64" && kind !== "regex" && kind !== "url" && kind !== "searchParams" && kind !== "stats" && kind !== "spawnRes" && kind !== "child" && kind !== "bytes" && kind !== "symbol") {
+    if (kind !== "string" && kind !== "array" && kind !== "map" && kind !== "set" && kind !== "f64" && kind !== "date" && kind !== "regex" && kind !== "url" && kind !== "searchParams" && kind !== "stats" && kind !== "spawnRes" && kind !== "child" && kind !== "bytes" && kind !== "symbol") {
         return null;
     }
     // child receivers also admit the user's own child-shaped interface
@@ -3004,7 +3055,21 @@ export function lowerIntrinsicProperty(L, expr) {
         if (name === "isFile" || name === "isDirectory") {
             L.unsupported("SC1090", expr, `Stats methods as values (call '${name}' directly)`);
         }
-        L.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), and size are the supported Stats members", L.checker.getSymbolAtLocation(expr.name));
+        L.noLowering(`Stats.${name}`, expr, "isFile(), isDirectory(), isSymbolicLink(), size, blocks, nlink, atimeMs, and mtimeMs are the supported Stats members", L.checker.getSymbolAtLocation(expr.name));
+    }
+    if (kind === "date") {
+        const methods = new Set([
+            "getTime", "valueOf", "toISOString",
+            "getFullYear", "getUTCFullYear", "getMonth", "getUTCMonth",
+            "getDate", "getUTCDate", "getDay", "getUTCDay", "getHours",
+            "getUTCHours", "getMinutes", "getUTCMinutes", "getSeconds",
+            "getUTCSeconds", "getMilliseconds", "getUTCMilliseconds",
+            "getTimezoneOffset",
+        ]);
+        if (methods.has(name)) {
+            L.unsupported("SC1090", expr, `Date methods as values (call '${name}' directly)`);
+        }
+        L.noLowering(`Date.prototype.${name}`, expr, "getTime(), valueOf(), toISOString(), the local/UTC calendar getters, and getTimezoneOffset() are supported; Date setters and locale/string formatters have no lowering", L.checker.getSymbolAtLocation(expr.name));
     }
     if (kind === "symbol") {
         const loc = locOf(expr);
@@ -3655,7 +3720,7 @@ function propNameText(L, name) {
    * (dynFrom's domain, functions box); a value with no dyn representation
    * fences per property. Spreads copy through dyn.assign in source order;
    * accessors stay fenced. */
-export function lowerDynObjectLiteral(L, expr) {
+export function lowerDynObjectLiteral(L, expr, boxValue) {
     const loc = locOf(expr);
     let fields = [];
     let acc = null;
@@ -3671,7 +3736,10 @@ export function lowerDynObjectLiteral(L, expr) {
     for (const prop of expr.properties) {
         if (ts.isSpreadAssignment(prop)) {
             flushFields();
-            const source = L.coerceToExpected(L.lowerExpr(prop.expression), DYN);
+            const raw = L.lowerExpr(prop.expression);
+            const source = boxValue
+                ? boxValue(prop.expression, raw)
+                : L.coerceToExpected(raw, DYN);
             if (source.type.kind !== "dyn") {
                 L.unsupported("SC1101", prop.expression, `spreading '${L.fmt(source.type)}' into a checked-dynamic object literal`);
             }
@@ -3765,7 +3833,9 @@ export function lowerDynObjectLiteral(L, expr) {
             });
             raw = { kind: "closure", fnName, captures: [], type: funcOf([], VOID), loc: locOf(prop) };
         }
-        let v = L.coerceToExpected(raw, DYN);
+        let v = boxValue
+            ? boxValue(valueExpr, raw)
+            : L.coerceToExpected(raw, DYN);
         if (v.type.kind !== "dyn") {
             const convDiagsBefore = L.diags.length;
             try {
@@ -5233,6 +5303,7 @@ export function lowerElementAccess(L, expr) {
     // spellings. Fence a statically-known unsupported key before the generic
     // checked-dynamic element-read path can turn it into a runtime missing
     // member.
+    L.fenceStaticAbortControllerMemberRead(expr);
     L.fenceStaticResponseMember(expr, "read");
     L.fenceStaticHeadersMember(expr, "read");
     L.fenceStaticReadableStreamMember(expr, "read");
@@ -7270,6 +7341,7 @@ function typeofAnswer(arm) {
         case "url":
         case "searchParams":
         case "stats":
+        case "fileHandle":
         case "spawnRes":
         case "child":
         case "netServer":