@scriptc/compiler 0.2.6 → 0.2.8

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

@@ -1,3 +1,4 @@
+import { THREADS_MODULE } from "../threads-import.js";
 import { dynUndefinedExpr } from "../../ir/build.js";
 import { everyStmtList, everyTypeChild } from "../../ir/traverse.js";
 import { InternalCompilerError } from "../../errors.js";
@@ -13,8 +14,9 @@ import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
 import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportDiscardReason, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, resolveImport, resolveNpmImport, } from "../program.js";
+import { markCycleEarlyBindings, withCycleInitFlags } from "./cycle-initialization.js";
 import { invalidJsonModuleDiag, npmEmbedFailedDiag, requiresDynamicImportDiag, } from "../../diagnostics/diagnostic.js";
-import { BOOL, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
+import { BOOL, CAUGHT, DYN, F64, JSVAL, RUNTIME_ERROR_CLASSES, STRING, VOID, arrayOf, canBoxFuncIntoDyn, canConvertToDyn, isUnitType, } from "../../ir/ir.js";
 import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall, } from "./lowerer.js";
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, } from "./builtins/module-bindings.js";
 import { isPromisifyCall, registerBuiltinCallableAlias } from "./builtins/callable-aliases.js";
@@ -386,6 +388,7 @@ export function collectProgram(lowerer, parts) {
         }
         lowerer.collecting = wasCollecting;
     }
+    markCycleEarlyBindings(lowerer);
 }
 /** The npm-import chokepoint, run once per pass during collection (so
  * bodies lowered in ANY pass resolve the bindings). In a static build
@@ -495,6 +498,10 @@ export function collectNpmImports(lowerer, parts) {
             }
             if (!npm && !relIsJs)
                 continue;
+            // scriptc's own @scriptc/threads: its exports lower to intrinsics at
+            // their use sites (threads-import.ts); its Node.js body never runs.
+            if (npm?.packageName === THREADS_MODULE)
+                continue;
             // An edge Node's RUNTIME resolution refuses at startup (types
             // resolved, but the exports target ships no JS — the types-only
             // package shape): preflight registered Node's startup crash for
@@ -865,6 +872,7 @@ export function moduleArtifacts(lowerer, functions) {
                 case "recordKeyGet":
                 case "recordOvfKeys":
                 case "recordOvfHas":
+                case "recordHas":
                     visitShape(node.shapeId);
                     break;
                 case "unionWrap":
@@ -874,6 +882,7 @@ export function moduleArtifacts(lowerer, functions) {
                 case "unionKeyGet":
                 case "unionIsTag":
                 case "unionEq":
+                case "fieldAbsent":
                     visitUnion(node.unionId);
                     break;
                 case "yieldExpr":
@@ -2835,8 +2844,12 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 body.push(...lowerer.lowerStaticFieldInits(statics[at].info));
                 at++;
             }
-            const deferred = lowerer.deferredModuleInitializers?.defer(lowerer, stmt);
-            const stmtIr = deferred ? [deferred] : lowerer.lowerStmts([stmt]);
+            // A cycle binding's declaration stays at its position: its
+            // initialization flag must be set where the declaration runs.
+            const deferred = lowerer.cycleInitDeclarations.has(stmt)
+                ? null
+                : lowerer.deferredModuleInitializers?.defer(lowerer, stmt);
+            const stmtIr = withCycleInitFlags(lowerer, stmt, deferred ? [deferred] : lowerer.lowerStmts([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.
@@ -2886,6 +2899,12 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 loc: loc0,
             });
         }
+        if (moduleRef === null &&
+            guardId !== undefined &&
+            !isAsync &&
+            importRetryModules(lowerer).has(sf)) {
+            rememberEvaluationError(lowerer, guardId, body, loc0);
+        }
         const loc = { file: sf.fileName, start: 0, end: 0 };
         return {
             name,
@@ -2905,6 +2924,84 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         lowerer.fnStack.pop();
     }
 }
+/** Program modules whose evaluation can be requested again after it
+ * threw: the targets of literal import() sites and their static ES-module
+ * dependencies. Node records the evaluation error on the module, and every
+ * later import of it (or of a module depending on it) throws that same
+ * error again instead of resolving. */
+function importRetryModules(lowerer) {
+    const memo = lowerer.importRetryModules;
+    if (memo !== null)
+        return memo;
+    const out = new Set();
+    const visit = (sf) => {
+        if (out.has(sf) || sf.fileName.endsWith(".cts") || isCjsJsFile(sf, lowerer.program))
+            return;
+        out.add(sf);
+        for (const { dep } of orderedImportsOf(lowerer.program, sf)) {
+            if (dep !== null && dep !== sf)
+                visit(dep);
+        }
+    };
+    for (const sf of lowerer.moduleOrder) {
+        for (const dep of dynamicProgramImportsOf(lowerer.program, sf))
+            visit(dep);
+    }
+    lowerer.importRetryModules = out;
+    return out;
+}
+/** Wraps a guarded module body so a thrown evaluation error is kept and
+ * thrown again by every later call of the initializer. The first two
+ * statements are the run-once guard and the flag store. */
+function rememberEvaluationError(lowerer, guardId, body, loc) {
+    const errorId = `${guardId}%error`;
+    const failedId = `${guardId}%failed`;
+    if (!lowerer.globalsList.some((g) => g.id === errorId)) {
+        lowerer.globalsList.push({ id: errorId, name: "%error", type: CAUGHT, mutable: true });
+        lowerer.globalsList.push({ id: failedId, name: "%failed", type: BOOL, mutable: true });
+    }
+    const guarded = body.splice(2);
+    const failed = { kind: "varRef", localId: failedId, type: BOOL, loc };
+    body[0] = {
+        kind: "if",
+        cond: { kind: "varRef", localId: guardId, type: BOOL, loc },
+        then: [
+            {
+                kind: "if",
+                cond: failed,
+                then: [{ kind: "rethrow", localId: errorId, loc }],
+                else_: null,
+                loc,
+            },
+            { kind: "return", value: null, loc },
+        ],
+        else_: null,
+        loc,
+    };
+    const caught = lowerer.declareHiddenLocal("%moduleError", CAUGHT);
+    body.push({
+        kind: "tryCatch",
+        tryBody: guarded,
+        catchBody: [
+            {
+                kind: "assign",
+                localId: errorId,
+                value: { kind: "varRef", localId: caught.id, type: CAUGHT, loc },
+                loc,
+            },
+            {
+                kind: "assign",
+                localId: failedId,
+                value: { kind: "boolLit", value: true, type: BOOL, loc },
+                loc,
+            },
+            { kind: "rethrow", localId: caught.id, loc },
+        ],
+        catchLocalId: caught.id,
+        finallyBody: null,
+        loc,
+    });
+}
 /** %main is just the entry's %init call: Node's whole module evaluation
  * order lives in the init functions themselves — each file's hoisted
  * import header runs its dependencies first (depth-first postorder by