@scriptc/compiler 0.2.1 → 0.2.2

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

@@ -1,3 +1,4 @@
+import { everyStmtList, everyTypeChild } from "../../ir/traverse.js";
 import { InternalCompilerError } from "../../errors.js";
 /* Module-graph lowering: splitting each source file into its parts, the
  * program-collection pass (signatures, classes, globals — reachability
@@ -17,7 +18,7 @@ import { ENTRY_NAME, PoisonError, boundIdentifiersOf, dynFallbackType, dynUndefi
 import { isNativeFfiRequire, builtinMemberRequireDecl, builtinNamespaceDestructureModuleOf, createRequireBindingDecl, createRequireNamespaceDecl, createRequireProgramModuleDecl, createRequireSpecOf, isPromisifyCall, registerBuiltinCallableAlias, stripTypeCasts } from "./lower-builtins.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, bindingNeverReassigned, deadUnmappableBinding, funcTypeFromParamShapes, implicitLocalFnInfoOf, implicitLocalFnNodeOf, nullishGenericBindingUnitOf, registerOverloadedCallableAlias } from "./lower-calls.js";
 import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl } from "./lower-stmts.js";
-import { objectFactorySignature } from "./object-factory-new.js";
+import { objectFactoryGlobalType } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { stdlibGlobalAliasDecl, stdlibGlobalAliasNameOf, stdlibGlobalNameOf } from "./surfaces.js";
 import { isNativeBuiltinValueInitializer } from "./lower-builtin-values.js";
@@ -25,7 +26,7 @@ import { collectNamespaceStmt, nsMemberIdentOf, nsPathPrefix, trapDeclRootOf } f
 import { collectExpandoMembers } from "./lower-expando.js";
 import { recordTextCodecClass } from "../../ir/ir.js";
 import { isUnitOnlyTsType, unitOnlyUnion } from "../type-mapper.js";
-import { collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType } from "./lower-classes.js";
+import { collectInheritedJsFieldWrites, collectVirtualJsMethods, decoratorNodesOf, genericIfaceBindingKeepsClass, guaranteedDecorationThrow, storedClassValueType } from "./lower-classes.js";
 import { isMixinFnBinding, mixinResultBindingClassOf } from "./lower-mixins.js";
 import { cjsModuleRef, cjsModuleRegistryPrelude } from "./lower-node-module.js";
 import { forkTargetPaths } from "../fork-target.js";
@@ -259,6 +260,7 @@ export function collectProgram(lowerer, parts) {
     lowerer.collecting = true;
     try {
         collectVirtualJsMethods(lowerer, parts.map((part) => part.sf));
+        collectInheritedJsFieldWrites(lowerer, parts.map((part) => part.sf));
         for (const fp of parts)
             for (const decl of fp.classDecls)
                 if (!computed.has(decl))
@@ -723,15 +725,14 @@ export function collectJsonImports(lowerer, parts) {
 /** The classes, records, and unions the emitted module carries: exactly
    * what the lowered functions and globals reference, closed transitively
    * over record fields, union arms, class field types, base chains, and
-   * WHOLE hierarchies (hierarchy membership decides object layout:
-   * dropping an unused subclass must not turn its base into a standalone
-   * class at emit time). Registry entries interned while collecting
+   * constructible descendants and their base chains. Registry entries interned while collecting
    * signatures nothing reaches stay out — an unreached type leaves no
    * trace. A referenced class with no registration had its collection
    * deferred: the reference flushes those diagnostics. Methods whose
    * bodies were not lowered leave the def's method list, so vtable slots
    * exist exactly for emitted overrides. */
 export function moduleArtifacts(lowerer, functions) {
+    const valueInstanceOfRoots = new Set();
     const classNames = new Set();
     const shapeIds = new Set();
     const unionIds = new Set();
@@ -759,56 +760,137 @@ export function moduleArtifacts(lowerer, functions) {
             default: return false;
         }
     };
