@scriptc/compiler 0.4.0 → 0.4.2

package/dist/frontend/program.js

@@ -44,10 +44,12 @@ import * as ts from "./ts7/adapter.js";
 import { commonJsModuleSyntaxDiag, invalidPackageConfigDiag, strictNullChecksFloorDiag, tscPassthroughDiag, unsupportedDiag, } from "../diagnostics/diagnostic.js";
 import { isNodeModulesPath, nearestInvalidPackageJsonPath, nearestPackageType, nearestPkgJsonPath, packageImportTarget, projectDtsRuntimeSibling, resolveBareModule, resolveProjectModule, resolveTypeDirective, setProjectPathMappings, setProjectRealm, } from "./resolve.js";
 import { probeNodeImportRefusal, probeNodeRequireRefusal } from "./npm.js";
-import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, npmStaticLexerVisibleNames, npmStaticLiveExportTable, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages, } from "./npm-static.js";
+import { isNpmStaticPackage, npmStaticActive, npmStaticFsShadow, programBuiltinAliasSource, clearProgramBuiltinAliasCache, npmStaticLexerVisibleNames, npmStaticLiveExportTable, npmStaticPackageOfPath, reportNpmStaticOffender, setNpmStaticDeclarationOverloads, setNpmStaticPackages, setNpmStaticTypeExports, } from "./npm-static.js";
 import { isPrunedNpmReexport, planNpmStaticReexports } from "./npm-static-prune.js";
+import { npmStaticTypeExportPlan } from "./npm-static-type-exports-host.js";
 import { isNpmStaticSubclassArgument } from "./npm-static-subtyping.js";
 import { npmStaticDeclarationReexports, npmStaticRuntimeClassTargets, parseNpmStaticDeclarationOverloads, parseNpmStaticDeclarationProperties, } from "./npm-static-declaration-syntax.js";
+import { configurePackageShims, isPackageShimFile, isPackageShimName, isShimmedImport, } from "./package-shims.js";
 import { provenanceEntryFor, provenancePaths } from "./provenance-registry.js";
 import { cjsLexedExportsOfFile, cjsVisibleNames } from "./cjs-syntax.js";
 import { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath, tsgoPath, } from "./dts-paths.js";
@@ -60,6 +62,7 @@ import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
+import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -559,6 +562,42 @@ function moduleSpecifierKind7(specifier) {
         ? "require"
         : "import";
 }
+/** The program's files with JSX, lowered with the project's jsx settings
+ * and each file's pragmas, or the refusal of a setting that emits no calls.
+ * TypeScript files (.ts, .mts, .cts) cannot hold JSX; without a jsx setting
+ * the checker already rejects any JSX (TS17004). */
+function lowerProgramJsx7(program, options) {
+    const sources = new Map();
+    const mode = jsxEmitName(options.jsx);
+    if (mode === undefined)
+        return { sources, refusal: null };
+    for (const sf of program.getImplementationSourceFiles()) {
+        if (sf.isDeclarationFile || /\.[mc]?ts$/.test(sf.fileName) || !containsJsx(sf))
+            continue;
+        const at = firstJsx(sf);
+        const loc = { file: sf.fileName, start: ts.tokenStartOfNode(at), end: at.end };
+        if (mode === "preserve" || mode === "react-native") {
+            return {
+                sources,
+                refusal: {
+                    code: "SC1090",
+                    message: `JSX with "jsx": "${mode}" is not supported: that setting keeps JSX in the output instead of lowering it to calls`,
+                    loc,
+                    hint: 'set "jsx" to "react", "react-jsx" or "react-jsxdev" in the project tsconfig',
+                },
+            };
+        }
+        const plan = jsxEmitPlan({
+            jsx: mode,
+            jsxFactory: options.jsxFactory,
+            jsxFragmentFactory: options.jsxFragmentFactory,
+            jsxImportSource: options.jsxImportSource,
+            reactNamespace: options.reactNamespace,
+        }, jsxPragmas(sf.text));
+        sources.set(sf.fileName, lowerJsx(sf, plan));
+    }
+    return { sources, refusal: null };
+}
 function loadProgram7(host, entryPath, externalTypes = new Map(), 
 /** The --npm-static lowering world: root opted-in packages' deep edges. */
 rootNpmStaticEdges = false) {
@@ -635,6 +674,28 @@ rootNpmStaticEdges = false) {
             };
             program = host.createProgram([...programRoots, overridesDtsPath()], options);
         }
