@scriptc/compiler 0.4.6 → 0.4.8

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

@@ -3,6 +3,7 @@ import { isIslandSubclassDecl } from "../../node-islands/boundary.js";
 import { globalValuesInstall, installsGlobalValues } from "./global-values.js";
 import { THREADS_MODULE } from "../threads-import.js";
 import { collectIslandImport, collectIslandRequires } from "./lower-node-island.js";
+import { staticString } from "./builtins/module-resolution.js";
 import { NODE_API_MODULE } from "../node-api-import.js";
 import { positionTag } from "./structural-positions.js";
 import { EXPERIMENTAL_MODULE } from "../experimental-import.js";
@@ -18,7 +19,7 @@ import { collectRebindableFunctions, isRebindableFunction } from "./rebindable-f
 import { bindingSource } from "../binding-source.js";
 import { sharedInitFlagStores, sharedModulePlans, sharedModuleRegistrations, } from "./lower-shared-modules.js";
 import { dirname as dirnamePath, resolve as resolvePath } from "node:path";
-import { packageNameOfPath, probeNodeImportRefusal } from "../npm.js";
+import { packageNameOfPath, probeNodeFileImportRefusal, probeNodeImportRefusal, } from "../npm.js";
 import { isNpmStaticPackage } from "../npm-static.js";
 import { isJsSourceFileName } from "../tsc-codes.js";
 import { isRelativeSpecifier } from "../workspace-registry.js";
@@ -41,7 +42,7 @@ import { isWebCryptoMemberType } from "./builtins/webcrypto.js";
 import { bindingContextualGenericFnNodeOf, bindingGenericFnAliasInfoOf, bindingGenericFnInfoOf, bindingGenericFnNodeOf, implicitLocalFnInfoOf, implicitLocalFnNodeOf, } from "./generic-functions.js";
 import { bindingNeverReassigned, deadUnmappableBinding, nullishGenericBindingUnitOf, } from "./binding-analysis.js";
 import { funcTypeFromParamShapes, registerOverloadedCallableAlias } from "./call-signatures.js";
-import { jsBindingHasOpenWrites, hasJsTypeAnnotation, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl, stdlibBufferVarAlias, } from "./lower-stmts.js";
+import { jsBindingHasOpenWrites, hasJsTypeAnnotation, inferredEvolvingLetType, isVarDeclared, numericIteratorSourceOf, provenanceElidedConstDecl, stdlibBufferVarAlias, } from "./lower-stmts.js";
 import { objectFactoryGlobalType } from "./object-factory-new.js";
 import { streamClassAliasDecl } from "./lower-stream.js";
 import { isAssertClassNew } from "./assert-instances.js";
@@ -60,7 +61,7 @@ import { workerTargetPaths } from "../worker-target.js";
 import { isNativeProxyInitializer } from "./expressions/native-proxy.js";
 import { handleEventReaderPrelude } from "./lower-event-target.js";
 import { dateClassOperationPrelude } from "./builtins/date-classes.js";
-import { cjsAccessorSnapshotStores, jsHoldsDynObject } from "./lower-exprs.js";
+import { cjsAccessorSnapshotStores, jsHoldsDynObject, jsHoldsMixedClassConstructors, } from "./lower-exprs.js";
 import { keptIdentityAssertion } from "./assertion-identity.js";
 /** An appended module's edges: its import and export declarations, then
  * the require() edges preflight resolved — a CommonJS file's only edges
@@ -169,7 +170,13 @@ function appendEntryModules(program, order, targets, paths, onCycle, graph) {
  * (tests, coverage on broken files) may arrive with an empty order — fall
  * back to the entry alone. */
 export function splitFiles(lowerer) {
-    const files = lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry];
+    // A declaration file is never a runtime module: it carries no
+    // implementation, so it has no %init to lower and its imports never load
+    // anything. Preflight keeps declarations out of the module order (a
+    // specifier that resolves only to declarations is refused at its own
+    // statement); this filter is the invariant that keeps a stray declaration
+    // from being lowered as code.
+    const files = (lowerer.moduleOrder.length > 0 ? lowerer.moduleOrder : [lowerer.entry]).filter((sf) => !sf.isDeclarationFile);
     return files.map((sf) => {
         const fp = { sf, fnDecls: [], classDecls: [], topStmts: [] };
         const rebindable = collectRebindableFunctions(lowerer, sf);
@@ -475,8 +482,19 @@ export function collectNpmImports(lowerer, parts) {
                 ? stmt.exportClause
                 : null;
             if (reexport === null &&
-                (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)))
+                (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))) {
+                // A star or namespace re-export (`export * from "pkg"`) names
+                // nothing the re-exporting module could bind: an island package's
+                // is refused at the boundary instead of silently dropped. Any
+                // other module keeps the previous skip, and a type-only one is
+                // erased like the type-only named re-export above.
+                if (ts.isExportDeclaration(stmt) &&
+                    !stmt.isTypeOnly &&
+                    stmt.moduleSpecifier !== undefined &&
+                    ts.isStringLiteral(stmt.moduleSpecifier))
+                    collectIslandImport(lowerer, fp.sf, stmt, stmt.moduleSpecifier.text);
                 continue;
+            }
             const specNode = ts.isImportDeclaration(stmt) || ts.isExportDeclaration(stmt)
                 ? stmt.moduleSpecifier
                 : undefined;
