@scriptc/compiler 0.0.9 → 0.0.10

package/dist/frontend/lowering/lowerer.js

@@ -26,7 +26,7 @@ import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mix
 import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction } from "./lower-calls.js";
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
-import { builtinImportOf, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
+import { builtinImportOf, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
 import { isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
@@ -299,6 +299,26 @@ export function nodeThrowExpr(kind, code, message, type, loc) {
         loc,
     };
 }
+/** The post-validation fence STRING a validation-ladder Chk libCall
+ * throws after its Node-order checks pass: the same SC2020 text the
+ * per-statement runtime fence would have thrown (message + "[code at
+ * file:line]"), rendered eagerly so the runtime can throw it verbatim
+ * (scr_throw_lowering_fence). The diagnostic joins the runtime-fence
+ * ledger exactly like a deferred statement fence — nothing silently
+ * drops off the coverage report. */
+export function ladderFenceExpr(L, surface, node, hint) {
+    const loc = locOf(node);
+    const d = noLoweringDiag(surface, loc, hint);
+    L.runtimeFences.push(d);
+    const sf = node.getSourceFile();
+    const pos = ts.getLineAndCharacterOfPosition(sf, loc.start);
+    return {
+        kind: "strLit",
+        value: `${d.message} [${d.code} at ${loc.file}:${pos.line + 1}]`,
+        type: STRING,
+        loc,
+    };
+}
 /** The checked-dynamic declaration fallback for unmappable binding types
  * (see irTypeOf), two gates over one story:
  *
@@ -477,6 +497,29 @@ export class Lowerer {
     /** Per-symbol result of the never-reassigned file scan
      * (bindingNeverReassigned — object-literal generic-method receivers). */
     neverReassignedCache = new Map();
+    /** TRAP bindings: declarations whose initializer provably throws before
+     * producing a value (its chain roots at an ambient-undefined name —
+     * ambientUndefVarRootOf). Module init unwinds at the declaration, so no
+     * reference to the binding can ever execute; the statement lowers to the
+     * root's throw, no storage exists, and references lower to the same
+     * trap shape (never reached — sound whatever the type). */
+    trapBindings = new Set();
+    /** NULLISH bindings of unmappable (generic-signature) types: `const i:
+     * I<A & B> = null as any` — the binding provably holds null/undefined
+     * forever (every write's RHS is nullish too), so no storage exists and
+     * each READ knows the value. Member reads and method calls through one
+     * lower to Node's exact TypeError ("Cannot read properties of null
+     * (reading 'fn')"); nullish-to-nullish flows lower to nothing. The map
+     * answers which unit the binding holds (the TypeError names it). Null
+     * entries cache probed non-qualifiers. */
+    nullishBindings = new Map();
+    /** DEAD bindings of unmappable types: never READ anywhere in the
+     * program, declared with no initializer or a value-only one (a function
+     * literal), every write's RHS side-effect-free. Node materializes the
+     * value and drops it — zero observable effect — so the declaration and
+     * its writes lower to nothing, and no type fence fires for a value the
+     * program never consumes. */
+    deadBindings = new Set();
     /** IMPLICIT-ANY function-value bindings (npm-static JS — `const knownBy
      * = (cmd) => ...`), by their VariableDeclaration: the registered info,
      * or null for probed non-qualifiers (implicitLocalFnNodeOf). */
@@ -2361,6 +2404,21 @@ export class Lowerer {
             return expr;
         }
         if (expr.type.kind === "jsval" && expected.kind !== "jsval") {
+            // The jsval→DOM crossing (the world unification's engine-handle
+            // kind): an 'any'-typed engine value flowing into an 'unknown'/
+            // 'object'/JS-residue slot wraps BY REFERENCE as the DOM's island
+            // kind — engine scalars normalize to native DOM kinds at wrap time,
+            // typeof/truthiness/String()/=== route to the engine, un-armed DOM
+            // walks fence loudly, and the value unwraps back identity-preserved
+            // (scr_jsval_from_dyn). Monotone under evolution/widening: a value
+            // wraps once at its first dyn edge and stays valid through every
+            // subsequent dyn slot; narrowing never changes representation.
+            // This wrap RETIRES the silent-wrong-answer fence-closure box for
+            // jsval members of DOM object literals (lowerDynObjectLiteral's
+            // coercion lands here first).
+            if (expected.kind === "dyn") {
+                return { kind: "dynFromJsval", value: expr, type: DYN, loc: expr.loc };
+            }
             // The exit set: everything round-trippable, plus bare undefined-armed
             // unions of JSON-safe data arms (the engine's undefined takes the
             // undefined arm before the JSON detour) — canExitIslandToType.
@@ -5161,6 +5219,11 @@ export class Lowerer {
         if (value.kind === "unitLit") {
             return { kind: "dynFrom", value, type: DYN, loc: value.loc };
         }
+        // An ISLAND ('any') value: the by-reference jsval→DOM wrap — the same
+        // edge coerceToExpected converts (dyn slots accept engine values).
+        if (value.type.kind === "jsval") {
+            return { kind: "dynFromJsval", value, type: DYN, loc: value.loc };
+        }
         if (!this.dynConvertible(value.type)) {
             this.unsupported("SC1100", node, `storing '${this.fmt(value.type)}' values under an 'unknown'-valued index signature (only numbers, strings, booleans, and JSON-safe records/arrays/unions convert)`);
         }
@@ -6116,7 +6179,7 @@ export class Lowerer {
     lowerDestructuringAssignParts(target, rhs, loc) {
         return lowerDestructuringAssignParts(this, target, rhs, loc);
     }
-    lowerBindingPattern(pattern, srcRef, srcType, isLet, out) {
+    lowerBindingPattern(pattern, srcRef, srcType, isLet, out, dynSpell) {
         // An ISLAND source (`const { readFileSync } = await import("fs")` —
         // a namespace handle, or any 'any'-typed object): each bound name is
         // an engine property read, mirroring the island property-read rule —
@@ -6180,7 +6243,7 @@ export class Lowerer {
             }
             return;
         }
-        return lowerBindingPattern(this, pattern, srcRef, srcType, isLet, out);
+        return lowerBindingPattern(this, pattern, srcRef, srcType, isLet, out, dynSpell);
     }
     checkBindingElement(el, allowDefault = false) {
         return checkBindingElement(this, el, allowDefault);
@@ -6261,6 +6324,16 @@ export class Lowerer {
                     const local = this.declareLocal(decl.name, decl.name.text, JSVAL, isLet);
                     return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
                 }
+                // The CHECKED-DYNAMIC twin of the handle rescue (the runtime-world
+                // local rule): an unmappable declared type over a dyn initializer
+                // (`const first = plugins[0]` — the checker spells 'string |
+                // object' while the read is a DOM keyed read) keeps the binding
+                // dyn; typed use sites ride validated extractions and the routed
+                // engine ops, exactly the JSON.parse-binding story.
+                if (mapped === null && init.type.kind === "dyn") {
+                    const local = this.declareLocal(decl.name, decl.name.text, DYN, isLet);
+                    return { kind: "varDecl", localId: local.id, init, loc: locOf(decl) };
+                }
                 if (mapped === null)
                     this.badType(decl.name, this.typeOf(decl.name));
                 // A mappable declared type with a non-island initializer: the
@@ -6634,6 +6707,27 @@ export class Lowerer {
                 const spec = requireSpecOf(decl.initializer);
                 return spec !== null ? canonicalBuiltinModule(spec) : null;
             }
+            // A DESTRUCTURED sub-namespace binding — `const { promises } =
+            // fs` / `= require('fs')`: the member is itself a supported module
+            // ("fs/promises"), so the binding carries that module's namespace
+            // surface. canonicalBuiltinModule gates the composition (an
+            // ordinary destructured FUNCTION binding composes to an unknown
+            // name and answers null — builtinImportOf owns those).
+            if (ts.isBindingElement(decl) && ts.isObjectBindingPattern(decl.parent) &&
+                ts.isVariableDeclaration(decl.parent.parent) && decl.parent.parent.initializer !== undefined &&
+                decl.propertyName === undefined && decl.initializer === undefined) {
+                const name = decl.name;
+                if (name === undefined || !ts.isIdentifier(name))
+                    return null;
+                const init = decl.parent.parent.initializer;
+                const spec = requireSpecOf(init);
+                const outer = spec !== null
+                    ? canonicalBuiltinModule(spec)
+                    : ts.isIdentifier(init) ? this.builtinNamespaceModuleOf(init) : null;
+                if (outer !== null)
+                    return canonicalBuiltinModule(`${outer}/${name.text}`);
+                return null;
+            }
         }
         // The INLINE CommonJS spelling: `require("cluster").isPrimary` — the
         // call expression IS the module namespace (Node evaluates the member
@@ -6746,6 +6840,12 @@ export class Lowerer {
         const fsTs = this.lowerFsToUnixTimestampCall(call, bi, locOf(access));
         if (fsTs)
             return fsTs;
+        // The fs validation-ladder spoke (checked-dynamic lane): misuse of
+        // implemented-namespace members throws Node's typed errors instead
+        // of meeting the table fence.
+        const fsLadder = this.lowerFsLadderCall(call, bi, locOf(access));
+        if (fsLadder)
+            return fsLadder;
         const builtinFn = builtinModuleFnOf(this, bi.module, bi.member);
         if (!builtinFn) {
             this.noLowering(`${bi.module}.${bi.member}`, call, builtinFenceHintOf(bi.module, bi.member), this.checker.getSymbolAtLocation(access.name));
@@ -6799,6 +6899,9 @@ export class Lowerer {
     lowerFsToUnixTimestampCall(expr, bi, loc) {
         return lowerFsToUnixTimestampCall(this, expr, bi, loc);
     }
+    lowerFsLadderCall(expr, bi, loc) {
+        return lowerFsLadderCall(this, expr, bi, loc);
+    }
     lowerChildArgsArg(node, loc) {
         return lowerChildArgsArg(this, node, loc);
     }