@scriptc/compiler 0.0.23 → 0.0.24

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
@@ -3005,7 +3055,7 @@ 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([
@@ -7291,6 +7341,7 @@ function typeofAnswer(arm) {
         case "url":
         case "searchParams":
         case "stats":
+        case "fileHandle":
         case "spawnRes":
         case "child":
         case "netServer":