@@ -501,6 +519,11 @@ export function collectNpmImports(lowerer, parts) {
             // graph: resolveImport follows its node_modules link to the loaded
             // TypeScript entry. Its internal `.js` spellings have already been
             // resolved to `.ts` by that graph.
+            // A relative import of a program module the pre-scan put in a Node
+            // island (DESIGN.md note 1 §3.2): the island loads at this module's
+            // position and its bindings are island values.
+            if (lowerer.nodeIslands !== null && collectIslandImport(lowerer, fp.sf, stmt, spec))
+                continue;
             const projectDep = isRelativeSpecifier(spec)
                 ? null
                 : resolveImport(lowerer.program, fp.sf, spec);
@@ -586,19 +609,32 @@ export function collectNpmImports(lowerer, parts) {
  * runtime-computed name). */
 /** The refusal a literal import() rejects with, or null when it loads:
  * Node's ERR_MODULE_NOT_FOUND for a package the project marks never loaded
- * (package-shims.ts), or the first refusal in the static graph of a module
- * only import() loads (LoadResult.dynamicImportRejections). */
+ * (package-shims.ts), the first refusal in the static graph of a module
+ * only import() loads (LoadResult.dynamicImportRejections), or Node's
+ * resolution refusal for a specifier nothing resolves (a package nothing
+ * installed provides, a relative path to a file that does not exist). */
 function dynamicImportRejectionOf(lowerer, sf, spec, call) {
-    if (isUnloadedPackage(spec)) {
-        const refusal = probeNodeImportRefusal(sf.fileName, spec);
-        if (refusal === null)
-            return null;
-        return { message: refusal.message, className: "%Error", code: refusal.code, loc: locOf(call) };
-    }
-    if (lowerer.dynamicImportRejections.size === 0)
-        return null;
+    const rejection = (refusal) => refusal === null
+        ? null
+        : {
+            message: refusal.message,
+            className: "%Error",
+            code: refusal.code,
+            ...(refusal.url === undefined ? {} : { url: refusal.url }),
+            loc: locOf(call),
+        };
+    if (isUnloadedPackage(spec))
+        return rejection(probeNodeImportRefusal(sf.fileName, spec));
     const root = resolveImport(lowerer.program, sf, spec) ?? npmStaticDepSf7(lowerer.program, sf, spec);
-    return root === null ? null : (lowerer.dynamicImportRejections.get(root) ?? null);
+    if (root !== null)
+        return lowerer.dynamicImportRejections.get(root) ?? null;
+    // Builtins, and URL specifiers (file:, data:), are not package names.
+    if (canonicalBuiltinModule(spec) !== null || /^[a-z][a-z0-9+.-]*:/i.test(spec))
+        return null;
+    return rejection(probeNodeFileImportRefusal(sf.fileName, spec) ??
+        (spec.startsWith(".") || spec.startsWith("/")
+            ? null
+            : probeNodeImportRefusal(sf.fileName, spec)));
 }
 function collectDynamicImports(lowerer, sf) {
     ts.walkPreorder(sf, (node) => {
@@ -606,8 +642,9 @@ function collectDynamicImports(lowerer, sf) {
             node.expression.kind === ts.SyntaxKind.ImportKeyword &&
             node.arguments.nodes.length >= 1 &&
             node.arguments.nodes[0] !== undefined &&
-            ts.isStringLiteralLike(node.arguments.nodes[0])) {
-            const spec = node.arguments.nodes[0].text;
+            staticString(lowerer, node.arguments.nodes[0]) !== null) {
+            // A constant expression names its module as surely as a literal.
+            const spec = staticString(lowerer, node.arguments.nodes[0]);
             if (lowerer.externalTypes.has(spec)) {
                 return undefined;
             }
@@ -626,8 +663,13 @@ function collectDynamicImports(lowerer, sf) {
                     return undefined;
                 }
                 const modSym = lowerer.checker.getSymbolAtLocation(node.arguments.nodes[0]);
-                const ownModule = modSym !== undefined &&
-                    modSym.declarations.some((d) => ts.isSourceFile(d) && !d.isDeclarationFile);
+                // A folded specifier carries no module symbol on its argument (the
+                // text comes from a `const`, not a literal), so fall back to the
+                // checker's program import resolution.
+                const folded = resolveImport(lowerer.program, sf, spec);
+                const ownModule = (modSym !== undefined &&
+                    modSym.declarations.some((d) => ts.isSourceFile(d) && !d.isDeclarationFile)) ||
+                    (folded !== null && !folded.isDeclarationFile);
                 const builtin = canonicalBuiltinModule(spec);
                 const res = ownModule
                     ? { kind: "program-module" }
@@ -1026,9 +1068,11 @@ function deferJsCollectionDiags(lowerer, sf, diagsBefore) {
         return;
     const captured = lowerer.diags.splice(diagsBefore);
     const ice = captured.filter((d) => d.code === "SC9001");
-    if (ice.length > 0)
-        lowerer.diags.push(...ice);
-    lowerer.runtimeFences.push(...captured.filter((d) => d.code !== "SC9001"));
+    for (const d of ice)
+        lowerer.diags.push(d);
+    for (const d of captured)
+        if (d.code !== "SC9001")
+            lowerer.runtimeFences.push(d);
 }
 /** A scalar-literal expression a single-value `module.exports =` can carry
  * without any declaration to alias to: string/number/boolean literals,
@@ -2198,6 +2242,36 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         }
                         continue;
                     }
+                    // A JS file-scope ARRAY LITERAL of several class constructors
+                    // (`const classes = [A, B]`): tsc's best common type spells the
+                    // FIRST constructor, but the literal is a fresh array of every
+                    // constructor it names, so the binding holds the checked-dynamic
+                    // array (lowerArrayLiteral's own rule). The spelled element type
+                    // would check each element against A's class key and reject B at
+                    // module init.
+                    if (isJsSourceFile(sf) &&
+                        ts.isIdentifier(decl.name) &&
+                        nameNode === decl.name &&
+                        !decl.type &&
+                        !hasJsTypeAnnotation(decl) &&
+                        decl.initializer !== undefined &&
+                        jsHoldsMixedClassConstructors(lowerer, decl.initializer)) {
+                        const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
+                        if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            const g = {
+                                id: `%g.${tag}${nsPrefix}${nameNode.text}`,
+                                name: nameNode.text,
+                                type: DYN,
+                                mutable: isLet,
+                                source: bindingSource(nameNode),
+                            };
+                            lowerer.globalsBySymbol.set(symbol, g);
+                            lowerer.globalsList.push(g);
+                            if (isVarDeclared(decl))
+                                noteVarGlobalEntryInit(lowerer, sf, g);
+                        }
+                        continue;
+                    }
                     // A JS file-scope ANY-RESIDUE binding whose VALUE provably
                     // lives in the checked-dynamic tree: no initializer (`let catchWarning;` —
                     // test/common's warning ledger), a unit initializer (`let
@@ -2219,10 +2293,15 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         dynFallbackType(lowerer, nameNode, lowerer.typeOf(nameNode))?.kind === "dyn") {
                         const symbol = lowerer.checker.getSymbolAtLocation(nameNode);
                         if (symbol && !lowerer.globalsBySymbol.has(symbol)) {
+                            // An initializer-less `let` whose writes all agree keeps
+                            // their type, as a function's local does (lowerVarDecl).
+                            const evolved = isLet && !isVarDeclared(decl) && decl.initializer === undefined
+                                ? inferredEvolvingLetType(lowerer, decl)
+                                : null;
                             const g = {
                                 id: `%g.${tag}${nsPrefix}${nameNode.text}`,
                                 name: nameNode.text,
-                                type: DYN,
+                                type: evolved ?? DYN,
                                 mutable: isLet,
                                 source: bindingSource(nameNode),
                             };
@@ -2231,7 +2310,7 @@ export function collectGlobals(lowerer, sf, topStmts) {
                             // Mutable dyn globals hold the dyn undefined from module
                             // entry (the main path's rule below): a closure called
                             // above the declaration reads undefined instead of
-                            // faulting on NULL.
+                            // faulting on NULL. An undefined-armed union does the same.
                             if (g.mutable)
                                 noteVarGlobalEntryInit(lowerer, sf, g);
                         }
@@ -2331,6 +2410,20 @@ export function collectGlobals(lowerer, sf, topStmts) {
                         !lowerer.mapTypeOf(lowerer.typeOf(nameNode)))
                         continue;
                     let type = handleT ?? factoryType ?? (inferredJsCall ? DYN : lowerer.irTypeOf(nameNode));
+                    // An initializer-less `let` without an annotation takes its
+                    // writes' type, as a function's local does (lowerVarDecl's own
+                    // binding path): `let stat; try { stat = lstatSync(".") } catch
+                    // { stat = null }` holds `Stats | null` rather than an
+                    // unchecked-dynamic slot.
+                    const evolvedGlobal = type.kind === "dyn" &&
+                        isLet &&
+                        !isVarDeclared(decl) &&
+                        decl.type === undefined &&
+                        decl.initializer === undefined
+                        ? inferredEvolvingLetType(lowerer, decl)
+                        : null;
+                    if (evolvedGlobal)
+                        type = evolvedGlobal;
                     if (isJsSourceFile(sf) &&
                         !decl.type &&
                         !hasJsTypeAnnotation(decl) &&
@@ -2552,7 +2645,9 @@ export function collectGlobals(lowerer, sf, topStmts) {
                     // reads the dyn undefined instead of faulting on NULL — the
                     // dyn face of let's documented pre-declaration window (Node
                     // throws the TDZ ReferenceError there).
-                    if (isVarDeclared(decl) || (g.type.kind === "dyn" && g.mutable)) {
+                    if (isVarDeclared(decl) ||
+                        evolvedGlobal !== null ||
+                        (g.type.kind === "dyn" && g.mutable)) {
                         noteVarGlobalEntryInit(lowerer, sf, g);
                     }
                 }
@@ -2915,7 +3010,14 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
             });
             ctx.hoistedFnDecls.add(stmt);
         }
+        const islandActions = lowerer.islandImportActions.get(sf);
+        const islandPlaced = new Set();
         for (const { stmt, dep } of orderedImportsOf(lowerer.program, sf)) {
+            const island = islandActions?.get(stmt);
+            if (island !== undefined) {
+                header.push(...island);
+                islandPlaced.add(stmt);
+            }
             const npm = lowerer.npmInitActions.get(sf)?.get(stmt);
             if (npm !== undefined && npm.length > 0) {
                 header.push(...npm);
@@ -2979,6 +3081,12 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 }
             }
         }
+        // An island load whose statement the import order leaves out keeps the
+        // prelude's place.
+        const islandUnplaced = [];
+        for (const [stmt, actions] of islandActions ?? [])
+            if (!islandPlaced.has(stmt))
+                islandUnplaced.push(...actions);
         if (asyncDeps.length === 1) {
             const dep = asyncDeps[0];
             const promiseT = { kind: "promise", inner: VOID };
@@ -3113,7 +3221,7 @@ export function lowerFileInit(lowerer, sf, stmts, name) {
                 statics.push({ pos: ms.pos, info: c });
         }
         statics.sort((a, b) => a.pos - b.pos);
-        const body = [...header, ...prelude];
+        const body = [...header, ...islandUnplaced, ...prelude];
         let at = 0;
         for (const stmt of stmts) {
             // `<=`: a mixin instantiation's position IS its statement's start