@scriptc/compiler 0.4.3 → 0.4.5

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";
@@ -204,22 +204,26 @@ function dynamicImportProgramTargetOf(program, sf, spec) {
     return dep;
 }
 /** Every distinct program module a file's `import("literal")` sites name
- * (source order, deduped). */
+ * (source order, deduped). The parser lists the specifier of every such call
+ * in the file's module references, in source order after the static imports,
+ * so the file's nodes need no walk. */
 function dynamicProgramImportsOf(program, sf) {
     const out = [];
     const seen = new Set();
-    ts.walkPreorder(sf, (node) => {
-        if (ts.isCallExpression(node) &&
-            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-            node.arguments.nodes[0] !== undefined &&
-            ts.isStringLiteralLike(node.arguments.nodes[0])) {
-            const dep = dynamicImportProgramTargetOf(program, sf, node.arguments.nodes[0].text);
-            if (dep && !seen.has(dep)) {
-                seen.add(dep);
-                out.push(dep);
-            }
+    for (const specifier of sf.imports) {
+        const call = specifier.parent;
+        if (call === undefined ||
+            !ts.isCallExpression(call) ||
+            call.expression.kind !== ts.SyntaxKind.ImportKeyword ||
+            call.arguments.nodes[0] !== specifier ||
+            !ts.isStringLiteralLike(specifier))
+            continue;
+        const dep = dynamicImportProgramTargetOf(program, sf, specifier.text);
+        if (dep && !seen.has(dep)) {
+            seen.add(dep);
+            out.push(dep);
         }
-    });
+    }
     return out;
 }
 export function appendDynamicImportModules(program, order, onCycle, graph) {
@@ -1033,15 +1037,22 @@ function jsDynHoldableInitializer(lowerer, init) {
         return true;
     if (ts.isIdentifier(e) && e.text === "undefined")
         return true;
-    if (ts.isConditionalExpression(e)) {
-        return (jsDynHoldableInitializer(lowerer, e.whenTrue) &&
-            jsDynHoldableInitializer(lowerer, e.whenFalse));
-    }
+    // The arms of a conditional or logical expression: checked values, or
+    // strings, numbers and booleans, which box into the checked-dynamic
+    // result (`const APP_NAME = config.name || "pi"`).
+    const arm = (x) => {
+        if (jsDynHoldableInitializer(lowerer, x))
+            return true;
+        const kind = lowerer.mapTypeOf(lowerer.typeOf(x))?.kind;
+        return kind === "string" || kind === "f64" || kind === "bool";
+    };
+    if (ts.isConditionalExpression(e))
+        return arm(e.whenTrue) && arm(e.whenFalse);
     if (ts.isBinaryExpression(e) &&
         (e.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken ||
             e.operatorToken.kind === ts.SyntaxKind.BarBarToken ||
             e.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken)) {
-        return jsDynHoldableInitializer(lowerer, e.left) && jsDynHoldableInitializer(lowerer, e.right);
+        return arm(e.left) && arm(e.right);
     }
     // A member of a checked module value is itself checked, including a
     // callable whose inferred overloads cannot describe one native ABI.
@@ -1413,12 +1424,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 +1452,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 +2181,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 +2485,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) &&