@scriptc/compiler 0.0.10 → 0.0.12

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

@@ -4,19 +4,19 @@
  * the module artifacts (globals, embedded npm tables) the IR module carries. */
 import * as ts from "../ts7/adapter.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
-import { NpmGraphBuilder, packageNameOfPath, probeNodeImportRefusal } from "../npm.js";
+import { NpmGraphBuilder, packageNameOfPath, probeNodeImportRefusal, probeNodeRequireRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName, isRelativeSpecifier } from "../shared.js";
-import { cjsExportAssignmentOf, cjsExportDiscardReason, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, orderedImportsOf, resolveImport, resolveNpmImport } from "../program.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/nodes.js";
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefinedExpr, importCallHandleType, newFnCtx, uncheckedOverloadHandleCall } from "./lowerer.js";
-import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, isPromisifyCall } from "./lower-builtins.js";
+import { builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, isPromisifyCall } from "./lower-builtins.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, deadUnmappableBinding, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf } from "./lower-calls.js";
 import { isVarDeclared, provenanceElidedConstDecl } from "./lower-stmts.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl } from "./surfaces.js";
-import { ambientUndefVarRootOf, collectNamespaceStmt, nsPathPrefix } from "./lower-namespaces.js";
+import { collectNamespaceStmt, nsPathPrefix, trapDeclRootOf } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../types.js";
 import { decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow } from "./lower-classes.js";
