@scriptc/compiler 0.4.1 → 0.4.3

package/dist/frontend/program.js

@@ -44,8 +44,9 @@ 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, programBuiltinAliasSource, clearProgramBuiltinAliasCache, 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";
@@ -60,7 +61,9 @@ import { forkTargetPaths } from "./fork-target.js";
 import { workerTargetPaths } from "./worker-target.js";
 import { erasedTypeOnlyImport, typeOnlyNamedImport, typeOnlyReachedFiles, } from "./type-only-imports.js";
 import { moduleSourceCandidates } from "./module-source-candidates.js";
+import { planDeclProjection } from "./decl-projection.js";
 import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
+import { containsJsx, firstJsx, jsxEmitName, jsxEmitPlan, jsxPragmas, lowerJsx, } from "./jsx-source.js";
 const BASE_OPTIONS = {
     strict: true,
 };
@@ -560,9 +563,48 @@ 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) {
+rootNpmStaticEdges = false, 
+/** The declaration-typed boundary's projection (decl-projection.ts):
+ * answers rewritten user files for the lowering world, or null. */
+projector) {
     const config = adoptProjectConfig7(host, entryPath);
     const configuredPaths = config.options["paths"];
     setProjectPathMappings(configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
@@ -636,6 +678,80 @@ 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;
+        const declBoundaryNotes = [];
+        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);
+        }
+        else if (projector !== undefined) {
+            // The declaration-typed boundary: user files typed from package
+            // declarations (decl-projection.ts). The tsc gate reads the original
+            // text; the lowering compiles the rewritten files.
+            const projection = projector(program);
+            if (projection !== null) {
+                const original = program;
+                const baseline = new Map();
+                for (const file of projection.files.keys()) {
+                    const sf = original.getSourceFile(file);
+                    if (sf !== undefined)
+                        baseline.set(file, original.getSemanticDiagnostics(sf).length);
+                }
+                for (const [file, text] of projection.files)
+                    host.addVirtualFile(file, text);
+                host.addVirtualFile(projection.declFile, projection.declText);
+                programRoots.push(projection.declFile);
+                program = host.createProgram([...programRoots, overridesDtsPath()], options);
+                // A rewrite the lowering world disagrees with (new errors) is
+                // dropped for that file: the file lowers as it would without it.
+                const dropped = [];
+                for (const file of projection.files.keys()) {
+                    const sf = program.getSourceFile(file);
+                    if (sf === undefined)
+                        continue;
+                    if (program.getSemanticDiagnostics(sf).length > (baseline.get(file) ?? 0)) {
+                        dropped.push(file);
+                        host.addVirtualFile(file, original.getSourceFile(file).text);
+                    }
+                }
+                if (dropped.length > 0) {
+                    program.dispose();
+                    program = host.createProgram([...programRoots, overridesDtsPath()], options);
+                    for (const file of dropped)
+                        declBoundaryNotes.push(declBoundaryDroppedDiag(file));
+                }
+                if (dropped.length === projection.files.size) {
+                    program.dispose();
+                    programRoots.pop();
+                    program = original;
+                }
+                else {
+                    tscWorld = {
+                        program: original,
+                        diagnostics: ts.getPreEmitDiagnostics(original),
+                        projectWorld: null,
+                        declWorldFallback: true,
+                    };
+                }
+            }
+        }
         const entry = program.getSourceFile(entryPath);
         if (!entry)
             throw new Error(`could not load ${entryPath}`);
