@scriptc/compiler 0.0.16 → 0.0.18

package/dist/frontend/lowering/lowerer.d.ts

@@ -549,6 +549,20 @@ export declare class Lowerer {
         idxsLocalId: string;
         ctx: FnCtx;
     }>;
+    /** STORED numeric value iterators: `const it = numbers.values()` (and
+     * the equivalent `[Symbol.iterator]()` spelling) over number[] or a
+     * represented typed array has no first-class IR value, so its statically
+     * known protocol state lives in hidden source/cursor/done locals. A
+     * later for-of in the SAME function reads and advances them.
+     * `doneLocalId` is sticky: once next() observes the end, later source
+     * changes do not revive the exhausted iterator, exactly like Node. */
+    readonly numericIterators: Map<ts.Symbol, {
+        sourceLocalId: string;
+        sourceType: IrType;
+        indexLocalId: string;
+        doneLocalId: string;
+        ctx: FnCtx;
+    }>;
     chainCounter: number;
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     readonly classes: Map<string, ClassInfo>;
@@ -628,6 +642,30 @@ export declare class Lowerer {
      * none — %main calls it exactly once (a dependency edge back to the
      * entry would be a fenced cycle). */
     readonly moduleGuardOf: Map<ts.SourceFile, string>;
+    /** Files whose module evaluation is asynchronous: direct top-level
+     * await/for-await modules plus their static ESM importers. Their %init
+     * bodies run on fibers and every async dependency edge awaits the
+     * dependency promise before the importer body starts. Synchronous files
+     * stay synchronous — adding even an already-settled await would insert
+     * an observable microtask hop. */
+    readonly asyncInitFiles: Set<ts.SourceFile>;
+    /** Async module → its cached evaluation-promise global. The emitted
+     * spawn wrapper fills this on first evaluation and returns a retained
+     * reference on cache hits, matching Node's one ModuleJob promise per
+     * module even across diamonds and concurrent dynamic imports. */
+    readonly modulePromiseOf: Map<ts.SourceFile, string>;
+    /** Async import-cycle member → the cycle's deterministic graph
+     * representative. Used to recognize internal SCC edges; this is NOT
+     * necessarily the runtime evaluation root, because a dynamically-only
+     * cycle can first be entered through any member. */
+    readonly asyncCycleRepresentativeOf: Map<ts.SourceFile, ts.SourceFile>;
+    /** Async import-cycle member → the shared completion-promise global for
+     * its SCC. Every member's spawn wrapper temporarily publishes its own
+     * promise while eager recursive evaluation unwinds; the outermost
+     * wrapper (the member actually requested first at runtime) writes last
+     * and therefore becomes the cycle's evaluation root. Dynamic imports
+     * wait on this shared verdict rather than a build-time-selected member. */
+    readonly asyncCyclePromiseOf: Map<ts.SourceFile, string>;
     /** Record-shape interner: canonical (name-sorted) field list → shapeId.
      * Threaded into every mapType call; its `shapes` array becomes
      * IrModule.records. */

package/dist/frontend/lowering/lowerer.js

@@ -17,7 +17,7 @@ import * as ts from "../ts7/adapter.js";
 import { anyOpRequiresDynamicDiag, blockedBindingUseDiag, checkerPanicDiag, componentTypeDiag, isCheckerPanic, genericSignatureTypeDiag, indexSignatureTypeDiag, intersectionTypeDiag, noLoweringDiag, overloadedSignatureTypeDiag, recordShapeMismatchDiag, requiresDynamicApiDiag, requiresDynamicPackageDiag, requiresDynamicTypeDiag, unionMismatchDiag, unsupportedDiag, unsupportedTypeDiag, } from "../../diagnostics/diagnostic.js";
 import { arrayOf, BOOL, canAdaptDynFuncTo, canConvertToDyn, canCrossIslandBoundary, canExitIslandToType, canMarshalTypedFuncIntoIsland, DYN, F64, isJsonSafeType, isUndefinedArmedUnion, isUnitType, JSVAL, RUNTIME_ERROR_CLASSES, STRING, typeEquals, UNDEFINED_T, VOID } from "../../ir/nodes.js";
 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 { ambientDtsPath, canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, fallbackDtsPath, isCjsExportTableLiteral, isJsSourceFile, isNodeEsmFile, isNodeTypesPath, locOf, orderedImportsOf, 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, 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";
@@ -716,6 +716,14 @@ export class Lowerer {
      * (the ctx guard keeps hidden locals out of closures — a cross-function
      * walk falls back to the plain array walk and the fence). */
     matchAllDrainIndexes = new Map();
+    /** STORED numeric value iterators: `const it = numbers.values()` (and
+     * the equivalent `[Symbol.iterator]()` spelling) over number[] or a
+     * represented typed array has no first-class IR value, so its statically
+     * known protocol state lives in hidden source/cursor/done locals. A
+     * later for-of in the SAME function reads and advances them.
+     * `doneLocalId` is sticky: once next() observes the end, later source
+     * changes do not revive the exhausted iterator, exactly like Node. */
+    numericIterators = new Map();
     chainCounter = 0;
     /** Keyed by program-wide qualified class name (what IR object types carry). */
     classes = new Map();
@@ -792,6 +800,30 @@ export class Lowerer {
      * none — %main calls it exactly once (a dependency edge back to the
      * entry would be a fenced cycle). */
     moduleGuardOf = new Map();
+    /** Files whose module evaluation is asynchronous: direct top-level
+     * await/for-await modules plus their static ESM importers. Their %init
+     * bodies run on fibers and every async dependency edge awaits the
+     * dependency promise before the importer body starts. Synchronous files
+     * stay synchronous — adding even an already-settled await would insert
+     * an observable microtask hop. */
+    asyncInitFiles = new Set();
+    /** Async module → its cached evaluation-promise global. The emitted
+     * spawn wrapper fills this on first evaluation and returns a retained
+     * reference on cache hits, matching Node's one ModuleJob promise per
+     * module even across diamonds and concurrent dynamic imports. */
+    modulePromiseOf = new Map();
+    /** Async import-cycle member → the cycle's deterministic graph
+     * representative. Used to recognize internal SCC edges; this is NOT
+     * necessarily the runtime evaluation root, because a dynamically-only
+     * cycle can first be entered through any member. */
+    asyncCycleRepresentativeOf = new Map();
+    /** Async import-cycle member → the shared completion-promise global for
+     * its SCC. Every member's spawn wrapper temporarily publishes its own
+     * promise while eager recursive evaluation unwinds; the outermost
+     * wrapper (the member actually requested first at runtime) writes last
+     * and therefore becomes the cycle's evaluation root. Dynamic imports
+     * wait on this shared verdict rather than a build-time-selected member. */
+    asyncCyclePromiseOf = new Map();
     /** Record-shape interner: canonical (name-sorted) field list → shapeId.
      * Threaded into every mapType call; its `shapes` array becomes
      * IrModule.records. */
@@ -1353,6 +1385,118 @@ export class Lowerer {
             this.moduleGuardOf.set(fp.sf, id);
             this.globalsList.push({ id, name: "%loaded", type: BOOL, mutable: true });
         }
+        // A module is intrinsically async when an await/for-await occurs
+        // outside every nested function-like boundary. Then propagate that
+        // status backwards through STATIC ESM edges: Node does not start an
+        // importer's body until each async dependency has completed. CJS
+        // import/require edges deliberately do not propagate — Node refuses
+        // require(esm) when the graph contains top-level await, and the call
+        // sites below keep that as a named unsupported boundary.
+        for (const fp of parts) {
+            let found = false;
+            ts.walkPreorder(fp.sf, (node) => {
+                if (node !== fp.sf && ts.isFunctionLike(node))
+                    return "skip";
+                if (ts.isAwaitExpression(node) ||
+                    (ts.isForOfStatement(node) && node.awaitModifier !== undefined)) {
+                    found = true;
+                    return "stop";
+                }
+                return undefined;
+            });
+            if (found)
+                this.asyncInitFiles.add(fp.sf);
+        }
+        let changed = true;
+        while (changed) {
+            changed = false;
+            for (const fp of parts) {
+                if (this.asyncInitFiles.has(fp.sf) || !isNodeEsmFile(fp.sf))
+                    continue;
+                if (orderedImportsOf(this.program, fp.sf).some(({ dep }) => dep !== null && this.asyncInitFiles.has(dep))) {
+                    this.asyncInitFiles.add(fp.sf);
+                    changed = true;
+                }
+            }
+        }
+        for (const fp of parts) {
+            if (!this.asyncInitFiles.has(fp.sf))
+                continue;
+            const rawTag = this.fileTag.get(fp.sf) ?? "";
+            const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, "");
+            const id = `%g.${tag}%initPromise`;
+            this.modulePromiseOf.set(fp.sf, id);
+            this.globalsList.push({
+                id,
+                name: "%initPromise",
+                type: { kind: "promise", inner: VOID },
+                mutable: true,
+            });
+        }
+        const orderIndex = new Map(parts.map((fp, i) => [fp.sf, i]));
+        const partSet = new Set(parts.map((fp) => fp.sf));
+        const staticDeps = (sf) => orderedImportsOf(this.program, sf)
+            .map(({ dep }) => dep)
+            .filter((dep) => dep !== null && dep !== sf && partSet.has(dep));
+        // Tarjan SCCs over the same static graph. The last postorder member is
+        // a deterministic COMPONENT representative for internal-edge tests
+        // and global naming. The runtime evaluation root can differ: a cycle
+        // reached only through import() starts at whichever member is actually
+        // requested first, not whichever import() site preflight discovered
+        // first. The shared cycle-promise slot below is filled by the emitted
+        // spawn wrappers so it records that runtime choice.
+        let nextIndex = 0;
+        const indexOf = new Map();
+        const lowOf = new Map();
+        const stack = [];
+        const onStack = new Set();
+        const visit = (sf) => {
+            const at = nextIndex++;
+            indexOf.set(sf, at);
+            lowOf.set(sf, at);
+            stack.push(sf);
+            onStack.add(sf);
+            for (const dep of staticDeps(sf)) {
+                if (!indexOf.has(dep)) {
+                    visit(dep);
+                    lowOf.set(sf, Math.min(lowOf.get(sf), lowOf.get(dep)));
+                }
+                else if (onStack.has(dep)) {
+                    lowOf.set(sf, Math.min(lowOf.get(sf), indexOf.get(dep)));
+                }
+            }
+            if (lowOf.get(sf) !== indexOf.get(sf))
+                return;
+            const component = [];
+            for (;;) {
+                const member = stack.pop();
+                onStack.delete(member);
+                component.push(member);
+                if (member === sf)
+                    break;
+            }
+            if (component.length < 2 || !component.some((member) => this.asyncInitFiles.has(member)))
+                return;
+            const root = component.reduce((a, b) => orderIndex.get(a) > orderIndex.get(b) ? a : b);
+            const rawTag = this.fileTag.get(root) ?? "";
+            const tag = rawTag === "" ? "e." : rawTag.replace(/^%/, "");
+            const cyclePromiseId = `%g.${tag}%cyclePromise`;
+            this.globalsList.push({
+                id: cyclePromiseId,
+                name: "%cyclePromise",
+                type: { kind: "promise", inner: VOID },
+                mutable: true,
+            });
+            for (const member of component) {
+                if (this.asyncInitFiles.has(member)) {
+                    this.asyncCycleRepresentativeOf.set(member, root);
+                    this.asyncCyclePromiseOf.set(member, cyclePromiseId);
+                }
+            }
+        };
+        for (const fp of parts)
+            if (!indexOf.has(fp.sf))
+                visit(fp.sf);
     }
     /** The lowering of a CommonJS `require("./local")` occurrence: a call of
      * the required module's run-once %init at exactly this statement's
@@ -1375,6 +1519,9 @@ export class Lowerer {
             : npmStaticDepSf7(this.program, node.getSourceFile(), spec);
         if (!dep || dep.fileName.endsWith(".json"))
             return null;
+        if (this.asyncInitFiles.has(dep)) {
+            this.unsupported("SC1090", node, `require() of '${spec}' (its ES-module graph uses top-level await; use import() instead)`);
+        }
         const initName = this.initNameOf.get(dep);
         if (initName === undefined)
             return null;
@@ -1625,7 +1772,7 @@ export class Lowerer {
         const module = this.diags.length > 0
             ? null
             : {
-                irVersion: 2,
+                irVersion: 3,
                 sourceFile: this.entry.fileName,
                 functions,
                 classes: artifacts.classes,