@scriptc/compiler 0.1.2 → 0.1.4

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

@@ -10,19 +10,76 @@ import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport } from "../program.js";
 import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag } from "../../diagnostics/diagnostic.js";
-import { BOOL, DYN, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canConvertToDyn, isUnitType } from "../../ir/ir.js";
-import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, isPromisifyCall, textCodecBindingDecl } from "./lower-builtins.js";
-import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf } from "./lower-calls.js";
+import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canConvertToDyn, isUnitType } from "../../ir/ir.js";
+import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall } from "./lowerer.js";
+import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, textCodecBindingDecl } from "./lower-builtins.js";
+import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
-import { stdlibGlobalAliasDecl } from "./surfaces.js";
+import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf } from "./surfaces.js";
 import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
 import { decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
+import { forkTargetPaths } from "../fork-target.js";
+/** Program modules selected by statically resolved child_process.fork()
+ * calls join the compiled graph without becoming startup dependencies of
+ * the parent entry. Their guarded init functions are selected by %main only
+ * in a re-executed fork child. `targets` is append-only so ids stay stable
+ * across the dynamic-import/fork discovery fixpoint. */
+export function appendForkModules(program, order, targets, onCycle) {
+    if (order.length === 0)
+        return;
+    const byPath = new Map(program.getSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
+    const state = new Map();
+    for (const sf of order)
+        state.set(sf, "done");
+    const added = [];
+    const stack = [];
+    const staticEdgesOf = (sf) => orderedImportsOf(program, sf).flatMap(({ stmt, dep }) => dep !== null && dep !== sf
+        ? [{ dep, stmt: stmt }]
+        : []);
+    const cycleAdmissionReason = makeCycleAdmission(program, staticEdgesOf);
+    const visit = (sf) => {
+        const prior = state.get(sf);
+        if (prior === "done")
+            return;
+        state.set(sf, "visiting");
+        stack.push(sf.fileName);
+        for (const edge of staticEdgesOf(sf)) {
+            const edgeState = state.get(edge.dep);
+            if (edgeState === "done")
+                continue;
+            if (edgeState === "visiting") {
+                const reason = cycleAdmissionReason(sf, edge);
+                if (reason !== null) {
+                    const cycleStart = stack.indexOf(edge.dep.fileName);
+                    onCycle([...stack.slice(cycleStart), edge.dep.fileName].join(" → "), reason);
+                }
+                continue;
+            }
+            visit(edge.dep);
+        }
+        stack.pop();
+        state.set(sf, "done");
+        added.push(sf);
+    };
+    const knownTargets = new Set(targets);
+    for (const path of forkTargetPaths(program, order)) {
+        const target = byPath.get(resolvePath(path));
+        if (!target || target.isDeclarationFile || target.fileName.endsWith(".json"))
+            continue;
+        if (!knownTargets.has(target)) {
+            knownTargets.add(target);
+            targets.push(target);
+        }
+        visit(target);
+    }
+    if (added.length > 0)
+        order.splice(order.length - 1, 0, ...added);
+}
 /** Splits each file into function/class declarations and the top-level
    * statements that form its init body. Node's evaluation order (depth-first
    * postorder, entry last), computed by preflight. Single-file programs
@@ -255,6 +312,14 @@ export function collectNpmImports(lowerer, parts) {
             // fences are the whole story.
             if (lowerer.externalTypes.has(spec))
                 continue;
+            // A source-only workspace package is part of the program module
+            // graph: resolveImport follows its node_modules link to the loaded
+            // TypeScript entry. Its internal `.js` spellings have already been
+            // resolved to `.ts` by that graph, and no source may be handed to
+            // the JavaScript island.
+            if (!isRelativeSpecifier(spec) && resolveImport(lowerer.program, fp.sf, spec) !== null) {
+                continue;
+            }
             const npm = resolveNpmImport(fp.sf.fileName, spec);
             // --npm-static: an opted-in package that made it through preflight
             // is a PROGRAM-MODULE dependency — its entry sits in the module
@@ -374,9 +439,9 @@ export function collectNpmImports(lowerer, parts) {
             }
         }
     }
+    for (const fp of parts)
+        collectDynamicImports(lowerer, builder, fp.sf);
     if (builder) {
-        for (const fp of parts)
-            collectDynamicImports(lowerer, builder, fp.sf);
         for (const fp of parts)
             collectCreateRequires(lowerer, builder, fp.sf);
         const graph = builder.finish();
@@ -389,11 +454,13 @@ export function collectNpmImports(lowerer, parts) {
             lowerer.npmLazyTraps = graph.lazyTraps;
     }
 }
-/** The dynamic-import half of the npm chokepoint (--dynamic only): every
+/** Literal dynamic-import collection: every
    * `import("literal")` in the file — whatever body it sits in — resolves
    * and embeds AT COLLECTION time, so the per-site lowering later just
    * looks its key up (the emitted tables are assembled once, here; a
    * site lowered in any pass finds its module embedded). Resolution
+   * In static builds this records compiled program modules and supported
+   * builtins without constructing an npm graph. Dynamic package-resolution
    * failures and unshimmed builtins are diagnostics HERE, at the import
    * expression, exactly like static npm imports at their statements; the
    * lowering poisons those sites without re-reporting. Non-literal
@@ -401,7 +468,7 @@ export function collectNpmImports(lowerer, parts) {
    * graph is a build-time artifact; there is nothing to embed for a
    * runtime-computed name). */
 function collectDynamicImports(lowerer, builder, sf) {
-    const visit = (node) => {
+    ts.walkPreorder(sf, (node) => {
         if (ts.isCallExpression(node) &&
             node.expression.kind === ts.SyntaxKind.ImportKeyword &&
             node.arguments.length >= 1 &&
@@ -409,8 +476,7 @@ function collectDynamicImports(lowerer, builder, sf) {
             ts.isStringLiteralLike(node.arguments[0])) {
             const spec = node.arguments[0].text;
             if (lowerer.externalTypes.has(spec)) {
-                ts.forEachChild(node, visit);
-                return;
+                return undefined;
             }
             const mapKey = `${sf.fileName}\u0000${spec}`;
             if (!lowerer.dynImports.has(mapKey)) {
@@ -421,9 +487,15 @@ function collectDynamicImports(lowerer, builder, sf) {
                 // .d.mts typing shipped JS is the EMBED case, not this one.
                 const modSym = lowerer.checker.getSymbolAtLocation(node.arguments[0]);
                 const ownModule = modSym !== undefined && lowerer.checker.declarationsOf(modSym).some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
+                const builtin = canonicalBuiltinModule(spec);
                 const res = ownModule
                     ? { kind: "program-module" }
-                    : builder.addDynamicImport(sf.fileName, spec);
+                    : !lowerer.dynamic && builtin !== null
+                        ? { kind: "static-builtin", module: builtin }
+                        : builder?.addDynamicImport(sf.fileName, spec);
+                if (res === undefined) {
+                    return undefined;
+                }
                 lowerer.dynImports.set(mapKey, res);
                 if (res.kind === "unsupported-builtin") {
                     lowerer.pushDiag(npmEmbedFailedDiag(`'${spec}' is a Node builtin the island does not provide a shim for`, locOf(node)));
@@ -433,9 +505,8 @@ function collectDynamicImports(lowerer, builder, sf) {
                 }
             }
         }
-        ts.forEachChild(node, visit);
-    };
-    visit(sf);
+        return undefined;
+    });
 }
 /** The createRequire half of the npm chokepoint (--dynamic only): every
    * `require("bare-literal")` through a createRequire binding — whatever
@@ -957,11 +1028,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 // included); unmappable pieces take the JS checked-dynamic
                 // fallback like every JS binding.
                 const fnValued = ts.isFunctionExpression(rhs) || ts.isArrowFunction(rhs);
-                if (cjsScalarLiteral(rhs) || fnValued) {
+                // A factory-returned CommonJS root (`module.exports = make()`)
+                // is a single value just like the scalar/function forms above
+                // when its result has a static or checked-dynamic representation. Register one
+                // snapshot slot keyed by the export-assignment declaration; the
+                // statement lowering evaluates the call exactly once at its
+                // source position and assigns that slot. Unmappable calls retain
+                // the existing statement-level fence.
+                const factoryValued = ts.isCallExpression(rhs);
+                if (cjsScalarLiteral(rhs) || fnValued || factoryValued) {
                     const diagsBefore = lowerer.diags.length;
                     try {
                         const strict = lowerer.typeOf(rhs);
-                        const t = lowerer.mapTypeOf(strict) ?? (fnValued ? dynFallbackType(lowerer, rhs, strict) : null);
+                        const t = lowerer.mapTypeOf(strict) ??
+                            (fnValued || factoryValued ? dynFallbackType(lowerer, rhs, strict) : null);
                         if (t && t.kind !== "void") {
                             const g = { id: `%g.${tag}exports`, name: "exports", type: t, mutable: false };
                             lowerer.globalsByDeclNode.set(cjs.expr, g);
@@ -1203,6 +1283,13 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 if (aliased)
                     continue;
             }
+            // An immutable alias of an overloaded declared function is a
+            // compile-time callable projection: calls retain per-site overload
+            // resolution and value reads reuse the source's interned closure.
+            if (isConst && registerOverloadedCallableAlias(lowerer, decl))
+                continue;
+            if (isConst && registerBuiltinCallableAlias(lowerer, decl.name, decl.initializer))
+                continue;
             // `const f = (x) => ...` at file scope of an npm-static JS file
             // whose params are implicit-any: the implicit-monomorphization
             // twin of the generic binding above — no global exists; calls and
@@ -1256,7 +1343,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // lowering poisons too, like every collectGlobals failure).
             if (ts.isIdentifier(decl.name) && decl.initializer && isPromisifyCall(lowerer, decl.initializer)) {
                 try {
-                    lowerer.promisifiedExecFileDecl(decl.name, decl.initializer);
+                    lowerer.registerPromisifiedBuiltinDecl(decl.name, decl.initializer);
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
@@ -1279,6 +1366,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // scope — a namespace import in const clothing, same story.
             if (isConst && createRequireNamespaceDecl(lowerer, decl.name, decl.initializer))
                 continue;
+            // `const local = require("./local.cjs")` through createRequire:
+            // the binding is static module alias plumbing. Its statement emits
+            // the dependency init at this exact source position; no value slot
+            // represents the namespace object itself.
+            if (isConst && createRequireProgramModuleDecl(lowerer, decl.name, decl.initializer))
+                continue;
             // `const { createSign } = crypto` over a builtin NAMESPACE binding
             // at file scope: alias plumbing like the destructured-require form
             // — no storage (the statement lowering skips by the same test).
@@ -1300,7 +1393,15 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // global snapshot — alias plumbing, no global storage (see
             // stdlibGlobalAliasDecl; the statement lowering skips it by the
             // same test).
-            if (isConst && stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer))
+            const stableStdlibAlias = isConst ||
+                ((list.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))
                 continue;
             // Stored default TextEncoder/TextDecoder instances are the same
             // compile-time alias plumbing as their statement lowering: calls
@@ -1429,11 +1530,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // production — whatever the checker's namespace type mapped to
                     // (lowerVarDecl's rule at module scope; the init body assigns
                     // it).
-                    const handleT = lowerer.dynamic && ts.isIdentifier(decl.name) && nameNode === decl.name
-                        ? (importCallHandleType(decl.initializer) ??
-                            // An unchecked-overload call result stores the handle,
-                            // exactly the local rule (uncheckedOverloadHandleCall).
-                            (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null))
+                    const handleT = ts.isIdentifier(decl.name) && nameNode === decl.name
+                        ? (lowerer.dynamic ? importCallHandleType(decl.initializer) : staticImportNamespaceType(lowerer, decl.initializer)) ??
+                            (lowerer.dynamic ?
+                                // An unchecked-overload call result stores the handle,
+                                // exactly the local rule (uncheckedOverloadHandleCall).
+                                (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
                         : null;
                     let type = handleT ?? lowerer.irTypeOf(nameNode);
                     // An evolving-`any` array's DERIVED file-scope binding under
@@ -1999,24 +2101,76 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
    * re-imports, re-requires) into a cache hit. */
 export function buildMain(lowerer) {
     const loc = { file: lowerer.entry.fileName, start: 0, end: 0 };
-    const entryInit = lowerer.initNameOf.get(lowerer.entry);
-    const isAsync = lowerer.asyncInitFiles.has(lowerer.entry);
-    const initCall = entryInit !== undefined
-        ? {
+    const body = [...cjsModuleRegistryPrelude(lowerer, loc)];
+    const roots = [lowerer.entry, ...lowerer.forkTargets];
+    const isAsync = roots.some((root) => lowerer.asyncInitFiles.has(root));
+    const callRoot = (root) => {
+        const init = lowerer.initNameOf.get(root);
+        if (init === undefined)
+            return [];
+        const rootAsync = lowerer.asyncInitFiles.has(root);
+        const call = {
             kind: "call",
-            callee: entryInit,
+            callee: init,
             args: [],
-            type: isAsync ? { kind: "promise", inner: VOID } : VOID,
+            type: rootAsync ? { kind: "promise", inner: VOID } : VOID,
             loc,
+        };
+        return [{
+                kind: "exprStmt",
+                expr: rootAsync ? { kind: "awaitExpr", value: call, type: VOID, loc } : call,
+                loc,
+            }];
+    };
+    const locals = [];
+    if (lowerer.forkTargets.length === 0) {
+        body.push(...callRoot(lowerer.entry));
+    }
+    else {
+        const targetId = "%forkTarget.0";
+        locals.push({ id: targetId, name: "%forkTarget", type: F64, mutable: false });
+        body.push({
+            kind: "varDecl",
+            localId: targetId,
+            init: {
+                kind: "libCall",
+                fn: "process.forkTarget",
+                args: [{ kind: "numLit", value: lowerer.forkTargets.length, type: F64, loc }],
+                type: F64,
+                loc,
+            },
+            loc,
+        });
+        const selector = () => ({ kind: "varRef", localId: targetId, type: F64, loc });
+        let workerBranch = null;
+        for (let id = lowerer.forkTargets.length - 1; id >= 0; id--) {
+            workerBranch = [{
+                    kind: "if",
+                    cond: {
+                        kind: "bin",
+                        op: "===",
+                        left: selector(),
+                        right: { kind: "numLit", value: id, type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    then: callRoot(lowerer.forkTargets[id]),
+                    else_: workerBranch,
+                    loc,
+                }];
         }
-        : null;
-    const body = [...cjsModuleRegistryPrelude(lowerer, loc)];
-    if (initCall !== null) {
         body.push({
-            kind: "exprStmt",
-            expr: isAsync
-                ? { kind: "awaitExpr", value: initCall, type: VOID, loc }
-                : initCall,
+            kind: "if",
+            cond: {
+                kind: "bin",
+                op: "<",
+                left: selector(),
+                right: { kind: "numLit", value: 0, type: F64, loc },
+                type: BOOL,
+                loc,
+            },
+            then: callRoot(lowerer.entry),
+            else_: workerBranch,
             loc,
         });
     }
@@ -2046,7 +2200,7 @@ export function buildMain(lowerer) {
         name: ENTRY_NAME,
         params: [],
         returnType: VOID,
-        locals: [],
+        locals,
         body,
         ...(isAsync ? { async: true } : {}),
         loc,