@scriptc/compiler 0.4.5 → 0.4.6

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

@@ -1,6 +1,6 @@
 import * as ts from "../ts7/adapter.js";
 import type { Lowerer } from "./lowerer.js";
-import type { CycleEdge } from "../program.js";
+import type { CycleEdge, StartupCrash } from "../program.js";
 import { type IrClassDef, type IrFunction, type IrRecordShape, type IrStmt, type IrUnionDef } from "../../ir/ir.js";
 /** One file's declarations, split for collection and init-body lowering. */
 export interface FileParts {
@@ -15,6 +15,8 @@ export interface FileParts {
 export interface AppendGraph {
     edges?: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]> | undefined;
     inlineCycleCalls?: Set<ts.Node>;
+    /** LoadResult.dynamicImportRejections: import() roots that never load. */
+    rejected?: ReadonlyMap<ts.SourceFile, StartupCrash> | undefined;
 }
 /** Program modules selected by statically resolved child_process.fork()
  * calls join the compiled graph without becoming startup dependencies of

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

@@ -1,4 +1,9 @@
+import { isIslandPromisifyCall, noteIslandSubclass } from "./lower-node-island.js";
+import { isIslandSubclassDecl } from "../../node-islands/boundary.js";
+import { globalValuesInstall, installsGlobalValues } from "./global-values.js";
 import { THREADS_MODULE } from "../threads-import.js";
+import { collectIslandImport, collectIslandRequires } from "./lower-node-island.js";
+import { NODE_API_MODULE } from "../node-api-import.js";
 import { positionTag } from "./structural-positions.js";
 import { EXPERIMENTAL_MODULE } from "../experimental-import.js";
 import { dynUndefinedExpr } from "../../ir/build.js";
@@ -11,12 +16,14 @@ import { InternalCompilerError } from "../../errors.js";
 import * as ts from "../ts7/adapter.js";
 import { collectRebindableFunctions, isRebindableFunction } from "./rebindable-functions.js";
 import { bindingSource } from "../binding-source.js";
+import { sharedInitFlagStores, sharedModulePlans, sharedModuleRegistrations, } from "./lower-shared-modules.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
 import { packageNameOfPath, probeNodeImportRefusal } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
-import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, requireSpecOf, resolveImport, resolveNpmImport, } from "../program.js";
+import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, npmStaticDepSf7, requireSpecOf, resolveImport, resolveNpmImport, } from "../program.js";
+import { isUnloadedPackage } from "../package-shims.js";
 import { markCycleEarlyBindings, withClassInitFlag, withCycleInitFlags, } from "./cycle-initialization.js";
 import { markRequireEarlyBindings } from "./require-initialization.js";
 import { cjsHasLiveMemberExports, cjsTableMethodEntry, inlineProgramRequireOf, nestedCjsExportAssignmentsOf, requireNestedPatternsOf, splitRequireBindingOf, splitRequireBindingOfIdent, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
@@ -27,6 +34,7 @@ import { BOOL, CAUGHT, DYN, F64, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, c
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, newFnCtx, staticImportNamespaceType, } from "./lowerer.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, } from "./builtins/module-bindings.js";
 import { isPromisifyCall, registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
+import { customInspectRegistrations } from "./lower-inspect.js";
 import { registerBuiltinClassAlias } from "./builtins/class-values.js";
 import { stripTypeCasts } from "./builtins/arguments.js";
 import { isWebCryptoMemberType } from "./builtins/webcrypto.js";
@@ -58,6 +66,13 @@ import { keptIdentityAssertion } from "./assertion-identity.js";
  * 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). */
+/** Whether a class declaration has a static field with an initializer,
+ * which Node runs where the class statement evaluates. */
+function hasStaticFieldInitializer(decl) {
+    return decl.members.nodes.some((member) => ts.isPropertyDeclaration(member) &&
+        member.initializer !== undefined &&
+        member.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword) === true);
+}
 function appendedEdgesOf(program, graph) {
     const cache = new Map();
     return (sf) => {
@@ -165,6 +180,10 @@ export function splitFiles(lowerer) {
                 fp.topStmts.push(stmt);
             else if (ts.isFunctionDeclaration(stmt))
                 fp.fnDecls.push(stmt);
+            // A native class extending an island class is a value the init body
+            // creates at its position (NI-5b, lower-node-island.ts).
+            else if (ts.isClassDeclaration(stmt) && noteIslandSubclass(lowerer, stmt))
+                fp.topStmts.push(stmt);
             else if (ts.isClassDeclaration(stmt))
                 fp.classDecls.push(stmt);
             // Namespaces: ambient/type-only ones are zero-runtime and skip;
@@ -276,7 +295,8 @@ export function appendDynamicImportModules(program, order, onCycle, graph) {
         for (const sf of scan) {
             scanned.add(sf);
             for (const dep of dynamicProgramImportsOf(program, sf))
-                visit(dep);
+                if (graph?.rejected?.has(dep) !== true)
+                    visit(dep);
         }
     }
     if (added.length > 0)
@@ -481,7 +501,14 @@ export function collectNpmImports(lowerer, parts) {
             // 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.
-            if (!isRelativeSpecifier(spec) && resolveImport(lowerer.program, fp.sf, spec) !== null) {
+            const projectDep = isRelativeSpecifier(spec)
+                ? null
+                : resolveImport(lowerer.program, fp.sf, spec);
+            if (projectDep !== null) {
+                // A Node island package that tsconfig `paths` maps to its installed
+                // directory resolves to its declarations: it loads in Node.
+                if (projectDep.isDeclarationFile)
+                    collectIslandImport(lowerer, fp.sf, stmt, spec);
                 continue;
             }
             const npm = resolveNpmImport(fp.sf.fileName, spec);
@@ -519,7 +546,9 @@ export function collectNpmImports(lowerer, parts) {
             // scriptc's own @scriptc/threads and @scriptc/experimental: their
             // exports lower at their use sites (threads-import.ts,
             // experimental-import.ts); their Node.js bodies never run.
-            if (npm?.packageName === THREADS_MODULE || npm?.packageName === EXPERIMENTAL_MODULE)
+            if (npm?.packageName === THREADS_MODULE ||
+                npm?.packageName === EXPERIMENTAL_MODULE ||
+                npm?.packageName === NODE_API_MODULE)
                 continue;
             // An edge Node's RUNTIME resolution refuses at startup (types
             // resolved, but the exports target ships no JS — the types-only
@@ -527,14 +556,20 @@ export function collectNpmImports(lowerer, parts) {
             // it, %main throws before any init runs, and the bindings never
             if (npm !== null && probeNodeImportRefusal(fp.sf.fileName, spec) !== null)
                 continue;
+            // A Node island package (scope-B NI-4): loaded in Node at this
+            // module's position, its bindings are island values.
+            if (collectIslandImport(lowerer, fp.sf, stmt, spec))
+                continue;
             {
                 lowerer.pushDiag(unsupportedPackageImportDiag(npm?.packageName ?? relPkg, locOf(stmt)));
                 continue;
             }
         }
     }
-    for (const fp of parts)
+    for (const fp of parts) {
         collectDynamicImports(lowerer, fp.sf);
+        collectIslandRequires(lowerer, fp.sf);
+    }
 }
 /** Literal dynamic-import collection: every
  * `import("literal")` in the file — whatever body it sits in — resolves
@@ -549,6 +584,22 @@ export function collectNpmImports(lowerer, parts) {
  * specifiers are skipped — the lowering owns that fence (the module
  * graph is a build-time artifact; there is nothing to embed for a
  * runtime-computed name). */
+/** The refusal a literal import() rejects with, or null when it loads:
+ * Node's ERR_MODULE_NOT_FOUND for a package the project marks never loaded
+ * (package-shims.ts), or the first refusal in the static graph of a module
+ * only import() loads (LoadResult.dynamicImportRejections). */
+function dynamicImportRejectionOf(lowerer, sf, spec, call) {
+    if (isUnloadedPackage(spec)) {
+        const refusal = probeNodeImportRefusal(sf.fileName, spec);
+        if (refusal === null)
+            return null;
+        return { message: refusal.message, className: "%Error", code: refusal.code, loc: locOf(call) };
+    }
+    if (lowerer.dynamicImportRejections.size === 0)
+        return null;
+    const root = resolveImport(lowerer.program, sf, spec) ?? npmStaticDepSf7(lowerer.program, sf, spec);
+    return root === null ? null : (lowerer.dynamicImportRejections.get(root) ?? null);
+}
 function collectDynamicImports(lowerer, sf) {
     ts.walkPreorder(sf, (node) => {
         if (ts.isCallExpression(node) &&
@@ -567,6 +618,13 @@ function collectDynamicImports(lowerer, sf) {
                 // module has no runtime namespace object — the per-site fence
                 // says so. Only non-declaration source files count; a sibling
                 // .d.mts typing shipped JS is the EMBED case, not this one.
+                // A package the project marks never loaded, or a module whose
+                // static graph Node's resolution refuses: the import() rejects.
+                const rejection = dynamicImportRejectionOf(lowerer, sf, spec, node);
+                if (rejection !== null) {
+                    lowerer.dynImports.set(mapKey, { kind: "rejected", crash: rejection });
+                    return undefined;
+                }
                 const modSym = lowerer.checker.getSymbolAtLocation(node.arguments.nodes[0]);
                 const ownModule = modSym !== undefined &&
                     modSym.declarations.some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
@@ -796,6 +854,12 @@ export function moduleArtifacts(lowerer, functions) {
                         visitClass("%Readable");
                         visitClass("%Writable");
                     }
+                    // A class declared `extends Array` named by its instanceof test
+                    // or by X.of / X.from.
+                    if (node.fn === "array.dynIsClass" && node.args[1]?.kind === "strLit")
+                        visitClass(node.args[1].value);
+                    if (node.fn === "array.classConstructAdopt" && node.args[0]?.kind === "strLit")
+                        visitClass(node.args[0].value);
                     break;
                 case "dynFrom":
                     if (boxedChild(node.value.type)) {
@@ -880,13 +944,12 @@ export function moduleArtifacts(lowerer, functions) {
         }
         while (pendingClasses.length > 0) {
             const name = pendingClasses.pop();
-            const info = lowerer.classes.get(name);
-            if (!info) {
-                // Referenced by an emitted type but never registered: collection
-                // deferred its diagnostics — a reached reference makes them count.
-                lowerer.flushDeferredClass(name);
+            // Referenced by an emitted type but never registered: collection
+            // deferred its diagnostics — a reached reference makes them count
+            // (or registers the class with dynamic slots, retryDeferred).
+            const info = lowerer.classes.get(name) ?? lowerer.flushDeferredClass(name);
+            if (!info)
                 continue;
-            }
             for (const field of info.def.fields)
                 visitType(field.type);
             if (info.base)
@@ -1155,6 +1218,20 @@ 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.isClassDeclaration(stmt) && stmt.name && isIslandSubclassDecl(stmt)) {
+            const symbol = lowerer.checker.getSymbolAtLocation(stmt.name);
+            const g = {
+                id: `%g.${tag}${stmt.name.text}`,
+                name: stmt.name.text,
+                type: DYN,
+                mutable: true,
+            };
+            if (symbol)
+                lowerer.globalsBySymbol.set(symbol, g);
+            lowerer.globalsByDeclNode.set(stmt, g);
+            lowerer.globalsList.push(g);
+            continue;
+        }
         if (ts.isFunctionDeclaration(stmt) && stmt.name && isRebindableFunction(lowerer, stmt)) {
             const symbol = lowerer.checker.getSymbolAtLocation(stmt.name);
             if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
@@ -1786,18 +1863,22 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // symbol registers HERE, before any use site can lower, and the
             // statement lowering skips the declaration by the same check. A
             // bad promisify target reports here (recorded once; the statement
-            // lowering poisons too, like every collectGlobals failure).
+            // lowering poisons too, like every collectGlobals failure). Targets
+            // that promisify to a function value (typed callback-last functions
+            // and untyped functions) keep an ordinary global.
             if (ts.isIdentifier(decl.name) &&
                 decl.initializer &&
                 isPromisifyCall(lowerer, decl.initializer)) {
+                let registered = true;
                 try {
-                    lowerer.registerPromisifiedBuiltinDecl(decl.name, decl.initializer);
+                    registered = lowerer.registerPromisifiedBuiltinDecl(decl.name, decl.initializer);
                 }
                 catch (e) {
                     if (!(e instanceof PoisonError))
                         throw e;
                 }
-                continue;
+                if (registered)
+                    continue;
             }
             // `const inspect = require("util").inspect` at file scope: a
             // named import in const clothing (builtinImportOf resolves uses)
@@ -1861,7 +1942,16 @@ export function collectGlobals(lowerer, sf, topStmts) {
             // Destructuring declarations register EVERY bound identifier (the
             // desugar in the init function assigns the pre-registered globals,
             // exactly like plain declarations).
-            for (const nameNode of boundIdentifiersOf(decl.name)) {
+            const names = boundIdentifiersOf(decl.name);
+            // Localized failure: a degradable type failure at a module global
+            // degrades that type and the same name registers again
+            // (globalSlotRetry), at most MAX_GLOBAL_RETRIES times.
+            let retries = 0;
+            let retriedIndex = -1;
+            for (let nameIndex = 0; nameIndex < names.length; nameIndex++) {
+                const nameNode = names[nameIndex];
+                if (nameIndex !== retriedIndex)
+                    retries = 0;
                 const diagsBefore = lowerer.diags.length;
                 try {
                     // Checked JavaScript factories can expose inferred callables by
@@ -1953,6 +2043,25 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         }
                         continue;
                     }
+                    // `const f = util.promisify(islandFn)` (NI-5b): an island function.
+                    if (ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        decl.initializer !== undefined &&
+                        isIslandPromisifyCall(lowerer, decl.initializer)) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol) {
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                        }
+                        continue;
+                    }
                     // 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 dyn array the
@@ -2450,6 +2559,12 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 catch (e) {
                     if (!(e instanceof PoisonError))
                         throw e;
+                    if (retries < MAX_GLOBAL_RETRIES && globalSlotRetry(lowerer, sf, e)) {
+                        retries++;
+                        retriedIndex = nameIndex;
+                        nameIndex--;
+                        continue;
+                    }
                     // diagnostic already recorded; lowering the statement poisons
                     // too — and in a JS file BOTH defer to the statement's
                     // runtime fence (deferJsCollectionDiags).
@@ -2459,6 +2574,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
         }
     }
 }
+/** Localized failure's commit point for module globals (design §3.3):
+ * collectGlobals commits a global's type failure directly, before any body
+ * lowers, so it degrades here and the registration runs again. */
+function globalSlotRetry(lowerer, sf, e) {
+    if (isJsSourceFile(sf))
+        return false;
+    const slot = lowerer.degradeAtCommit(e, GLOBAL_SLOTS);
+    if (slot === null)
+        return false;
+    lowerer.noteDynamicSlot(slot);
+    return true;
+}
+const MAX_GLOBAL_RETRIES = 16;
+const GLOBAL_SLOTS = new Set(["global"]);
 /** Registers the entry-init note for a `var` module global: JS hoists
  * module vars to `undefined` at module entry, so an undefined-armed slot
  * must hold the interned undefined arm BEFORE the body runs (a function
@@ -2748,6 +2877,15 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         }
         if (sf === lowerer.entry)
             header.push(...lowerer.punycodeLinkWarning());
+        // Modules shared with Node islands register before any module runs
+        // (NI-6); the plan also creates their declarations' TDZ flags.
+        if (sharedModulePlans(lowerer).length > 0 && sf === lowerer.entry)
+            header.push(...sharedModuleRegistrations(lowerer));
+        // A module that reads builtin globals through the global object, by
+        // computed names or through a sloppy-mode function's `this`, installs
+        // the program's lookup before its body runs.
+        if (installsGlobalValues(lowerer, sf))
+            header.push(globalValuesInstall(lowerer, loc0));
         // Top-level `this` of a CommonJS module: its object exists before the
         // module's first statement (lowerCjsTopLevelThis).
         const exportsThis = lowerer.cjsExportsThis.get(sf);
@@ -2922,6 +3060,13 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // by position) — exactly when JS evaluates decorators, static
         // initializers, and blocks, so code reading an earlier module
         // binding sees its assigned value.
+        const runsStatics = (c) => lowerer.classInitFlags.has(c.def.name) ||
+            c.callableBase !== undefined ||
+            c.def.baseValueGlobal !== undefined ||
+            c.runtimeStatics !== undefined ||
+            c.staticFields.length > 0 ||
+            (c.staticBlocks?.length ?? 0) > 0 ||
+            c.classDecorators !== undefined;
         const statics = [...lowerer.classes.values()]
             .filter((c) => 
         // Class DECLARATIONS only: expression classes run their static
@@ -2933,14 +3078,29 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
             ts.isClassDeclaration(c.decl) &&
             !c.mixinInstance &&
             ts.getSourceFileOfNode(c.decl) === sf &&
-            (lowerer.classInitFlags.has(c.def.name) ||
-                c.callableBase !== undefined ||
-                c.def.baseValueGlobal !== undefined ||
-                c.runtimeStatics !== undefined ||
-                c.staticFields.length > 0 ||
-                (c.staticBlocks?.length ?? 0) > 0 ||
-                c.classDecorators !== undefined))
+            runsStatics(c))
             .map((c) => ({ pos: ts.tokenStartOfNode(c.decl), info: c }));
+        // Localized failure: a deferred class with static field initializers
+        // is reached at its statement, where Node runs them. Its place retries
+        // it (retryDeferredAtDeclaration), and once it has registered there or
+        // through an earlier flush, its initializers lower in place.
+        for (const symbol of lowerer.deferredCollectors.keys())
+            for (const decl of symbol.declarations)
+                if (ts.isClassDeclaration(decl) &&
+                    ts.getSourceFileOfNode(decl) === sf &&
+                    hasStaticFieldInitializer(decl))
+                    statics.push({ pos: ts.tokenStartOfNode(decl), info: null, deferred: { symbol, decl } });
+        const lowerStaticsAt = (entry) => {
+            let info = entry.info;
+            if (entry.deferred) {
+                if (!lowerer.retryDeferredAtDeclaration(entry.deferred.symbol))
+                    return [];
+                info = lowerer.classes.get(lowerer.classNamer(entry.deferred.decl)) ?? null;
+                if (info === null || !runsStatics(info))
+                    return [];
+            }
+            return withClassInitFlag(lowerer, info, lowerer.lowerStaticFieldInits(info));
+        };
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the
         // top-level statement lower-mixins recorded. Insertion order is
@@ -2962,7 +3122,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
             // declarations never share a kept statement's start, so `<=`
             // changes nothing for them.
             while (at < statics.length && statics[at].pos <= ts.tokenStartOfNode(stmt)) {
-                body.push(...withClassInitFlag(lowerer, statics[at].info, lowerer.lowerStaticFieldInits(statics[at].info)));
+                body.push(...lowerStaticsAt(statics[at]));
                 at++;
             }
             // A cycle binding's declaration stays at its position: its
@@ -2971,13 +3131,15 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 ? null
                 : lowerer.deferredModuleInitializers?.defer(lowerer, stmt);
             const stmtIr = withCycleInitFlags(lowerer, stmt, deferred ? [deferred] : lowerer.lowerStmts([stmt]));
+            if (lowerer.sharedInitFlags.size > 0)
+                stmtIr.push(...sharedInitFlagStores(lowerer, stmt));
             // Class EXPRESSIONS inside this statement queued their static
             // inits while it lowered: they land immediately before it — JS's
             // order for the supported whole-initializer positions.
             body.push(...lowerer.pendingClassExprInits.splice(0), ...stmtIr);
         }
         while (at < statics.length) {
-            body.push(...withClassInitFlag(lowerer, statics[at].info, lowerer.lowerStaticFieldInits(statics[at].info)));
+            body.push(...lowerStaticsAt(statics[at]));
             at++;
         }
         for (const { at, g } of unionEntryInits) {
@@ -3254,6 +3416,9 @@ export function buildMain(lowerer) {
             loc,
         });
     }
+    // Classes with custom inspect methods register their compiled calls for
+    // the runtime's inspect walk before any module runs, in every thread.
+    body.unshift(...customInspectRegistrations(lowerer, loc));
     // Node's startup refusal (a resolution the graph carries that Node
     // rejects — preflight's Node-order resolution walk — or a module-LINK
     // SyntaxError from either named-import checker): the graph is refused