@scriptc/compiler 0.1.3 → 0.1.5

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

@@ -8,22 +8,22 @@ 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 { abstractPropertyDeclOf, aliasTypeofNarrows, isMatchSliceType, lowerAbsenceProbe, lowerElementCompound, lowerGroupsProjection, lowerOptionalNumber, matchResultNamedGroupsOf, runtimeOptionalTrueIds, symbolFieldInfo, withRuntimeOptionalNarrowed } from "./lower-exprs.js";
 import { isSafeToRepeat } from "./expressions/evaluation-safety.js";
 import { tryLowerExpression } from "./expressions/try-lower-expression.js";
 import { checkerPanicDiag, isCheckerPanic, requiresDynamicDiag } from "../../diagnostics/diagnostic.js";
@@ -706,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;
@@ -1123,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
@@ -3304,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;
@@ -3342,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
@@ -3373,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
@@ -3566,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" &&
@@ -4278,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)
@@ -4290,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)) {
@@ -4352,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;
@@ -4576,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) &&
@@ -4872,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
@@ -4969,12 +5072,12 @@ export function lowerExprStatement(lowerer, expr) {
             // Desugar `x op= e` to `x = x op e` — reads x before e, like JS.
             if (ts.isElementAccessExpression(expr.left)) {
                 // `this[kLimit] += v` — a declared symbol-keyed class field is
-                // the dotted compound in element spelling; every other element
-                // target keeps the fence.
+                // the dotted compound in element spelling. Array and byte-view
+                // elements use the sequenced indexed compound path.
                 if (symbolFieldInfo(lowerer, expr.left)) {
                     return lowerer.lowerFieldCompound(expr.left, compound, expr.right, locOf(expr));
                 }
-                lowerer.unsupported("SC1090", expr.left, "compound array-element assignment (a[i] += v)");
+                return { kind: "exprStmt", expr: lowerElementCompound(lowerer, expr, compound), loc: locOf(expr) };
             }
             if (ts.isPropertyAccessExpression(expr.left)) {
                 // `N.x += v` — the namespace-qualified spelling of a module-