@scriptc/compiler 0.4.2 → 0.4.3

package/dist/frontend/program.js

@@ -61,6 +61,7 @@ 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 = {
@@ -600,7 +601,10 @@ function lowerProgramJsx7(program, options) {
 }
 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
@@ -678,6 +682,7 @@ rootNpmStaticEdges = false) {
         // 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);
         }
@@ -696,6 +701,57 @@ rootNpmStaticEdges = false) {
                 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}`);
@@ -706,6 +762,7 @@ rootNpmStaticEdges = false) {
             entry,
             moduleOrder: [],
             configDiags: config.diags,
+            ...(declBoundaryNotes.length > 0 ? { declBoundaryNotes } : {}),
             typeWorld: {
                 nodeFallback: nodeTypes === null,
                 projectLib: config.projectLib ?? null,
@@ -877,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();
@@ -913,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
@@ -1023,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;
@@ -1055,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
@@ -3362,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(),
                     });
@@ -3438,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;
@@ -3451,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)));
@@ -3472,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.
@@ -3523,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;
@@ -3853,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 ?? [])];
@@ -4356,7 +4769,9 @@ function preflight7(load) {
     const tscWorld = load.tscWorld;
     const tscErrors = tscWorld === undefined ? errorsOf(program) : keptErrors(tscWorld.program, tscWorld.diagnostics);
     if (tscErrors.length > 0) {
-        const world = tscWorld === undefined ? load.projectWorld() : (tscWorld.projectWorld ?? tscWorld.program);
+        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);