@scriptc/compiler 0.2.5 → 0.2.7

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

@@ -13,6 +13,7 @@ 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 { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, importCallHandleType, newFnCtx, staticImportNamespaceType, uncheckedOverloadHandleCall, } from "./lowerer.js";
@@ -35,6 +36,7 @@ import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesO
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
+import { workerTargetPaths } from "../worker-target.js";
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 /** Program modules selected by statically resolved child_process.fork()
  * calls join the compiled graph without becoming startup dependencies of
@@ -42,9 +44,15 @@ import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
  * 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 appendWorkerModules(program, order, targets, onCycle) {
+    appendEntryModules(program, order, targets, workerTargetPaths(program, order), onCycle);
+}
+function appendEntryModules(program, order, targets, paths, onCycle) {
     if (order.length === 0)
         return;
-    const byPath = new Map(program.getSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
+    const byPath = new Map(program.getImplementationSourceFiles().map((sf) => [resolvePath(sf.fileName), sf]));
     const state = new Map();
     for (const sf of order)
         state.set(sf, "done");
@@ -79,7 +87,7 @@ export function appendForkModules(program, order, targets, onCycle) {
         added.push(sf);
     };
     const knownTargets = new Set(targets);
-    for (const path of forkTargetPaths(program, order)) {
+    for (const path of paths) {
         const target = byPath.get(resolvePath(path));
         if (!target || target.isDeclarationFile || target.fileName.endsWith(".json"))
             continue;
@@ -379,6 +387,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
@@ -858,6 +867,7 @@ export function moduleArtifacts(lowerer, functions) {
                 case "recordKeyGet":
                 case "recordOvfKeys":
                 case "recordOvfHas":
+                case "recordHas":
                     visitShape(node.shapeId);
                     break;
                 case "unionWrap":
@@ -867,6 +877,7 @@ export function moduleArtifacts(lowerer, functions) {
                 case "unionKeyGet":
                 case "unionIsTag":
                 case "unionEq":
+                case "fieldAbsent":
                     visitUnion(node.unionId);
                     break;
                 case "yieldExpr":
@@ -979,6 +990,8 @@ export function moduleArtifacts(lowerer, functions) {
                 visitType(field.type);
             if (info.base)
                 visitClass(info.base.def.name);
+            if (info.def.genericOf)
+                visitClass(info.def.genericOf);
             if (lowerer.inHierarchy(info)) {
                 let root = info;
                 while (root.base)
@@ -2293,12 +2306,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         handleArrayPreservingCall(lowerer, decl.initializer)) {
                         type = arrayOf(JSVAL);
                     }
-                    // `const r: Repo = new MemRepo()` over an all-generic-method
-                    // interface: the binding keeps the initializer's CLASS
-                    // representation (the record shape maps empty and the width
-                    // copy would drop the class the generic-method calls
-                    // monomorphize against) — see genericIfaceBindingKeepsClass.
-                    if (type.kind === "record" &&
+                    // An exact class behind a generic interface keeps its native
+                    // representation so generic calls can specialize against its body.
+                    if ((type.kind === "record" || type.kind === "dyn") &&
                         ts.isIdentifier(decl.name) &&
                         nameNode === decl.name &&
                         genericIfaceBindingKeepsClass(lowerer, decl, type)) {
@@ -2829,8 +2839,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.
@@ -2908,7 +2922,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
 export function buildMain(lowerer) {
     const loc = { file: lowerer.entry.fileName, start: 0, end: 0 };
     const body = [...cjsModuleRegistryPrelude(lowerer, loc)];
-    const roots = [lowerer.entry, ...lowerer.forkTargets];
+    const roots = [lowerer.entry, ...lowerer.forkTargets, ...lowerer.workerTargets];
     const isAsync = roots.some((root) => lowerer.asyncInitFiles.has(root));
     const callRoot = (root) => {
         const init = lowerer.initNameOf.get(root);
@@ -2984,6 +2998,35 @@ export function buildMain(lowerer) {
             loc,
         });
     }
+    if (lowerer.workerTargets.length > 0) {
+        const mainBody = body.splice(0);
+        let workerBody = null;
+        for (let id = lowerer.workerTargets.length - 1; id >= 0; id--) {
+            workerBody = [
+                {
+                    kind: "if",
+                    cond: {
+                        kind: "bin",
+                        op: "===",
+                        left: { kind: "libCall", fn: "worker.root", args: [], type: F64, loc },
+                        right: { kind: "numLit", value: id, type: F64, loc },
+                        type: BOOL,
+                        loc,
+                    },
+                    then: callRoot(lowerer.workerTargets[id]),
+                    else_: workerBody,
+                    loc,
+                },
+            ];
+        }
+        body.push({
+            kind: "if",
+            cond: { kind: "libCall", fn: "worker.isMainThread", args: [], type: BOOL, loc },
+            then: mainBody,
+            else_: [...cjsModuleRegistryPrelude(lowerer, loc), ...(workerBody ?? [])],
+            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