@scriptc/compiler 0.0.23 → 0.0.24

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

@@ -165,6 +165,10 @@ export declare function lowerVarStatement(L: Lowerer, stmt: ts.VariableStatement
    * object: it has observable mutable protocol state, represented by
    * hidden locals only while a stored binding stays in one function. */
 export declare function numericIteratorSourceOf(L: Lowerer, expr: ts.Expression | undefined): ts.Expression | null;
+/** Whether a checker type belongs to node:util.parseArgs's dyn-backed
+ * declaration family. Module ancestry disambiguates short private helper
+ * names such as `Token` from names in other standard-library modules. */
+export declare function isParseArgsDynCheckerType(L: Lowerer, type: ts.Type): boolean;
 /** Destructuring declarations, desugared as sugar over indexed/field
    * reads: the initializer evaluates ONCE into a hidden temp, then each
    * bound name declares (or assigns its pre-registered module global) from
@@ -178,7 +182,7 @@ export declare function numericIteratorSourceOf(L: Lowerer, expr: ts.Expression
 export declare function lowerDestructuringDecl(L: Lowerer, decl: ts.VariableDeclaration, isLet: boolean): IrStmt[];
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
-export declare function lowerBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string): void;
+export declare function lowerBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, srcType: IrType, isLet: boolean, out: IrStmt[], dynSpell?: string, allowDynObject?: boolean): void;
 /** The STATIC property name of a destructuring key: identifiers spell
    * themselves, string/numeric-literal keys and COMPUTED keys fold through
    * foldedStringKeyOf — pure single-name expressions only (`{ [k]: v }`
@@ -217,7 +221,7 @@ export declare function enginePatternSpec(L: Lowerer, pattern: ts.ArrayBindingPa
    * exit), rest, and transportable defaults all ride. False when the
    * pattern has no engine form (the caller fences). */
 export declare function lowerJsvalBindingPattern(L: Lowerer, pattern: ts.ArrayBindingPattern | ts.ObjectBindingPattern, srcRef: () => IrExpr, isLet: boolean, out: IrStmt[]): boolean;
-export declare function bindPatternTarget(L: Lowerer, name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[]): void;
+export declare function bindPatternTarget(L: Lowerer, name: ts.BindingName, value: IrExpr, isLet: boolean, out: IrStmt[], allowDynObject?: boolean): void;
 /** For-loop initializers. let/const stay restricted to ONE declarator (JS
    * per-iteration binding copies for several captured loop variables are
    * not modeled yet); `var` initializers take any number — a `var` is ONE

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

@@ -22,7 +22,7 @@ import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRe
 import { lowerEnumDeclaration } from "./lower-enums.js";
 import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerGroupsProjection, matchResultNamedGroupsOf, probeLower, pureReemittable, symbolFieldInfo } from "./lower-exprs.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
-import { isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
+import { isParseArgsDynTypeName, isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
 import { canonicalBuiltinModule, isRelativeSpecifier } from "../shared.js";
 import { probeNodeRequireRefusal } from "../npm.js";
 /** `const X = /* @__PURE__ *\/ makeX()` at a module's top level: every
@@ -1076,6 +1076,36 @@ function lowerMatchAllDrainDecl(L, decl, isConst) {
         },
     ];
 }
+/** Whether a checker type belongs to node:util.parseArgs's dyn-backed
+ * declaration family. Module ancestry disambiguates short private helper
+ * names such as `Token` from names in other standard-library modules. */
+export function isParseArgsDynCheckerType(L, type) {
+    const widened = L.checker.getBaseTypeOfLiteralType(type);
+    const declarationBelongs = (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;
+    };
+    const sym = widened.getAliasSymbol() ?? widened.getSymbol();
+    if (sym && isParseArgsDynTypeName(sym.name) &&
+        L.checker.declarationsOf(sym).some(declarationBelongs)) {
+        return true;
+    }
+    // A discriminant check erases the token alias and leaves one anonymous
+    // object arm. Its properties still point into the parseArgs alias, which
+    // is the same stable signal the dotted-member bridge uses.
+    return L.checker.getPropertiesOfType(widened).some((p) => L.checker.declarationsOf(p).some(declarationBelongs));
+}
 /** Destructuring declarations, desugared as sugar over indexed/field
    * reads: the initializer evaluates ONCE into a hidden temp, then each
    * bound name declares (or assigns its pre-registered module global) from
@@ -1106,6 +1136,7 @@ export function lowerDestructuringDecl(L, decl, isLet) {
             return tokenBound;
     }
     let init = L.lowerExpr(decl.initializer);
+    const parseArgsDynObject = init.type.kind === "dyn" && isParseArgsDynCheckerType(L, L.typeOf(decl.initializer));
     // A TS `any`-origin source whose lowered value is NOT a destructurable
     // shape (`var { x } = <any>0` — the cast erases to the f64; a dyn
     // value — the checked-dynamic tree has no destructure): JS reads the properties off
@@ -1240,12 +1271,12 @@ export function lowerDestructuringDecl(L, decl, isLet) {
         : ts.isCallExpression(src) && ts.isIdentifier(src.expression)
             ? `${src.expression.text} is not a function or its return value is not iterable`
             : undefined;
-    L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: init.type, loc }), init.type, isLet, out, dynSpell);
+    L.lowerBindingPattern(decl.name, () => ({ kind: "varRef", localId: tmp.id, type: init.type, loc }), init.type, isLet, out, dynSpell, parseArgsDynObject);
     return out;
 }
 /** One pattern level: emits a declaration (or global assignment) per
    * bound name, recursing through hidden temps for nested patterns. */
-export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dynSpell) {
+export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dynSpell, allowDynObject = false) {
     if (ts.isArrayBindingPattern(pattern)) {
         L.fenceStaticHeadersIteration(pattern);
         // Tuple sources: each position is a field read of the tuple's record
@@ -1538,8 +1569,12 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
     // default applied exactly when the read answers undefined (lazily,
     // like a defaulted parameter). Bindings are dyn (the checker's `any`),
     // nested object patterns recurse through this same branch. TS files
-    // keep the fence — annotations exist there.
-    if (srcType.kind === "dyn" && isJsSourceFile(pattern.getSourceFile())) {
+    // keep the fence — annotations exist there. node:util.parseArgs is the
+    // scoped TypeScript exception: its declared result/token types are
+    // deliberately carried by the checked-dynamic tree, so their ordinary
+    // object patterns use the same exact keyed-read desugar.
+    if (srcType.kind === "dyn" &&
+        (isJsSourceFile(pattern.getSourceFile()) || allowDynObject)) {
         for (const el of pattern.elements) {
             if (el.name === undefined)
                 continue;
@@ -1576,7 +1611,7 @@ export function lowerBindingPattern(L, pattern, srcRef, srcType, isLet, out, dyn
                     loc,
                 };
             }
-            L.bindPatternTarget(el.name, value, isLet, out);
+            L.bindPatternTarget(el.name, value, isLet, out, allowDynObject);
         }
         return;
     }
@@ -2669,7 +2704,7 @@ export function lowerJsvalBindingPattern(L, pattern, srcRef, isLet, out) {
 function jsvalFlavoredType(t) {
     return t.kind === "jsval" || (t.kind === "array" && t.elem.kind === "jsval");
 }
-export function bindPatternTarget(L, name, value, isLet, out) {
+export function bindPatternTarget(L, name, value, isLet, out, allowDynObject = false) {
     const loc = value.loc;
     if (ts.isIdentifier(name)) {
         const symbol = L.checker.getSymbolAtLocation(name);
@@ -2713,7 +2748,7 @@ export function bindPatternTarget(L, name, value, isLet, out) {
     }
     const tmp = L.declareHiddenLocal("%destr", value.type);
     out.push({ kind: "varDecl", localId: tmp.id, init: value, loc });
-    L.lowerBindingPattern(name, () => ({ kind: "varRef", localId: tmp.id, type: value.type, loc }), value.type, isLet, out);
+    L.lowerBindingPattern(name, () => ({ kind: "varRef", localId: tmp.id, type: value.type, loc }), value.type, isLet, out, undefined, allowDynObject);
 }
 /** For-loop initializers. let/const stay restricted to ONE declarator (JS
    * per-iteration binding copies for several captured loop variables are
@@ -2871,8 +2906,8 @@ export function lowerVarDecl(L, decl, isLet) {
     // alias plumbing (see stdlibGlobalAliasDecl), no storage, no code.
     if (!isLet && stdlibGlobalAliasDecl(L, decl.name, decl.initializer))
         return null;
-    // `const encoder = new TextEncoder()` and the default TextDecoder
-    // twin: the codec has no general value representation, but calls
+    // `const encoder = new TextEncoder()` and a statically-labelled
+    // TextDecoder twin: the codec has no general value representation, but calls
     // through this stable binding resolve back to the initializer. The
     // supported constructors are effect-free, so the declaration itself
     // is compile-time alias plumbing with no storage or code.