@@ -646,6 +762,7 @@ rootNpmStaticEdges = false) {
             entry,
             moduleOrder: [],
             configDiags: config.diags,
+            ...(declBoundaryNotes.length > 0 ? { declBoundaryNotes } : {}),
             typeWorld: {
                 nodeFallback: nodeTypes === null,
                 projectLib: config.projectLib ?? null,
@@ -654,10 +771,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();
@@ -779,6 +900,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
@@ -809,25 +934,58 @@ export function loadProgram(entryPath, services, opts) {
         hideFile: (path) => (npmShadow?.hideFile(path) ?? false) || projectDtsRuntimeSibling(path) !== null,
     };
     const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
+    let authoredHost = null;
+    let authoredLoad = null;
+    const authored = () => {
+        if (!authoredLoad) {
+            authoredHost = services.createProgramHost({ cwd: dirname(entryPath) });
+            authoredLoad = loadProgram7(authoredHost, entryPath, externalTypes);
+        }
+        return authoredLoad;
+    };
+    const declPackages = npmStaticPackages.filter((pkg) => {
+        const resolved = resolveBareModule(entryPath, pkg, "types-only");
+        return resolved !== null && /\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile);
+    });
+    const projector = declPackages.length === 0
+        ? undefined
+        : (program) => {
+            const userFiles = declBoundaryUserFiles(program, declPackages);
+            if (userFiles.length === 0)
+                return null;
+            let projection;
+            try {
+                projection = planDeclProjection({
+                    jsProgram: program,
+                    declProgram: authored().program,
+                    userFiles,
+                    outDir: dirname(entryPath),
+                });
+            }
+            catch (error) {
+                if (process.env["SCRIPTC_DEBUG_DECL_BOUNDARY"] === "1")
+                    throw error;
+                return null;
+            }
+            if (process.env["SCRIPTC_DEBUG_DECL_BOUNDARY"] === "1") {
+                process.stderr.write(`[decl-boundary] ${projection === null ? "no projection" : projection.plan.join("\n[decl-boundary] ")}\n`);
+                if (projection !== null)
+                    process.stderr.write(projection.declText);
+            }
+            return projection;
+        };
     try {
-        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0);
-        let authoredHost = null;
-        let authoredLoad = null;
+        const load = loadProgram7(host, entryPath, externalTypes, npmStaticPackages.length > 0, projector);
         return {
             ...load,
             services,
             projectWorld: npmStaticPackages.length === 0
                 ? load.projectWorld
-                : () => {
-                    // Check authored code against the package's published declarations.
-                    // Runtime bodies still lower from JavaScript in the original world;
-                    // inference there must not manufacture errors in valid user code.
-                    if (!authoredLoad) {
-                        authoredHost = services.createProgramHost({ cwd: dirname(entryPath) });
-                        authoredLoad = loadProgram7(authoredHost, entryPath, externalTypes);
-                    }
-                    return authoredLoad.projectWorld();
-                },
+                : () => 
+                // Check authored code against the package's published declarations.
+                // Runtime bodies still lower from JavaScript in the original world;
+                // inference there must not manufacture errors in valid user code.
+                authored().projectWorld(),
             dispose: () => {
                 try {
                     authoredLoad?.disposeAll();
@@ -845,10 +1003,39 @@ export function loadProgram(entryPath, services, opts) {
         };
     }
     catch (error) {
+        authoredLoad?.disposeAll();
+        authoredHost?.close();
         host.close();
         throw error;
     }
 }
+/** User TypeScript files (outside node_modules) that import one of the
+ * packages whose declarations the boundary projects from. */
+function declBoundaryUserFiles(program, packages) {
+    const out = [];
+    for (const sf of program.getSourceFiles()) {
+        const name = sf.fileName.split("\\").join("/");
+        if (sf.isDeclarationFile || name.includes("/node_modules/") || !/\.[mc]?tsx?$/.test(name))
+            continue;
+        if (name.endsWith(".tsx"))
+            continue; // JSX files: not projected yet
+        const text = sf.text;
+        if (packages.some((pkg) => text.includes(`"${pkg}"`) ||
+            text.includes(`'${pkg}'`) ||
+            text.includes(`"${pkg}/`) ||
+            text.includes(`'${pkg}/`)))
+            out.push(sf.fileName);
+    }
+    return out;
+}
+/** SC6102 — a projected file the lowering world disagreed with. */
+function declBoundaryDroppedDiag(file) {
+    return {
+        code: "SC6102",
+        message: "values from npm packages stay checked-dynamic in this file: the types projected from the packages' declarations do not type-check against their JavaScript",
+        loc: { file, start: 0, end: 0 },
+    };
+}
 /** tsc diagnostics (syntax + types), the supported-import fence, and the
  * module evaluation order: fills load.moduleOrder (the SourceFiles
  * themselves — the lowering consumes them directly) and returns the
@@ -955,8 +1142,17 @@ function requiresOf7(stmt) {
     }
     return out;
 }
+/** `true`, or `!0`, its minified spelling. */
+function isTrueLiteral(expr) {
+    return (expr.kind === ts.SyntaxKind.TrueKeyword ||
+        (ts.isPrefixUnaryExpression(expr) &&
+            expr.operator === ts.SyntaxKind.ExclamationToken &&
+            ts.isNumericLiteral(expr.operand) &&
+            expr.operand.text === "0"));
+}
 /** The exact `Object.defineProperty(exports|module.exports, "__esModule",
- * { value: true })` interop stamp (shared by preflight and the no-op lowering). */
+ * { value: true })` interop stamp (shared by preflight and the no-op lowering);
+ * `{ value: !0 }` is the same stamp. */
 export function isEsModuleStamp(expr) {
     if (!ts.isCallExpression(expr) || expr.questionDotToken !== undefined)
         return false;
@@ -987,7 +1183,7 @@ export function isEsModuleStamp(expr) {
     return (ts.isPropertyAssignment(p) &&
         ts.isIdentifier(p.name) &&
         p.name.text === "value" &&
-        p.initializer.kind === ts.SyntaxKind.TrueKeyword);
+        isTrueLiteral(p.initializer));
 }
 /** Plain CommonJS prologue writes only publish values; in particular,
  * publishing a hoisted function does not invoke its body. Later runnable
@@ -3294,6 +3490,7 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                         start: ts.tokenStartOfNode(stmt),
                         end: stmt.end,
                         reference: null,
+                        deferredReference: null,
                         folded: null,
                         localNames: new Map(),
                     });
@@ -3370,10 +3567,13 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                     ts.tokenStartOfNode(ref) >= c.start &&
                     ref.end <= c.end)
                     continue;
+                if (inDeferredPosition7(ref)) {
+                    if (c.exposed && c.deferredReference === null)
+                        c.deferredReference = ref;
+                    continue;
+                }
                 let early;
-                if (inDeferredPosition7(ref))
-                    early = c.exposed;
-                else if (sf === c.module)
+                if (sf === c.module)
                     early = ts.tokenStartOfNode(ref) < c.start;
                 else if (!memberSet.has(sf) || !rankOf.has(sf))
                     early = false;
@@ -3383,7 +3583,15 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
                     c.reference = ref;
             }
         }
+        // With a static evaluation order, a deferred reference only runs early
+        // when the code that runs before the declaration completes can reach
+        // the function holding it.
+        const reached = known && [...candidates.values()].some((c) => c.reference === null && c.deferredReference)
+            ? cycleReachedDeferredReferences7(program, evaluation, candidates)
+            : null;
         for (const c of candidates.values()) {
+            if (c.reference === null && c.deferredReference !== null)
+                c.reference = reached === null ? c.deferredReference : (reached.get(c.symbol) ?? null);
             if (c.reference === null)
                 continue;
             const settled = new Set(order.filter((sf) => !rankOf.has(sf)));
@@ -3404,6 +3612,292 @@ function computeCycleEarlyBindings7(program, entry, order, singleRoot, exact) {
     }
     return out;
 }
+/** Collects into `units` the callables an initializer expression stores
+ * (see moduleEarlyBindingsOf7), recording in `immediate` the parts of a
+ * stored node that run where it is evaluated. */
+function storedCallables7(checker, e, units, immediate) {
+    while (ts.isParenthesizedExpression(e) ||
+        ts.isAsExpression(e) ||
+        ts.isSatisfiesExpression(e) ||
+        ts.isNonNullExpression(e))
+        e = e.expression;
+    if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
+        units.push(e);
+    }
+    else if (ts.isClassExpression(e)) {
+        units.push(e);
+        immediate.set(e, classSyncParts7(e));
+    }
+    else if (ts.isObjectLiteralExpression(e)) {
+        for (const p of e.properties.nodes) {
+            if (ts.isMethodDeclaration(p) ||
+                ts.isGetAccessorDeclaration(p) ||
+                ts.isSetAccessorDeclaration(p)) {
+                // A computed key evaluates where the literal does; a plain
+                // member-chain key (`[Equal.symbol]`) runs no user code.
+                if (!ts.isComputedPropertyName(p.name))
+                    units.push(p);
+                else if (memberChainKey7(p.name.expression)) {
+                    units.push(p);
+                    immediate.set(p, [p.name]);
+                }
+            }
+            else if (ts.isPropertyAssignment(p))
+                storedCallables7(checker, p.initializer, units, immediate);
+        }
+    }
+    else if (ts.isArrayLiteralExpression(e)) {
+        for (const el of e.elements.nodes)
+            if (!ts.isSpreadElement(el))
+                storedCallables7(checker, el, units, immediate);
+    }
+    else if (ts.isCallExpression(e)) {
+        // `const f = wrap(callback)` where wrap only returns closures over
+        // the callback: it runs when the stored result is called.
+        e.arguments.nodes.forEach((arg, index) => {
+            let fn = arg;
+            while (ts.isParenthesizedExpression(fn))
+                fn = fn.expression;
+            if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
+                returnsOnlyClosuresOver7(checker, e.expression, index))
+                units.push(fn);
+        });
+    }
+}
+/** For one import cycle with a static evaluation order: the first deferred
+ * reference to each candidate that code running before the candidate's
+ * declaration completes can reach, or null when the walk cannot be precise
+ * (top-level await, a default-exported function or class declaration).
+ *
+ * The cycle's top-level code runs in evaluation order. A stored callable
+ * (a function or class declaration, or a function, class or object-literal
+ * method stored by a variable initializer) becomes reachable once
+ * reachable code names its binding, through an import alias or a
+ * namespace member too; every other function-like in reachable code counts
+ * as reachable, since it may be handed to a callee. A namespace import of
+ * a cycle member used other than for a member read makes every stored
+ * callable reachable. moduleEarlyBindingsOf7 is the single-module form. */
+function cycleReachedDeferredReferences7(program, evaluation, candidates) {
+    const checker = program.getTypeChecker();
+    const members = new Set(evaluation);
+    for (const sf of evaluation) {
+        if (hasTopLevelAwait7(sf))
+            return null;
+        for (const stmt of sf.statements.nodes) {
+            if ((ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt)) &&
+                (ts.getCombinedModifierFlags(stmt) &
+                    ts.ModifierFlags.Default) !==
+                    0)
+                return null;
+        }
+    }
+    const stored = new Set();
+    const immediate = new Map();
+    const storedNames = [];
+    const unitsOfName = new Map();
+    const store = (name, units) => {
+        if (units.length === 0)
+            return;
+        for (const u of units)
+            stored.add(u);
+        storedNames.push(name);
+        unitsOfName.set(name, units);
+    };
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if ((ts.getCombinedModifierFlags(stmt) &
+                ts.ModifierFlags.Ambient) !==
+                0)
+                continue;
+            if (ts.isFunctionDeclaration(stmt) && stmt.name !== undefined && stmt.body !== undefined) {
+                store(stmt.name, [stmt]);
+            }
+            else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) {
+                store(stmt.name, [stmt]);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                for (const d of stmt.declarationList.declarations.nodes) {
+                    if (ts.isIdentifier(d.name) && d.initializer !== undefined) {
+                        const units = [];
+                        storedCallables7(checker, d.initializer, units, immediate);
+                        store(d.name, units);
+                    }
+                }
+            }
+        }
+    }
+    const unitsBySymbol = new Map();
+    const allUnits = [];
+    for (const name of storedNames) {
+        const symbol = checker.getSymbolAtLocation(name);
+        if (symbol === undefined)
+            continue;
+        const units = unitsOfName.get(name);
+        unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), ...units]);
+        allUnits.push(...units);
+    }
+    // A named class expression's inner name (`class Impl { static x =
+    // Impl.m(); }`) names the class inside its own body, as the binding it
+    // is stored in names it outside.
+    const innerNames = [];
+    for (const unit of allUnits) {
+        if (!ts.isClassExpression(unit) || unit.name === undefined)
+            continue;
+        const symbol = checker.getSymbolAtLocation(unit.name);
+        if (symbol === undefined)
+            continue;
+        innerNames.push(unit.name);
+        unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), unit]);
+    }
+    // The identifier texts worth resolving: declared names, and the local
+    // names of imports (named, default and namespace) in cycle members.
+    const names = new Set();
+    for (const c of candidates.values())
+        names.add(c.name.text);
+    for (const name of storedNames)
+        names.add(name.text);
+    for (const name of innerNames)
+        names.add(name.text);
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined)
+                continue;
+            const clause = stmt.importClause;
+            if (clause.name !== undefined)
+                names.add(clause.name.text);
+            const bindings = clause.namedBindings;
+            if (bindings === undefined)
+                continue;
+            if (ts.isNamedImports(bindings))
+                for (const element of bindings.elements.nodes)
+                    names.add(element.name.text);
+            else
+                names.add(bindings.name.text);
+        }
+    }
+    const idents = [];
+    for (const sf of evaluation) {
+        ts.walkPreorder(sf, (node) => {
+            if (ts.isImportDeclaration(node))
+                return "skip";
+            if (ts.isIdentifier(node) && names.has(node.text))
+                idents.push(node);
+            return undefined;
+        });
+    }
+    checker.prefetchSymbolNodesExact(idents);
+    const symbolOf = (id) => {
+        const parent = id.parent;
+        let symbol = checker.getSymbolAtLocation(id);
+        if (parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === id) {
+            symbol = checker.getShorthandAssignmentValueSymbol(parent) ?? symbol;
+        }
+        if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        return symbol;
+    };
+    const isMemberNamespace = (symbol) => (symbol.flags & ts.SymbolFlags.ValueModule) !== 0 &&
+        symbol.declarations.some((d) => ts.isSourceFile(d) && members.has(d));
+    const declared = new Set();
+    const reachedUnits = new Set();
+    const out = new Map();
+    const work = [];
+    const reach = (unit) => {
+        if (reachedUnits.has(unit))
+            return;
+        reachedUnits.add(unit);
+        work.push(unit);
+    };
+    const visit = (root) => {
+        ts.walkPreorder(root, (node) => {
+            if (node !== root && stored.has(node)) {
+                for (const part of immediate.get(node) ?? [])
+                    visit(part);
+                return "skip";
+            }
+            if (ts.isImportDeclaration(node))
+                return "skip";
+            if (node.kind === ts.SyntaxKind.ThisKeyword) {
+                // `this` in a static initializer or block names the class, so it
+                // reaches the class's methods as naming the class does.
+                const owner = staticThisClass7(node);
+                if (owner !== undefined && stored.has(owner))
+                    reach(owner);
+                return undefined;
+            }
+            if (!ts.isIdentifier(node) || !names.has(node.text))
+                return undefined;
+            if (inTypePosition7(node))
+                return undefined;
+            const parent = node.parent;
+            if (parent !== undefined && ts.isExportSpecifier(parent))
+                return undefined;
+            if (parent !== undefined && declaredName7(parent) === node)
+                return undefined;
+            const symbol = symbolOf(node);
+            if (symbol === undefined)
+                return undefined;
+            if (isMemberNamespace(symbol)) {
+                // `ns.member` resolves through the member's own identifier; any
+                // other use can reach every export.
+                if (!(parent !== undefined &&
+                    ts.isPropertyAccessExpression(parent) &&
+                    parent.expression === node))
+                    for (const unit of allUnits)
+                        reach(unit);
+                return undefined;
+            }
+            const c = candidates.get(symbol);
+            if (c !== undefined &&
+                node !== c.name &&
+                !declared.has(symbol) &&
+                !out.has(symbol) &&
+                inDeferredPosition7(node) &&
+                !(c.kind === "class" &&
+                    ts.getSourceFileOfNode(node) === c.module &&
+                    ts.tokenStartOfNode(node) >= c.start &&
+                    node.end <= c.end))
+                out.set(symbol, node);
+            for (const unit of unitsBySymbol.get(symbol) ?? [])
+                reach(unit);
+            return undefined;
+        });
+    };
+    const drain = () => {
+        while (work.length > 0)
+            visit(work.pop());
+    };
+    const declare = (name) => {
+        for (const id of boundNames7(name)) {
+            const symbol = checker.getSymbolAtLocation(id);
+            if (symbol !== undefined)
+                declared.add(symbol);
+        }
+    };
+    for (const sf of evaluation) {
+        for (const stmt of sf.statements.nodes) {
+            if (ts.isClassDeclaration(stmt)) {
+                for (const part of classSyncParts7(stmt))
+                    visit(part);
+                drain();
+                if (stmt.name !== undefined)
+                    declare(stmt.name);
+            }
+            else if (ts.isVariableStatement(stmt)) {
+                for (const d of stmt.declarationList.declarations.nodes) {
+                    visit(d);
+                    drain();
+                    declare(d.name);
+                }
+            }
+            else if (!ts.isFunctionDeclaration(stmt))
+                visit(stmt);
+            drain();
+        }
+    }
+    return out;
+}
 /** Top-level let/const and class bindings, in modules outside the
  * exactly-initialized cycles, that code running before their declaration
  * completes can read.
@@ -3455,55 +3949,7 @@ function moduleEarlyBindingsOf7(program, sf, order) {
         storedBy.set(name.text, list);
     };
     const checker = program.getTypeChecker();
-    const storedIn = (e, units) => {
-        while (ts.isParenthesizedExpression(e) ||
-            ts.isAsExpression(e) ||
-            ts.isSatisfiesExpression(e) ||
-            ts.isNonNullExpression(e))
-            e = e.expression;
-        if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) {
-            units.push(e);
-        }
-        else if (ts.isClassExpression(e)) {
-            units.push(e);
-            immediate.set(e, classSyncParts7(e));
-        }
-        else if (ts.isObjectLiteralExpression(e)) {
-            for (const p of e.properties.nodes) {
-                if (ts.isMethodDeclaration(p) ||
-                    ts.isGetAccessorDeclaration(p) ||
-                    ts.isSetAccessorDeclaration(p)) {
-                    // A computed key evaluates where the literal does; a plain
-                    // member-chain key (`[Equal.symbol]`) runs no user code.
-                    if (!ts.isComputedPropertyName(p.name))
-                        units.push(p);
-                    else if (memberChainKey7(p.name.expression)) {
-                        units.push(p);
-                        immediate.set(p, [p.name]);
-                    }
-                }
-                else if (ts.isPropertyAssignment(p))
-                    storedIn(p.initializer, units);
-            }
-        }
-        else if (ts.isArrayLiteralExpression(e)) {
-            for (const el of e.elements.nodes)
-                if (!ts.isSpreadElement(el))
-                    storedIn(el, units);
-        }
-        else if (ts.isCallExpression(e)) {
-            // `const f = wrap(callback)` where wrap only returns closures over
-            // the callback: it runs when the stored result is called.
-            e.arguments.nodes.forEach((arg, index) => {
-                let fn = arg;
-                while (ts.isParenthesizedExpression(fn))
-                    fn = fn.expression;
-                if ((ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
-                    returnsOnlyClosuresOver7(checker, e.expression, index))
-                    units.push(fn);
-            });
-        }
-    };
+    const storedIn = (e, units) => storedCallables7(checker, e, units, immediate);
     sf.statements.nodes.forEach((stmt, index) => {
         if (ambient(stmt))
             return;
@@ -3785,6 +4231,41 @@ function returnsOnlyClosuresOver7(checker, callee, index) {
  * expressions, decorators, computed member keys, static field
  * initializers and static blocks. Methods and instance fields wait for a
  * call or a construction. */
