@scriptc/compiler 0.0.10 → 0.0.11

package/dist/frontend/lowering/lowerer.js

@@ -19,14 +19,15 @@ import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBounda
 import { provenanceActive } from "../provenance-registry.js";
 import { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, overridesDtsPath, npmStaticDepSf7, requireSpecOf, resolveImport, workspacePackageOfPath, } from "../program.js";
 import { containsRecord, containsUnion, describeComponentBlocker, describeRecordMemberBlocker, formatIrType, ISLAND_AMBIENT_TYPES, isUnitOnlyTsType, mapType, ShapeRegistry, typeKey, UnionRegistry, withUndefinedArm as withUndefinedArmCanonical, } from "../types.js";
-import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
+import { boundaryIntoIslandMsg, boundaryOutOfIslandMsg, builtinConstLit, builtinModuleConstOf, builtinModulesArrayLit, builtinFenceHintOf, builtinModuleFnOf, stdlibMemberFence, isStdlibMember, isStdlibSymbol, isStdlibGlobal, stdlibGlobalMember, nodeTypesOnlySymbol } from "./surfaces.js";
 import { splitFiles, collectProgram, collectNpmImports, collectJsonImports, moduleArtifacts, collectGlobals, declSymbolOf, defaultExportSymbolOf, lowerFileInit, lowerDefaultExport, buildMain, appendDynamicImportModules } from "./lower-modules.js";
 import { registerBuiltinErrorClasses, registerBuiltinEmitterClass, registerBuiltinStreamClasses, builtinErrorInfoOf, builtinEmitterInfoOf, builtinStreamInfoOf, analyzeClassDecoration, classIteratorDrainCall, classIteratorNextCall, classIteratorOf, classIteratorOpenCall, classIteratorRestDrainCall, classMemberNameOf, classValueRef, collectClassShape, exactClassOfReceiver, collectClassShapeInner, ctorAbiEquals, findMethodOn, findStaticOn, findGenericMethodOn, findGenericStaticOn, genericClassInstanceType, isSubclassOf, inHierarchy, overrideBelow, staticShadowBelow, upcastTo, lowerClassMembers, lowerClassCtor, lowerClassExpression, lowerClassExpressionInfo, lowerClassMethodMember, lowerClassValueProperty, lowerStaticMethod, throwingSetterFn, fieldInitStmts, lowerStaticFieldInits, lowerStaticFieldRead, lowerDerivedCtorBody, superCallStmt, lowerSuperMethodCall, superThisRef, lowerSuperAccessorRead, lowerSuperAccessorWrite, inheritsBuiltinErrorCtor, inheritsBuiltinEmitterCtor, errorMessageArg, lowerNew, accessorCall } from "./lower-classes.js";
 import { mixinCallClassInfoOf, mixinIntersectionInstanceType } from "./lower-mixins.js";
 import { bindingNeverReassigned, bodyReadsArguments, isThisParameter, paramShape, paramShapes, checkDefaultParamBodyType, completeArgs, wrappedUndefined, undefinedArgFor, requireExactArityValue, bodyReturnType, declaredReturnType, collectSignature, collectSignatureInner, collectGenericSignature, genericFnOf, lowerGenericCall, lowerGenericFnValue, inferTypeParamBindings, lowerGenericInstance, lowerCall, lowerTimersMemberCall, lowerPromiseMethodCall, lowerFilterNarrowCall, isTopLevelFnSymbol, lowerNestedFunctionDecl, lambdaSignature, lowerLambda, lowerFunction } from "./lower-calls.js";
 import { lowerArrayMethodCall, lowerBufferStaticCall, lowerBytesMethodCall, lowerBytesNew, lowerMapMethodCall, lowerMapForEachCall, buildMapForEachFn, lowerRecordOvfCaptureHelper, lowerEnvToPairsHelper, lowerSetMethodCall, lowerSetForEachCall, buildSetForEachFn, lowerRegexMethodCall, lowerStringMethodCall } from "./lower-containers.js";
 import { lowerStreamModuleCall } from "./lower-stream.js";
