@scriptc/compiler 0.4.0 → 0.4.1

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

@@ -8,6 +8,7 @@ import { InternalCompilerError } from "../../errors.js";
  * seeds), npm/JSON import collection, per-file %init functions, %main, and
  * the module artifacts (globals, embedded npm tables) the IR module carries. */
 import * as ts from "../ts7/adapter.js";
+import { collectRebindableFunctions, isRebindableFunction } from "./rebindable-functions.js";
 import { bindingSource } from "../binding-source.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
 import { packageNameOfPath, probeNodeImportRefusal } from "../npm.js";
@@ -37,11 +38,12 @@ import { streamClassAliasDecl } from "./lower-stream.js";
 import { isAssertClassNew } from "./assert-instances.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
+import { isPromisePrototypeRead } from "./expressions/property-access.js";
 import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf, } from "./lower-namespaces.js";
 import { collectExpandoMembers } from "./lower-expando.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType, } from "./lower-classes.js";
+import { builtinRequireBaseOf, collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType, } 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";
@@ -50,18 +52,45 @@ import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 import { handleEventReaderPrelude } from "./lower-event-target.js";
 import { cjsAccessorSnapshotStores, jsHoldsDynObject } from "./lower-exprs.js";
 import { keptIdentityAssertion } from "./assertion-identity.js";