-    const visit = (node) => {
-        if (Array.isArray(node)) {
-            // This walk only reads compiler-owned arrays. A callback traversal
-            // reuses one checked view instead of refreshing it at each step.
-            node.forEach(visit);
+    const visitClass = (name) => {
+        if (classNames.has(name))
             return;
-        }
-        if (node === null || typeof node !== "object")
+        classNames.add(name);
+        pendingClasses.push(name);
+    };
+    const visitShape = (id) => {
+        if (shapeIds.has(id))
             return;
-        const rec = node;
-        if (rec["kind"] === "dynFrom" && boxedChild(rec["value"].type)) {
-            // A generic child can expose native stdio without importing stream.
-            visit([{ className: "%Readable" }, { className: "%Writable" }]);
-        }
-        if (typeof rec["className"] === "string" && !classNames.has(rec["className"])) {
-            classNames.add(rec["className"]);
-            pendingClasses.push(rec["className"]);
-        }
-        if (typeof rec["shapeId"] === "string" && !shapeIds.has(rec["shapeId"])) {
-            shapeIds.add(rec["shapeId"]);
-            pendingShapes.push(rec["shapeId"]);
-        }
-        if (typeof rec["unionId"] === "string" && !unionIds.has(rec["unionId"])) {
-            unionIds.add(rec["unionId"]);
-            pendingUnions.push(rec["unionId"]);
-        }
-        for (const key of Object.keys(rec)) {
-            if (key !== "loc")
-                visit(rec[key]);
+        shapeIds.add(id);
+        pendingShapes.push(id);
+    };
+    const visitUnion = (id) => {
+        if (unionIds.has(id))
+            return;
+        unionIds.add(id);
+        pendingUnions.push(id);
+    };
+    const visitType = (type) => {
+        switch (type.kind) {
+            case "object":
+            case "classval":
+                visitClass(type.className);
+                break;
+            case "record":
+                visitShape(type.shapeId);
+                break;
+            case "union":
+                visitUnion(type.unionId);
+                break;
         }
+        return everyTypeChild(type, visitType);
+    };
+    const visitor = {
+        expr: (node) => {
+            visitType(node.type);
+            switch (node.kind) {
+                case "fieldIncDec":
+                case "new":
+                case "classRef":
+                case "instanceOf":
+                case "virtualCall":
+                case "fieldGet":
+                case "caughtCheck":
+                    visitClass(node.className);
+                    break;
+                case "caughtTest":
+                    if (node.className !== undefined)
+                        visitClass(node.className);
+                    break;
+                case "recordGet":
+                case "recordKeyGet":
+                case "recordOvfKeys":
+                case "recordOvfHas":
+                    visitShape(node.shapeId);
+                    break;
+                case "unionWrap":
+                case "unionFuncEq":
+                case "unionNarrow":
+                case "unionDisc":
+                case "unionKeyGet":
+                case "unionIsTag":
+                case "unionEq":
+                    visitUnion(node.unionId);
+                    break;
+                case "yieldExpr":
+                    if (node.captureCompletion !== undefined)
+                        visitType(node.captureCompletion.returnType);
+                    break;
+                case "instanceOfValue":
+                    for (const type of [node.value.type, node.classValue.type]) {
+                        if (type.kind !== "object" && type.kind !== "classval")
+                            continue;
+                        let root = lowerer.classes.get(type.className);
+                        if (!root)
+                            continue;
+                        while (root.base)
+                            root = root.base;
+                        valueInstanceOfRoots.add(root.def.name);
+                    }
+                    break;
+                case "dynFrom":
+                    if (boxedChild(node.value.type)) {
+                        // A generic child can expose native stdio without importing stream.
+                        visitClass("%Readable");
+                        visitClass("%Writable");
+                    }
+                    break;
+                default:
+                    // A new node with a named artifact reference must join this switch.
+                    node;
+            }
+            return true;
+        },
+        stmt: (node) => {
+            switch (node.kind) {
+                case "fieldSet":
+                    visitClass(node.className);
+                    break;
+                case "recordSet":
+                case "recordKeySet":
+                case "recordKeyDelete":
+                    visitShape(node.shapeId);
+                    break;
+                default:
+                    node;
+            }
+            return true;
+        },
     };
-    // Keep function lists and their typed slots in native storage. Reflective
-    // array iteration refreshes a complete view at each step; only executable
-    // nodes and individual types need the general dependency walk.
+    // Visit compiler-owned typed storage and executable trees directly, without
+    // creating dynamic snapshots of every node's properties and metadata.
     for (const fn of functions) {
         for (const param of fn.params)
-            visit(param.type);
-        visit(fn.returnType);
+            visitType(param.type);
+        visitType(fn.returnType);
         for (const local of fn.locals)
-            visit(local.type);
+            visitType(local.type);
         for (const capture of fn.captures ?? [])
-            visit(capture.type);
+            visitType(capture.type);
         for (const capture of fn.classCaptures ?? [])
-            visit(capture.type);
-        visit(fn.generator);
-        for (const stmt of fn.body)
-            visit(stmt);
+            visitType(capture.type);
+        if (fn.generator !== undefined) {
+            visitType(fn.generator.yieldT);
+            visitType(fn.generator.nextT);
+            visitType(fn.generator.resultType);
+        }
+        everyStmtList(fn.body, visitor);
     }
     for (const global of lowerer.globalsList)
-        visit(global.type);
+        visitType(global.type);
     // The builtin error classes ride EVERY module: the runtime's own throws
     // (JSON/dynCheck/regex failures) mint instances of them whether or not
     // user code mentions Error, and the uncaught printer tells Error
@@ -829,12 +911,19 @@ export function moduleArtifacts(lowerer, functions) {
             // overflow-valued shape (`{ [key: string]: {script?: string} }`)
             // references its value shape through indexValue alone.
             const shape = lowerer.shapes.get(pendingShapes.pop());
-            visit(shape?.fields);
-            if (shape?.indexValue)
-                visit(shape.indexValue);
+            if (shape !== undefined) {
+                for (const field of shape.fields)
+                    visitType(field.type);
+                if (shape.indexValue !== undefined)
+                    visitType(shape.indexValue);
+            }
+        }
+        while (pendingUnions.length > 0) {
+            const union = lowerer.unions.get(pendingUnions.pop());
+            if (union !== undefined)
+                for (const arm of union.arms)
+                    visitType(arm);
         }
-        while (pendingUnions.length > 0)
-            visit(lowerer.unions.get(pendingUnions.pop())?.arms);
         while (pendingClasses.length > 0) {
             const name = pendingClasses.pop();
             const info = lowerer.classes.get(name);
@@ -844,15 +933,17 @@ export function moduleArtifacts(lowerer, functions) {
                 lowerer.flushDeferredClass(name);
                 continue;
             }
-            visit(info.def.fields);
+            for (const field of info.def.fields)
+                visitType(field.type);
             if (info.base)
-                visit([{ className: info.base.def.name }]);
+                visitClass(info.base.def.name);
             if (lowerer.inHierarchy(info)) {
                 let root = info;
                 while (root.base)
                     root = root.base;
                 const wholeTree = (c) => {
-                    visit([{ className: c.def.name }]);
+                    if (valueInstanceOfRoots.has(root.def.name) || lowerer.classCanBeConstructed(c))
+                        visitClass(c.def.name);
                     for (const s of c.subclasses)
                         wholeTree(s);
                 };
@@ -1121,6 +1212,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 let type = lowerer.mapTypeOf(tsType) ?? dynFallbackType(lowerer, stmt.expression, tsType);
                 if (type === null)
                     lowerer.badType(stmt.expression, tsType);
+                // Inferred JavaScript factory exports keep their original value,
+                // including callable objects decorated with Object.assign.
+                if (isJsSourceFile(sf) && ts.isCallExpression(stmt.expression) && type.kind === "record" && lowerer.dynConvertible(type))
+                    type = DYN;
                 // `export default undefined` — the unit-only union, like any
                 // unit-only binding (`export default null` maps via mapType).
                 if (type.kind === "void" && isUnitOnlyTsType(tsType)) {
@@ -1169,16 +1264,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     const t = lowerer.mapTypeOf(strict) ?? dynFallbackType(lowerer, nameNode, strict);
                     if (!t || t.kind === "void")
                         lowerer.badType(typeNode, strict);
-                    // `module.exports.Strings = Strings` naming a dyn-HOLDING
-                    // const (the JS file-scope object-literal identity story): the
-                    // export ALIASES the const's own dyn global — one storage, one
-                    // owner, identity by construction (a record-typed second slot
-                    // would either copy or mismatch the dyn value — that mismatch
-                    // was an ICE; a second same-named global double-released at
-                    // teardown). The statement's assign degenerates to a harmless
-                    // self-assign. Mutable (`let`) sources keep the registration
-                    // below: Node copies the VALUE at this statement, and separate
-                    // storage is exactly that copy.
+                    // An immutable export source shares its live storage and native
+                    // callable ABI. Mutable sources need a separate snapshot slot:
+                    // later writes to the binding do not change the exported value.
                     {
                         let rhs = typeNode;
                         while (ts.isParenthesizedExpression(rhs))
@@ -1186,19 +1274,14 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         if (ts.isIdentifier(rhs)) {
                             const vSym = lowerer.checker.getSymbolAtLocation(rhs);
                             const vG = vSym && lowerer.globalsBySymbol.get(vSym);
-                            if (vG?.type.kind === "dyn") {
+                            if (vG) {
                                 if (!vG.mutable) {
                                     lowerer.globalsBySymbol.set(symbol, vG);
                                     for (const d of lowerer.checker.declarationsOf(symbol))
                                         lowerer.globalsByDeclNode.set(d, vG);
                                     return;
                                 }
-                                // A mutable (`let`) dyn source: separate DYN storage IS
-                                // Node's copy-of-the-reference at this statement (later
-                                // reassignments of the let stay invisible through the
-                                // export). The id must not collide with the let's own
-                                // `%g.<tag><name>` global.
-                                const g = { id: `%g.${tag}%export.${name}`, name, type: DYN, mutable: false };
+                                const g = { id: `%g.${tag}%export.${name}`, name, type: vG.type, mutable: false };
                                 lowerer.globalsBySymbol.set(symbol, g);
                                 for (const d of lowerer.checker.declarationsOf(symbol))
                                     lowerer.globalsByDeclNode.set(d, g);
@@ -1207,7 +1290,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             }
                         }
                     }
-                    const g = { id: `%g.${tag}${name}`, name, type: t, mutable: false };
+                    const g = { id: `%g.${tag}%export.${name}`, name, type: t, mutable: false };
                     lowerer.globalsBySymbol.set(symbol, g);
                     // Importer aliases resolve to a DISTINCT late-bound symbol with
                     // the same declaration — key the node too (globalOf's fallback).
@@ -1849,9 +1932,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // their own per-site runtime fences.
                     const factoryType = !isLet && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
                         ts.isIdentifier(decl.name) && nameNode === decl.name && decl.initializer && ts.isNewExpression(decl.initializer)
-                        ? objectFactorySignature(lowerer, decl.initializer)?.returnType : undefined;
-                    if (!factoryType && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
-                        continue;
+                        ? objectFactoryGlobalType(lowerer, decl.initializer) ?? undefined : undefined;
                     // `var p1 = import("./m")` at file scope: the global holds the
                     // island promise/handle — the import expression's only
                     // production — whatever the checker's namespace type mapped to
@@ -1865,20 +1946,39 @@ export function collectGlobals(lowerer, sf, topStmts) {
                                 // exactly the local rule (uncheckedOverloadHandleCall).
                                 (uncheckedOverloadHandleCall(lowerer, decl.initializer) ? JSVAL : null) : null)
                         : null;
-                    // Unannotated results of JavaScript calls can carry callable
-                    // objects or heterogeneous unions absent from the native type
-                    // map. Their compiled initializer still validates every crossing.
-                    const callSignature = !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer && ts.isCallExpression(decl.initializer)
+                    // JavaScript factory results with unmappable annotations still
+                    // need shared storage. Unannotated callable unions also use a
+                    // checked slot; mappable authored annotations keep their layout.
+                    const unannotatedCall = !decl.type && !hasJsTypeAnnotation(decl);
+                    const callSignature = (isJsSourceFile(sf) || unannotatedCall) && decl.initializer && ts.isCallExpression(decl.initializer)
                         ? lowerer.checker.getResolvedSignature(decl.initializer) : undefined;
                     const callDeclaration = callSignature && lowerer.checker.signatureDeclaration(callSignature);
+                    const callType = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile())
+                        ? lowerer.mapTypeOf(lowerer.typeOf(nameNode)) : null;
                     const inferredJsCall = callDeclaration && isJsSourceFile(callDeclaration.getSourceFile()) &&
-                        !lowerer.mapTypeOf(lowerer.typeOf(nameNode));
+                        (!callType || unannotatedCall && callType.kind === "union" && lowerer.unions.get(callType.unionId)?.arms.some((arm) => arm.kind === "func"));
+                    if (!factoryType && !inferredJsCall && isJsSourceFile(sf) && !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
+                        continue;
                     let type = handleT ?? factoryType ?? (inferredJsCall ? DYN : lowerer.irTypeOf(nameNode));
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && decl.initializer &&
                         (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) &&
                         !decl.initializer.typeParameters?.length) {
                         type = lowerer.lambdaSignature(decl.initializer).funcType;
                     }
+                    // Namespace aliases of inferred helpers carry the helper's
+                    // settled callable, whose return can differ from checker inference.
+                    // Keep a shared checked slot before any consumer specializes it.
+                    if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "func" &&
+                        decl.initializer && ts.isPropertyAccessExpression(decl.initializer)) {
+                        const member = nsMemberIdentOf(lowerer, decl.initializer);
+                        if (member && lowerer.genericFnOf(member)?.implicitParams)
+                            type = DYN;
+                        else if (member) {
+                            const source = lowerer.globalOf(member);
+                            if (source?.type.kind === "func")
+                                type = source.type;
+                        }
+                    }
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
                         decl.initializer && ts.isCallExpression(decl.initializer) && type.kind === "union") {
                         const arms = lowerer.unions.get(type.unionId)?.arms;
@@ -1892,8 +1992,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // Calls through checked function values retain their object
                     // identity, including symbol keys absent from inferred records.
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
-                        decl.initializer && ts.isCallExpression(decl.initializer) &&
-                        ts.isIdentifier(decl.initializer.expression) && lowerer.globalOf(decl.initializer.expression)?.type.kind === "dyn") {
+                        decl.initializer && ts.isCallExpression(decl.initializer) && lowerer.dynConvertible(type)) {
                         type = DYN;
                     }
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "record" &&
@@ -1916,6 +2015,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) && type.kind === "array" &&
                         decl.initializer && ts.isCallExpression(decl.initializer))
                         type = DYN;
+                    if (!lowerer.dynamic && isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
+                        decl.initializer && ts.isNewExpression(decl.initializer) && lowerer.isStdlibGlobal(decl.initializer.expression, "Array") &&
+                        (type.kind !== "array" || type.elem.kind === "dyn"))
+                        type = DYN;
                     // Unannotated JavaScript aliases retain an existing native
                     // checked object instead of copying it into an inferred record.
                     if (isJsSourceFile(sf) && !decl.type && !hasJsTypeAnnotation(decl) &&
@@ -2417,7 +2520,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
         // SITE's position instead (below) — their inner class node may
         // even live in another file.
         c.decl && ts.isClassDeclaration(c.decl) && !c.mixinInstance && c.decl.getSourceFile() === sf &&
-            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
+            (c.callableBase !== undefined || c.def.baseValueGlobal !== undefined || c.runtimeStatics !== undefined || c.staticFields.length > 0 || (c.staticBlocks?.length ?? 0) > 0 || c.classDecorators !== undefined))
             .map((c) => ({ pos: c.decl.getStart(), info: c }));
         // Statics-bearing MIXIN instantiations whose call evaluates in THIS
         // file: their declaration-time code runs when the call does — the
@@ -2443,7 +2546,8 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 body.push(...lowerer.lowerStaticFieldInits(statics[at].info));
                 at++;
             }
-            const stmtIr = lowerer.lowerStmts([stmt]);
+            const deferred = lowerer.deferredModuleInitializers?.defer(lowerer, stmt);
+            const stmtIr = 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.