+/** The class whose static field initializer or static block evaluates `this`
+ * (through arrow functions, which keep the enclosing `this`), or undefined
+ * when another function or a class's instance side binds it. */
+function staticThisClass7(node) {
+    let child = node;
+    for (let n = node.parent; n !== undefined; child = n, n = n.parent) {
+        if (ts.isArrowFunction(n))
+            continue;
+        if (ts.isClassStaticBlockDeclaration(n))
+            return n.parent;
+        if (ts.isPropertyDeclaration(n)) {
+            if (n.initializer !== child)
+                return undefined;
+            return (ts.getCombinedModifierFlags(n) & ts.ModifierFlags.Static) !== 0
+                ? n.parent
+                : undefined;
+        }
+        if (ts.isComputedPropertyName(n)) {
+            // A computed key evaluates in the scope around the class.
+            const member = n.parent;
+            const cls = member?.parent;
+            if (cls === undefined)
+                return undefined;
+            child = cls;
+            n = cls;
+            continue;
+        }
+        if (ts.isFunctionLike(n) ||
+            ts.isClassDeclaration(n) ||
+            ts.isClassExpression(n) ||
+            ts.isSourceFile(n))
+            return undefined;
+    }
+    return undefined;
+}
 function classSyncParts7(c) {
     const decorators = (n) => (n.modifiers?.nodes ?? []).filter((m) => m.kind === ts.SyntaxKind.Decorator);
     const parts = [...decorators(c), ...(c.heritageClauses?.nodes ?? [])];
@@ -4243,8 +4724,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();
@@ -4281,10 +4762,41 @@ 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 || tscWorld.declWorldFallback === true
+            ? 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