+/** An appended module's edges: its import and export declarations, then
+ * the require() edges preflight resolved — a CommonJS file's only edges
+ * (the compiled CommonJS package a workspace module loaded on demand
+ * imports, and the sibling packages and files IT requires). */
+function appendedEdgesOf(program, graph) {
+    const cache = new Map();
+    return (sf) => {
+        let out = cache.get(sf);
+        if (out !== undefined)
+            return out;
+        out = orderedImportsOf(program, sf).flatMap(({ stmt, dep }) => dep !== null && dep !== sf
+            ? [{ dep, stmt: stmt }]
+            : []);
+        for (const e of graph?.edges?.get(sf) ?? [])
+            if (e.stmt === undefined && e.dep !== sf)
+                out.push(e);
+        cache.set(sf, out);
+        return out;
+    };
+}
+/** Lazy inline requires run after their module's top level: their modules
+ * join the order afterwards, as in preflight's walk. */
+function visitLazyEdges(sf, edgesOf, state, visit) {
+    for (const e of edgesOf(sf))
+        if (e.lazy === true && state.get(e.dep) === undefined)
+            visit(e.dep);
+}
 /** 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) {
-    appendEntryModules(program, order, targets, forkTargetPaths(program, order), onCycle);
+export function appendForkModules(program, order, targets, onCycle, graph) {
+    appendEntryModules(program, order, targets, forkTargetPaths(program, order), onCycle, graph);
 }
-export function appendWorkerModules(program, order, targets, onCycle) {
-    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle);
+export function appendWorkerModules(program, order, targets, onCycle, graph) {
+    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle, graph);
 }
-function appendEntryModules(program, order, targets, paths, onCycle) {
+function appendEntryModules(program, order, targets, paths, onCycle, graph) {
     if (order.length === 0)
         return;
     const byPath = new Map(program.getImplementationSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
@@ -70,10 +99,8 @@ function appendEntryModules(program, order, targets, paths, 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 staticEdgesOf = appendedEdgesOf(program, graph);
+    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => staticEdgesOf(sf).filter((e) => e.call === undefined));
     const visit = (sf) => {
         const prior = state.get(sf);
         if (prior === "done")
@@ -81,10 +108,16 @@ function appendEntryModules(program, order, targets, paths, onCycle) {
         state.set(sf, "visiting");
         stack.push(sf.fileName);
         for (const edge of staticEdgesOf(sf)) {
+            if (edge.lazy === true)
+                continue; // visited after this module completes
             const edgeState = state.get(edge.dep);
             if (edgeState === "done")
                 continue;
             if (edgeState === "visiting") {
+                if (edge.call !== undefined) {
+                    graph?.inlineCycleCalls?.add(edge.call);
+                    continue;
+                }
                 const reason = cycleAdmissionReason(sf, edge);
                 if (reason !== null) {
                     const cycleStart = stack.indexOf(edge.dep.fileName);
@@ -97,6 +130,7 @@ function appendEntryModules(program, order, targets, paths, onCycle) {
         stack.pop();
         state.set(sf, "done");
         added.push(sf);
+        visitLazyEdges(sf, staticEdgesOf, state, visit);
     };
     const knownTargets = new Set(targets);
     for (const path of paths) {
@@ -121,8 +155,13 @@ export function splitFiles(lowerer) {
     const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
     return files.map((sf) => {
         const fp = { sf, fnDecls: [], classDecls: [], topStmts: [] };
+        const rebindable = collectRebindableFunctions(lowerer, sf);
         for (const stmt of sf.statements.nodes) {
-            if (ts.isFunctionDeclaration(stmt))
+            // A reassigned JavaScript declaration lives in a module global that
+            // the init body assigns first (rebindable-functions.ts).
+            if (ts.isFunctionDeclaration(stmt) && rebindable.has(stmt))
+                fp.topStmts.push(stmt);
+            else if (ts.isFunctionDeclaration(stmt))
                 fp.fnDecls.push(stmt);
             else if (ts.isClassDeclaration(stmt))
                 fp.classDecls.push(stmt);
@@ -181,7 +220,7 @@ function dynamicProgramImportsOf(program, sf) {
     });
     return out;
 }
-export function appendDynamicImportModules(program, order, onCycle) {
+export function appendDynamicImportModules(program, order, onCycle, graph) {
     if (order.length === 0)
         return; // no preflight order — sites keep their fences
     const state = new Map();
@@ -189,20 +228,24 @@ 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 staticEdgesOf = appendedEdgesOf(program, graph);
+    const cycleAdmissionReason = makeCycleAdmission(program, (sf) => staticEdgesOf(sf).filter((e) => e.call === undefined));
     const visit = (sf) => {
         if (state.get(sf) !== undefined)
             return;
         state.set(sf, "visiting");
         stack.push(sf.fileName);
         for (const e of staticEdgesOf(sf)) {
+            if (e.lazy === true)
+                continue; // visited after this module completes
             const s = state.get(e.dep);
             if (s === "done")
                 continue;
             if (s === "visiting") {
+                if (e.call !== undefined) {
+                    graph?.inlineCycleCalls?.add(e.call);
+                    continue;
+                }
                 // 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);
@@ -217,6 +260,7 @@ export function appendDynamicImportModules(program, order, onCycle) {
         stack.pop();
         state.set(sf, "done");
         added.push(sf);
+        visitLazyEdges(sf, staticEdgesOf, state, visit);
     };
     const scanned = new Set();
     for (;;) {
@@ -242,7 +286,7 @@ export function collectProgram(lowerer, parts) {
     for (const fp of parts)
         for (const decl of fp.classDecls) {
             const heritage = decl.heritageClauses?.nodes.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types?.nodes[0]?.expression;
-            if (heritage && ts.isCallExpression(heritage))
+            if (heritage && ts.isCallExpression(heritage) && !builtinRequireBaseOf(lowerer, heritage))
                 computed.add(decl);
         }
     // Descendants need the computed ancestor's completed layout before
@@ -1056,6 +1100,30 @@ function jsDynHoldableInitializer(lowerer, init) {
     }
     return false;
 }
+/** A JavaScript default-export object literal holding a class the program
+ * could not lower (`export default { parse, TomlDate }` where TomlDate
+ * extends an unsupported base): the literal narrows that member away, its
+ * diagnostics deferred to the reads that reach it, so the binding's type
+ * drops it too. Otherwise the module's own initialization would fail the
+ * width check against members no build can supply. */
+function withoutRejectedClassMembers(lowerer, expression, type) {
+    let literal = expression;
+    while (ts.isParenthesizedExpression(literal))
+        literal = literal.expression;
+    if (!ts.isObjectLiteralExpression(literal) || type.kind !== "record")
+        return type;
+    const shape = lowerer.shapes.get(type.shapeId);
+    if (!shape || shape.tuple)
+        return type;
+    const rejected = (t) => t.kind === "classval" &&
+        !lowerer.classes.has(t.className) &&
+        lowerer.deferredClassByName.has(t.className);
+    if (!shape.fields.some((f) => rejected(f.type)))
+        return type;
+    const kept = shape.fields.filter((f) => !rejected(f.type));
+    const shapeId = lowerer.shapes.intern(kept.map((f) => ({ name: f.name, type: f.type })), false, shape.indexValue);
+    return { kind: "record", shapeId };
+}
 export function collectGlobals(lowerer, sf, topStmts) {
     // Segment-tagged so mangled names can't collide across files (user
     // identifiers cannot contain '.'): entry globals "e.<name>", others
@@ -1067,6 +1135,21 @@ export function collectGlobals(lowerer, sf, topStmts) {
     // collected earlier in this pass must resolve them (lower-expando.ts).
     collectExpandoMembers(lowerer, sf);
     for (const stmt of topStmts) {
+        if (ts.isFunctionDeclaration(stmt) && stmt.name && isRebindableFunction(lowerer, stmt)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(stmt.name);
+            if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                const g = {
+                    id: `%g.${tag}${stmt.name.text}`,
+                    name: stmt.name.text,
+                    type: DYN,
+                    mutable: true,
+                };
+                lowerer.globalsBySymbol.set(symbol, g);
+                lowerer.globalsByDeclNode.set(stmt, g);
+                lowerer.globalsList.push(g);
+            }
+            continue;
+        }
         // `export default <expr>`: the module's `default` binding is a const
         // module global (registered under the checker's default-export
         // symbol — the symbol a default IMPORT's alias chain terminates at,
@@ -1155,6 +1238,8 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 }
                 if (type.kind === "void")
                     lowerer.badType(stmt.expression, tsType);
+                if (isJsSourceFile(sf))
+                    type = withoutRejectedClassMembers(lowerer, stmt.expression, type);
                 const g = { id: `%g.${tag}default`, name: "default", type, mutable: false };
                 lowerer.globalsBySymbol.set(symbol, g);
                 lowerer.globalsList.push(g);
@@ -1194,9 +1279,19 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // common/tls's `exports.check = function (certs) {...}` —
                     // keep func-ness with dyn pieces; everything else is dyn).
                     const strict = lowerer.checker.getTypeOfSymbol(symbol);
-                    const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
+                    let t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
                     if (!t || t.kind === "void")
                         lowerer.badType(typeNode, strict);
+                    // An export typed as the empty object literal (tsc's enum output
+                    // `exports.E || (exports.E = {})` after its `exports.E = void 0`
+                    // preamble): TS's `{}` admits any later non-nullish value and the
+                    // export is undefined until then, so it rides checked-dynamic
+                    // storage like the same-shaped var binding (varBindingType).
+                    if (t.kind === "record" && isJsSourceFile(sf)) {
+                        const shape = lowerer.shapes.get(t.shapeId);
+                        if (shape && shape.fields.length === 0 && !shape.indexValue && !shape.tuple)
+                            t = DYN;
+                    }
                     // An immutable export source shares its live storage and native
                     // callable ABI. Mutable sources need a separate snapshot slot:
                     // later writes to the binding do not change the exported value.
@@ -1442,44 +1537,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
         if (isRequireStatement(stmt) &&
             !(ts.isVariableStatement(stmt) &&
                 stmt.declarationList.declarations.nodes.some((decl) => isNativeFfiRequire(lowerer, decl.initializer) || isJsonRequireDecl(lowerer, decl)))) {
-            if (ts.isVariableStatement(stmt) && (stmt.declarationList.flags & ts.NodeFlags.Const) !== 0) {
-                for (const decl of stmt.declarationList.declarations.nodes) {
-                    stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
-                }
-            }
-            // `const { codes: { ERR_X } } = require("./errors")`: the outer
-            // keys stay alias plumbing, but a nested pattern destructures the
-            // export's value at the require, so its bindings own storage like
-            // any destructured declaration (lowerVarDeclarator assigns them).
-            if (ts.isVariableStatement(stmt)) {
-                const isLetList = (stmt.declarationList.flags & ts.NodeFlags.Let) !== 0 ||
-                    (stmt.declarationList.flags & ts.NodeFlags.BlockScoped) === 0;
-                for (const decl of stmt.declarationList.declarations.nodes) {
-                    for (const element of requireNestedPatternsOf(decl)) {
-                        for (const nameNode of boundIdentifiersOf(element.name)) {
-                            const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
-                            if (!symbol || lowerer.globalsBySymbol.has(symbol))
-                                continue;
-                            const mapped = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
-                            const type = mapped && mapped.kind !== "void" ? mapped : DYN;
-                            const g = {
-                                id: `%g.${tag}${nameNode.text}`,
-                                name: nameNode.text,
-                                type,
-                                mutable: isLetList,
-                                source: bindingSource(nameNode),
-                                ...((type.kind === "func" || type.kind === "dyn") && !isVarDeclared(decl)
-                                    ? { tdz: true }
-                                    : {}),
-                            };
-                            lowerer.globalsBySymbol.set(symbol, g);
-                            lowerer.globalsList.push(g);
-                            if (isVarDeclared(decl))
-                                noteVarGlobalEntryInit(lowerer, sf, g);
-                        }
-                    }
-                }
-            }
+            if (ts.isVariableStatement(stmt))
+                for (const decl of stmt.declarationList.declarations.nodes)
+                    registerRequireDeclBindings(lowerer, sf, stmt.declarationList, decl, tag);
             continue;
         }
         // `declare const __VERSION__: string` — AMBIENT: no storage exists
@@ -1512,6 +1572,16 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // and put its fences on the build.
             if (provenanceElidedConstDecl(lowerer, decl))
                 continue;
+            // A require declarator beside other declarators (`var EventEmitter =
+            // require("events"), R = class extends EventEmitter {}`): the
+            // statement lowering treats it as the alias plumbing of a whole
+            // require statement (lowerVarDeclarator), so it owns no storage
+            // either. A global here would never be assigned, and a read through
+            // it would see null.
+            if (requireAliasDecl(lowerer, decl)) {
+                registerRequireDeclBindings(lowerer, sf, list, decl, tag);
+                continue;
+            }
             // A stored built-in numeric value iterator has no first-class
             // global representation. Its same-%init for-of uses are backed by
             // hidden source/cursor/done locals registered when the declaration
@@ -1789,18 +1859,23 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Builtin declarations do not always describe the concrete native
                     // callable ABI. Preserve checked-native values in shared storage;
                     // adapting the loader to (string) would replace its validation.
+                    // An inferred Promise.prototype binding holds an ordinary object
+                    // (isPromisePrototypeRead), in TypeScript as well.
                     const initializer = decl.initializer ? stripTypeCasts(decl.initializer) : undefined;
-                    if (isJsSourceFile(sf) &&
-                        nameNode === decl.name &&
-                        initializer &&
-                        (isNativeBuiltinValueInitializer(lowerer, initializer) ||
-                            (!decl.type &&
-                                !hasJsTypeAnnotation(decl) &&
-                                lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
-                            (!decl.type &&
-                                !hasJsTypeAnnotation(decl) &&
-                                checkedGlobalReference(lowerer, initializer)) ||
-                            stdlibGlobalNameOf(lowerer, initializer) === "globalThis")) {
+                    if ((nameNode === decl.name &&
+                        !decl.type &&
+                        isPromisePrototypeRead(lowerer, decl.initializer)) ||
+                        (isJsSourceFile(sf) &&
+                            nameNode === decl.name &&
+                            initializer &&
+                            (isNativeBuiltinValueInitializer(lowerer, initializer) ||
+                                (!decl.type &&
+                                    !hasJsTypeAnnotation(decl) &&
+                                    lowerer.mapTypeOf(lowerer.typeOf(nameNode))?.kind === "date") ||
+                                (!decl.type &&
+                                    !hasJsTypeAnnotation(decl) &&
+                                    checkedGlobalReference(lowerer, initializer)) ||
+                                stdlibGlobalNameOf(lowerer, initializer) === "globalThis"))) {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
                             const g = {
@@ -2372,6 +2447,52 @@ function noteVarGlobalEntryInit(lowerer, sf, g) {
     inits.push(g);
     lowerer.varGlobalEntryInits.set(sf, inits);
 }
+/** A JavaScript require declaration the statement lowering treats as alias
+ * plumbing (lowerVarDeclarator): no storage, the reads resolve through to
+ * the module. JSON documents and native FFI requires keep their storage. */
+function requireAliasDecl(lowerer, decl) {
+    return (decl.initializer !== undefined &&
+        requireSpecOf(decl.initializer) !== null &&
+        !isNativeFfiRequire(lowerer, decl.initializer) &&
+        !isJsonRequireDecl(lowerer, decl) &&
+        isJsSourceFile(decl.getSourceFile()));
+}
+/** The registrations a top-level require declaration does make. `const
+ * process = require('node:process')` aliases the global process
+ * (stdlibGlobalAliasDecl's require form) so reads through the binding
+ * lower via the process surface. In `const { codes: { ERR_X } } =
+ * require("./errors")` the outer keys stay alias plumbing, but a nested
+ * pattern destructures the export's value at the require, so its bindings
+ * own storage like any destructured declaration (lowerVarDeclarator
+ * assigns them). */
+function registerRequireDeclBindings(lowerer, sf, list, decl, tag) {
+    if ((list.flags & ts.NodeFlags.Const) !== 0)
+        stdlibGlobalAliasDecl(lowerer, decl.name, decl.initializer);
+    const isLetList = (list.flags & ts.NodeFlags.Let) !== 0 || (list.flags & ts.NodeFlags.BlockScoped) === 0;
+    for (const element of requireNestedPatternsOf(decl)) {
+        for (const nameNode of boundIdentifiersOf(element.name)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+            if (!symbol || lowerer.globalsBySymbol.has(symbol))
+                continue;
+            const mapped = lowerer.mapTypeOf(lowerer.typeOf(nameNode));
+            const type = mapped && mapped.kind !== "void" ? mapped : DYN;
+            const g = {
+                id: `%g.${tag}${nameNode.text}`,
+                name: nameNode.text,
+                type,
+                mutable: isLetList,
+                source: bindingSource(nameNode),
+                ...((type.kind === "func" || type.kind === "dyn") && !isVarDeclared(decl)
+                    ? { tdz: true }
+                    : {}),
+            };
+            lowerer.globalsBySymbol.set(symbol, g);
+            lowerer.globalsList.push(g);
+            if (isVarDeclared(decl))
+                noteVarGlobalEntryInit(lowerer, sf, g);
+        }
+    }
+}
 /** The nested half of module-scope `var` hoisting: a `var` inside a
  * top-level BLOCK (an if arm, a loop body, a try) is module-scoped in
  * JS — other functions in the file read the same binding — so it must
@@ -2409,6 +2530,12 @@ function collectNestedVarGlobals(lowerer, sf, stmt, tag) {
     });
     for (const list of lists) {
         for (const decl of list.declarations.nodes) {
+            // A nested builtin require (`if (c) { var fs = require("fs"); }`)
+            // lowers to nothing: its bindings are alias plumbing wherever the
+            // statement sits (lowerVarDeclarator), so they own no storage.
+            if (requireAliasDecl(lowerer, decl) &&
+                canonicalBuiltinModule(requireSpecOf(decl.initializer)) !== null)
+                continue;
             for (const nameNode of boundIdentifiersOf(decl.name)) {
                 const diagsBefore = lowerer.diags.length;
                 try {
@@ -2565,6 +2692,24 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 loc: loc0,
             });
         }
+        // Reassigned function declarations are initialized when the module
+        // starts, as declarations are hoisted: before its dependencies run, so
+        // a module of an import cycle can call one while it initializes. Their
+        // statements then lower to nothing (rebindable-functions.ts).
+        for (const stmt of stmts) {
+            if (!ts.isFunctionDeclaration(stmt) || !stmt.name || !isRebindableFunction(lowerer, stmt))
+                continue;
+            const g = lowerer.globalsByDeclNode.get(stmt);
+            if (!g)
+                continue;
+            header.push({
+                kind: "assign",
+                localId: g.id,
+                value: lowerer.coerceToExpected(lowerer.lowerLambda(stmt), DYN),
+                loc: locOf(stmt),
+            });
+            ctx.hoistedFnDecls.add(stmt);
+        }
         for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) {
             const npm = lowerer.npmInitActions.get(sf)?.get(stmt);
             if (npm !== undefined && npm.length > 0) {