+        // JSX: the program above checks the files as written; the program the
+        // lowering compiles holds them with their JSX lowered.
+        const jsx = lowerProgramJsx7(program, options);
+        let tscWorld;
+        if (jsx.refusal !== null) {
+            config.diags.push(jsx.refusal);
+        }
+        else if (jsx.sources.size > 0) {
+            const original = program;
+            // The project world must read the original text too, so it is built
+            // before the rewritten files are served, and only when it is needed.
+            const diagnostics = ts.getPreEmitDiagnostics(original);
+            const errors = diagnostics.some((d) => d.category === ts.DiagnosticCategory.Error);
+            tscWorld = {
+                program: original,
+                diagnostics,
+                projectWorld: errors ? host.createProgram(programRoots, options) : null,
+            };
+            for (const [file, lowered] of jsx.sources)
+                host.addVirtualFile(file, lowered.text);
+            program = host.createProgram([...programRoots, overridesDtsPath()], options);
+        }
         const entry = program.getSourceFile(entryPath);
         if (!entry)
             throw new Error(`could not load ${entryPath}`);
@@ -653,10 +714,14 @@ rootNpmStaticEdges = false) {
             },
             externalTypes,
             externalTypeSpecifiersByFile,
+            ...(tscWorld === undefined ? {} : { jsxSources: jsx.sources }),
+            ...(tscWorld === undefined ? {} : { tscWorld }),
             projectWorld: () => (projectWorld ??= host.createProgram(programRoots, options)),
             disposeAll: () => {
                 try {
                     projectWorld?.dispose();
+                    tscWorld?.projectWorld?.dispose();
+                    tscWorld?.program.dispose();
                 }
                 finally {
                     program.dispose();
@@ -686,7 +751,11 @@ export function loadProgram(entryPath, services, opts) {
         }
         externalTypes.set(specifier, declarationPath);
     }
-    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])];
+    // Packages scriptc implements itself or the project marks never loaded
+    // (package-shims.ts) never compile their published JavaScript, even when
+    // named.
+    configurePackageShims(entryPath);
+    const npmStaticPackages = [...new Set(opts?.npmStatic ?? [])].filter((name) => !isPackageShimName(name));
     // Resolve authored declaration entries before enabling the JS-only
     // package resolver. Safe overload metadata binds through the runtime
     // entry to one exact implementation file; it never contributes values
@@ -774,6 +843,10 @@ export function loadProgram(entryPath, services, opts) {
     }
     setNpmStaticPackages(npmStaticPackages);
     setNpmStaticDeclarationOverloads(declarationOverloads, declarationProperties);
+    // Types only the packages' .d.ts declares keep their declarations
+    // (npm-static-type-exports.ts).
+    const typeExports = npmStaticTypeExportPlan(services, entryPath, npmStaticPackages);
+    setNpmStaticTypeExports(typeExports.copies, typeExports.typedefs);
     // Workspace-package registrations reset per load (same discipline as the
     // npm-static set), then the opted-in names are probed UP FRONT: a
     // workspace-linked opt-in resolves to files whose realpaths carry no
