@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -45,10 +45,11 @@ export declare function predeclareForwardCapture(lowerer: Lowerer, symbol: ts.Sy
 /** The FUNCTION-DECLARATION twin of predeclareForwardCapture: JS hoists a
    * nested `function f() {}` to scope entry — the binding is LIVE from the
    * first statement, so a reference lexically above the declaration in the
-   * SAME function lowers the declaration eagerly at the reference (varDecl
-   * pushed before the current statement's IR, registered in the list's
-   * scope frame) and the statement loop skips the source statement when it
-   * arrives (lowerer.hoistedFnDecls). Same-function only: the declaration's own
+   * SAME function lowers the declaration eagerly at the reference (storage
+   * declaration and initializing assignment are pushed before the current
+   * statement's IR, registered in the list's scope frame) and the statement
+   * loop skips the source statement when it arrives
+   * (lowerer.hoistedFnDecls). Same-function only: the declaration's own
    * lowering runs under the ctx that owns its statement list, and a
    * cross-function early capture would need lowering under a DIFFERENT
    * ctx than the one currently open — that shape keeps the honest fence. */

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

@@ -8,20 +8,20 @@ import { arrayValueRead, arrayValueStore, arrayValueType } from "./array-values.
 import { lowerForAwaitGenerator, lowerForOfGenerator, lowerYieldStarStatement } from "./lower-generators.js";
 import { lowerForAwaitBuiltin } from "./lower-async-iteration.js";
 import { BOOL, BYTES_U8, CAUGHT, DYN, F64, JSVAL, STRING, UNDEFINED_T, VOID, arrayOf, isUnitType, shapeHasAccessorSlots, typeEquals } from "../../ir/ir.js";
-import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
+import { PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, neverTaintedJsType, staticImportNamespaceType, stmtUsesIsland, uncheckedOverloadHandleCall } from "./lowerer.js";
 import { enforceLibBoundary } from "./lib-boundary.js";
 import { cjsExportAssignmentOf, cjsExportDiscardReason, cjsExportTargetLiteral, isCjsJsFile, isJsSourceFile, locOf, requireSpecOf } from "../program.js";
-import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalNameOf } from "./surfaces.js";
+import { COMPOUND_ASSIGN_OPS, STR_METHODS, UNSUPPORTED_STMT, isStdlibMember, sideEffectFreeOptionValue, stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isProvenanceSourceFile } from "../provenance-registry.js";
 import { ambientUndefVarRootOf, lowerImportEquals, nsUndefRead, nsWritableTarget, trapDeclRootOf } from "./lower-namespaces.js";
 import { expandoWritableTarget, lowerExpandoAssignStmt } from "./lower-expando.js";
 import { lowerForOfArrayIter, lowerForOfMap, lowerForOfSearchParams, lowerForOfSet, lowerSafeIndexRead, objectIterOverIndexShape, strCharsCall } from "./lower-containers.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall } from "./lower-calls.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, implicitMethodCallInfersReturn, nullishExprUnitOf, nullishGenericBindingUnitOf, recordKeysArrayCall, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { genericIfaceBindingKeepsClass } from "./lower-classes.js";
 import { lowerStreamUnderscoreAssign, streamClassAliasDecl } from "./lower-stream.js";
 import { lowerHttpResPropertyAssignment, lowerHttpServerTimeoutAssignment, lowerServerCloseOverrideAssignment } from "./lower-server.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, textCodecBindingDecl } from "./lower-builtins.js";