@@ -101,10 +101,13 @@ function dynamicProgramImportsOf(program, sf) {
    * still evaluates exactly when Node evaluates it: the import() site's
    * namespace builder calls the guarded init on the engine microtask.
    * Fixpoint: an added module's own import() sites are scanned too. Static
-   * cycles inside the added subgraph get preflight's SC1016 via `onCycle`
-   * (preflight only walked the entry's static graph, so it never saw
-   * these). Idempotent — re-running on an already-extended order adds
-   * nothing (both lowering passes share one array). */
+   * cycles inside the added subgraph ride preflight's own admission engine
+   * (makeCycleAdmission — preflight only walked the entry's static graph,
+   * so it never judged these): benign back edges are Node cache hits the
+   * run-once init guards reproduce, and inadmissible ones get preflight's
+   * SC1016 with the same narrowed reason via `onCycle`. Idempotent —
+   * re-running on an already-extended order adds nothing (both lowering
+   * passes share one array). */
 export function appendDynamicImportModules(program, order, onCycle) {
     if (order.length === 0)
         return; // no preflight order — sites keep their fences
@@ -113,20 +116,31 @@ export function appendDynamicImportModules(program, order, onCycle) {
         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 s = state.get(sf);
-        if (s === "done")
+        if (state.get(sf) !== undefined)
             return;
-        if (s === "visiting") {
-            const cycleStart = stack.indexOf(sf.fileName);
-            onCycle([...stack.slice(cycleStart), sf.fileName].join(" → "));
-            return;
-        }
         state.set(sf, "visiting");
         stack.push(sf.fileName);
-        for (const { dep } of orderedImportsOf(program, sf))
-            if (dep && dep !== sf)
-                visit(dep);
+        for (const e of staticEdgesOf(sf)) {
+            const s = state.get(e.dep);
+            if (s === "done")
+                continue;
+            if (s === "visiting") {
+                // A back edge: Node answers it from the cache. Same admission
+                // question as preflight's static walk, same fence when refused.
+                const reason = cycleAdmissionReason(sf, e);
+                if (reason !== null) {
+                    const cycleStart = stack.indexOf(e.dep.fileName);
+                    onCycle([...stack.slice(cycleStart), e.dep.fileName].join(" → "), reason);
+                }
+                continue;
+            }
+            visit(e.dep);
+        }
         stack.pop();
         state.set(sf, "done");
         added.push(sf);
@@ -356,6 +370,8 @@ export function collectNpmImports(L, parts) {
     if (builder) {
         for (const fp of parts)
             collectDynamicImports(L, builder, fp.sf);
+        for (const fp of parts)
+            collectCreateRequires(L, builder, fp.sf);
         const graph = builder.finish();
         if (graph.modules.length > 0) {
             L.npmEmbedded = { modules: graph.modules, edges: graph.edges };
@@ -410,6 +426,47 @@ function collectDynamicImports(L, builder, sf) {
     };
     visit(sf);
 }
+/** The createRequire half of the npm chokepoint (--dynamic only): every
+   * `require("bare-literal")` through a createRequire binding — whatever
+   * body it sits in — resolves under Node's "require" condition and
+   * embeds AT COLLECTION time, so the per-site lowering later just looks
+   * its entry up (lowerCreateRequireCall). Builtins, relative documents,
+   * "#" specifiers, --npm-static opt-ins, and Node-refused bare names
+   * are the lowering's own arms — only resolvable installed packages
+   * register here; resolution failures are diagnostics at the call
+   * expression, exactly like static npm imports at their statements. */
+function collectCreateRequires(L, builder, sf) {
+    const visit = (node) => {
+        if (ts.isCallExpression(node)) {
+            const cr = createRequireSpecOf(L, node);
+            const spec = cr?.spec ?? null;
+            if (cr !== null &&
+                spec !== null &&
+                canonicalBuiltinModule(spec) === null &&
+                !isRelativeSpecifier(spec) &&
+                !spec.startsWith("/") &&
+                !spec.startsWith("#") &&
+                probeNodeRequireRefusal(cr.baseFile.fileName, spec) === null) {
+                const pkgName = spec.startsWith("@")
+                    ? spec.split("/").slice(0, 2).join("/")
+                    : spec.split("/")[0];
+                const mapKey = `${cr.baseFile.fileName}\u0000${spec}`;
+                if (!L.createRequireImports.has(mapKey) && !isNpmStaticPackage(pkgName)) {
+                    const before = builder.errors.length;
+                    const entryKey = builder.addRequire(cr.baseFile.fileName, spec);
+                    for (const err of builder.errors.slice(before)) {
+                        L.pushDiag(npmEmbedFailedDiag(err.message, locOf(node)));
+                    }
+                    L.createRequireImports.set(mapKey, entryKey === null
+                        ? ""
+                        : { entryKey, format: builder.moduleFormatOf(entryKey) ?? "cjs" });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sf);
+}
 /** JSON module default imports (`import pkg from "../package.json"`):
    * the document is DATA known at build time, so the binding bakes into a
    * record global — the checker's structural type for the module (thanks
@@ -639,7 +696,7 @@ function cjsScalarLiteral(e) {
 /** True when a JS file-scope declaration's initializer provably LOWERS to
  * a checked-dynamic (or unit) value, so a DYN module global can hold it:
  * no initializer, a unit literal, or a checker-`any` call/member/
- * identifier read (any-typed operations lower through the DOM in JS).
+ * identifier read (any-typed operations lower through the checked-dynamic tree in JS).
  * `new` expressions stay OUT even when checker-any (`new Anon.Sub()` over
  * an expando class member constructs a TYPED instance — corpus 2032), as
  * does everything else (object/array literals have their own rules;
@@ -661,7 +718,7 @@ function jsDynHoldableInitializer(L, init) {
     // A CALL whose inferred type has no static mapping and whose residue
     // falls to the checked-dynamic kind (`const exec = common.mustCall(() =>
     // ... exec ...)` — the wrapper's rest-args type is not checker-`any`,
-    // but the VALUE lowers through the DOM the same way): registering the
+    // but the VALUE lowers through the checked-dynamic tree the same way): registering the
     // dyn global BEFORE the initializer lowers is what lets the callback
     // capture the binding itself — the Node-suite self-referential-const
     // idiom. Non-dyn residues (pure single-signature function types, typed
@@ -802,7 +859,7 @@ export function collectGlobals(L, sf, topStmts) {
                     const t = L.mapTypeOf(strict) ?? dynFallbackType(L, nameNode, strict);
                     if (!t || t.kind === "void")
                         L.badType(typeNode, strict);
-                    // `module.exports.Strings = Strings` naming a DOM-HOLDING
+                    // `module.exports.Strings = Strings` naming a dyn-HOLDING
                     // const (the JS file-scope object-literal identity story): the
                     // export ALIASES the const's own dyn global — one storage, one
                     // owner, identity by construction (a record-typed second slot
@@ -826,7 +883,7 @@ export function collectGlobals(L, sf, topStmts) {
                                         L.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
-                                // A mutable (`let`) DOM source: separate DYN storage IS
+                                // A mutable (`let`) dyn source: separate DYN storage IS
                                 // Node's copy-of-the-reference at this statement (later
                                 // reassignments of the let stay invisible through the
                                 // export). The id must not collide with the let's own
@@ -1025,37 +1082,65 @@ export function collectGlobals(L, sf, topStmts) {
             // and put its fences on the build.
             if (provenanceElidedConstDecl(L, decl))
                 continue;
-            // A TRAP declaration at file scope — the initializer's chain roots
-            // at an ambient-undefined name (`declare const t: Type<string>;
-            // export const out = t.pipe(...)`): Node throws the root's
-            // ReferenceError evaluating the initializer, so no value ever
-            // exists and no reference can ever run. No global registers; the
-            // binding enters trapBindings (registered HERE, before any body
-            // lowers, so hoisted-function references resolve the trap), and
-            // the statement lowering emits the throw at its position.
-            if (decl.initializer !== undefined && ambientUndefVarRootOf(L, decl.initializer) !== null) {
-                for (const nameNode of boundIdentifiersOf(decl.name)) {
-                    const sym = L.checker.getSymbolAtLocation(nameNode);
-                    if (sym)
-                        L.trapBindings.add(sym);
+            // The trap/nullish/dead classification probes below resolve
+            // symbols INSIDE the initializer, and resolution can fence (the
+            // cross-block merged-namespace SC1090, resolveValueSymbol →
+            // fenceCrossBlockNsRef): a fence mid-probe means the probe cannot
+            // classify the declaration, not that collection dies — the
+            // diagnostic is recorded, the binding falls through to ordinary
+            // registration, and the statement lowering re-fences at its own
+            // site (pushDiag dedupes), exactly the per-probe recovery the
+            // alias/generic-fn registrations below already use.
+            const classifyDiagsBefore = L.diags.length;
+            const classified = (() => {
+                try {
+                    // A TRAP declaration at file scope — the initializer's chain roots
+                    // at an ambient-undefined name (`declare const t: Type<string>;
+                    // export const out = t.pipe(...)`): Node throws the root's
+                    // ReferenceError evaluating the initializer, so no value ever
+                    // exists and no reference can ever run. No global registers; the
+                    // binding enters trapBindings (registered HERE, before any body
+                    // lowers, so hoisted-function references resolve the trap), and
+                    // the statement lowering emits the throw at its position.
+                    // Written bindings keep ordinary storage (trapDeclRootOf).
+                    if (trapDeclRootOf(L, decl) !== null) {
+                        for (const nameNode of boundIdentifiersOf(decl.name)) {
+                            const sym = L.checker.getSymbolAtLocation(nameNode);
+                            if (sym)
+                                L.trapBindings.add(sym);
+                        }
+                        return true;
+                    }
+                    // A NULLISH generic binding at file scope (`export const Mixin:
+                    // MixinHelperFunc = null as any`): no storage — reads know the
+                    // value (lower-exprs/lower-calls claim them); the statement
+                    // lowering emits nothing by the same test.
+                    if (ts.isIdentifier(decl.name) &&
+                        nullishGenericBindingUnitOf(L, L.checker.getSymbolAtLocation(decl.name) ?? null) !== null) {
+                        return true;
+                    }
+                    // A DEAD unmappable binding at file scope (`var xs2: typeof
+                    // Array;` — never read anywhere): no global, no statement, no
+                    // type fence for a value the program never consumes.
+                    if (ts.isIdentifier(decl.name) &&
+                        deadUnmappableBinding(L, L.checker.getSymbolAtLocation(decl.name) ?? null, decl)) {
+                        return true;
+                    }
                 }
+                catch (e) {
+                    if (!(e instanceof PoisonError))
+                        throw e;
+                    // A probe fenced mid-classification: JS files defer the
+                    // recorded diagnostics to runtime fences like every other
+                    // collection failure; TS keeps the eager report (the
+                    // statement lowering re-fences at its own site — pushDiag
+                    // dedupes).
+                    deferJsCollectionDiags(L, sf, classifyDiagsBefore);
+                }
+                return false;
+            })();
+            if (classified)
                 continue;
-            }
-            // A NULLISH generic binding at file scope (`export const Mixin:
-            // MixinHelperFunc = null as any`): no storage — reads know the
-            // value (lower-exprs/lower-calls claim them); the statement
-            // lowering emits nothing by the same test.
-            if (ts.isIdentifier(decl.name) &&
-                nullishGenericBindingUnitOf(L, L.checker.getSymbolAtLocation(decl.name) ?? null) !== null) {
-                continue;
-            }
-            // A DEAD unmappable binding at file scope (`var xs2: typeof
-            // Array;` — never read anywhere): no global, no statement, no
-            // type fence for a value the program never consumes.
-            if (ts.isIdentifier(decl.name) &&
-                deadUnmappableBinding(L, L.checker.getSymbolAtLocation(decl.name) ?? null, decl)) {
-                continue;
-            }
             // `const f = <T>(x: T) => x` at file scope: a generic function
             // value binding — no global exists (the binding is never read;
             // calls and pinned references monomorphize against the
@@ -1163,6 +1248,15 @@ export function collectGlobals(L, sf, topStmts) {
             // same test.
             if (builtinMemberRequireDecl(decl.name, decl.initializer))
                 continue;
+            // `const require = createRequire(import.meta.url)` at file scope:
+            // compile-time plumbing — no global storage; the statement
+            // lowering skips it by the same test.
+            if (isConst && createRequireBindingDecl(L, decl.name, decl.initializer))
+                continue;
+            // `const fs = require("node:fs")` through that binding at file
+            // scope — a namespace import in const clothing, same story.
+            if (isConst && createRequireNamespaceDecl(L, 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).
@@ -1194,7 +1288,7 @@ export function collectGlobals(L, sf, topStmts) {
                 try {
                     // A JS file-scope evolving ARRAY (`const mustCallChecks = [];`
                     // — test/common's exit-accounting ledger): the strict type
-                    // (any[]) has no mapping, but the VALUE is the DOM array the
+                    // (any[]) has no mapping, but the VALUE is the dyn array the
                     // literal builds (lowerArrayLiteral's JS fallback) — register
                     // a checked-dynamic global so separately-declared function
                     // bodies (runCallChecks, _mustCallInner) reach the SAME
@@ -1217,11 +1311,11 @@ export function collectGlobals(L, sf, topStmts) {
                     // the literal's contract — the SAME object flows into untyped
                     // callees, gets stamped by them, and is compared back against
                     // the binding (assert.strictEqual(found, input)). A static
-                    // record global would re-box at every DOM crossing and lose
-                    // that identity, so the binding holds the DOM object itself.
+                    // record global would re-box at every dyn crossing and lose
+                    // that identity, so the binding holds the dyn object itself.
                     // Gated to literals that are PURE DATA WRITTEN INLINE — every
                     // property a non-computed PropertyAssignment whose value is
-                    // dyn-representable (unmappable member types are the DOM
+                    // dyn-representable (unmappable member types are the checked-dynamic tree
                     // fallback's own case) — so shorthand aggregates (test/common's
                     // export object: alias plumbing importers resolve THROUGH),
                     // spreads, accessors, and literals holding unconvertible typed
@@ -1245,7 +1339,7 @@ export function collectGlobals(L, sf, topStmts) {
                         continue;
                     }
                     // A JS file-scope ANY-RESIDUE binding whose VALUE provably
-                    // lives in the DOM: no initializer (`let catchWarning;` —
+                    // lives in the checked-dynamic tree: no initializer (`let catchWarning;` —
                     // test/common's warning ledger), a unit initializer (`let
                     // localhostIPv4 = null;` — the lazy-cache idiom), or an
                     // initializer whose own checker type is `any` (`const handler
@@ -1255,7 +1349,7 @@ export function collectGlobals(L, sf, topStmts) {
                     // storage instead of fencing per reference. Typed-but-
                     // unmappable initializers (`new Set(...)` — a real Set the
                     // decl keeps as an %init local) stay OUT: forcing those into
-                    // the DOM would trade their working typed representation for
+                    // the checked-dynamic tree would trade their working typed representation for
                     // fences.
                     if (isJsSourceFile(sf) && !L.mapTypeOf(L.typeOf(nameNode)) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name &&
@@ -1266,7 +1360,7 @@ export function collectGlobals(L, sf, topStmts) {
                             const g = { id: `%g.${tag}${nsPrefix}${nameNode.text}`, name: nameNode.text, type: DYN, mutable: isLet };
                             L.globalsBySymbol.set(symbol, g);
                             L.globalsList.push(g);
-                            // Mutable dyn globals hold the DOM undefined from module
+                            // Mutable dyn globals hold the dyn undefined from module
                             // entry (the main path's rule below): a closure called
                             // above the declaration reads undefined instead of
                             // faulting on NULL.
@@ -1370,7 +1464,7 @@ export function collectGlobals(L, sf, topStmts) {
                     // infers a record (`const wrapped = function () { return
                     // expectedResult; }`): the closure VALUE lowers with a dyn
                     // return (declaredReturnType's record twin — JS object
-                    // literals are DOM values, and a record return would copy
+                    // literals are dyn values, and a record return would copy
                     // identity away), so the binding's slot must agree or an
                     // adapter would re-copy at the assignment.
                     if (isJsSourceFile(sf) &&
@@ -1407,7 +1501,7 @@ export function collectGlobals(L, sf, topStmts) {
                     L.globalsList.push(g);
                     // Mutable checked-dynamic LET globals ride the same entry
                     // init: a closure called above the declaration statement
-                    // reads the DOM undefined instead of faulting on NULL — the
+                    // reads the dyn undefined instead of faulting on NULL — the
                     // dyn face of let's documented pre-declaration window (Node
                     // throws the TDZ ReferenceError there).
                     if (isVarDeclared(decl) || (g.type.kind === "dyn" && g.mutable)) {
@@ -1457,7 +1551,7 @@ function handleArrayPreservingCall(L, e) {
    * must hold the interned undefined arm BEFORE the body runs (a function
    * called above the declaration statement may read it — lowerFileInit
    * emits the assigns right after the run-once guard). Checked-dynamic
-   * slots hold the DOM undefined the same way (a NULL dyn is a trap, not
+   * slots hold the dyn undefined the same way (a NULL dyn is a trap, not
    * a value). Other types need nothing: tsc's flow analysis rejects their
    * direct early reads, and closure reads share let's documented
    * zero/NULL divergence window. */
@@ -1465,7 +1559,7 @@ function noteVarGlobalEntryInit(L, sf, g) {
     // 'any' globals need the entry init exactly like undefined-armed
     // unions: tsc never guards `any` reads, so `var x: any;` is readable
     // before any assignment and its slot must hold its world's undefined
-    // — the ENGINE's for jsval (--dynamic), the DOM's for dyn (static) —
+    // — the ENGINE's for jsval (--dynamic), the checked-dynamic tree's for dyn (static) —
     // rather than a C-level NULL (an op or validated exit on NULL is
     // memory-unsafe, not a TypeError).
     if (g.type.kind !== "union" && g.type.kind !== "jsval" && g.type.kind !== "dyn")
@@ -1667,7 +1761,7 @@ export function lowerFileInit(L, sf, stmts, name) {
         // Module-scope `var` hoisting: undefined-armed var globals hold the
         // interned undefined from module entry (before any body statement —
         // a function called above the declaration reads `undefined`, exactly
-        // Node); checked-dynamic var globals hold the DOM undefined the same
+        // Node); checked-dynamic var globals hold the dyn undefined the same
         // way. After the guard: a cache-hit revisit must not reset them.
         for (const g of L.varGlobalEntryInits.get(sf) ?? []) {
             const wrapped = g.type.kind === "dyn" ? dynUndefinedExpr(loc0) : L.unassignedSlotInit(g.type, loc0);