-import { builtinImportOf, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
+import { lowerEmitOverrideSpec } from "./lower-emitter.js";
+import { builtinImportOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireSpecOf, stripTypeCasts, lowerBuiltinModuleCall, lowerFsToUnixTimestampCall, lowerFsLadderCall, lowerChildArgsArg, lowerSpawnSyncCall, lowerSpawnCall, lowerExecSyncCall, recordToEnvPairs, lowerJsonMethodCall, fencedBuiltinImportOf, lowerCryptoComposedCall, lowerUrlMethodCall, lowerSearchParamsMethodCall, lowerStatsMethodCall, lowerChildMethodCall, lowerAtomicsCall, lowerBuiltinExtraProperty, promisifiedExecFileDecl, lowerExecFileAsyncCall, execFileAsyncHelper, lowerStringDecoderMethodCall, strdecHelper, lowerReadlineMethodCall, lowerDcChannelMethodCall, lowerDcChannelProperty, lowerAlsMethodCall, lowerDcTracingChannelMethodCall, lowerDcTracingChannelProperty, lowerJsonProperty, lowerErrorCodeProperty, lowerProcessProperty, isProcessEnv, envValueType, lowerProcessEnvGet, lowerProcessMethodCall, lowerProcessOptionalMethodCall, lowerTimeoutMethodCall, envSnapshotHelper, isConsoleLog, consoleCallMember, lowerNumberStaticCall, lowerNumberStaticProperty, lowerDateCall, lowerTextCodecCall, lowerFsConstantsProperty, lowerHttp2ConstantsProperty, http2ConstantBindingOf, http2ConstantsDestructureDecl, lowerProcessStreamProperty, lowerStringStaticCall, lowerStringLastIndexOfCall, lowerPromiseStaticCall } from "./lower-builtins.js";
 import { isIslandExpr, islandFuncValueFence, islandRegexpOf, jsvalIn, requireDynamicApi, islandGlobalFnOf, lowerDynamicImportCall, lowerFetchCall, lowerIslandMethodCall, lowerMathProperty, npmPackageOf, npmMemberFence, npmPackageOfSymbol } from "./lower-island.js";
 import { lowerHttpHeadersElement, lowerNetModuleCall, lowerServerMethodCall, lowerServerProperty } from "./lower-server.js";
 import { lowerDgramDnsModuleCall, lowerDgramMethodCall } from "./lower-dgram.js";
@@ -148,8 +149,24 @@ export function lowerToIr(program, entry, moduleOrder, options = {}) {
     const dynamic = options.dynamic ?? false;
     const targetPlatform = options.targetPlatform ?? process.platform;
     const startupCrash = options.startupCrash ?? null;
+    // --dynamic: modules reachable only through dynamic import() of the
+    // program's own files join the compiled graph here, ONCE, before any
+    // pass constructs (nothing calls their %init at startup — the import()
+    // site's namespace builder does, on the engine microtask, Node's
+    // evaluation point for them). Inadmissible static cycles inside the
+    // added subgraph are minted here and handed to the EMIT pass: the
+    // discovery pass's diagnostics are discarded by design, and after this
+    // extension of the shared array no later pass re-walks the subgraph.
+    const dynamicCycleDiags = [];
+    if (dynamic) {
+        appendDynamicImportModules(program, moduleOrder, (cycle, reason) => {
+            dynamicCycleDiags.push(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle}; ${reason})`));
+        });
+    }
     const reachable = new Lowerer(program, entry, moduleOrder, dynamic, { targetPlatform }).discover(options.libRoots);
     const emit = new Lowerer(program, entry, moduleOrder, dynamic, { reachable, targetPlatform, startupCrash });
+    for (const d of dynamicCycleDiags)
+        emit.pushDiag(d);
     const result = emit.run();
     if (options.coverage !== true)
         return result;
@@ -583,6 +600,13 @@ export class Lowerer {
     /** Synthetic array-HOF loop functions (map/filter/forEach desugar),
      * interned per method + element/callback-result type: key → fn name. */
     arrHofHelpers = new Map();
+    /** Emit-override specializations (`%C.emit:<event>` — lower-emitter.ts's
+     * emit-overrides block): interned names, the drive-loop queue, and the
+     * currently-lowering specialization's context (the super-forward
+     * interception reads it). */
+    emitSpecDone = new Set();
+    emitSpecQueue = [];
+    emitSpecCtx = null;
     /** Width-coercion helpers (%rec.width.N / %arr.width.N), interned per
      * (from, to) shape pair — see widthCoerce. */
     widthHelpers = new Map();
@@ -704,6 +728,12 @@ export class Lowerer {
      * `fileName\u0000specifier` (collectDynamicImports fills it during npm
      * collection; lowerDynamicImportCall reads it per site). */
     dynImports = new Map();
+    /** createRequire-require resolutions of BARE npm specifiers, keyed
+     * `fileName\u0000specifier` (collectCreateRequires fills it during npm
+     * collection under --dynamic — the require-condition entry key plus its
+     * embedded format; lowerCreateRequireCall reads it per site; "" marks a
+     * failed resolution already reported at collection). */
+    createRequireImports = new Map();
     /** Module → the name of its synthesized namespace-BUILDER function
      * (lowerOwnModuleImport): every `import()` of the same program module
      * shares one builder. */
@@ -892,16 +922,12 @@ export class Lowerer {
             // lowering, long after the constructor completes.
             isProgramFile: (sf) => this.fileTag.has(sf),
         };
-        // --dynamic: modules reachable only through dynamic import() of the
-        // program's own files join the compiled graph (nothing calls their
-        // %init at startup — the import() site's namespace builder does, on
-        // the engine microtask, which is Node's evaluation point for them).
-        // Mutates the SHARED moduleOrder array; idempotent across passes.
-        if (dynamic) {
-            appendDynamicImportModules(program, this.moduleOrder, (cycle) => {
-                this.pushDiag(unsupportedDiag("SC1016", { file: entry.fileName, start: 0, end: 0 }, `circular imports (${cycle})`));
-            });
-        }
+        // --dynamic: modules reachable only through dynamic import() joined
+        // moduleOrder BEFORE any pass constructed — lowerToIr runs
+        // appendDynamicImportModules once on the shared array (a per-pass run
+        // here minted cycle refusals into the DISCOVERY pass, whose
+        // diagnostics are discarded by design, and the extended order left
+        // nothing for the emit pass to re-detect).
         this.moduleOrder.forEach((sf, i) => {
             this.fileTag.set(sf, sf === entry ? "" : `%m${i}.`);
         });
@@ -1410,9 +1436,11 @@ export class Lowerer {
             let ec = 0;
             let gc = 0;
             let gi = 0;
+            let es = 0;
             while (ec < this.exprClasses.length ||
                 gc < this.genericClassInstances.length ||
-                gi < this.instantiationQueue.length) {
+                gi < this.instantiationQueue.length ||
+                es < this.emitSpecQueue.length) {
                 while (ec < this.exprClasses.length) {
                     functions.push(...this.lowerClassMembers(this.exprClasses[ec++]));
                 }
@@ -1433,6 +1461,20 @@ export class Lowerer {
                             throw e;
                     }
                 }
+                // Emit-override specializations queued by the emit sites above (a
+                // body can queue more — the super-forward chain — and generic
+                // instances of its own; the joint fixpoint covers both).
+                while (es < this.emitSpecQueue.length) {
+                    try {
+                        const fn = lowerEmitOverrideSpec(this, this.emitSpecQueue[es++]);
+                        if (fn)
+                            functions.push(fn);
+                    }
+                    catch (e) {
+                        if (!(e instanceof PoisonError))
+                            throw e;
+                    }
+                }
             }
         }
         // Lambdas lifted while lowering any of the above (plus synthetic
@@ -1750,9 +1792,11 @@ export class Lowerer {
         // the joint fixpoint).
         let instLowered = 0;
         let clsInstLowered = 0;
+        let specLowered = 0;
         const drainInstances = () => {
             while (instLowered < this.instantiationQueue.length ||
-                clsInstLowered < this.genericClassInstances.length) {
+                clsInstLowered < this.genericClassInstances.length ||
+                specLowered < this.emitSpecQueue.length) {
                 while (instLowered < this.instantiationQueue.length) {
                     const { info, inst } = this.instantiationQueue[instLowered++];
                     // Body-level poisons skip the instance here too (the emit pass
@@ -1769,6 +1813,18 @@ export class Lowerer {
                 while (clsInstLowered < this.genericClassInstances.length) {
                     this.lowerClassMembers(this.genericClassInstances[clsInstLowered++]);
                 }
+                // Emit-override specialization bodies fire edges of their own
+                // (the super-forward chain, closures, generic calls) — lower them
+                // for discovery exactly like generic instances.
+                while (specLowered < this.emitSpecQueue.length) {
+                    try {
+                        lowerEmitOverrideSpec(this, this.emitSpecQueue[specLowered++]);
+                    }
+                    catch (e) {
+                        if (!(e instanceof PoisonError))
+                            throw e;
+                    }
+                }
             }
         };
         parts.forEach((fp) => {
@@ -6311,7 +6367,12 @@ export class Lowerer {
             // out-of-block read would split the variable in two) — vars take the
             // standard path and its own fences.
             (ts.getCombinedNodeFlags(decl) & ts.NodeFlags.BlockScoped) !== 0 &&
-            islandCandidate(decl.initializer)) {
+            islandCandidate(decl.initializer) &&
+            // createRequire's plumbing decls are COMPILE-TIME erasures (the
+            // require binding and its builtin-namespace bindings) — never
+            // island values; the standard path's skips own them.
+            !createRequireBindingDecl(this, decl.name, decl.initializer) &&
+            !createRequireNamespaceDecl(this, decl.name, decl.initializer)) {
             const mapped = this.mapTypeOf(this.typeOf(decl.name));
             const handleOnly = mapped === null ||
                 (mapped.kind !== "jsval" &&
@@ -6702,10 +6763,21 @@ export class Lowerer {
             if (!decl)
                 return null;
             // The CommonJS twin: `const fs = require("fs")` binds the same
-            // namespace surface as `import * as fs from "node:fs"`.
+            // namespace surface as `import * as fs from "node:fs"` — and the
+            // createRequire spelling (`const fs = require("node:fs")` through a
+            // createRequire binding, the fallback-typed cast idiom stripped)
+            // binds it too.
             if (ts.isVariableDeclaration(decl) && ts.isIdentifier(decl.name) && decl.initializer) {
                 const spec = requireSpecOf(decl.initializer);
-                return spec !== null ? canonicalBuiltinModule(spec) : null;
+                if (spec !== null)
+                    return canonicalBuiltinModule(spec);
+                const init = stripTypeCasts(decl.initializer);
+                if (ts.isCallExpression(init)) {
+                    const cr = createRequireSpecOf(this, init);
+                    if (cr !== null && cr.spec !== null)
+                        return canonicalBuiltinModule(cr.spec);
+                }
+                return null;
             }
             // A DESTRUCTURED sub-namespace binding — `const { promises } =
             // fs` / `= require('fs')`: the member is itself a supported module
@@ -6738,6 +6810,17 @@ export class Lowerer {
             if (spec !== null)
                 return canonicalBuiltinModule(spec);
         }
+        // The createRequire spelling of the same inline form:
+        // `require("node:path").join(...)` through a createRequire binding
+        // (the fallback-typed cast idiom strips: `(require("x") as T).m`).
+        {
+            const inner = stripTypeCasts(expr);
+            if (ts.isCallExpression(inner)) {
+                const cr = createRequireSpecOf(this, inner);
+                if (cr !== null && cr.spec !== null)
+                    return canonicalBuiltinModule(cr.spec);
+            }
+        }
         if (ts.isIdentifier(expr)) {
             const symbol = this.checker.getSymbolAtLocation(expr);
             const decl = symbol ? this.checker.declarationsOf(symbol)[0] : undefined;
@@ -6884,6 +6967,11 @@ export class Lowerer {
         const c = builtinModuleConstOf(this, bi.module, bi.member);
         if (c !== undefined)
             return builtinConstLit(c, loc);
+        // module.builtinModules through a namespace binding — the baked
+        // Node v24 list, a fresh string[] per read.
+        if (bi.module === "module" && bi.member === "builtinModules") {
+            return builtinModulesArrayLit(loc);
+        }
         if (bi.member === "constants" && bi.module === "fs") {
             // A bare `fs.constants` read (not one of the baked bits above).
             this.noLowering(`fs.constants`, expr, "F_OK, R_OK, W_OK, and X_OK are the lowered constants");