+import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireCalleeFileOf, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireProgramModuleOf, lowerNodeModuleCall, registerBuiltinCallableAlias, textCodecBindingDecl } from "./lower-builtins.js";
 import { lowerEnumDeclaration } from "./lower-enums.js";
 import { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
@@ -518,7 +518,7 @@ const TDZ_KINDS = new Set([
     // shape is the const's own initializer capturing the const:
     // `const server = http.createServer(h).listen(0, done)` with `done`
     // reading `server` — a TDZ read until the assign completes, JS exactly.
-    "child", "childStream", "netServer", "netSocket", "dgramSocket", "testCtx",
+    "child", "childStream", "childWriter", "netServer", "netSocket", "dgramSocket", "testCtx",
     "httpReq", "httpRes", "httpClientReq",
     // The h2 handles — `const client = http2.connect(url, mustCall(() =>
     // ...client...))` is the suite's canonical self-capturing const.
@@ -594,10 +594,11 @@ export function predeclareForwardCapture(lowerer, symbol) {
 /** The FUNCTION-DECLARATION twin of predeclareForwardCapture: JS hoists a
    * nested `function f() {}` to scope entry — the binding is LIVE from the
    * first statement, so a reference lexically above the declaration in the
-   * SAME function lowers the declaration eagerly at the reference (varDecl
-   * pushed before the current statement's IR, registered in the list's
-   * scope frame) and the statement loop skips the source statement when it
-   * arrives (lowerer.hoistedFnDecls). Same-function only: the declaration's own
+   * SAME function lowers the declaration eagerly at the reference (storage
+   * declaration and initializing assignment are pushed before the current
+   * statement's IR, registered in the list's scope frame) and the statement
+   * loop skips the source statement when it arrives
+   * (lowerer.hoistedFnDecls). Same-function only: the declaration's own
    * lowering runs under the ctx that owns its statement list, and a
    * cross-function early capture would need lowering under a DIFFERENT
    * ctx than the one currently open — that shape keeps the honest fence. */
@@ -705,6 +706,9 @@ function varBindingType(lowerer, nameNode) {
                 (uncheckedOverloadHandleCall(lowerer, nameNode.parent.initializer) ? JSVAL : null) ??
                 type;
     }
+    if (!lowerer.dynamic && ts.isVariableDeclaration(nameNode.parent) && nameNode.parent.name === nameNode) {
+        type = staticImportNamespaceType(lowerer, nameNode.parent.initializer) ?? type;
+    }
     if (!type || type.kind === "void")
         return null;
     return type;
@@ -1086,7 +1090,8 @@ export function lowerStmt(lowerer, stmt) {
         return null;
     if (ts.isFunctionDeclaration(stmt)) {
         // Already lowered eagerly by the forward-hoisting machinery
-        // (predeclareForwardFnDecl) — the varDecl is in the list's output.
+        // (predeclareForwardFnDecl) — its declaration and assignment are in
+        // the list's output.
         if (lowerer.hoistedFnDecls.has(stmt))
             return null;
         return lowerer.lowerNestedFunctionDecl(stmt);
@@ -1121,6 +1126,18 @@ export function lowerVarStatement(lowerer, stmt) {
     const isConst = (list.flags & ts.NodeFlags.Const) !== 0;
     const isLet = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
     return list.declarations.flatMap((decl) => {
+        // The canonical ESM bridge to a compiled program module. Like a
+        // top-level CommonJS require declaration, the binding is alias
+        // plumbing while the dependency evaluates at this statement's
+        // exact position through its run-once initializer.
+        if (isConst && createRequireProgramModuleDecl(lowerer, decl.name, decl.initializer)) {
+            if (!ts.isSourceFile(stmt.parent)) {
+                lowerer.unsupported("SC1090", decl, "createRequire program-module bindings outside the module's top level (move the binding to the top of the file; side-effect-only requires may remain nested)");
+            }
+            const target = createRequireProgramModuleOf(lowerer, decl.initializer);
+            const init = lowerer.requireInitStmt(target.spec, decl);
+            return init ? [init] : [];
+        }
         // CommonJS require declarations (JS files): at the module's top
         // level the BINDINGS are alias plumbing (no storage;
         // resolveValueSymbol routes the reads), but the require itself is
@@ -3302,13 +3319,10 @@ export function lowerVarDecl(lowerer, decl, isLet) {
             (ts.canHaveModifiers(s) && ts.getModifiers(s)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true))) {
         lowerer.unsupported("SC1090", decl.name, `initializer-less top-level declarations named '${decl.name.text}' in an import/export-free file (Node hosts the file as CommonJS, where the wrapper's own binding keeps its value — the declaration reads as the module object there, which has no lowering; rename the variable or give it an initializer)`);
     }
-    // `const execFileAsync = promisify(execFile)` — the one lowered
-    // util.promisify shape: the binding registers (calls through it lower
-    // to the interned async-exec helper; value uses fence) and the
-    // declaration itself emits nothing — the promisified function value
-    // never exists at runtime. collectGlobals skipped registering a
-    // module global for it by the same test.
-    if (lowerer.promisifiedExecFileDecl(decl.name, decl.initializer))
+    // `const asyncFn = promisify(supportedBuiltin)`: the binding registers
+    // a static callable projection; calls route to the target's promise
+    // lowering and the declaration emits no runtime slot.
+    if (lowerer.registerPromisifiedBuiltinDecl(decl.name, decl.initializer))
         return null;
     // `const inspect = require("util").inspect` — a named import in const
     // clothing: builtinImportOf resolves uses through the module tables;
@@ -3340,7 +3354,16 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         return null;
     // `const process = globalThis.process` — a stdlib-global snapshot:
     // alias plumbing (see stdlibGlobalAliasDecl), no storage, no code.
-    if (!isLet && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
+    const stableStdlibAlias = !isLet ||
+        (ts.isVariableDeclarationList(decl.parent) &&
+            (decl.parent.flags & ts.NodeFlags.Let) !== 0 &&
+            ts.isIdentifier(decl.name) &&
+            stdlibGlobalAliasNameOf(lowerer, decl.initializer) !== null &&
+            (() => {
+                const symbol = lowerer.checker.getSymbolAtLocation(decl.name);
+                return symbol !== undefined && bindingNeverReassigned(lowerer, symbol, decl);
+            })());
+    if (stableStdlibAlias && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
         return null;
     // `const encoder = new TextEncoder()` and a statically-labelled
     // TextDecoder twin: the codec has no general value representation, but calls
@@ -3371,6 +3394,13 @@ export function lowerVarDecl(lowerer, decl, isLet) {
     // globals by the same test; block-scoped aliases register here).
     if (bindingGenericFnAliasInfoOf(lowerer, decl))
         return null;
+    // `const stored = overloadedDeclaration`: no runtime slot is needed;
+    // calls project onto the declaration's implementation ABI and value
+    // reads reuse its interned closure identity.
+    if (!isLet && registerOverloadedCallableAlias(lowerer, decl))
+        return null;
+    if (!isLet && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer))
+        return null;
     // `const knownBy = (cmd) => ...` — an IMPLICIT-ANY function-value
     // binding in npm-static JS (function-scope bindings register here, in
     // source order before any use can lower; file-scope ones registered at
@@ -3564,6 +3594,8 @@ export function lowerVarDecl(lowerer, decl, isLet) {
         // island members).
         (lowerer.dynamic && init.type.kind === "dyn" && jsvalFlavoredType(lowerer.mapTypeOf(lowerer.typeOf(decl.name)) ?? DYN) ? DYN : null) ??
         (bindingTainted ? null : lowerer.mapTypeOf(lowerer.typeOf(decl.name))) ??
+        staticImportNamespaceType(lowerer, decl.initializer) ??
+        (init.type.kind === "moduleNs" ? init.type : null) ??
         (init.type.kind === "dyn" ? DYN : null);
     if (lowerer.implicitParamTypes !== null &&
         init.type.kind === "dyn" &&
@@ -4276,7 +4308,7 @@ function lowerCjsExportStatement(lowerer, cjs) {
         if (discarded !== null)
             lowerer.unsupported("SC1090", cjs.expr, discarded);
     }
-    const assignExport = (nameNode, value) => {
+    const assignExport = (nameNode, value, root) => {
         const symbol = lowerer.checker.getSymbolAtLocation(nameNode) ??
             (ts.isIdentifier(nameNode) || ts.isPrivateIdentifier(nameNode)
                 ? lowerer.cjsModuleExportSymbol(cjs.expr.getSourceFile(), nameNode.text)
@@ -4288,7 +4320,42 @@ function lowerCjsExportStatement(lowerer, cjs) {
             lowerer.lowerExpr(value);
             lowerer.badType(value, lowerer.typeOf(value));
         }
-        return { kind: "assign", localId: g.id, value: lowerer.lowerExprExpecting(value, g.type), loc: locOf(value) };
+        const lowered = lowerer.lowerExprExpecting(value, g.type);
+        if (root?.type.kind !== "dyn" || !ts.isIdentifier(nameNode)) {
+            return { kind: "assign", localId: g.id, value: lowered, loc: locOf(value) };
+        }
+        // A factory whole export is represented by its checked-dynamic root.
+        // A later `module.exports.name = value` mutates THAT same object in
+        // Node; the separate export global exists only so named-import and
+        // lexer-visible member paths have a static snapshot. Evaluate the
+        // RHS once, perform the observable object write first (it may throw
+        // if a factory returned a primitive), then publish the snapshot.
+        const saved = lowerer.declareHiddenLocal("%cjsMember", g.type);
+        const savedRef = () => ({ kind: "varRef", localId: saved.id, type: g.type, loc: locOf(value) });
+        const dynValue = lowerer.coerceInto(value, savedRef(), DYN);
+        return {
+            kind: "block",
+            body: [
+                { kind: "varDecl", localId: saved.id, init: lowered, loc: locOf(value) },
+                {
+                    kind: "exprStmt",
+                    expr: {
+                        kind: "libCall",
+                        fn: "dyn.keySet",
+                        args: [
+                            { kind: "varRef", localId: root.id, type: DYN, loc },
+                            { kind: "strLit", value: nameNode.text, type: STRING, loc: locOf(nameNode) },
+                            dynValue,
+                        ],
+                        type: VOID,
+                        loc,
+                    },
+                    loc,
+                },
+                { kind: "assign", localId: g.id, value: savedRef(), loc: locOf(value) },
+            ],
+            loc,
+        };
     };
     if (cjs.kind === "member") {
         if (!ts.isIdentifier(cjs.name)) {
@@ -4350,7 +4417,15 @@ function lowerCjsExportStatement(lowerer, cjs) {
                     return { kind: "block", body: [], loc };
             }
         }
-        return assignExport(cjs.name, cjs.value);
+        const sf = cjs.expr.getSourceFile();
+        let root;
+        for (const stmt of sf.statements) {
+            const whole = cjsExportAssignmentOf(stmt);
+            if (whole?.kind !== "table" || cjsExportDiscardReason(stmt) !== null)
+                continue;
+            root = lowerer.globalsByDeclNode.get(whole.expr);
+        }
+        return assignExport(cjs.name, cjs.value, root);
     }
     let tableObj = cjs.obj;
     let resolvedTarget = false;
@@ -4494,6 +4569,21 @@ export function lowerExprStatement(lowerer, expr) {
     const stmtNode = expr.parent;
     while (ts.isParenthesizedExpression(expr))
         expr = expr.expression;
+    // A discarded conditional has no value to merge: represent its lazy
+    // branch selection directly as statement control flow. In particular,
+    // both arms may be void calls (`flag ? emitA() : emitB()`), for which a
+    // value-shaped void ternary has no IR representation. Preserve the same
+    // narrowing environments as a source if statement, and lower only a
+    // statically selected arm when the condition folded without effects.
+    if (ts.isConditionalExpression(expr)) {
+        const cond = lowerer.lowerCondition(expr.condition);
+        if (cond.kind === "boolLit") {
+            return lowerExprStatement(lowerer, cond.value ? expr.whenTrue : expr.whenFalse);
+        }
+        const then = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, expr.condition, true), () => withRuntimeOptionalNarrowed(lowerer, runtimeOptionalTrueIds(lowerer, expr.condition), () => [lowerExprStatement(lowerer, expr.whenTrue)]));
+        const else_ = lowerer.narrowingAliases(aliasTypeofNarrows(lowerer, expr.condition, false), () => [lowerExprStatement(lowerer, expr.whenFalse)]);
+        return { kind: "if", cond, then, else_, loc: locOf(expr) };
+    }
     // Assignment statements over the no-storage binding families:
     //   - `f1 = f2` where the RHS roots at an ambient-undefined name:
     //     Node evaluates the RHS first and dies on the root's
@@ -4559,6 +4649,27 @@ export function lowerExprStatement(lowerer, expr) {
         ts.isExpressionStatement(stmtNode) &&
         ts.isSourceFile(stmtNode.parent) &&
         isJsSourceFile(stmtNode.parent);
+    // createRequire's side-effect program-module form uses the same inline
+    // run-once initializer as a CommonJS require statement. The expression
+    // has no represented namespace value in statement position.
+    if (ts.isCallExpression(expr)) {
+        const created = createRequireProgramModuleOf(lowerer, expr);
+        if (created !== null) {
+            return lowerer.requireInitStmt(created.spec, expr) ?? { kind: "block", body: [], loc: locOf(expr) };
+        }
+        // syncBuiltinESMExports() is the other compiler-only statement: the
+        // call validates its zero-argument shape, then emits no code because
+        // the static builtin surface is immutable.
+        const bi = ts.isIdentifier(expr.expression)
+            ? lowerer.builtinImportOf(expr.expression)
+            : ts.isPropertyAccessExpression(expr.expression)
+                ? lowerer.builtinMemberOf(expr.expression)
+                : null;
+        if (bi?.module === "module" && bi.member === "syncBuiltinESMExports") {
+            lowerNodeModuleCall(lowerer, expr, bi, locOf(expr));
+            return { kind: "block", body: [], loc: locOf(expr) };
+        }
+    }
     if (requireSpecOf(expr) !== null &&
         ts.isCallExpression(expr) &&
         ts.isIdentifier(expr.expression) &&
@@ -4855,6 +4966,15 @@ export function lowerExprStatement(lowerer, expr) {
                         }
                     }
                 }
+                if (!expr.left.questionDotToken && lowerer.stdlibGlobalMember(expr.left, "process") === "exitCode") {
+                    const loc = locOf(expr);
+                    const value = lowerer.lowerExprExpecting(expr.right, F64);
+                    return {
+                        kind: "exprStmt",
+                        expr: { kind: "libCall", fn: "process.setExitCode", args: [value], type: VOID, loc },
+                        loc,
+                    };
+                }
                 // `r._read = fn` / `w._write = fn` (and the other underscore
                 // methods) on a runtime-stream-rooted receiver: Node's
                 // own-property shadow of the prototype method — the runtime