@@ -798,8 +871,9 @@ export function loadProgram(entryPath, services, opts) {
     // the checker, so its resolution lands on the JS Node actually loads;
     // resolve.ts answers the same sibling for scriptc's own edges).
     const npmShadow = npmStaticFsShadow(services);
+    clearProgramBuiltinAliasCache();
     const fsShadow = {
-        readFile: (path) => npmShadow?.readFile(path),
+        readFile: (path) => npmShadow?.readFile(path) ?? programBuiltinAliasSource(services, path),
         hideFile: (path) => (npmShadow?.hideFile(path) ?? false) || projectDtsRuntimeSibling(path) !== null,
     };
     const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
@@ -849,10 +923,11 @@ export function loadProgram(entryPath, services, opts) {
  * preflight diagnostics. Preserve the caller's complete load shape when
  * mutating it, including its owned services and disposal callback. */
 export function checkPreflight(load) {
-    const { diags, moduleOrder, startupCrash, inlineRequireCycleCalls } = preflight7(load);
+    const { diags, moduleOrder, startupCrash, inlineRequireCycleCalls, moduleEdges } = preflight7(load);
     load.moduleOrder = moduleOrder;
     load.startupCrash = startupCrash;
     load.inlineRequireCycleCalls = inlineRequireCycleCalls;
+    load.moduleEdges = moduleEdges;
     return diags;
 }
 /* Finding 5: tsgo's strict CommonJS modeling fires checker codes on JS
@@ -1847,8 +1922,9 @@ function staticCreateRequireUse7(expr) {
 }
 function stableCreateRequireBindingReason7(program, decl) {
     const cache = program.analysis.createRequireReasons;
-    if (cache.has(decl))
-        return cache.get(decl);
+    const cached = cache.get(decl);
+    if (cached !== undefined)
+        return cached;
     const check = () => {
         const stmt = decl.parent?.parent;
         if (!ts.isIdentifier(decl.name) ||
@@ -3287,6 +3363,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                         end: stmt.end,
                         reference: null,
                         folded: null,
+                        localNames: new Map(),
                     });
                     names.add(name.text);
                 }
@@ -3297,14 +3374,36 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
         if (candidates.size === 0)
             continue;
         const rankOf = new Map(evaluation.map((m, i) => [m, i]));
-        // References: every identifier spelled like a candidate, resolved
-        // through import aliases to the declaration's symbol.
+        // References: every identifier spelled like a candidate or like a
+        // local name the file imports one under (`import { x as y }`, a
+        // default import), resolved through import aliases to the
+        // declaration's symbol.
         for (const sf of order) {
+            const local = new Set();
+            for (const stmt of sf.statements.nodes) {
+                if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined)
+                    continue;
+                const clause = stmt.importClause;
+                const bound = clause.name !== undefined ? [clause.name] : [];
+                if (clause.namedBindings !== undefined && ts.isNamedImports(clause.namedBindings))
+                    for (const element of clause.namedBindings.elements.nodes)
+                        bound.push(element.name);
+                for (const name of bound) {
+                    if (names.has(name.text))
+                        continue;
+                    const imported = checker.getSymbolAtLocation(name);
+                    const candidate = imported === undefined ? undefined : candidates.get(checker.getAliasedSymbol(imported));
+                    if (candidate === undefined)
+                        continue;
+                    local.add(name.text);
+                    candidate.localNames.set(sf.fileName, name.text);
+                }
+            }
             const refs = [];
             ts.walkPreorder(sf, (node) => {
                 if (ts.isImportDeclaration(node))
                     return "skip";
-                if (ts.isIdentifier(node) && names.has(node.text))
+                if (ts.isIdentifier(node) && (names.has(node.text) || local.has(node.text)))
                     refs.push(node);
                 return undefined;
             });
@@ -3367,6 +3466,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                 reference: c.reference,
                 ...(c.folded !== null ? { folded: c.folded } : {}),
                 settled,
+                ...(c.localNames.size > 0 ? { localNames: c.localNames } : {}),
             });
         }
     }
@@ -3933,6 +4033,11 @@ function resolveNpmImport7(fromFileName, specifier, resolutionKind = "import") {
     // its attested source compiles as program modules (resolveProjectModule
     if (provenanceEntryFor(specifier) !== null)
         return null;
+    // Shimmed and never-loaded packages (package-shims.ts) are not npm
+    // imports either: the shim compiles as a program module, and an unloaded
+    // package's require() is Node's MODULE_NOT_FOUND.
+    if (isShimmedImport(fromFileName, specifier))
+        return null;
     const resolved = resolveBareModule(fromFileName, specifier, undefined, resolutionKind);
     if (!resolved)
         return null;
@@ -4160,6 +4265,29 @@ function preflight7(load) {
             return true;
         return d.code === 2300 && commentDup.has(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
     };
+    /* `typeof window` / `typeof self` in a JavaScript file: the operand of
+     * typeof may name a global nothing declares (Node answers "undefined"
+     * and never throws), the feature-detection idiom every isomorphic
+     * package uses, and the guarded uses of that name (`typeof window < "u"
+     * ? window : …`) are code Node never runs. A name the file feature-tests
+     * this way is therefore not a type error in JavaScript; a reached use
+     * still meets the lowering's located refusal. TypeScript files keep the
+     * error and its hint. */
+    const typeofTestedNameSuppressed = (p, d) => {
+        if (d.code !== 2304 && d.code !== 2552 && d.code !== 2584)
+            return false;
+        if (d.fileName === undefined || !isJsSourceFileName(d.fileName))
+            return false;
+        if (d.pos === undefined || d.end === undefined)
+            return false;
+        const sf = p.getSourceFile(d.fileName);
+        if (!sf)
+            return false;
+        const name = sf.text.slice(d.pos, d.end);
+        if (!/^[A-Za-z_$][\w$]*$/.test(name))
+            return false;
+        return new RegExp(`\\btypeof\\s*\\(?\\s*${name.replace(/\$/g, "\\$")}(?![\\w$])`).test(sf.text);
+    };
     const workspaceImplicitAnySuppressed = (p, d) => {
         if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
             return false;
@@ -4183,8 +4311,8 @@ function preflight7(load) {
         const sf = p.getSourceFile(d.fileName);
         return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs);
     };
-    const errorsOf = (p) => {
-        const all = ts.getPreEmitDiagnostics(p);
+    const errorsOf = (p) => keptErrors(p, ts.getPreEmitDiagnostics(p));
+    const keptErrors = (p, all) => {
         // First pass: every comment-side 2300's (file, name) — the partners
         // the second pass forgives.
         const commentDup = new Set();
@@ -4201,10 +4329,12 @@ function preflight7(load) {
             (!suppressedJsStrictness7(d) || enforcedInCheckedJs(p, d)) &&
             !npmStaticFileSuppressed(d) &&
             !nodeModulesJsSuppressed(d) &&
+            (d.fileName === undefined || !isPackageShimFile(d.fileName)) &&
             !namespaceCalleeSuppressed(p, d) &&
             !inferredJsDiagnosticSuppressed(p, d) &&
             !isNpmStaticSubclassArgument(p, d) &&
             !workspaceImplicitAnySuppressed(p, d) &&
+            !typeofTestedNameSuppressed(p, d) &&
             !jsdocTypeSuppressed(p, d, commentDup));
     };
     // The tsc gate, with a second chance: the LOWERING world's checker
@@ -4219,10 +4349,39 @@ function preflight7(load) {
     // instead (the SC1100 checked-cast family). Dirty there → the project-
     // world errors are the ones reported: they are reproducible with the
     // project's own tsc, which is what "fix type errors first" asks for.
-    const tscErrors = errorsOf(program);
+    // With JSX sources, the program over the original text answers the tsc
+    // gate; its positions move into the rewritten text the program holds.
+    // Errors only the rewritten text has come from the calls the JSX lowers
+    // to (a factory whose signature does not accept them).
+    const tscWorld = load.tscWorld;
+    const tscErrors = tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics);
     if (tscErrors.length > 0) {
-        for (const d of errorsOf(load.projectWorld()))
-            diags.push(toPassthrough(d));
+        const world = tscWorld === undefined ? load.projectWorld() : (tscWorld.projectWorld ?? tscWorld.program);
+        for (const d of errorsOf(world)) {
+            const diag = toPassthrough(d);
+            const lowered = tscWorld === undefined ? undefined : load.jsxSources?.get(diag.loc.file);
+            if (lowered !== undefined) {
+                diag.loc = {
+                    ...diag.loc,
+                    start: lowered.rewrittenPosition(diag.loc.start, false),
+                    end: lowered.rewrittenPosition(diag.loc.end, true),
+                };
+            }
+            diags.push(diag);
+        }
+    }
+    else if (load.jsxSources !== undefined) {
+        for (const file of load.jsxSources.keys()) {
+            const sf = program.getSourceFile(file);
+            if (sf === undefined)
+                continue;
+            const own = [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)];
+            for (const d of keptErrors(program, own)) {
+                const diag = toPassthrough(d);
+                diag.message = `${diag.message} (in the call this JSX lowers to)`;
+                diags.push(diag);
+            }
+        }
     }
     // Preflight and lowering share this CheckerFacade. Claim executable
     // source files after workspace discovery and the tsc gate but before
@@ -4999,6 +5158,7 @@ function preflight7(load) {
         moduleOrder: order,
         startupCrash: resolveCrash ?? linkCrash,
         inlineRequireCycleCalls,
+        moduleEdges: edges,
     };
 }
 /** Walks the entry's ESM instantiate graph exactly as V8 does — children