@scriptc/compiler 0.4.2 → 0.4.4

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

@@ -19,7 +19,7 @@ import { isRelativeSpecifier } from "../workspace-registry.js";
 import { canonicalBuiltinModule, cjsExportAssignmentOf, cjsExportChainOf, cjsVoidInitPreambleReals, cjsExportDiscardReason, cjsExportTargetLiteral, entryPackageFilePredicate, isCjsJsFile, isJsSourceFile, isRequireStatement, locOf, makeCycleAdmission, orderedImportsOf, requireSpecOf, resolveImport, resolveNpmImport, } from "../program.js";
 import { markCycleEarlyBindings, withClassInitFlag, withCycleInitFlags, } from "./cycle-initialization.js";
 import { markRequireEarlyBindings } from "./require-initialization.js";
-import { cjsTableMethodEntry, inlineProgramRequireOf, nestedCjsExportAssignmentsOf, requireNestedPatternsOf, } from "./cjs-inline-require.js";
+import { cjsHasLiveMemberExports, cjsTableMethodEntry, inlineProgramRequireOf, nestedCjsExportAssignmentsOf, requireNestedPatternsOf, splitRequireBindingOf, splitRequireBindingOfIdent, wholeExportSymbolOfModule, } from "./cjs-inline-require.js";
 import { isDeadTscHelperDecl, tscInteropBindingOfDecl } from "./cjs-tsc-interop.js";
 import { collectJsonRequires, isJsonRequireDecl } from "./json-require.js";
 import { invalidJsonModuleDiag, unsupportedPackageImportDiag, } from "../../diagnostics/diagnostic.js";
@@ -1413,12 +1413,23 @@ export function collectGlobals(lowerer, sf, topStmts) {
                 // require() of a program module is not: the exporter re-exports
                 // that module's exports, which requirers resolve through the
                 // checker's alias (the statement lowers to the dep's %init).
-                const factoryValued = !ts.isIdentifier(rhs) &&
+                // A split binding re-exported whole with later member writes needs
+                // a mutable root: `module.exports = m; module.exports.extra = 1`
+                // extends the SAME object Node exposes. Without later members the
+                // binder is pure alias plumbing (no storage).
+                const splitWholeBinding = ts.isIdentifier(rhs)
+                    ? splitRequireBindingOfIdent(lowerer, rhs)
+                    : null;
+                const hasMemberExports = cjsHasLiveMemberExports(lowerer, sf);
+                const splitWhole = splitWholeBinding !== null &&
+                    wholeExportSymbolOfModule(lowerer, splitWholeBinding.dep) !== null &&
+                    hasMemberExports;
+                const factoryValued = (!ts.isIdentifier(rhs) || splitWhole) &&
                     !ts.isClassExpression(rhs) &&
                     !ts.isObjectLiteralExpression(rhs) &&
                     !(requireSpecOf(rhs) !== null &&
                         inlineProgramRequireOf(lowerer, rhs) !== null &&
-                        !sf.statements.nodes.some((s) => cjsExportAssignmentOf(s)?.kind === "member")) &&
+                        !hasMemberExports) &&
                     cjsExportTargetLiteral(rhs, sf) === null;
                 if (cjsScalarLiteral(rhs) || fnValued || factoryValued) {
                     const diagsBefore = lowerer.diags.length;
@@ -1430,6 +1441,10 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         // exports.member writes must update that same open object.
                         if (factoryValued && t?.kind === "record" && lowerer.dynConvertible(t))
                             t = DYN;
+                        // A split whole-export root is extended by later member writes;
+                        // keep it checked-dynamic so those writes reach the same object.
+                        if (splitWhole && t && t.kind !== "dyn")
+                            t = DYN;
                         if (t && t.kind !== "void") {
                             const g = {
                                 id: `%g.${tag}exports`,
@@ -2155,8 +2170,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // and closures created in the init body capture it normally.
                     // References from separately-declared functions cascade to
                     // their own per-site runtime fences.
-                    const factoryType = !isLet &&
-                        isJsSourceFile(sf) &&
+                    const factoryType = isJsSourceFile(sf) &&
                         !decl.type &&
                         !hasJsTypeAnnotation(decl) &&
                         ts.isIdentifier(decl.name) &&
@@ -2460,6 +2474,8 @@ function noteVarGlobalEntryInit(lowerer, sf, g) {
  * plumbing (lowerVarDeclarator): no storage, the reads resolve through to
  * the module. JSON documents and native FFI requires keep their storage. */
 function requireAliasDecl(lowerer, decl) {
+    if (splitRequireBindingOf(lowerer, decl) !== null)
+        return true;
     return (decl.initializer !== undefined &&
         requireSpecOf(decl.initializer) !== null &&
         !isNativeFfiRequire(lowerer, decl.initializer) &&
@@ -2660,10 +2676,41 @@ export function lowerDefaultExport(lowerer, stmt) {
     const value = lowerer.lowerExprExpecting(stmt.expression, g.type);
     return { kind: "assign", localId: g.id, value, loc: locOf(stmt) };
 }
+/** Marks the runtime fences recorded since `fencesBefore` that lie in
+ * `sf`'s top-level code: they run when the module initializes. A fence
+ * inside a function, or inside a class member that runs later (a method,
+ * accessor, constructor or instance field initializer), runs when that
+ * code is called. */
+function markModuleInitFences(lowerer, sf, fencesBefore) {
+    for (let i = fencesBefore; i < lowerer.runtimeFences.length; i++) {
+        const fence = lowerer.runtimeFences[i];
+        if (fence.loc.file !== sf.fileName || runsAfterModuleInit(sf, fence.loc.start))
+            continue;
+        lowerer.runtimeFences[i] = { ...fence, startup: true };
+    }
+}
+/** Whether the code at `pos` sits in a function or a later-running class
+ * member body. */
+function runsAfterModuleInit(sf, pos) {
+    let later = false;
+    ts.walkPreorder(sf, (node) => {
+        if (node.pos > pos || node.end <= pos)
+            return "skip";
+        if (ts.isFunctionLike(node) ||
+            (ts.isPropertyDeclaration(node) &&
+                !node.modifiers?.nodes.some((m) => m.kind === ts.SyntaxKind.StaticKeyword))) {
+            later = true;
+            return "stop";
+        }
+        return undefined;
+    });
+    return later;
+}
 export function lowerFileInit(lowerer, sf, stmts, name) {
     const isAsync = lowerer.asyncInitFiles.has(sf);
     const ctx = newFnCtx(false, null, null, VOID);
     ctx.isAsync = isAsync;
+    const fencesBefore = lowerer.runtimeFences.length;
     lowerer.fnStack.push(ctx);
     try {
         const loc0 = { file: sf.fileName, start: 0, end: 0 };
@@ -2996,6 +3043,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
     }
     finally {
         lowerer.fnStack.pop();
+        markModuleInitFences(lowerer, sf, fencesBefore);
     }
 }
 /** Program modules whose evaluation can be requested again after it