mirror of
https://github.com/vercel-labs/scriptc.git
synced 2026-10-27 06:43:19 +08:00
7474 lines
314 KiB
TypeScript
7474 lines
314 KiB
TypeScript
/* THE program lifecycle: load → preflight — tsconfig adoption, the tsc
|
|
* gate with its project-world second chance, the import/export form
|
|
* fences, CommonJS require discipline, and the module evaluation order —
|
|
* on the native TypeScript compiler (one spawned tsgo server behind
|
|
* Ts7Host, through the ts7/ adapter) with scriptc's OWN resolver
|
|
* (resolve.ts) standing in for ts.resolveModuleName /
|
|
* ts.resolveTypeReferenceDirective, which typescript@7.0.2 no longer
|
|
* ships.
|
|
*
|
|
* HISTORY. This began as a deliberately MECHANICAL PORT of the
|
|
* typescript@5.9.3 checkPreflight (the adapter's design: swap the ts
|
|
* import, keep every spelling), shipped alongside it for phases 2-3 with
|
|
* the order-parity suite holding both lanes to identical diagnostics and
|
|
* module order over the whole corpus. The phase-4 flip deleted the 5.9.3
|
|
* pipeline; its recorded verdicts live on as the canary baselines
|
|
* (test/ts7/baselines/order-parity/), and the rationale prose the old
|
|
* program.ts carried was folded in here where behavior demands it.
|
|
*
|
|
* Differences from the retired 5.9.3 lane, each deliberate and each
|
|
* pinned by the canary baselines:
|
|
* - Module resolution is resolve.ts (answer-parity proven by its suite).
|
|
* - Diagnostics carry pos/end and flat text + messageChain; toPassthrough
|
|
* renders through the adapter's flattenDiagnosticMessageText, whose
|
|
* output is identical to 5.9.3's flattener output.
|
|
* - Finding 5 (tsgo models CommonJS strictly): TS2309 joins the JS-file
|
|
* relaxation here — 5.9.3 never fires it on JS CJS files, tsgo does on
|
|
* the table-then-member pattern. The EXPORT-IDENTITY fences do not live
|
|
* in tsc codes at all: cjsExportDiscardReason (lowering) names every
|
|
* genuinely discarded export, so relaxing the checker's stricter
|
|
* modeling loses nothing.
|
|
* - isNodeEsmFile: 7's client SourceFile has no impliedNodeFormat, so this
|
|
* lane spells Node's format decision directly: fixed extensions first,
|
|
* then an explicit nearest-package `type`, then syntax detection for
|
|
* ambiguous .js/.ts files.
|
|
* - Malformed tsconfig.json: tsgo's parseConfigFile swallows JSONC syntax
|
|
* errors (recovers to empty options) where 5.9.3 reported a passthrough
|
|
* diagnostic, so this lane validates the config's JSONC syntax itself
|
|
* (jsoncSyntaxError) and fails preflight like 5.9.3 does — with
|
|
* JSON.parse's wording rather than tsc's, the one message-text delta on
|
|
* that path (no snapshot pins it). */
|
|
|
|
import { builtinModules } from "node:module";
|
|
import { dirname, isAbsolute, resolve } from "node:path";
|
|
import * as ts from "./ts7/adapter.js";
|
|
import type { ScrDiagnostic } from "../diagnostics/diagnostic.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,
|
|
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 type { FrontendServices } from "./services.js";
|
|
import type {
|
|
NpmStaticDeclarationOverloads,
|
|
NpmStaticDeclarationProperties,
|
|
NpmStaticOverloadSignature,
|
|
} 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";
|
|
import {
|
|
builtinDefaultImportModule,
|
|
canonicalBuiltinModule,
|
|
npmBuiltinAliasOf,
|
|
SUPPORTED_NODE_MODULES,
|
|
unsupportedModuleFeatureOf,
|
|
TEMPORAL_GLOBAL,
|
|
} from "./builtin-modules.js";
|
|
import {
|
|
clearWorkspacePackages,
|
|
isRelativeSpecifier,
|
|
isWorkspacePackageName,
|
|
npmPackageNameOf,
|
|
registerWorkspacePackage,
|
|
workspacePackageOfPath,
|
|
} from "./workspace-registry.js";
|
|
import {
|
|
ADOPTED_OPTIONS,
|
|
isJsSourceFileName,
|
|
JS_ANY_OPERATOR_CODES,
|
|
JS_RELAXED_TSC_CODES,
|
|
} from "./tsc-codes.js";
|
|
import { trackedFileExists, trackedReadFile, trackedRealpath } from "./input-tracker.js";
|
|
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, type DeclProjection } from "./decl-projection.js";
|
|
import { inferredJsDiagnosticSuppressed } from "./inferred-js-diagnostics.js";
|
|
import {
|
|
containsJsx,
|
|
firstJsx,
|
|
jsxEmitName,
|
|
jsxEmitPlan,
|
|
jsxPragmas,
|
|
lowerJsx,
|
|
type LoweredJsx,
|
|
} from "./jsx-source.js";
|
|
|
|
const BASE_OPTIONS: ts.Ts7CompilerOptions = {
|
|
strict: true,
|
|
};
|
|
|
|
const FORCED_OPTIONS: ts.Ts7CompilerOptions = {
|
|
target: ts.ScriptTarget.ESNext as number,
|
|
module: ts.ModuleKind.ESNext as number,
|
|
moduleResolution: ts.ModuleResolutionKind.Bundler,
|
|
// Every file Node executes has its own lexical module wrapper: ESM has a
|
|
// module environment and CommonJS has the per-file function wrapper. In
|
|
// particular, an ambiguous file whose ONLY ESM marker is top-level await
|
|
// must not remain a TypeScript global script (otherwise declarations in
|
|
// sibling files merge and reads cross module boundaries). Runtime format
|
|
// classification is intentionally independent below; this option is only
|
|
// the binder's scope decision.
|
|
moduleDetection: ts.ModuleDetectionKind.Force,
|
|
// Explicit resource management, Array.fromAsync and Error.isError are
|
|
// ESNext library slices in TS 7 even though Node 24 ships them. Include
|
|
// those focused libs without widening the rest of the standard-library
|
|
// target past ES2025.
|
|
lib: [
|
|
"lib.es2025.d.ts",
|
|
"lib.esnext.disposable.d.ts",
|
|
"lib.esnext.array.d.ts",
|
|
"lib.esnext.error.d.ts",
|
|
],
|
|
types: [],
|
|
allowImportingTsExtensions: true,
|
|
allowJs: true,
|
|
checkJs: true,
|
|
resolveJsonModule: true,
|
|
noEmit: true,
|
|
};
|
|
|
|
/** JSONC syntax validation for a tsconfig text: tsgo's parseConfigFile
|
|
* RECOVERS over syntax errors without reporting them (probed: a hard-broken
|
|
* file answers empty options, no diagnostic), where 5.9.3's readConfigFile
|
|
* reported the first parse error — a preflight-visible difference (a broken
|
|
* config fails the build instead of being adopted). tsconfig's grammar is
|
|
* JSON plus comments and trailing commas, so stripping exactly those and
|
|
* handing the rest to JSON.parse decides validity without either
|
|
* TypeScript's parser. The
|
|
* MESSAGE is JSON.parse's, not 5.9.3's ("'}' expected.") — the one
|
|
* remaining wording delta on this path, unpinned by any snapshot. */
|
|
function jsoncSyntaxError(text: string): string | null {
|
|
let out = "";
|
|
for (let i = 0; i < text.length; i++) {
|
|
const ch = text[i]!;
|
|
if (ch === '"') {
|
|
const from = i;
|
|
i++;
|
|
while (i < text.length && text[i] !== '"') i += text[i] === "\\" ? 2 : 1;
|
|
out += text.slice(from, i + 1);
|
|
continue;
|
|
}
|
|
if (ch === "/" && text[i + 1] === "/") {
|
|
while (i < text.length && text[i] !== "\n") i++;
|
|
out += "\n";
|
|
continue;
|
|
}
|
|
if (ch === "/" && text[i + 1] === "*") {
|
|
const close = text.indexOf("*/", i + 2);
|
|
i = close < 0 ? text.length : close + 1;
|
|
continue;
|
|
}
|
|
out += ch;
|
|
}
|
|
// Trailing commas: `,` followed only by whitespace before } or ].
|
|
out = out.replace(/,(\s*[}\]])/g, "$1");
|
|
if (out.trim() === "") return null; // an empty config file is legal
|
|
try {
|
|
JSON.parse(out);
|
|
return null;
|
|
} catch (e) {
|
|
return e instanceof Error ? e.message : String(e);
|
|
}
|
|
}
|
|
|
|
/** Preserve TypeScript 5.9's computed synthetic-default permission from the
|
|
* project's own module settings. Preflight later forces ESNext/Bundler for
|
|
* scriptc's checker, so those forced options must not decide which source
|
|
* import forms were legal in the original project. */
|
|
function projectAllowsSyntheticDefaultImports(options: Record<string, unknown>): boolean {
|
|
const explicitSyntheticDefaultImports = options["allowSyntheticDefaultImports"];
|
|
if (explicitSyntheticDefaultImports !== undefined)
|
|
return explicitSyntheticDefaultImports === true;
|
|
const moduleKind = options["module"];
|
|
const explicitEsModuleInterop = options["esModuleInterop"];
|
|
const esModuleInterop =
|
|
explicitEsModuleInterop !== undefined
|
|
? explicitEsModuleInterop === true
|
|
: moduleKind === ts.ModuleKind.Node16 ||
|
|
moduleKind === ts.ModuleKind.Node18 ||
|
|
moduleKind === ts.ModuleKind.Node20 ||
|
|
moduleKind === ts.ModuleKind.NodeNext ||
|
|
moduleKind === ts.ModuleKind.Preserve;
|
|
return (
|
|
esModuleInterop ||
|
|
moduleKind === ts.ModuleKind.System ||
|
|
options["moduleResolution"] === ts.ModuleResolutionKind.Bundler
|
|
);
|
|
}
|
|
|
|
/** The project's tsconfig adoption in the 7 world: tsgo's own config parser
|
|
* (extends chains resolved server-side), the ADOPTED_OPTIONS subset taken,
|
|
* the rest forced, the strictNullChecks floor enforced. */
|
|
function adoptProjectConfig7(
|
|
host: ts.Ts7Host,
|
|
entryPath: string,
|
|
): {
|
|
configFile: string | null;
|
|
options: ts.Ts7CompilerOptions;
|
|
diags: ScrDiagnostic[];
|
|
projectLib?: readonly string[];
|
|
forcedStrictNullChecks?: boolean;
|
|
checkJs?: boolean;
|
|
} {
|
|
const configFile = ts.findConfigFile(dirname(entryPath), ts.sys.fileExists) ?? null;
|
|
if (!configFile) {
|
|
return { configFile, options: { ...BASE_OPTIONS, ...FORCED_OPTIONS }, diags: [] };
|
|
}
|
|
const diags: ScrDiagnostic[] = [];
|
|
const syntaxError = jsoncSyntaxError(ts.sys.readFile(configFile) ?? "");
|
|
if (syntaxError !== null) {
|
|
diags.push(tscPassthroughDiag(syntaxError, { file: configFile, start: 0, end: 0 }));
|
|
return { configFile, options: { ...BASE_OPTIONS, ...FORCED_OPTIONS }, diags };
|
|
}
|
|
const parsed = host.parseConfigFile(configFile);
|
|
const adopted: Record<string, unknown> = {};
|
|
for (const key of ADOPTED_OPTIONS) {
|
|
const value = parsed.options[key];
|
|
if (value !== undefined) adopted[key] = value;
|
|
}
|
|
if (projectAllowsSyntheticDefaultImports(parsed.options)) {
|
|
adopted["allowSyntheticDefaultImports"] = true;
|
|
}
|
|
// TS 7 accepts `paths`, but no longer accepts `baseUrl` as a compiler
|
|
// option. Translate the established baseUrl+paths spelling into absolute
|
|
// targets: the synthesized config lives beside the entry rather than the
|
|
// real config, so preserving relative targets would change their meaning
|
|
// without a diagnostic. The absolute map is also the own resolver's
|
|
// configuration.
|
|
const rawPaths = parsed.options["paths"];
|
|
if (rawPaths !== undefined && typeof rawPaths === "object" && rawPaths !== null) {
|
|
const configDir = dirname(configFile);
|
|
const rawBaseUrl = parsed.options["baseUrl"];
|
|
const base =
|
|
typeof rawBaseUrl === "string"
|
|
? isAbsolute(rawBaseUrl)
|
|
? rawBaseUrl
|
|
: resolve(configDir, rawBaseUrl)
|
|
: configDir;
|
|
const paths: Record<string, string[]> = {};
|
|
for (const [key, targets] of Object.entries(rawPaths as Record<string, unknown>)) {
|
|
if (!Array.isArray(targets)) continue;
|
|
paths[key] = targets
|
|
.filter((target): target is string => typeof target === "string")
|
|
.map((target) => (isAbsolute(target) ? target : resolve(base, target)));
|
|
}
|
|
adopted["paths"] = paths;
|
|
}
|
|
const nullChecks = adopted["strictNullChecks"] ?? adopted["strict"] ?? false;
|
|
const forcedStrictNullChecks = nullChecks !== true;
|
|
if (forcedStrictNullChecks) {
|
|
diags.push(strictNullChecksFloorDiag(configFile));
|
|
adopted["strictNullChecks"] = true;
|
|
}
|
|
// The project's own library selection, kept only to explain errors: the
|
|
// checker always uses scriptc's fixed library set (FORCED_OPTIONS).
|
|
const rawLib = parsed.options["lib"];
|
|
const projectLib = Array.isArray(rawLib)
|
|
? rawLib.filter((entry): entry is string => typeof entry === "string")
|
|
: undefined;
|
|
return {
|
|
configFile,
|
|
options: { ...BASE_OPTIONS, ...adopted, ...FORCED_OPTIONS },
|
|
diags,
|
|
...(projectLib === undefined ? {} : { projectLib }),
|
|
forcedStrictNullChecks,
|
|
checkJs: parsed.options["checkJs"] === true,
|
|
};
|
|
}
|
|
|
|
/** The target project's @types/node, resolved with the OWN resolver's
|
|
* type-directive lookup anchored at the ENTRY (typeRoots-free — exactly the
|
|
* secondary lookup 5.9.3 ran with typeRoots emptied). */
|
|
function resolveNodeTypes7(entryPath: string): string | null {
|
|
const file = resolveTypeDirective("node", entryPath);
|
|
return file !== null && isNodeTypesPath(file) ? file : null;
|
|
}
|
|
|
|
export interface TypeWorldDifferences {
|
|
/** No @types/node: the bundled fallback declarations type Node. */
|
|
nodeFallback: boolean;
|
|
/** The project tsconfig's "lib" entries (scriptc checks with its own). */
|
|
projectLib: readonly string[] | null;
|
|
/** The project disables strictNullChecks; scriptc forces it on. */
|
|
forcedStrictNullChecks: boolean;
|
|
/** The project's tsconfig sets `checkJs` (scriptc's own checker always
|
|
* reads JavaScript files; this records whether the project's does). */
|
|
projectCheckJs: boolean;
|
|
}
|
|
|
|
export interface LoadResult {
|
|
program: ts.Program;
|
|
entry: ts.SourceFile;
|
|
/** User source files in Node's evaluation order: depth-first postorder
|
|
* of the import graph from the entry, each module once. The entry is
|
|
* last. Empty until checkPreflight runs (and empty when preflight fails
|
|
* structurally). */
|
|
moduleOrder: ts.SourceFile[];
|
|
/** Inline require() calls whose edge closes a require cycle. Node answers
|
|
* them with the still-evaluating module's partial exports, which the
|
|
* static export globals do not model; their lowering refuses them by name
|
|
* at run time instead of refusing the whole program. Filled by
|
|
* checkPreflight. */
|
|
inlineRequireCycleCalls?: ReadonlySet<ts.Node>;
|
|
/** Every program file's module edges as preflight resolved them,
|
|
* require() edges included: the lowering orders the modules only a
|
|
* literal import(), fork() or Worker reaches with them. Filled by
|
|
* checkPreflight. */
|
|
moduleEdges?: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]> | undefined;
|
|
/** Node's startup refusal, when the graph carries an import edge Node
|
|
* rejects before ANY module evaluates — a RESOLUTION refusal (a bare
|
|
* specifier nothing installed resolves, an exports/imports map that
|
|
* refuses the subpath or names a missing file, an invalid "#"
|
|
* specifier: fetch/resolve phase, ERR_MODULE_NOT_FOUND and friends) or
|
|
* the module-LINK SyntaxError (a named import of a CommonJS export
|
|
* Node's lexer cannot detect: instantiate phase). Either way Node
|
|
* refuses the whole program before evaluation, so the lowering compiles
|
|
* the program to exactly that startup crash (buildMain); resolution
|
|
* refusals win over the link SyntaxError because Node's fetch phase
|
|
* runs first. Null when the graph resolves and links clean. Set by
|
|
* checkPreflight. */
|
|
startupCrash?: StartupCrash | null;
|
|
configDiags: ScrDiagnostic[];
|
|
/** SC6102 performance notes of the declaration-typed boundary
|
|
* (decl-projection.ts): files whose projection was dropped. */
|
|
declBoundaryNotes?: ScrDiagnostic[];
|
|
/** The files whose JSX the program lowers (jsx-source.ts), by file name.
|
|
* The program holds their rewritten text; positions in diagnostics refer
|
|
* to it. */
|
|
jsxSources?: ReadonlyMap<string, LoweredJsx>;
|
|
/** With JSX sources: the program over the original text, whose TypeScript
|
|
* errors are the program's, and its project world when it has errors. */
|
|
tscWorld?: {
|
|
program: ts.Program;
|
|
/** The program's pre-emit diagnostics, computed once. */
|
|
diagnostics: readonly ts.Diagnostic[];
|
|
projectWorld: ts.Program | null;
|
|
/** The declaration-typed boundary rewrote user files: errors fall
|
|
* back to the declaration world (load.projectWorld()), as without it. */
|
|
declWorldFallback?: true;
|
|
};
|
|
/** How scriptc's type world differs from the project's own tsc setup —
|
|
* used only to label the TypeScript errors those differences cause. */
|
|
typeWorld?: TypeWorldDifferences;
|
|
/** Coverage-only external host modules: exact bare specifier → local
|
|
* declaration file. These participate in checker resolution but never
|
|
* become runtime module edges. */
|
|
externalTypes: ReadonlyMap<string, string>;
|
|
/** The mapped declarations plus their relative declaration-file closure,
|
|
* keyed by normalized file name and attributed to every owning external
|
|
* specifier. Multiple exact module names may deliberately share one
|
|
* declaration surface. */
|
|
externalTypeSpecifiersByFile: ReadonlyMap<string, readonly string[]>;
|
|
projectWorld: () => ts.Program;
|
|
}
|
|
|
|
function declarationReexportTarget(fromFile: string, specifier: string): string | null {
|
|
const base = resolve(dirname(fromFile), specifier);
|
|
const candidates: string[] = [];
|
|
const extension = /\.(mjs|cjs|js)$/.exec(base)?.[1];
|
|
if (extension !== undefined) {
|
|
const stem = base.slice(0, -(extension.length + 1));
|
|
if (extension === "mjs") candidates.push(`${stem}.d.mts`, `${stem}.d.ts`);
|
|
else if (extension === "cjs") candidates.push(`${stem}.d.cts`, `${stem}.d.ts`);
|
|
else candidates.push(`${stem}.d.ts`, `${stem}.d.mts`, `${stem}.d.cts`);
|
|
} else {
|
|
candidates.push(base, `${base}.d.ts`, `${base}.d.mts`, `${base}.d.cts`);
|
|
}
|
|
candidates.push(
|
|
resolve(base, "index.d.ts"),
|
|
resolve(base, "index.d.mts"),
|
|
resolve(base, "index.d.cts"),
|
|
);
|
|
return candidates.find((candidate) => trackedFileExists(candidate)) ?? null;
|
|
}
|
|
|
|
function runtimeReexportTarget(fromFile: string, specifier: string): string | null {
|
|
const base = resolve(dirname(fromFile), specifier);
|
|
const candidates = [
|
|
base,
|
|
`${base}.js`,
|
|
`${base}.mjs`,
|
|
`${base}.cjs`,
|
|
resolve(base, "index.js"),
|
|
resolve(base, "index.mjs"),
|
|
resolve(base, "index.cjs"),
|
|
];
|
|
const target = candidates.find(
|
|
(candidate) => trackedFileExists(candidate) && isJsSourceFileName(candidate),
|
|
);
|
|
return target === undefined ? null : (trackedRealpath(target) ?? target);
|
|
}
|
|
|
|
/** Visits an opted package's own declaration entry and relative barrel
|
|
* closure. This is intentionally narrower than TypeScript module
|
|
* resolution: bare edges name other packages and never inherit trust. */
|
|
function visitNpmStaticDeclarationClosure(
|
|
services: FrontendServices,
|
|
entryPath: string,
|
|
onSource: (path: string, source: string) => void,
|
|
): void {
|
|
const seen = new Set<string>();
|
|
const packageJson = nearestPkgJsonPath(entryPath);
|
|
const packageRoot = (packageJson === null ? dirname(entryPath) : dirname(packageJson))
|
|
.split("\\")
|
|
.join("/");
|
|
const visit = (path: string): void => {
|
|
path = resolve(path);
|
|
const normalized = path.split("\\").join("/");
|
|
if (normalized !== packageRoot && !normalized.startsWith(packageRoot + "/")) return;
|
|
if (seen.has(path)) return;
|
|
seen.add(path);
|
|
const source = trackedReadFile(path);
|
|
if (source === null) return;
|
|
onSource(path, source);
|
|
for (const specifier of npmStaticDeclarationReexports(services.parse(path, source, "ts"))) {
|
|
const target = declarationReexportTarget(path, specifier);
|
|
if (target !== null) visit(target);
|
|
}
|
|
};
|
|
visit(entryPath);
|
|
}
|
|
|
|
function npmStaticDeclarationOverloadsOf(
|
|
services: FrontendServices,
|
|
entryPath: string,
|
|
): NpmStaticDeclarationOverloads {
|
|
const classes = new Map<string, Map<string, readonly NpmStaticOverloadSignature[]>>();
|
|
visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
|
|
for (const [className, methods] of parseNpmStaticDeclarationOverloads(
|
|
services.parse(path, source, "ts"),
|
|
)) {
|
|
const target =
|
|
classes.get(className) ?? new Map<string, readonly NpmStaticOverloadSignature[]>();
|
|
classes.set(className, target);
|
|
for (const [methodName, signatures] of methods) {
|
|
if (!target.has(methodName)) target.set(methodName, signatures);
|
|
}
|
|
}
|
|
});
|
|
return classes;
|
|
}
|
|
|
|
function npmStaticDeclarationPropertiesOf(
|
|
services: FrontendServices,
|
|
entryPath: string,
|
|
): NpmStaticDeclarationProperties {
|
|
const classes = new Map<string, Map<string, string>>();
|
|
visitNpmStaticDeclarationClosure(services, entryPath, (path, source) => {
|
|
for (const [className, properties] of parseNpmStaticDeclarationProperties(
|
|
services.parse(path, source, "ts"),
|
|
)) {
|
|
const target = classes.get(className) ?? new Map<string, string>();
|
|
classes.set(className, target);
|
|
for (const [propertyName, type] of properties) {
|
|
if (!target.has(propertyName)) target.set(propertyName, type);
|
|
}
|
|
}
|
|
});
|
|
return classes;
|
|
}
|
|
|
|
/** See LoadResult.startupCrash: Node's exact error message, the IR error
|
|
* class that carries it (a RUNTIME_ERROR_CLASSES name — %Error for the
|
|
* resolver's ERR_MODULE_NOT_FOUND family, %TypeError for invalid-specifier
|
|
* refusals, %SyntaxError for either named-import link check), and the source
|
|
* position of the refused edge. */
|
|
export interface StartupCrash {
|
|
message: string;
|
|
className: "%Error" | "%TypeError" | "%SyntaxError";
|
|
loc: { file: string; start: number; end: number };
|
|
}
|
|
|
|
/** True when a coverage mapping names one exact bare host module. TypeScript
|
|
* gives `paths` keys containing `*` pattern semantics, so accepting one here
|
|
* would broaden the mapping beyond the specifier the caller named. */
|
|
export function isExactExternalTypeSpecifier(specifier: string): boolean {
|
|
return (
|
|
specifier !== "" &&
|
|
!specifier.startsWith(".") &&
|
|
!specifier.startsWith("/") &&
|
|
!specifier.startsWith("#") &&
|
|
!specifier.startsWith("node:") &&
|
|
!specifier.includes("*")
|
|
);
|
|
}
|
|
|
|
function externalHostModuleDiag7(specifier: string, node: ts.Node): ScrDiagnostic {
|
|
return unsupportedDiag(
|
|
"SC1010",
|
|
locOf7(node),
|
|
`the '${specifier}' external host module (types supplied by --external-types, but no runtime implementation or scriptc lowering was provided)`,
|
|
"the declaration mapping is analysis-only: coverage continues through project code, while executing this module requires an embedder integration with explicit runtime semantics",
|
|
);
|
|
}
|
|
|
|
/** Expand each mapped declaration entry through RELATIVE declaration
|
|
* dependencies. Declaration packages commonly expose a barrel index.d.ts;
|
|
* the structural types declared in its sibling files are part of the same
|
|
* checker-only host surface. Bare imports deliberately do not inherit this
|
|
* trust: they name a separate package/surface and need their own mapping. */
|
|
function externalTypeFileClosure7(
|
|
program: ts.Program,
|
|
externalTypes: ReadonlyMap<string, string>,
|
|
): ReadonlyMap<string, readonly string[]> {
|
|
const ownersByFile = new Map<string, Set<string>>();
|
|
const addOwner = (file: string, specifier: string): boolean => {
|
|
let owners = ownersByFile.get(file);
|
|
if (owners === undefined) {
|
|
owners = new Set();
|
|
ownersByFile.set(file, owners);
|
|
}
|
|
if (owners.has(specifier)) return false;
|
|
owners.add(specifier);
|
|
return true;
|
|
};
|
|
for (const [specifier, file] of externalTypes) {
|
|
addOwner(tsgoPath(resolve(file)), specifier);
|
|
}
|
|
|
|
const queue: { sf: ts.SourceFile; owner: string }[] = [];
|
|
for (const [owner, entry] of externalTypes) {
|
|
const file = tsgoPath(resolve(entry));
|
|
const sf = program.getSourceFile(file);
|
|
if (sf?.isDeclarationFile) queue.push({ sf, owner });
|
|
}
|
|
const visited = new Set<string>();
|
|
while (queue.length > 0) {
|
|
const { sf, owner } = queue.shift()!;
|
|
const file = tsgoPath(resolve(sf.fileName));
|
|
const visitKey = `${file}\0${owner}`;
|
|
if (visited.has(visitKey)) continue;
|
|
visited.add(visitKey);
|
|
|
|
const admit = (dep: ts.SourceFile | null): void => {
|
|
if (dep === null || !dep.isDeclarationFile) return;
|
|
const depFile = tsgoPath(resolve(dep.fileName));
|
|
if (!addOwner(depFile, owner)) return;
|
|
queue.push({ sf: dep, owner });
|
|
};
|
|
// SourceFile.imports includes import/export declarations, import =
|
|
// require(), and import("…") type nodes. Only relative edges inherit
|
|
// the mapped entry's ownership.
|
|
for (const node of sf.imports) {
|
|
if (ts.isStringLiteralLike(node) && isRelativeSpecifier(node.text)) {
|
|
admit(resolveImport7(program, sf, node.text));
|
|
}
|
|
}
|
|
// Triple-slash path references are the other declaration-local edge.
|
|
for (const ref of sf.referencedFiles) {
|
|
const depPath = tsgoPath(resolve(dirname(sf.fileName), ref.fileName));
|
|
admit(program.getSourceFile(depPath) ?? null);
|
|
}
|
|
}
|
|
return new Map([...ownersByFile].map(([file, owners]) => [file, [...owners]] as const));
|
|
}
|
|
|
|
/** Program roots hidden behind canonical createRequire bindings. tsgo
|
|
* discovers ordinary import/require edges itself, but a source binding
|
|
* returned by createRequire is intentionally just a function to the type
|
|
* checker. Rebuild the native program with each literal project target as
|
|
* an explicit root, to a fixpoint, so the same TS 7 AST/checker world owns
|
|
* their exports and transitive graph. */
|
|
function createRequireProgramRoots7(program: ts.Program): string[] {
|
|
const known = new Set(program.getSourceFileNames().map((name) => tsgoPath(resolve(name))));
|
|
const roots = new Set<string>();
|
|
for (const sf of program.getImplementationSourceFiles()) {
|
|
if (sf.isDeclarationFile || sf.fileName.endsWith(".json")) continue;
|
|
const calls: { callee: ts.Identifier; spec: string }[] = [];
|
|
for (const node of moduleSourceCandidates(program, sf).calls) {
|
|
if (
|
|
node.questionDotToken !== undefined ||
|
|
node.arguments.nodes.length !== 1 ||
|
|
!ts.isStringLiteralLike(node.arguments.nodes[0]!) ||
|
|
!ts.isIdentifier(node.expression)
|
|
) {
|
|
continue;
|
|
}
|
|
calls.push({ callee: node.expression, spec: node.arguments.nodes[0]!.text });
|
|
}
|
|
// Root discovery only needs the callee's binding. A first-miss lookup
|
|
// otherwise fetches symbols and types for every identifier in the file,
|
|
// including all unreachable bodies in large published packages.
|
|
program.getTypeChecker().prefetchSymbolNodesExact(calls.map((call) => call.callee));
|
|
for (const { callee, spec } of calls) {
|
|
if (!isCreateRequireBinding7(program, callee)) continue;
|
|
if (canonicalBuiltinModule(spec) !== null) continue;
|
|
let target = resolveProjectModule(sf.fileName, spec);
|
|
if (target === null && !spec.startsWith("#")) {
|
|
const npm = resolveNpmImport7(sf.fileName, spec, "require");
|
|
if (
|
|
npm !== null &&
|
|
isNpmStaticPackage(npm.packageName) &&
|
|
isJsSourceFileName(npm.typesFile)
|
|
) {
|
|
target = npm.typesFile;
|
|
}
|
|
}
|
|
// A directory's package.json may point at a native addon. Keep it
|
|
// out of TypeScript's source roots so the require call can report
|
|
// the native-addon boundary instead of an unsupported-file error.
|
|
if (target === null || target.endsWith(".json") || target.endsWith(".node")) continue;
|
|
const normalized = tsgoPath(resolve(target));
|
|
if (!known.has(normalized)) roots.add(normalized);
|
|
}
|
|
}
|
|
return [...roots].sort();
|
|
}
|
|
|
|
/** Classify the explicitly selected installed package's own sources. */
|
|
export function entryPackageFilePredicate(entryPath: string): (file: string) => boolean {
|
|
const entryFile = tsgoPath(entryPath);
|
|
const installedAt = entryFile.lastIndexOf("/node_modules/");
|
|
const prefix =
|
|
installedAt < 0
|
|
? null
|
|
: entryFile.slice(0, installedAt) + "/node_modules/" + npmPackageNameOf(entryFile) + "/";
|
|
return (file) => {
|
|
const normalized = tsgoPath(file);
|
|
return (
|
|
normalized === entryFile ||
|
|
(prefix !== null &&
|
|
normalized.startsWith(prefix) &&
|
|
!normalized.slice(prefix.length).split("/").includes("node_modules"))
|
|
);
|
|
};
|
|
}
|
|
|
|
/** maxNodeModuleJsDepth can omit relative imports within an admitted
|
|
* package, and opted-in packages deep in the dependency graph. Discover
|
|
* their runtime sources to a fixpoint so the checker and module resolver
|
|
* see the same graph regardless of import traversal order or depth. */
|
|
function entryPackageProgramRoots7(
|
|
program: ts.Program,
|
|
entryPath: string,
|
|
rootNpmStaticEdges: boolean,
|
|
): string[] {
|
|
const belongsToEntry = entryPackageFilePredicate(entryPath);
|
|
const roots = new Set<string>();
|
|
for (const sf of program.getImplementationSourceFiles()) {
|
|
if (
|
|
sf.isDeclarationFile ||
|
|
(!belongsToEntry(sf.fileName) && npmStaticPackageOfPath(sf.fileName) === null)
|
|
)
|
|
continue;
|
|
for (const specifier of sf.imports) {
|
|
if (!ts.isStringLiteralLike(specifier)) continue;
|
|
const target = resolveProjectModule(sf.fileName, specifier.text);
|
|
if (
|
|
target !== null &&
|
|
(belongsToEntry(target) || npmStaticPackageOfPath(target) !== null) &&
|
|
isJsSourceFileName(target) &&
|
|
program.getSourceFile(target) === undefined
|
|
)
|
|
roots.add(target);
|
|
// An opted-in package's bare edge counts against the same depth
|
|
// budget: tsgo charges every node_modules JS hop, so express's
|
|
// body-parser → qs → side-channel → get-intrinsic chain runs out of
|
|
// depth before its leaves load. Root the runtime file this edge
|
|
// lowers to (preflight's own resolution and miss rule) so the leaf
|
|
// joins like a shallow one; complete programs add nothing. Only
|
|
// the shadowed lowering world does this (the authored world checks
|
|
// user code against declarations), and only from package files: a
|
|
// program file's own edges are never deeper than one hop.
|
|
// (resolveBareModule directly: resolveNpmImport7's workspace
|
|
// registration stays with preflight's own walk.)
|
|
if (
|
|
target === null &&
|
|
rootNpmStaticEdges &&
|
|
npmStaticPackageOfPath(sf.fileName) !== null &&
|
|
!isRelativeSpecifier(specifier.text)
|
|
) {
|
|
const spec = specifier.text;
|
|
if (spec.startsWith("#") || canonicalBuiltinModule(spec) !== null) continue;
|
|
const npm = resolveBareModule(
|
|
sf.fileName,
|
|
spec,
|
|
undefined,
|
|
moduleSpecifierKind7(specifier),
|
|
);
|
|
if (
|
|
npm !== null &&
|
|
isNpmStaticPackage(npm.packageName) &&
|
|
(isNodeModulesPath(npm.typesFile) || npm.workspaceDir !== undefined) &&
|
|
isJsSourceFileName(npm.typesFile) &&
|
|
npmStaticProgramFile(program, npm.typesFile) === null
|
|
)
|
|
roots.add(tsgoPath(resolve(npm.typesFile)));
|
|
}
|
|
}
|
|
}
|
|
return [...roots].sort();
|
|
}
|
|
|
|
/** TS 7's ESNext temporal declarations: a lib slice scriptc adds only for
|
|
* programs whose sources name the global (programNamesTemporal7). */
|
|
const TEMPORAL_LIB = "lib.esnext.temporal.d.ts";
|
|
|
|
/** True when a program source (user code or compiled npm JavaScript)
|
|
* contains the temporal global's name as a whole word. A cheap syntactic
|
|
* scan of the implementation files root discovery already materialized; a
|
|
* mention in a comment or string also counts, which only adds the lib
|
|
* slice. */
|
|
function programNamesTemporal7(program: ts.Program): boolean {
|
|
for (const sf of program.getImplementationSourceFiles()) {
|
|
const text = sf.text;
|
|
for (
|
|
let at = text.indexOf(TEMPORAL_GLOBAL);
|
|
at >= 0;
|
|
at = text.indexOf(TEMPORAL_GLOBAL, at + 8)
|
|
) {
|
|
if (!isIdentifierCharAt(text, at - 1) && !isIdentifierCharAt(text, at + 8)) return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isIdentifierCharAt(text: string, index: number): boolean {
|
|
if (index < 0 || index >= text.length) return false;
|
|
const c = text.charCodeAt(index);
|
|
return (
|
|
(c >= 48 && c <= 57) ||
|
|
(c >= 65 && c <= 90) ||
|
|
(c >= 97 && c <= 122) ||
|
|
c === 36 ||
|
|
c === 95 ||
|
|
c > 127
|
|
);
|
|
}
|
|
|
|
/** "require" for a CommonJS edge (`require("x")`, `import x = require("x")`),
|
|
* "import" for every ESM form — the resolution kind preflight uses. */
|
|
function moduleSpecifierKind7(specifier: ts.StringLiteralLike): "import" | "require" {
|
|
const parent = specifier.parent;
|
|
if (ts.isExternalModuleReference(parent)) return "require";
|
|
return ts.isCallExpression(parent) &&
|
|
ts.isIdentifier(parent.expression) &&
|
|
parent.expression.text === "require"
|
|
? "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: ts.Program,
|
|
options: ts.Ts7CompilerOptions,
|
|
): { sources: Map<string, LoweredJsx>; refusal: ScrDiagnostic | null } {
|
|
const sources = new Map<string, LoweredJsx>();
|
|
const mode = jsxEmitName(options.jsx as string | number | undefined);
|
|
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 as string | undefined,
|
|
jsxFragmentFactory: options.jsxFragmentFactory as string | undefined,
|
|
jsxImportSource: options.jsxImportSource as string | undefined,
|
|
reactNamespace: options.reactNamespace as string | undefined,
|
|
},
|
|
jsxPragmas(sf.text),
|
|
);
|
|
sources.set(sf.fileName, lowerJsx(sf, plan));
|
|
}
|
|
return { sources, refusal: null };
|
|
}
|
|
|
|
function loadProgram7(
|
|
host: ts.Ts7Host,
|
|
entryPath: string,
|
|
externalTypes: ReadonlyMap<string, string> = new Map(),
|
|
/** The --npm-static lowering world: root opted-in packages' deep edges. */
|
|
rootNpmStaticEdges = false,
|
|
/** The declaration-typed boundary's projection (decl-projection.ts):
|
|
* answers rewritten user files for the lowering world, or null. */
|
|
projector?: (program: ts.Program) => DeclProjection | null,
|
|
): LoadResult & { disposeAll: () => void } {
|
|
const config = adoptProjectConfig7(host, entryPath);
|
|
const configuredPaths = config.options["paths"];
|
|
setProjectPathMappings(
|
|
configuredPaths !== undefined && typeof configuredPaths === "object" && configuredPaths !== null
|
|
? (configuredPaths as Record<string, string[]>)
|
|
: null,
|
|
);
|
|
const nodeTypes = config.configFile ? resolveNodeTypes7(entryPath) : null;
|
|
// skipLibCheck is FORCED with @types/node in the program: checking a
|
|
// third-party lib's internals against OUR lib choice (es2025, no dyn) is
|
|
// not scriptc's fence and drowns real diagnostics in hundreds of
|
|
// .d.ts-internal errors. Fence discipline never depended on it: the
|
|
// lowerer checks provenance and forms at every use site.
|
|
let options: ts.Ts7CompilerOptions = nodeTypes
|
|
? { ...config.options, skipLibCheck: true }
|
|
: { ...config.options };
|
|
// --npm-static: opted-in packages' shipped JS must be TYPE-INCLUDED (not
|
|
// just resolved) — without maxNodeModuleJsDepth, node_modules JS types as
|
|
// an implicit-any module (TS7016) and nothing infers. Only flagged
|
|
// compiles pay this; flagless builds keep the exact historical options.
|
|
// Eight levels retain package-internal re-export chains such as Effect's;
|
|
// the former four-level cap left valid bindings outside the checker graph.
|
|
if (npmStaticActive()) options.maxNodeModuleJsDepth = 8;
|
|
// --provenance-sources: the registered entries become tsconfig "paths"
|
|
// so tsgo's OWN resolution of the bare specifiers lands on the same
|
|
// source files the preflight resolver answers — the checker types the
|
|
// driver against the package's real TypeScript, not its shipped .d.ts.
|
|
const provenance = provenancePaths();
|
|
if (provenance !== null || externalTypes.size > 0) {
|
|
const paths: Record<string, string[]> = {
|
|
...(configuredPaths as Record<string, string[]> | undefined),
|
|
// Keep an index-signature source for native lowering when provenance is absent.
|
|
// oxlint-disable-next-line unicorn/no-useless-fallback-in-spread
|
|
...(provenance ?? {}),
|
|
};
|
|
for (const [specifier, declarationPath] of externalTypes) {
|
|
paths[specifier] = [declarationPath];
|
|
}
|
|
options = { ...options, paths };
|
|
}
|
|
const coreRoots = [entryPath, ambientDtsPath(), nodeTypes ?? fallbackDtsPath()];
|
|
const programRoots = [...coreRoots];
|
|
let program = host.createProgram([...programRoots, overridesDtsPath()], options);
|
|
try {
|
|
for (let pass = 0; pass < 32; pass++) {
|
|
const candidates = [
|
|
...entryPackageProgramRoots7(program, entryPath, rootNpmStaticEdges),
|
|
...createRequireProgramRoots7(program),
|
|
...forkTargetPaths(program, program.getImplementationSourceFiles()),
|
|
...workerTargetPaths(program, program.getImplementationSourceFiles()),
|
|
];
|
|
const extraRoots = candidates.filter(
|
|
(root, index) => !programRoots.includes(root) && candidates.indexOf(root) === index,
|
|
);
|
|
if (extraRoots.length === 0) break;
|
|
program.dispose();
|
|
programRoots.push(...extraRoots);
|
|
program = host.createProgram([...programRoots, overridesDtsPath()], options);
|
|
if (pass === 31) throw new Error("static program-root discovery did not converge");
|
|
}
|
|
// Node 24 ships no temporal global, but TS 7 types it in an ESNext
|
|
// lib slice. Programs that name it (feature probes such as smol-toml's
|
|
// typeof check) get that slice so they type-check, and lower to Node's
|
|
// answers (typeof "undefined", ReferenceError on use). Every other
|
|
// program keeps the identical lib set: the slice would add globals to
|
|
// the checker's world for everyone.
|
|
if (programNamesTemporal7(program)) {
|
|
program.dispose();
|
|
options = {
|
|
...options,
|
|
lib: [...((options.lib as string[] | undefined) ?? []), TEMPORAL_LIB],
|
|
};
|
|
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: LoadResult["tscWorld"];
|
|
const declBoundaryNotes: ScrDiagnostic[] = [];
|
|
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<string, number>();
|
|
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: string[] = [];
|
|
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}`);
|
|
const externalTypeSpecifiersByFile = externalTypeFileClosure7(program, externalTypes);
|
|
let projectWorld: ts.Program | null = null;
|
|
return {
|
|
program,
|
|
entry,
|
|
moduleOrder: [],
|
|
configDiags: config.diags,
|
|
...(declBoundaryNotes.length > 0 ? { declBoundaryNotes } : {}),
|
|
typeWorld: {
|
|
nodeFallback: nodeTypes === null,
|
|
projectLib: config.projectLib ?? null,
|
|
forcedStrictNullChecks: config.forcedStrictNullChecks ?? false,
|
|
projectCheckJs: config.checkJs ?? 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();
|
|
}
|
|
},
|
|
};
|
|
} catch (error) {
|
|
program.dispose();
|
|
throw error;
|
|
}
|
|
}
|
|
|
|
/** The pipeline surface: ONE tsgo program serves preflight AND the
|
|
* lowering. The caller runs checkPreflight, hands program/entry/
|
|
* moduleOrder straight to lowerToIr, and MUST dispose() when done — the
|
|
* spawned tsgo server must not outlive the compile. */
|
|
export interface ProgramLoadOptions {
|
|
/** Package names whose shipped JavaScript is compiled as program code. */
|
|
npmStatic?: readonly string[];
|
|
/** Exact host module specifiers paired with their declaration paths. */
|
|
externalTypes?: readonly (readonly [string, string])[];
|
|
}
|
|
|
|
export function loadProgram(
|
|
entryPath: string,
|
|
services: FrontendServices,
|
|
opts?: ProgramLoadOptions,
|
|
): LoadResult & { services: FrontendServices; dispose: () => void } {
|
|
entryPath = resolve(entryPath);
|
|
const externalTypeEntries = opts?.externalTypes ?? [];
|
|
const externalTypes = new Map<string, string>();
|
|
for (const [specifier, file] of externalTypeEntries) {
|
|
if (!isExactExternalTypeSpecifier(specifier)) {
|
|
throw new TypeError(
|
|
`invalid external type specifier ${JSON.stringify(specifier)} (expected an exact bare package specifier)`,
|
|
);
|
|
}
|
|
if (!/\.d\.(?:ts|mts|cts)$/.test(file)) {
|
|
throw new TypeError(
|
|
`invalid external type declaration ${JSON.stringify(file)} for ${JSON.stringify(specifier)} (expected a .d.ts, .d.mts, or .d.cts file)`,
|
|
);
|
|
}
|
|
const declarationPath = resolve(file);
|
|
if (!trackedFileExists(declarationPath)) {
|
|
throw new TypeError(
|
|
`external type declaration for ${JSON.stringify(specifier)} does not name a readable file: ${declarationPath}`,
|
|
);
|
|
}
|
|
externalTypes.set(specifier, declarationPath);
|
|
}
|
|
// 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
|
|
// or executable module edges.
|
|
const declarationOverloads = new Map<string, NpmStaticDeclarationOverloads>();
|
|
const declarationProperties = new Map<string, NpmStaticDeclarationProperties>();
|
|
const projectionOwners = new Map<string, string | null>();
|
|
for (const pkg of npmStaticPackages) {
|
|
const resolved = resolveBareModule(entryPath, pkg, "types-only");
|
|
if (
|
|
resolved === null ||
|
|
resolved.packageName !== pkg ||
|
|
!/\.d\.(?:ts|mts|cts)$/.test(resolved.typesFile)
|
|
) {
|
|
continue;
|
|
}
|
|
const overloads = npmStaticDeclarationOverloadsOf(services, resolved.typesFile);
|
|
const properties = npmStaticDeclarationPropertiesOf(services, resolved.typesFile);
|
|
const classNames = new Set([...overloads.keys(), ...properties.keys()]);
|
|
if (classNames.size === 0) continue;
|
|
const runtime = resolveBareModule(entryPath, pkg, "js-only");
|
|
if (runtime === null || !isJsSourceFileName(runtime.typesFile)) continue;
|
|
const runtimeSource = trackedReadFile(runtime.typesFile);
|
|
if (runtimeSource === null) continue;
|
|
const targets = npmStaticRuntimeClassTargets(
|
|
services.parse(runtime.typesFile, runtimeSource, "js"),
|
|
runtimeSource,
|
|
classNames,
|
|
);
|
|
for (const [className, { specifier, localName }] of targets) {
|
|
const methods = overloads.get(className);
|
|
const fields = properties.get(className);
|
|
if (methods === undefined && fields === undefined) continue;
|
|
const target =
|
|
specifier === null
|
|
? runtime.typesFile
|
|
: runtimeReexportTarget(runtime.typesFile, specifier);
|
|
if (target === null) continue;
|
|
const targetPackage = npmPackageNameOf(target);
|
|
const targetNorm = target.split("\\").join("/");
|
|
const insideWorkspace =
|
|
runtime.workspaceDir !== undefined &&
|
|
targetNorm.startsWith(runtime.workspaceDir.split("\\").join("/") + "/");
|
|
if (targetPackage !== pkg && !insideWorkspace) continue;
|
|
const projectionKey = JSON.stringify([targetNorm, localName]);
|
|
const previousOwner = projectionOwners.get(projectionKey);
|
|
if (previousOwner !== undefined && previousOwner !== className) {
|
|
// Two public class declarations naming one runtime class are
|
|
// ambiguous. Keep inference instead of choosing one alias's ABI.
|
|
projectionOwners.set(projectionKey, null);
|
|
const priorMethods = new Map(declarationOverloads.get(targetNorm) ?? []);
|
|
priorMethods.delete(localName);
|
|
declarationOverloads.set(targetNorm, priorMethods);
|
|
const priorFields = new Map(declarationProperties.get(targetNorm) ?? []);
|
|
priorFields.delete(localName);
|
|
declarationProperties.set(targetNorm, priorFields);
|
|
continue;
|
|
}
|
|
projectionOwners.set(projectionKey, className);
|
|
// The safe declaration grammar can name only its own class. Bind
|
|
// that type to the actual runtime class after a named ESM alias.
|
|
const renameSelf = (type: string): string =>
|
|
type
|
|
.split(/([\s[\]<>()|,]+)/)
|
|
.map((name) => (name === className ? localName : name))
|
|
.join("");
|
|
if (methods !== undefined) {
|
|
const byClass = new Map(declarationOverloads.get(targetNorm) ?? []);
|
|
byClass.set(
|
|
localName,
|
|
new Map(
|
|
[...methods].map(([name, signatures]) => [
|
|
name,
|
|
signatures.map((signature) => ({
|
|
parameters: signature.parameters.map((parameter) => ({
|
|
name: parameter.name,
|
|
type: renameSelf(parameter.type),
|
|
optional: parameter.optional,
|
|
})),
|
|
returnType: renameSelf(signature.returnType),
|
|
})),
|
|
]),
|
|
),
|
|
);
|
|
declarationOverloads.set(targetNorm, byClass);
|
|
}
|
|
if (fields !== undefined) {
|
|
const byClass = new Map(declarationProperties.get(targetNorm) ?? []);
|
|
byClass.set(
|
|
localName,
|
|
new Map([...fields].map(([name, type]) => [name, renameSelf(type)])),
|
|
);
|
|
declarationProperties.set(targetNorm, byClass);
|
|
}
|
|
}
|
|
}
|
|
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
|
|
// node_modules segment, and the tsgo host's fs shadow must already
|
|
// recognize those directories while the PROGRAM is created (hiding the
|
|
// package's declaration twins along its internal relative edges).
|
|
// Non-opted workspace packages register lazily as preflight's own
|
|
// resolver discovers their import edges.
|
|
clearWorkspacePackages();
|
|
for (const pkg of opts?.npmStatic ?? []) {
|
|
const probe = resolveBareModule(entryPath, pkg);
|
|
if (probe?.workspaceDir !== undefined)
|
|
registerWorkspacePackage(probe.packageName, probe.workspaceDir);
|
|
}
|
|
// Declaration-twin hiding is scoped to the entry's own package realm
|
|
// (see projectDtsRuntimeSibling) — set before the host exists so the
|
|
// program never sees an out-of-realm twin hidden.
|
|
setProjectRealm(entryPath);
|
|
// Two fs shadows compose: --npm-static's per-package hiding, and the
|
|
// always-on project declaration-TWIN hiding (a .d.ts beside runtime JS
|
|
// outside node_modules — the classic typed-JS-library entry — must not exist for
|
|
// 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: string) =>
|
|
npmShadow?.readFile(path) ?? programBuiltinAliasSource(services, path),
|
|
hideFile: (path: string) =>
|
|
(npmShadow?.hideFile(path) ?? false) || projectDtsRuntimeSibling(path) !== null,
|
|
};
|
|
const host = services.createProgramHost({ cwd: dirname(entryPath), fsShadow });
|
|
let authoredHost: ts.Ts7Host | null = null;
|
|
let authoredLoad: ReturnType<typeof loadProgram7> | null = null;
|
|
const authored = (): ReturnType<typeof loadProgram7> => {
|
|
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: ts.Program): DeclProjection | null => {
|
|
const userFiles = declBoundaryUserFiles(program, declPackages);
|
|
if (userFiles.length === 0) return null;
|
|
let projection: DeclProjection | null;
|
|
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,
|
|
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.
|
|
authored().projectWorld(),
|
|
dispose: () => {
|
|
try {
|
|
(authoredLoad as ReturnType<typeof loadProgram7> | null)?.disposeAll();
|
|
} finally {
|
|
(authoredHost as ts.Ts7Host | null)?.close();
|
|
try {
|
|
load.disposeAll();
|
|
} finally {
|
|
host.close();
|
|
}
|
|
}
|
|
},
|
|
};
|
|
} catch (error) {
|
|
(authoredLoad as ReturnType<typeof loadProgram7> | null)?.disposeAll();
|
|
(authoredHost as ts.Ts7Host | null)?.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: ts.Program, packages: readonly string[]): string[] {
|
|
const out: string[] = [];
|
|
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: string): ScrDiagnostic {
|
|
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
|
|
* preflight diagnostics. Preserve the caller's complete load shape when
|
|
* mutating it, including its owned services and disposal callback. */
|
|
export function checkPreflight<T extends LoadResult>(load: T): ScrDiagnostic[] {
|
|
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
|
|
* shapes 5.9.3 accepted, and the real hazards those shapes carry are fenced
|
|
* by scriptc's OWN analysis, never by these codes — so for JS FILES ONLY
|
|
* they join the relaxation (TS sources keep the full gate; the order-parity
|
|
* harness holds both lanes to identical verdicts, so a case where 5.9.3
|
|
* itself raises one of these on a JS file would fail there, not slip by):
|
|
* - TS2309 ("export assignment with other exported elements") on the
|
|
* table-then-member pattern — cjsExportDiscardReason names every export
|
|
* Node actually discards.
|
|
* - TS2323 ("cannot redeclare exported variable") on symbol-keyed expando
|
|
* assignments in CJS classes (`this[kSym] = v` under `module.exports =
|
|
* Class`) — 5.9.3 synthesized expando symbols, tsgo trips its
|
|
* redeclaration check instead (the corpus's countdown fixture). */
|
|
// Ordinary JavaScript functions are constructable even when the checker
|
|
// retains only their call signature after a factory return. Heritage
|
|
// lowering separately verifies the actual constructor implementation.
|
|
const TS7_JS_RELAXED_EXTRA: ReadonlySet<number> = new Set([2309, 2323, 2507]);
|
|
|
|
/** Relaxed JavaScript codes that checked JavaScript files keep: values of
|
|
* another type in a typed slot (2322 and its elaborations 2740/2741/2559,
|
|
* 2345, 2769), call arity (2554-2556) and incompatible subclass members
|
|
* (2415). */
|
|
const CHECKED_JS_ENFORCED_CODES: ReadonlySet<number> = new Set([
|
|
2322, 2345, 2415, 2554, 2555, 2556, 2559, 2740, 2741, 2769,
|
|
]);
|
|
|
|
function suppressedJsStrictness7(d: ts.Diagnostic): boolean {
|
|
const file = d.fileName;
|
|
if (!file || !isJsSourceFileName(file)) return false;
|
|
if (JS_RELAXED_TSC_CODES.has(d.code) || TS7_JS_RELAXED_EXTRA.has(d.code)) return true;
|
|
// The 8xxx range is TypeScript's JSDoc-specific diagnostic family
|
|
// (malformed tags, signature/tag mismatches): comment semantics with no
|
|
// runtime meaning in a JS file.
|
|
if (d.code >= 8000 && d.code <= 8999) return true;
|
|
if (JS_ANY_OPERATOR_CODES.has(d.code)) {
|
|
return ts.flattenDiagnosticMessageText(d, "\n").includes("'any'");
|
|
}
|
|
// The deprecated Buffer(...) call without `new`, which Node's Buffer
|
|
// function accepts (containers/bytes.ts lowers it).
|
|
if (d.code === 2348) {
|
|
return ts.flattenDiagnosticMessageText(d, "\n").includes("'BufferConstructor'");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** The specifier of a `require("...")` call: the callee is the bare
|
|
* identifier `require` and the single argument a string literal. The one
|
|
* recognizer preflight edges, global collection, and statement lowering
|
|
* share — anything require-shaped it does NOT match (computed specifiers,
|
|
* extra arguments) is not a module edge and fences at its use site. */
|
|
function requireSpecOf7(node: ts.Node): string | null {
|
|
let value = node;
|
|
while (
|
|
ts.isParenthesizedExpression(value) ||
|
|
ts.isAsExpression(value) ||
|
|
ts.isTypeAssertion(value) ||
|
|
ts.isNonNullExpression(value)
|
|
) {
|
|
value = value.expression;
|
|
}
|
|
if (!ts.isCallExpression(value)) return null;
|
|
if (!ts.isIdentifier(value.expression) || value.expression.text !== "require") return null;
|
|
if (value.arguments.nodes.length !== 1) return null;
|
|
const arg = value.arguments.nodes[0]!;
|
|
return ts.isStringLiteral(arg) ? arg.text : null;
|
|
}
|
|
|
|
/** True for statements that are CommonJS require IMPORTS at a module's top
|
|
* level: `const x = require("s")` / `const { a, b } = require("s")`
|
|
* (every declarator a require), and the bare side-effect `require("s");`.
|
|
* These lower to NOTHING — the bindings are alias plumbing (tsc models
|
|
* them as import aliases) and the module edge lives in the order walk. */
|
|
function isRequireStatement7(stmt: ts.Statement): boolean {
|
|
if (ts.isExpressionStatement(stmt)) return requireSpecOf7(stmt.expression) !== null;
|
|
if (!ts.isVariableStatement(stmt)) return false;
|
|
const decls = stmt.declarationList.declarations.nodes;
|
|
return (
|
|
decls.length > 0 &&
|
|
decls.every((d) => d.initializer !== undefined && requireSpecOf7(d.initializer) !== null)
|
|
);
|
|
}
|
|
|
|
/** A require() occurrence of a top-level statement. `split` marks the
|
|
* assignment of a split require binding (splitRequireBindings7): `node`
|
|
* is its require call and `decl` the binding's declaration. */
|
|
interface RequireOccurrence7 {
|
|
spec: string;
|
|
node: ts.Node;
|
|
decl: ts.VariableDeclaration | null;
|
|
split?: true;
|
|
}
|
|
|
|
/** The require() occurrences of one top-level statement: the declaration
|
|
* forms, the bare side-effect call, and the assignment of a split require
|
|
* binding. Empty for everything else. */
|
|
function requiresOf7(stmt: ts.Statement, program: ts.Program): RequireOccurrence7[] {
|
|
if (ts.isExpressionStatement(stmt)) {
|
|
const split = splitRequireOfStatement7(program, stmt);
|
|
if (split !== null)
|
|
return [
|
|
{ spec: requireSpecOf7(split.call)!, node: split.call, decl: split.decl, split: true },
|
|
];
|
|
const spec = requireSpecOf7(stmt.expression);
|
|
return spec !== null ? [{ spec, node: stmt.expression, decl: null }] : [];
|
|
}
|
|
if (!ts.isVariableStatement(stmt)) return [];
|
|
const out: RequireOccurrence7[] = [];
|
|
for (const decl of stmt.declarationList.declarations.nodes) {
|
|
const spec = decl.initializer !== undefined ? requireSpecOf7(decl.initializer) : null;
|
|
if (spec !== null) out.push({ spec, node: decl, decl });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** CommonJS require bindings split into a declaration and one later
|
|
* assignment (`var m; m = require("./x")`): a top-level `var` or `let`
|
|
* declaration without initializer in a CommonJS file, assigned by exactly one
|
|
* top-level `m = require("<literal>")` statement of the require global over
|
|
* a compiled program module, and written nowhere else. The binding holds the
|
|
* module's exports from the assignment on, as `const m = require("./x")`
|
|
* does, so preflight treats the assignment as that require: its module edge,
|
|
* its cycle admission and its early-read fence. The lowering's recognizer
|
|
* (splitRequireBindingOf in cjs-inline-require.ts) accepts only these
|
|
* bindings. Keyed by declaration, with the assignment's require call. */
|
|
function splitRequireBindings7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
): ReadonlyMap<ts.VariableDeclaration, ts.CallExpression> {
|
|
const memo = program.analysis.splitRequireBindings;
|
|
const cached = memo.get(sf);
|
|
if (cached !== undefined) return cached;
|
|
const out = new Map<ts.VariableDeclaration, ts.CallExpression>();
|
|
memo.set(sf, out);
|
|
if (sf.isDeclarationFile || !isCjsJsFile7(sf, program) || !sf.text.includes("require"))
|
|
return out;
|
|
const checker = program.getTypeChecker();
|
|
const stmts = sf.statements.nodes;
|
|
const candidates = new Map<
|
|
ts.Symbol,
|
|
{ decl: ts.VariableDeclaration; call: ts.CallExpression | null; assigns: number }
|
|
>();
|
|
for (const stmt of stmts) {
|
|
if (!ts.isVariableStatement(stmt)) continue;
|
|
if ((stmt.declarationList.flags & (ts.NodeFlags.Const | ts.NodeFlags.Using)) !== 0) continue;
|
|
for (const decl of stmt.declarationList.declarations.nodes) {
|
|
if (!ts.isIdentifier(decl.name) || decl.initializer !== undefined) continue;
|
|
const symbol = checker.getSymbolAtLocation(decl.name);
|
|
if (symbol === undefined || symbol.declarations.length !== 1) continue;
|
|
candidates.set(symbol, { decl, call: null, assigns: 0 });
|
|
}
|
|
}
|
|
if (candidates.size === 0) return out;
|
|
// The one top-level `m = ...` statement, whose right side is the require.
|
|
for (const stmt of stmts) {
|
|
if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression)) continue;
|
|
const assign = stmt.expression;
|
|
if (assign.operatorToken.kind !== ts.SyntaxKind.EqualsToken || !ts.isIdentifier(assign.left))
|
|
continue;
|
|
const symbol = checker.getSymbolAtLocation(assign.left);
|
|
const candidate = symbol !== undefined ? candidates.get(symbol) : undefined;
|
|
if (candidate === undefined) continue;
|
|
candidate.assigns++;
|
|
let right = assign.right;
|
|
while (ts.isParenthesizedExpression(right)) right = right.expression;
|
|
if (ts.isCallExpression(right) && splitRequireTarget7(program, sf, right))
|
|
candidate.call = right;
|
|
}
|
|
const names = new Set<string>();
|
|
for (const candidate of candidates.values()) {
|
|
if (candidate.assigns === 1 && candidate.call !== null)
|
|
names.add((candidate.decl.name as ts.Identifier).text);
|
|
}
|
|
if (names.size === 0) return out;
|
|
// Exactly one write in the whole file: the assignment itself.
|
|
const writes = new Map<ts.Symbol, number>();
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (!ts.isIdentifier(node) || !names.has(node.text)) return undefined;
|
|
const parent = node.parent;
|
|
const symbol =
|
|
parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === node
|
|
? (checker.getShorthandAssignmentValueSymbol(parent) ?? checker.getSymbolAtLocation(node))
|
|
: checker.getSymbolAtLocation(node);
|
|
if (symbol === undefined || !candidates.has(symbol) || !isWriteReference7(node))
|
|
return undefined;
|
|
writes.set(symbol, (writes.get(symbol) ?? 0) + 1);
|
|
return undefined;
|
|
});
|
|
for (const [symbol, candidate] of candidates) {
|
|
if (candidate.assigns === 1 && candidate.call !== null && writes.get(symbol) === 1)
|
|
out.set(candidate.decl, candidate.call);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** True when `call` is a require of the CommonJS global over a compiled
|
|
* program module: not a builtin, a JSON document or a declaration file. */
|
|
function splitRequireTarget7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
call: ts.CallExpression,
|
|
): boolean {
|
|
const spec = requireSpecOf7(call);
|
|
if (spec === null || canonicalBuiltinModule(spec) !== null) return false;
|
|
if (requireCallBindingKind7(program, call) !== "ambient") return false;
|
|
const dep =
|
|
resolveImport7(program, sf, spec, "require") ?? npmStaticDepSf7(program, sf, spec, "require");
|
|
return dep !== null && !dep.isDeclarationFile && !dep.fileName.endsWith(".json");
|
|
}
|
|
|
|
/** The split require binding a top-level statement assigns, or null. */
|
|
function splitRequireOfStatement7(
|
|
program: ts.Program,
|
|
stmt: ts.Statement,
|
|
): { decl: ts.VariableDeclaration; call: ts.CallExpression } | null {
|
|
if (
|
|
!ts.isExpressionStatement(stmt) ||
|
|
!ts.isBinaryExpression(stmt.expression) ||
|
|
!ts.isSourceFile(stmt.parent)
|
|
)
|
|
return null;
|
|
let right = stmt.expression.right;
|
|
while (ts.isParenthesizedExpression(right)) right = right.expression;
|
|
for (const [decl, call] of splitRequireBindings7(program, stmt.parent))
|
|
if (call === right) return { decl, call };
|
|
return null;
|
|
}
|
|
|
|
/** The top-level statement of a split require binding's assignment, from
|
|
* its require call (`m = require("./x")` or `m = (require("./x"))`). */
|
|
function splitRequireStatementOf7(call: ts.CallExpression): ts.Node | undefined {
|
|
let node: ts.Node = call;
|
|
while (node.parent !== undefined && ts.isParenthesizedExpression(node.parent)) node = node.parent;
|
|
return node.parent?.parent;
|
|
}
|
|
|
|
/** The require call of a split require binding's declaration, or null. */
|
|
function splitRequireCallOf7(
|
|
program: ts.Program,
|
|
decl: ts.VariableDeclaration,
|
|
): ts.CallExpression | null {
|
|
return splitRequireBindings7(program, ts.getSourceFileOfNode(decl)).get(decl) ?? null;
|
|
}
|
|
|
|
/** True when `id` is written: an assignment target (compound and
|
|
* destructuring included), an update operand, or a for-in/of target. */
|
|
function isWriteReference7(id: ts.Identifier): boolean {
|
|
let n: ts.Node = id;
|
|
for (;;) {
|
|
const p: ts.Node | undefined = n.parent;
|
|
if (p === undefined) return false;
|
|
if (ts.isBinaryExpression(p)) {
|
|
const k = p.operatorToken.kind;
|
|
return (
|
|
p.left === n && k >= ts.SyntaxKind.FirstAssignment && k <= ts.SyntaxKind.LastAssignment
|
|
);
|
|
}
|
|
if (ts.isPostfixUnaryExpression(p) || ts.isPrefixUnaryExpression(p)) {
|
|
return (
|
|
(p.operator === ts.SyntaxKind.PlusPlusToken ||
|
|
p.operator === ts.SyntaxKind.MinusMinusToken) &&
|
|
p.operand === n
|
|
);
|
|
}
|
|
if (ts.isForOfStatement(p) || ts.isForInStatement(p)) return p.initializer === n;
|
|
if (
|
|
ts.isParenthesizedExpression(p) ||
|
|
ts.isArrayLiteralExpression(p) ||
|
|
ts.isSpreadElement(p) ||
|
|
ts.isSpreadAssignment(p) ||
|
|
ts.isShorthandPropertyAssignment(p) ||
|
|
ts.isObjectLiteralExpression(p) ||
|
|
(ts.isPropertyAssignment(p) && p.initializer === n)
|
|
) {
|
|
n = p;
|
|
continue;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** `true`, or `!0`, its minified spelling. */
|
|
function isTrueLiteral(expr: ts.Expression): boolean {
|
|
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: !0 }` is the same stamp. */
|
|
export function isEsModuleStamp(expr: ts.Expression): boolean {
|
|
if (!ts.isCallExpression(expr) || expr.questionDotToken !== undefined) return false;
|
|
const callee = expr.expression;
|
|
if (
|
|
!ts.isPropertyAccessExpression(callee) ||
|
|
!ts.isIdentifier(callee.expression) ||
|
|
callee.expression.text !== "Object" ||
|
|
!ts.isIdentifier(callee.name) ||
|
|
callee.name.text !== "defineProperty"
|
|
) {
|
|
return false;
|
|
}
|
|
if (expr.arguments.nodes.length !== 3) return false;
|
|
const [recv, nameArg, desc] = expr.arguments.nodes as unknown as [
|
|
ts.Expression,
|
|
ts.Expression,
|
|
ts.Expression,
|
|
];
|
|
const isExports =
|
|
(ts.isIdentifier(recv) && recv.text === "exports") ||
|
|
(ts.isPropertyAccessExpression(recv) &&
|
|
ts.isIdentifier(recv.expression) &&
|
|
recv.expression.text === "module" &&
|
|
ts.isIdentifier(recv.name) &&
|
|
recv.name.text === "exports");
|
|
if (!isExports) return false;
|
|
if (!ts.isStringLiteral(nameArg) || nameArg.text !== "__esModule") return false;
|
|
if (!ts.isObjectLiteralExpression(desc) || desc.properties.nodes.length !== 1) return false;
|
|
const p = desc.properties.nodes[0]!;
|
|
return (
|
|
ts.isPropertyAssignment(p) &&
|
|
ts.isIdentifier(p.name) &&
|
|
p.name.text === "value" &&
|
|
isTrueLiteral(p.initializer)
|
|
);
|
|
}
|
|
|
|
/** Plain CommonJS prologue writes only publish values; in particular,
|
|
* publishing a hoisted function does not invoke its body. Later runnable
|
|
* statements may call the export or mutate its receiver, and still need
|
|
* the conservative TDZ scan over the whole prefix. */
|
|
function pureCjsExport7(program: ts.Program, stmt: ts.Statement): boolean {
|
|
const cjs = cjsExportAssignmentOf(stmt);
|
|
if (cjs === null) return false;
|
|
const sf = ts.getSourceFileOfNode(stmt);
|
|
const plainMember = (left: ts.Expression): boolean => {
|
|
if (!ts.isPropertyAccessExpression(left) || left.questionDotToken) return false;
|
|
// A replacement export can have setters or non-writable function
|
|
// properties. Only the wrapper's original object gets this exception.
|
|
if (sf.statements.nodes.some((s) => cjsExportAssignmentOf(s)?.kind === "table")) return false;
|
|
if (left.name.text === "__proto__" || left.name.text === "__esModule") return false;
|
|
let receiver = left.expression;
|
|
if (isModuleExportsAccess(receiver)) {
|
|
receiver = receiver.expression;
|
|
return ts.isIdentifier(receiver) && !sourceBinding7(program, receiver);
|
|
}
|
|
return (
|
|
ts.isIdentifier(receiver) && receiver.text === "exports" && !sourceBinding7(program, receiver)
|
|
);
|
|
};
|
|
if (cjs.kind === "member") {
|
|
if (!plainMember(cjs.expr.left)) return false;
|
|
} else {
|
|
const receiver = (cjs.expr.left as ts.PropertyAccessExpression).expression as ts.Identifier;
|
|
if (sourceBinding7(program, receiver)) return false;
|
|
}
|
|
let value = cjs.expr.right;
|
|
// tsc emits chains such as exports.A = exports.B = void 0.
|
|
while (ts.isBinaryExpression(value) && value.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
|
|
if (!plainMember(value.left)) return false;
|
|
value = value.right;
|
|
}
|
|
if (ts.isVoidExpression(value) && ts.isNumericLiteral(value.expression)) return true;
|
|
if (
|
|
ts.isStringLiteralLike(value) ||
|
|
ts.isNumericLiteral(value) ||
|
|
value.kind === ts.SyntaxKind.TrueKeyword ||
|
|
value.kind === ts.SyntaxKind.FalseKeyword ||
|
|
value.kind === ts.SyntaxKind.NullKeyword
|
|
)
|
|
return true;
|
|
if (!ts.isIdentifier(value)) return false;
|
|
if (value.text === "undefined" && !sourceBinding7(program, value)) return true;
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(value);
|
|
return (
|
|
symbol !== undefined &&
|
|
symbol.declarations.some(
|
|
(decl) => ts.isFunctionDeclaration(decl) && decl.parent === stmt.parent,
|
|
)
|
|
);
|
|
}
|
|
|
|
function sourceBinding7(program: ts.Program, ident: ts.Identifier): boolean {
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(ident);
|
|
return (
|
|
symbol !== undefined &&
|
|
symbol.declarations.some(
|
|
(decl) => !ts.getSourceFileOfNode(decl).isDeclarationFile && !ts.isSourceFile(decl),
|
|
)
|
|
);
|
|
}
|
|
|
|
function purePrefixDecl7(decl: ts.VariableDeclaration): boolean {
|
|
const init = decl.initializer;
|
|
return (
|
|
init === undefined ||
|
|
requireSpecOf7(init) !== null ||
|
|
ts.isStringLiteralLike(init) ||
|
|
ts.isNumericLiteral(init) ||
|
|
init.kind === ts.SyntaxKind.TrueKeyword ||
|
|
init.kind === ts.SyntaxKind.FalseKeyword ||
|
|
init.kind === ts.SyntaxKind.NullKeyword
|
|
);
|
|
}
|
|
|
|
/** True for top-level statements that cannot run user code: directives,
|
|
* empty statements, hoisted declarations, require statements themselves,
|
|
* literal-initialized variables, and CommonJS function-export prologues.
|
|
* A require preceded ONLY by these cannot observe its own bindings early;
|
|
* require cycles are checked separately by the module graph fences. */
|
|
function purePrefixStmt7(program: ts.Program, s: ts.Statement): boolean {
|
|
if (ts.isEmptyStatement(s) || ts.isFunctionDeclaration(s)) return true;
|
|
if (ts.isExpressionStatement(s) && ts.isStringLiteral(s.expression)) return true; // directive
|
|
if (isRequireStatement7(s) || splitRequireOfStatement7(program, s) !== null) return true;
|
|
if (isCjsJsFile7(ts.getSourceFileOfNode(s), program)) {
|
|
if (ts.isExpressionStatement(s) && isEsModuleStamp(s.expression)) {
|
|
const call = s.expression as ts.CallExpression;
|
|
const object = (call.expression as ts.PropertyAccessExpression).expression as ts.Identifier;
|
|
let receiver = call.arguments.nodes[0]!;
|
|
if (ts.isPropertyAccessExpression(receiver)) receiver = receiver.expression;
|
|
if (
|
|
!sourceBinding7(program, object) &&
|
|
ts.isIdentifier(receiver) &&
|
|
!sourceBinding7(program, receiver)
|
|
)
|
|
return true;
|
|
}
|
|
if (pureCjsExport7(program, s)) return true;
|
|
}
|
|
if (ts.isVariableStatement(s)) {
|
|
return s.declarationList.declarations.nodes.every(purePrefixDecl7);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** Can code that runs BEFORE the declaration at index `k` reach one of
|
|
* its bindings? Static require aliases and symbol field keys bypass
|
|
* storage reads, so an early use could erase a TDZ error or a var's
|
|
* initial undefined value. Conservative reachability: earlier
|
|
* statements' whole subtrees (arrows and function expressions included)
|
|
* read the binding directly, or reference a hoisted function/class whose
|
|
* body (transitively through other hoisted declarations) reads it — a
|
|
* referenced function value may be invoked immediately by whatever takes
|
|
* it. Asynchronously-scheduled callbacks run after the whole module body,
|
|
* hence after the require: never an early read. Returns the first
|
|
* reachable binding's name, or null when position is provably free.
|
|
* (The CheckerFacade memoizes symbol queries, and 7's client dedupes
|
|
* symbol identity by server handle, so the Map-keyed-by-Symbol discipline
|
|
* carries over from the 5.9.3 original unchanged.) */
|
|
export function bindingEarlyUse7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
k: number,
|
|
decl: ts.VariableDeclaration,
|
|
precedingDecls: readonly ts.VariableDeclaration[],
|
|
): string | null {
|
|
const checker = program.getTypeChecker();
|
|
const bound: ts.Identifier[] = [];
|
|
if (ts.isIdentifier(decl.name)) bound.push(decl.name);
|
|
else if (ts.isObjectBindingPattern(decl.name)) {
|
|
for (const el of decl.name.elements.nodes)
|
|
if (el.name !== undefined && ts.isIdentifier(el.name)) bound.push(el.name);
|
|
}
|
|
const bindings = new Map<ts.Symbol, string>();
|
|
for (const id of bound) {
|
|
const sym = checker.getSymbolAtLocation(id);
|
|
if (sym) bindings.set(sym, id.text);
|
|
}
|
|
if (bindings.size === 0) return null;
|
|
const stmts = sf.statements.nodes;
|
|
const hoisted = new Map<ts.Symbol, ts.Statement>();
|
|
for (const s of stmts) {
|
|
if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name) {
|
|
const sym = checker.getSymbolAtLocation(s.name);
|
|
if (sym) hoisted.set(sym, s);
|
|
}
|
|
}
|
|
let hit: string | null = null;
|
|
const scanned = new Set<ts.Statement>();
|
|
const work: ts.Statement[] = [];
|
|
const scan = (root: ts.Node): void => {
|
|
// Iterative walk (walkPreorder): a statement's subtree can be
|
|
// pathologically deep (the binderBinaryExpressionStress chains), and
|
|
// this scan must survive it so the nesting fence can answer later.
|
|
ts.walkPreorder(root, (n) => {
|
|
if (ts.isIdentifier(n)) {
|
|
const sym = ts.isShorthandPropertyAssignment(n.parent)
|
|
? checker.getShorthandAssignmentValueSymbol(n.parent)
|
|
: checker.getSymbolAtLocation(n);
|
|
if (sym) {
|
|
const name = bindings.get(sym);
|
|
if (name !== undefined) {
|
|
hit = name;
|
|
return "stop";
|
|
}
|
|
const target = hoisted.get(sym);
|
|
if (target && !scanned.has(target)) {
|
|
scanned.add(target);
|
|
work.push(target);
|
|
}
|
|
}
|
|
}
|
|
return undefined;
|
|
});
|
|
};
|
|
// These are the exact roots the TDZ analysis scans eagerly. Their files
|
|
// are phase-managed already, so warm their deferred identifiers as one
|
|
// symbol-only batch instead of paying one IPC query per occurrence.
|
|
const roots = [
|
|
...stmts.slice(0, k).filter((stmt) => !ts.isFunctionDeclaration(stmt)),
|
|
...precedingDecls,
|
|
];
|
|
checker.prefetchSymbolRoots(roots);
|
|
for (const root of roots) {
|
|
if (hit !== null) break;
|
|
scan(root);
|
|
}
|
|
while (hit === null && work.length > 0) {
|
|
// A scanned reference can make a hoisted declaration's body reachable
|
|
// to this analysis. Batch every currently discovered root before
|
|
// retaining the historical LIFO traversal order.
|
|
checker.prefetchSymbolRoots(work);
|
|
scan(work.pop()!);
|
|
}
|
|
return hit;
|
|
}
|
|
|
|
/** The first reference to a top-level require declaration's bindings that
|
|
* code running before the require completes can reach, or null when no
|
|
* earlier code can run or reach one. Memoized per program: preflight
|
|
* decides the fence and the lowering places the initialization checks
|
|
* from the same answer. */
|
|
function requireEarlyReference7(
|
|
program: ts.Program,
|
|
decl: ts.VariableDeclaration,
|
|
): ts.Identifier | null {
|
|
const memo = program.analysis.requireEarlyReferences;
|
|
const cached = memo.get(decl);
|
|
if (cached !== undefined) return cached;
|
|
let found: ts.Identifier | null = null;
|
|
const sf = ts.getSourceFileOfNode(decl);
|
|
// A split require binding is bound at its assignment statement.
|
|
const splitCall = splitRequireCallOf7(program, decl);
|
|
const stmt = splitCall !== null ? splitRequireStatementOf7(splitCall) : decl.parent?.parent;
|
|
if (
|
|
stmt !== undefined &&
|
|
(ts.isVariableStatement(stmt) || splitCall !== null) &&
|
|
ts.isSourceFile(stmt.parent)
|
|
) {
|
|
const stmts = sf.statements.nodes;
|
|
const k = stmts.indexOf(stmt as ts.Statement);
|
|
const declarations = ts.isVariableStatement(stmt)
|
|
? stmt.declarationList.declarations.nodes
|
|
: [];
|
|
// Earlier declarators run too: `const x = read(), dep = require('./dep')`.
|
|
const precedingDecls = declarations.slice(0, declarations.indexOf(decl));
|
|
let firstRunnable = program.analysis.requireFirstRunnable.get(sf);
|
|
if (firstRunnable === undefined) {
|
|
firstRunnable = stmts.findIndex((s) => !purePrefixStmt7(program, s));
|
|
program.analysis.requireFirstRunnable.set(sf, firstRunnable);
|
|
}
|
|
const prefixCanRun =
|
|
(firstRunnable >= 0 && firstRunnable < k) || precedingDecls.some((d) => !purePrefixDecl7(d));
|
|
if (prefixCanRun) found = requireBindingEarlyUse7(program, sf, k, decl, precedingDecls);
|
|
}
|
|
memo.set(decl, found);
|
|
return found;
|
|
}
|
|
|
|
/** The CommonJS twin of bindingEarlyUse7 for a top-level require binding:
|
|
* the first reference to one of `decl`'s bindings that code running before
|
|
* the require completes can reach, or null. It follows Node's evaluation
|
|
* order instead of the conservative "every earlier statement" scan:
|
|
* - hoisted functions and classes, and the function and class values a
|
|
* var stored before the require, run only when reachable code names
|
|
* them; a class statement runs only its heritage, computed keys,
|
|
* decorators and static initializers;
|
|
* - callbacks handed to timers, microtasks and promise reactions run after
|
|
* the module body, hence after the require;
|
|
* - publishing a value (`module.exports = f`, `exports.n = f`,
|
|
* `Object.defineProperty(exports, "n", { get })`, `F.prototype.m = f`)
|
|
* runs nothing. The published value becomes reachable only when
|
|
* reachable code reads it back: an `exports.n` read reaches the values
|
|
* published as `n`, any other read of the export object reaches all of
|
|
* them, and naming `F` reaches what was stored on `F`. No other module
|
|
* can read this module's exports before its body completes: require
|
|
* cycles keep their SC1016 fence and a compiled module graph has no
|
|
* reflective exports object.
|
|
* Every other function-like met in reachable code counts as reachable
|
|
* because it may be handed to a callee. */
|
|
export function requireBindingEarlyUse7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
k: number,
|
|
decl: ts.VariableDeclaration,
|
|
precedingDecls: readonly ts.VariableDeclaration[],
|
|
/** A reference of the binding whose early evaluation is known exact. */
|
|
exactEarlyRead?: (reference: ts.Identifier) => boolean,
|
|
): ts.Identifier | null {
|
|
const checker = program.getTypeChecker();
|
|
const bindings = new Set<ts.Symbol>();
|
|
for (const id of boundNames7(decl.name)) {
|
|
const sym = checker.getSymbolAtLocation(id);
|
|
if (sym) bindings.add(sym);
|
|
}
|
|
if (bindings.size === 0) return null;
|
|
// A split require binding's assignment writes the binding; it reads nothing.
|
|
let splitWrite: ts.Node | null = splitRequireCallOf7(program, decl);
|
|
while (splitWrite !== null && ts.isParenthesizedExpression(splitWrite.parent))
|
|
splitWrite = splitWrite.parent;
|
|
splitWrite =
|
|
splitWrite !== null && ts.isBinaryExpression(splitWrite.parent) ? splitWrite.parent.left : null;
|
|
const stmts = sf.statements.nodes;
|
|
const cjs = isCjsJsFile7(sf, program);
|
|
const symbolOf = (id: ts.Identifier): ts.Symbol | undefined => {
|
|
const parent = id.parent;
|
|
if (parent !== undefined && ts.isShorthandPropertyAssignment(parent) && parent.name === id) {
|
|
return checker.getShorthandAssignmentValueSymbol(parent);
|
|
}
|
|
return checker.getSymbolAtLocation(id);
|
|
};
|
|
// Stored callables and the scans that skip them.
|
|
const units = new Map<ts.Symbol, ts.Node[]>();
|
|
const stored = new Set<ts.Node>();
|
|
const addUnit = (name: ts.Identifier, node: ts.Node): void => {
|
|
const sym = checker.getSymbolAtLocation(name);
|
|
if (sym === undefined) return;
|
|
stored.add(node);
|
|
const list = units.get(sym);
|
|
if (list) list.push(node);
|
|
else units.set(sym, [node]);
|
|
};
|
|
const storedCallables = (e: ts.Expression, out: ts.Node[]): void => {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
if (ts.isArrowFunction(e) || ts.isFunctionExpression(e) || ts.isClassExpression(e)) {
|
|
out.push(e);
|
|
} else if (ts.isObjectLiteralExpression(e)) {
|
|
for (const p of e.properties.nodes) {
|
|
if (
|
|
(ts.isMethodDeclaration(p) ||
|
|
ts.isGetAccessorDeclaration(p) ||
|
|
ts.isSetAccessorDeclaration(p)) &&
|
|
!ts.isComputedPropertyName(p.name)
|
|
) {
|
|
out.push(p);
|
|
} else if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
|
|
storedCallables(p.initializer, out);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
stmts.forEach((s, i) => {
|
|
if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name !== undefined) {
|
|
addUnit(s.name, s);
|
|
} else if (i < k && ts.isVariableStatement(s)) {
|
|
for (const d of s.declarationList.declarations.nodes) {
|
|
if (!ts.isIdentifier(d.name) || d.initializer === undefined) continue;
|
|
const out: ts.Node[] = [];
|
|
storedCallables(d.initializer, out);
|
|
for (const node of out) addUnit(d.name, node);
|
|
}
|
|
}
|
|
});
|
|
// Callbacks that only run as later jobs never run before the require:
|
|
// the timers, microtasks and promise reactions. (Event listeners can run
|
|
// synchronously from an emit, so they keep the conservative rule.)
|
|
const laterJob = (callee: ts.Expression): boolean => {
|
|
while (ts.isParenthesizedExpression(callee)) callee = callee.expression;
|
|
const name = ts.isIdentifier(callee)
|
|
? callee.text
|
|
: ts.isPropertyAccessExpression(callee)
|
|
? callee.name.text
|
|
: null;
|
|
return (
|
|
name !== null &&
|
|
(LATER_JOB_BUILTINS7.has(name) || name === "nextTick") &&
|
|
laterJobCallee7(checker, callee)
|
|
);
|
|
};
|
|
if (!hasTopLevelAwait7(sf)) {
|
|
const callbacks = (e: ts.Expression): void => {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) stored.add(e);
|
|
};
|
|
for (const s of stmts.slice(0, k)) {
|
|
ts.walkPreorder(s, (node) => {
|
|
if ((ts.isCallExpression(node) || ts.isNewExpression(node)) && laterJob(node.expression)) {
|
|
for (const arg of node.arguments?.nodes ?? []) callbacks(arg);
|
|
}
|
|
return undefined;
|
|
});
|
|
}
|
|
}
|
|
const isWrapperName = (e: ts.Node, name: string): e is ts.Identifier =>
|
|
ts.isIdentifier(e) && e.text === name && !sourceBinding7(program, e);
|
|
/** `this` at the module's top level: the original export object. */
|
|
const isModuleThis = (e: ts.Node): boolean => {
|
|
if (e.kind !== ts.SyntaxKind.ThisKeyword) return false;
|
|
for (let p = e.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
|
|
if (ts.isFunctionLike(p) && !ts.isArrowFunction(p)) return false;
|
|
if (ts.isClassExpression(p) || ts.isClassDeclaration(p)) return false;
|
|
}
|
|
return true;
|
|
};
|
|
const isExportObject = (e: ts.Expression): boolean =>
|
|
isWrapperName(e, "exports") ||
|
|
isModuleThis(e) ||
|
|
(isModuleExportsAccess(e) && isWrapperName(e.expression, "module"));
|
|
const replacesExports = stmts.some((st) => cjsExportAssignmentOf(st)?.kind === "table");
|
|
// Published values: by export name ("*" for a whole replacement), and by
|
|
// the stored callable whose properties hold them.
|
|
const exportLinks = new Map<string, ts.Node[]>();
|
|
const ownerLinks = new Map<ts.Symbol, ts.Node[]>();
|
|
const reachedKeys = new Set<string>();
|
|
const writtenKeys = new Set<string>();
|
|
const reachedUnits = new Set<ts.Node>();
|
|
const work: ts.Node[] = [];
|
|
let hit: ts.Identifier | null = null;
|
|
const reachUnit = (node: ts.Node): void => {
|
|
if (reachedUnits.has(node)) return;
|
|
reachedUnits.add(node);
|
|
work.push(node);
|
|
};
|
|
const reachSymbol = (sym: ts.Symbol): void => {
|
|
for (const node of units.get(sym) ?? []) reachUnit(node);
|
|
for (const node of ownerLinks.get(sym) ?? []) reachUnit(node);
|
|
};
|
|
let allReached = false;
|
|
const reachKey = (key: string | null): void => {
|
|
if (key === null) {
|
|
allReached = true;
|
|
for (const list of exportLinks.values()) for (const node of list) reachUnit(node);
|
|
return;
|
|
}
|
|
reachedKeys.add(key);
|
|
for (const name of [key, "*"]) for (const node of exportLinks.get(name) ?? []) reachUnit(node);
|
|
};
|
|
const keyReached = (key: string): boolean =>
|
|
allReached || reachedKeys.has(key) || (key === "*" && reachedKeys.size > 0);
|
|
/** A read of the export object: which published names it can observe. */
|
|
const exportRead = (node: ts.Expression): void => {
|
|
let use: ts.Node = node;
|
|
while (ts.isParenthesizedExpression(use.parent)) use = use.parent;
|
|
const parent = use.parent;
|
|
// A truthiness test reads no member (tsc's `this && this.__helper`).
|
|
if (
|
|
ts.isBinaryExpression(parent) &&
|
|
parent.left === use &&
|
|
parent.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken
|
|
) {
|
|
return;
|
|
}
|
|
if (ts.isTypeOfExpression(parent)) return;
|
|
if (ts.isPropertyAccessExpression(parent) && parent.expression === use) {
|
|
let target: ts.Node = parent;
|
|
while (ts.isParenthesizedExpression(target.parent)) target = target.parent;
|
|
const assignment = target.parent;
|
|
if (
|
|
ts.isBinaryExpression(assignment) &&
|
|
assignment.left === target &&
|
|
assignment.operatorToken.kind === ts.SyntaxKind.EqualsToken
|
|
) {
|
|
// A plain write reads no member. It can still run a setter: one
|
|
// published for that name (now or later), or a static one of a
|
|
// replacing class.
|
|
writtenKeys.add(parent.name.text);
|
|
for (const node of exportLinks.get(parent.name.text) ?? []) reachUnit(node);
|
|
for (const node of exportLinks.get("*") ?? []) {
|
|
if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) reachUnit(node);
|
|
}
|
|
return;
|
|
}
|
|
reachKey(parent.name.text);
|
|
return;
|
|
}
|
|
if (
|
|
ts.isElementAccessExpression(parent) &&
|
|
parent.expression === use &&
|
|
ts.isStringLiteralLike(parent.argumentExpression)
|
|
) {
|
|
reachKey(parent.argumentExpression.text);
|
|
return;
|
|
}
|
|
reachKey(null);
|
|
};
|
|
const scan = (root: ts.Node): void => {
|
|
ts.walkPreorder(root, (n) => {
|
|
if (hit !== null) return "stop";
|
|
if (n !== root && stored.has(n)) {
|
|
if (ts.isClassExpression(n) || ts.isClassDeclaration(n)) {
|
|
for (const part of classSyncParts7(n)) scan(part);
|
|
}
|
|
return "skip";
|
|
}
|
|
// A self-require answers this module's partially built exports.
|
|
if (cjs && ts.isCallExpression(n)) {
|
|
const spec = requireSpecOf7(n);
|
|
if (spec !== null && resolveImport7(program, sf, spec, "require") === sf) reachKey(null);
|
|
}
|
|
if (cjs && n.kind === ts.SyntaxKind.ThisKeyword && isModuleThis(n)) {
|
|
exportRead(n as ts.Expression);
|
|
return undefined;
|
|
}
|
|
if (!ts.isIdentifier(n)) return undefined;
|
|
if (inTypePosition7(n)) return undefined;
|
|
const named = n.parent;
|
|
if (
|
|
(ts.isPropertyAccessExpression(named) ||
|
|
ts.isPropertyAssignment(named) ||
|
|
ts.isMethodDeclaration(named) ||
|
|
ts.isGetAccessorDeclaration(named) ||
|
|
ts.isSetAccessorDeclaration(named) ||
|
|
ts.isPropertyDeclaration(named)) &&
|
|
named.name === n
|
|
) {
|
|
return undefined;
|
|
}
|
|
// A declaration's own name reads nothing.
|
|
if (named !== undefined && declaredName7(named) === n) return undefined;
|
|
if (cjs && isWrapperName(n, "exports")) {
|
|
exportRead(n);
|
|
return undefined;
|
|
}
|
|
if (cjs && isWrapperName(n, "module")) {
|
|
const parent = n.parent;
|
|
if (ts.isPropertyAccessExpression(parent) && parent.expression === n) {
|
|
if (parent.name.text === "exports") exportRead(parent);
|
|
return "skip";
|
|
}
|
|
reachKey(null);
|
|
return undefined;
|
|
}
|
|
const sym = symbolOf(n);
|
|
if (sym === undefined) return undefined;
|
|
if (bindings.has(sym)) {
|
|
if (n === splitWrite || exactEarlyRead?.(n) === true) return undefined;
|
|
hit = n;
|
|
return "stop";
|
|
}
|
|
reachSymbol(sym);
|
|
return undefined;
|
|
});
|
|
};
|
|
/** Links a published value: evaluating it reads identifiers, but the
|
|
* callables it names run only once they are read back. */
|
|
const publish = (value: ts.Expression, link: (node: ts.Node) => void): void => {
|
|
while (ts.isParenthesizedExpression(value)) value = value.expression;
|
|
if (ts.isIdentifier(value)) {
|
|
const sym = symbolOf(value);
|
|
if (sym !== undefined && bindings.has(sym)) {
|
|
hit = value;
|
|
return;
|
|
}
|
|
if (sym !== undefined) {
|
|
// What was stored on the value stays reachable through it.
|
|
for (const node of [...(units.get(sym) ?? []), ...(ownerLinks.get(sym) ?? [])]) link(node);
|
|
}
|
|
return;
|
|
}
|
|
if (ts.isFunctionExpression(value) || ts.isArrowFunction(value)) {
|
|
link(value);
|
|
return;
|
|
}
|
|
if (ts.isClassExpression(value)) {
|
|
for (const part of classSyncParts7(value)) scan(part);
|
|
link(value);
|
|
return;
|
|
}
|
|
if (ts.isObjectLiteralExpression(value)) {
|
|
for (const p of value.properties.nodes) {
|
|
if (ts.isShorthandPropertyAssignment(p)) {
|
|
const sym = checker.getShorthandAssignmentValueSymbol(p);
|
|
if (sym !== undefined && bindings.has(sym)) hit = p.name as ts.Identifier;
|
|
else if (sym !== undefined) {
|
|
for (const node of [...(units.get(sym) ?? []), ...(ownerLinks.get(sym) ?? [])]) {
|
|
link(node);
|
|
}
|
|
}
|
|
} else if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name)) {
|
|
publish(p.initializer, link);
|
|
} else if (
|
|
(ts.isMethodDeclaration(p) ||
|
|
ts.isGetAccessorDeclaration(p) ||
|
|
ts.isSetAccessorDeclaration(p)) &&
|
|
!ts.isComputedPropertyName(p.name)
|
|
) {
|
|
link(p);
|
|
} else scan(p);
|
|
}
|
|
return;
|
|
}
|
|
if (
|
|
ts.isStringLiteralLike(value) ||
|
|
ts.isNumericLiteral(value) ||
|
|
value.kind === ts.SyntaxKind.TrueKeyword ||
|
|
value.kind === ts.SyntaxKind.FalseKeyword ||
|
|
value.kind === ts.SyntaxKind.NullKeyword ||
|
|
(ts.isVoidExpression(value) && ts.isNumericLiteral(value.expression))
|
|
) {
|
|
return;
|
|
}
|
|
scan(value);
|
|
// Whatever an arbitrary expression evaluates to is opaque: treat it as
|
|
// reachable through the target too (scan already reached its parts).
|
|
};
|
|
/** Where a publication stores: an export name, or a stored callable. */
|
|
type Target = { kind: "key"; key: string } | { kind: "owner"; owner: ts.Symbol };
|
|
const targetOf = (left: ts.Expression): Target | null => {
|
|
if (isModuleExportsAccess(left) && isWrapperName(left.expression, "module")) {
|
|
return { kind: "key", key: "*" };
|
|
}
|
|
const names: string[] = [];
|
|
let e: ts.Expression = left;
|
|
for (;;) {
|
|
if (ts.isPropertyAccessExpression(e) && !e.questionDotToken) {
|
|
if (isExportObject(e)) break;
|
|
names.unshift(e.name.text);
|
|
e = e.expression;
|
|
} else if (
|
|
ts.isElementAccessExpression(e) &&
|
|
!e.questionDotToken &&
|
|
ts.isStringLiteralLike(e.argumentExpression)
|
|
) {
|
|
names.unshift(e.argumentExpression.text);
|
|
e = e.expression;
|
|
} else break;
|
|
}
|
|
if (names.length === 0) return null;
|
|
if (isExportObject(e)) {
|
|
// __proto__ and the interop marker are not plain data slots, and a
|
|
// member of a replaced export may be a read-only function property:
|
|
// those writes keep the conservative scan.
|
|
if (names[0] === "__proto__" || names[0] === "__esModule" || replacesExports) return null;
|
|
return { kind: "key", key: names[0]! };
|
|
}
|
|
if (ts.isIdentifier(e)) {
|
|
const sym = symbolOf(e);
|
|
if (sym !== undefined && units.has(sym) && !bindings.has(sym))
|
|
return { kind: "owner", owner: sym };
|
|
}
|
|
return null;
|
|
};
|
|
const linkTo = (target: Target, node: ts.Node): void => {
|
|
if (target.kind === "key") {
|
|
const replacingClass =
|
|
target.key === "*" &&
|
|
writtenKeys.size > 0 &&
|
|
(ts.isClassDeclaration(node) || ts.isClassExpression(node));
|
|
if (keyReached(target.key) || writtenKeys.has(target.key) || replacingClass) {
|
|
reachUnit(node);
|
|
}
|
|
const list = exportLinks.get(target.key);
|
|
if (list) list.push(node);
|
|
else exportLinks.set(target.key, [node]);
|
|
} else {
|
|
if ((units.get(target.owner) ?? []).some((u) => reachedUnits.has(u))) reachUnit(node);
|
|
if ((units.get(target.owner) ?? []).includes(node)) return;
|
|
const list = ownerLinks.get(target.owner);
|
|
if (list === undefined) ownerLinks.set(target.owner, [node]);
|
|
else if (!list.includes(node)) list.push(node);
|
|
}
|
|
};
|
|
/** A top-level publication statement, handled in place; false for any
|
|
* other statement. */
|
|
const publication = (s: ts.Statement): boolean => {
|
|
if (!cjs || !ts.isExpressionStatement(s)) return false;
|
|
const e = s.expression;
|
|
if (ts.isBinaryExpression(e) && e.operatorToken.kind === ts.SyntaxKind.EqualsToken) {
|
|
const targets: Target[] = [];
|
|
let value: ts.Expression = e;
|
|
while (
|
|
ts.isBinaryExpression(value) &&
|
|
value.operatorToken.kind === ts.SyntaxKind.EqualsToken
|
|
) {
|
|
const target = targetOf(value.left);
|
|
if (target === null) return false;
|
|
targets.push(target);
|
|
value = value.right;
|
|
}
|
|
publish(value, (node) => {
|
|
for (const t of targets) linkTo(t, node);
|
|
});
|
|
return true;
|
|
}
|
|
// Object.defineProperty(exports, "name", { get() {...}, value: f, ... })
|
|
if (
|
|
ts.isCallExpression(e) &&
|
|
ts.isPropertyAccessExpression(e.expression) &&
|
|
isWrapperName(e.expression.expression, "Object") &&
|
|
e.expression.name.text === "defineProperty" &&
|
|
e.arguments.nodes.length === 3
|
|
) {
|
|
const [recv, key, desc] = e.arguments.nodes as unknown as [
|
|
ts.Expression,
|
|
ts.Expression,
|
|
ts.Expression,
|
|
];
|
|
if (!isExportObject(recv) || !ts.isStringLiteralLike(key)) return false;
|
|
if (!ts.isObjectLiteralExpression(desc)) return false;
|
|
const keyTarget: Target = { kind: "key", key: key.text };
|
|
const link = (node: ts.Node): void => linkTo(keyTarget, node);
|
|
for (const p of desc.properties.nodes) {
|
|
if (
|
|
(ts.isMethodDeclaration(p) || ts.isPropertyAssignment(p)) &&
|
|
ts.isIdentifier(p.name) &&
|
|
(p.name.text === "get" || p.name.text === "set")
|
|
) {
|
|
if (ts.isMethodDeclaration(p)) link(p);
|
|
else publish(p.initializer, link);
|
|
} else if (
|
|
ts.isPropertyAssignment(p) &&
|
|
ts.isIdentifier(p.name) &&
|
|
p.name.text === "value"
|
|
) {
|
|
publish(p.initializer, link);
|
|
} else scan(p);
|
|
}
|
|
return true;
|
|
}
|
|
return false;
|
|
};
|
|
const drain = (): void => {
|
|
while (hit === null && work.length > 0) {
|
|
const unit = work.pop()!;
|
|
checker.prefetchSymbolRoots([unit]);
|
|
scan(unit);
|
|
}
|
|
};
|
|
const roots = stmts.slice(0, k);
|
|
checker.prefetchSymbolRoots([...roots, ...precedingDecls]);
|
|
for (const s of roots) {
|
|
if (hit !== null) break;
|
|
if (ts.isFunctionDeclaration(s)) continue;
|
|
if (ts.isClassDeclaration(s)) {
|
|
for (const part of classSyncParts7(s)) scan(part);
|
|
} else if (!publication(s)) {
|
|
scan(s);
|
|
}
|
|
drain();
|
|
}
|
|
for (const d of precedingDecls) {
|
|
if (hit !== null) break;
|
|
scan(d);
|
|
drain();
|
|
}
|
|
return hit;
|
|
}
|
|
|
|
/** Bare `require("...")` EXPRESSION STATEMENTS anywhere below the top
|
|
* level of a file — inside top-level ifs/blocks/loops and inside function
|
|
* bodies (the lazy-require idiom). No bindings, pure side-effect loads. */
|
|
function nestedBareRequiresOf7(sf: ts.SourceFile): ts.CallExpression[] {
|
|
const out: ts.CallExpression[] = [];
|
|
// Iterative walk (walkPreorder): this sweep sees every JS file whole,
|
|
// including pathologically deep expression chains that must live to be
|
|
// fenced by name, not crash a recursive visit.
|
|
ts.walkPreorder(sf, (n) => {
|
|
if (
|
|
ts.isExpressionStatement(n) &&
|
|
!ts.isSourceFile(n.parent) &&
|
|
ts.isCallExpression(n.expression) &&
|
|
requireSpecOf7(n.expression) !== null
|
|
) {
|
|
out.push(n.expression);
|
|
}
|
|
});
|
|
return out;
|
|
}
|
|
|
|
/** INLINE `require("...")` calls in expression position anywhere in a file
|
|
* (`require("./x").f`, `require("debug")("ns")`, `module.exports =
|
|
* require("./y")`, `{ v: require("./v") }`): each evaluates its module at
|
|
* that position, exactly like a bare require statement. Top-level require
|
|
* statements and bare require statements are collected by their own
|
|
* scans; a require that initializes a nested declaration keeps its
|
|
* lowering fence and is not an edge. */
|
|
function inlineRequiresOf7(sf: ts.SourceFile): ts.CallExpression[] {
|
|
const out: ts.CallExpression[] = [];
|
|
ts.walkPreorder(sf, (n) => {
|
|
if (!ts.isCallExpression(n) || requireSpecOf7(n) === null) return;
|
|
let outer: ts.Node = n;
|
|
while (
|
|
outer.parent !== undefined &&
|
|
(ts.isParenthesizedExpression(outer.parent) ||
|
|
ts.isAsExpression(outer.parent) ||
|
|
ts.isTypeAssertion(outer.parent) ||
|
|
ts.isNonNullExpression(outer.parent))
|
|
) {
|
|
outer = outer.parent;
|
|
}
|
|
const parent = outer.parent;
|
|
if (parent !== undefined && ts.isExpressionStatement(parent)) return;
|
|
if (parent !== undefined && ts.isVariableDeclaration(parent) && parent.initializer === outer)
|
|
return;
|
|
out.push(n);
|
|
});
|
|
return out;
|
|
}
|
|
|
|
type RequireCallBindingKind7 = "ambient" | "createRequire" | "source";
|
|
|
|
function stripRequireCasts7(expr: ts.Expression): ts.Expression {
|
|
let cur = expr;
|
|
while (
|
|
ts.isParenthesizedExpression(cur) ||
|
|
ts.isAsExpression(cur) ||
|
|
ts.isTypeAssertion(cur) ||
|
|
ts.isNonNullExpression(cur)
|
|
) {
|
|
cur = cur.expression;
|
|
}
|
|
return cur;
|
|
}
|
|
|
|
/** The supported-builtin provenance of an imported identifier, narrowed to
|
|
* the one member this preflight distinction needs. Mirrors the lowering's
|
|
* builtinImportOf alias handling so a re-export facade remains supported. */
|
|
function isCreateRequireImport7(program: ts.Program, ident: ts.Identifier): boolean {
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(ident);
|
|
const decl = symbol ? symbol.declarations[0] : undefined;
|
|
if (decl === undefined || !ts.isImportSpecifier(decl)) return false;
|
|
const importDecl = decl.parent?.parent?.parent;
|
|
if (ts.isImportDeclaration(importDecl) && ts.isStringLiteral(importDecl.moduleSpecifier)) {
|
|
const module = canonicalBuiltinModule(importDecl.moduleSpecifier.text);
|
|
const member = decl.propertyName?.text ?? decl.name.text;
|
|
if (module === "module" && member === "createRequire") return true;
|
|
}
|
|
if (symbol !== undefined && (symbol.flags & ts.SymbolFlags.Alias) !== 0) {
|
|
const target = checker.getAliasedSymbol(symbol);
|
|
const targetDecl = target.declarations[0];
|
|
if (targetDecl !== undefined && ts.getSourceFileOfNode(targetDecl).isDeclarationFile) {
|
|
for (
|
|
let p: ts.Node | undefined = targetDecl.parent;
|
|
p !== undefined && !ts.isSourceFile(p);
|
|
p = p.parent
|
|
) {
|
|
if (ts.isModuleDeclaration(p) && ts.isStringLiteral(p.name)) {
|
|
return (
|
|
canonicalBuiltinModule(p.name.text) === "module" &&
|
|
ts.symbolName(target) === "createRequire"
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** True only for createRequire bindings the lowering can erase. Mutable
|
|
* declaration syntax needs a whole-file proof: no writes or escapes, and
|
|
* no code before initialization can reach the binding. */
|
|
export function isCreateRequireBinding7(program: ts.Program, callee: ts.Identifier): boolean {
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(callee);
|
|
const decl = symbol
|
|
? symbol.declarations.find((d): d is ts.VariableDeclaration => ts.isVariableDeclaration(d))
|
|
: undefined;
|
|
if (
|
|
decl === undefined ||
|
|
decl.initializer === undefined ||
|
|
!ts.isVariableDeclarationList(decl.parent)
|
|
) {
|
|
return false;
|
|
}
|
|
return (
|
|
isCreateRequireBaseCall7(program, decl.initializer) &&
|
|
((decl.parent.flags & ts.NodeFlags.Const) !== 0 ||
|
|
stableCreateRequireBindingReason7(program, decl) === null)
|
|
);
|
|
}
|
|
|
|
/** Only literal calls and literal resolution queries can erase the loader
|
|
* value. In particular, assignments, exported aliases, shorthand properties,
|
|
* optional calls, and passing the loader to user code cannot pass this test. */
|
|
function staticCreateRequireUse7(expr: ts.Expression): boolean {
|
|
let use: ts.Node = expr;
|
|
while (ts.isParenthesizedExpression(use.parent)) use = use.parent;
|
|
if (
|
|
ts.isPropertyAccessExpression(use.parent) &&
|
|
use.parent.expression === use &&
|
|
use.parent.name.text === "resolve" &&
|
|
!use.parent.questionDotToken
|
|
) {
|
|
use = use.parent;
|
|
if (
|
|
ts.isPropertyAccessExpression(use.parent) &&
|
|
use.parent.expression === use &&
|
|
use.parent.name.text === "paths" &&
|
|
!use.parent.questionDotToken
|
|
)
|
|
use = use.parent;
|
|
}
|
|
const call = use.parent;
|
|
return (
|
|
ts.isCallExpression(call) &&
|
|
call.expression === use &&
|
|
!call.questionDotToken &&
|
|
call.arguments.nodes.length === 1 &&
|
|
ts.isStringLiteralLike(call.arguments.nodes[0]!)
|
|
);
|
|
}
|
|
|
|
function stableCreateRequireBindingReason7(
|
|
program: ts.Program,
|
|
decl: ts.VariableDeclaration,
|
|
): string | null {
|
|
const cache = program.analysis.createRequireReasons;
|
|
const cached = cache.get(decl);
|
|
if (cached !== undefined) return cached;
|
|
const check = (): string | null => {
|
|
const stmt = decl.parent?.parent;
|
|
if (
|
|
!ts.isIdentifier(decl.name) ||
|
|
!ts.isVariableStatement(stmt) ||
|
|
!ts.isSourceFile(stmt.parent)
|
|
) {
|
|
return "its mutable createRequire binding is outside the module's top level";
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(decl.name);
|
|
if (!symbol || symbol.declarations.length !== 1)
|
|
return "its createRequire binding is redeclared";
|
|
if ((ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Export) !== 0)
|
|
return "its createRequire result escapes through an exported binding";
|
|
const sf = ts.getSourceFileOfNode(decl);
|
|
const refs = identifierOccurrences7(sf, decl.name.text);
|
|
checker.prefetchSymbolNodesExact(refs);
|
|
for (const ref of refs) {
|
|
if (ref === decl.name || inTypePosition7(ref)) continue;
|
|
let target = ts.isShorthandPropertyAssignment(ref.parent)
|
|
? checker.getShorthandAssignmentValueSymbol(ref.parent)
|
|
: checker.getSymbolAtLocation(ref);
|
|
if (target && (target.flags & ts.SymbolFlags.Alias) !== 0)
|
|
target = checker.getAliasedSymbol(target);
|
|
if (target === symbol && !staticCreateRequireUse7(ref)) {
|
|
return "its createRequire binding is reassigned, escapes, or uses a computed specifier";
|
|
}
|
|
}
|
|
const preceding = stmt.declarationList.declarations.nodes.slice(
|
|
0,
|
|
stmt.declarationList.declarations.nodes.indexOf(decl),
|
|
);
|
|
if (
|
|
bindingEarlyUse7(program, sf, sf.statements.nodes.indexOf(stmt), decl, preceding) !== null
|
|
) {
|
|
return "its createRequire binding can be used before initialization";
|
|
}
|
|
return null;
|
|
};
|
|
const reason = check();
|
|
cache.set(decl, reason);
|
|
return reason;
|
|
}
|
|
|
|
function isCreateRequireBaseCall7(program: ts.Program, expr: ts.Expression): boolean {
|
|
const init = stripRequireCasts7(expr);
|
|
if (
|
|
!ts.isCallExpression(init) ||
|
|
init.questionDotToken !== undefined ||
|
|
!ts.isIdentifier(init.expression) ||
|
|
!isCreateRequireImport7(program, init.expression) ||
|
|
init.arguments.nodes.length !== 1
|
|
) {
|
|
return false;
|
|
}
|
|
const base = stripRequireCasts7(init.arguments.nodes[0]!);
|
|
if (ts.isIdentifier(base) && base.text === "__filename") return !sourceBinding7(program, base);
|
|
return (
|
|
ts.isPropertyAccessExpression(base) &&
|
|
base.questionDotToken === undefined &&
|
|
ts.isMetaProperty(base.expression) &&
|
|
base.expression.keywordToken === ts.SyntaxKind.ImportKeyword &&
|
|
(base.name.text === "url" || base.name.text === "filename")
|
|
);
|
|
}
|
|
|
|
/** Refuse require indirection the lowering cannot erase, while
|
|
* admitting literal calls through the same stable/inline shapes as program
|
|
* code. Inspect symbols, not names: nested shadows are unrelated bindings. */
|
|
function npmStaticModuleImportReason7(
|
|
program: ts.Program,
|
|
stmt: ts.ImportDeclaration,
|
|
): string | null {
|
|
const clause = stmt.importClause;
|
|
if (!clause) return null;
|
|
const bindings = clause.namedBindings;
|
|
if (clause.name || (bindings && !ts.isNamedImports(bindings))) {
|
|
return "its node:module namespace or default import has no static createRequire usage proof";
|
|
}
|
|
if (!bindings || !ts.isNamedImports(bindings)) return null;
|
|
const checker = program.getTypeChecker();
|
|
const sf = ts.getSourceFileOfNode(stmt);
|
|
for (const specifier of bindings.elements.nodes) {
|
|
if ((specifier.propertyName?.text ?? specifier.name.text) !== "createRequire") continue;
|
|
const imported = checker.getSymbolAtLocation(specifier.name);
|
|
if (!imported) return "its createRequire import could not be resolved";
|
|
checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, specifier.name.text));
|
|
let reason: string | null = null;
|
|
const checkUse = (expr: ts.Expression): void => {
|
|
if (!staticCreateRequireUse7(expr)) {
|
|
reason =
|
|
"its createRequire result escapes or is used with a computed specifier (static requires need literal specifiers)";
|
|
}
|
|
};
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (
|
|
reason ||
|
|
!ts.isIdentifier(node) ||
|
|
node.text !== specifier.name.text ||
|
|
node === specifier.name ||
|
|
checker.getSymbolAtLocation(node) !== imported
|
|
)
|
|
return;
|
|
const call = node.parent;
|
|
if (
|
|
!ts.isCallExpression(call) ||
|
|
call.expression !== node ||
|
|
!isCreateRequireBaseCall7(program, call)
|
|
) {
|
|
reason =
|
|
"its createRequire import is used outside a supported call based on the current file";
|
|
return;
|
|
}
|
|
const decl = call.parent;
|
|
if (
|
|
ts.isVariableDeclaration(decl) &&
|
|
decl.initializer === call &&
|
|
ts.isIdentifier(decl.name)
|
|
) {
|
|
if ((ts.getCombinedModifierFlags(decl) & ts.ModifierFlags.Export) !== 0) {
|
|
reason = "its createRequire result escapes through an exported binding";
|
|
return;
|
|
}
|
|
if (!isCreateRequireBinding7(program, decl.name)) {
|
|
reason = stableCreateRequireBindingReason7(program, decl);
|
|
return;
|
|
}
|
|
const sym = checker.getSymbolAtLocation(decl.name);
|
|
const name = decl.name.text;
|
|
checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, name));
|
|
ts.walkPreorder(sf, (ref) => {
|
|
if (
|
|
ts.isIdentifier(ref) &&
|
|
ref.text === name &&
|
|
ref !== decl.name &&
|
|
checker.getSymbolAtLocation(ref) === sym
|
|
)
|
|
checkUse(ref);
|
|
});
|
|
} else {
|
|
checkUse(call);
|
|
}
|
|
});
|
|
if (reason) return reason;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** Classifies a require-shaped call as Node's ambient CommonJS global, the
|
|
* one supported createRequire source binding, or another source binding.
|
|
* The scanners still collect createRequire calls because they carry static
|
|
* module edges; other source bindings get a pointed fence before lowering
|
|
* can mistake them for module syntax. */
|
|
function requireCallBindingKind7(program: ts.Program, node: ts.Node): RequireCallBindingKind7 {
|
|
const raw = ts.isVariableDeclaration(node) ? node.initializer : node;
|
|
const call = raw && ts.isExpression(raw) ? stripRequireCasts7(raw) : raw;
|
|
if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression)) return "ambient";
|
|
const checker = program.getTypeChecker();
|
|
const symbol = checker.getSymbolAtLocation(call.expression);
|
|
if (symbol === undefined) return "ambient";
|
|
const decls = symbol.declarations;
|
|
if (decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile)) return "ambient";
|
|
return isCreateRequireBinding7(program, call.expression) ? "createRequire" : "source";
|
|
}
|
|
|
|
function esmRequireFeature7(kind: Exclude<RequireCallBindingKind7, "createRequire">): string {
|
|
return kind === "ambient"
|
|
? "require() in an ES module (Node throws ReferenceError — use import)"
|
|
: "calls through a source binding named 'require' (this spelling is reserved for CommonJS/createRequire module edges — rename the binding)";
|
|
}
|
|
|
|
const CJS_WRAPPER_NAMES = new Set(["require", "module", "exports", "__dirname", "__filename"]);
|
|
|
|
function bindingDeclaresCjsWrapper7(name: ts.BindingName): ts.Identifier | null {
|
|
if (ts.isIdentifier(name)) return CJS_WRAPPER_NAMES.has(name.text) ? name : null;
|
|
for (const el of name.elements.nodes) {
|
|
if (el.name === undefined) continue;
|
|
const hit = bindingDeclaresCjsWrapper7(el.name);
|
|
if (hit !== null) return hit;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function insideFunctionLike7(node: ts.Node): boolean {
|
|
for (let p = node.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
|
|
if (ts.isFunctionLike(p)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** The first syntax marker Node's ambiguous-file detector recognizes. This
|
|
* cannot use ts.isExternalModule: moduleDetection=force deliberately gives
|
|
* EVERY executable file module-local checker scope, including CommonJS.
|
|
* Runtime classification remains Node's own narrower question: value-level
|
|
* import/export forms, import.meta, top-level await/for-await, or a top-level
|
|
* lexical declaration that would redeclare a CommonJS wrapper binding. */
|
|
function nodeEsmSyntaxMarker7(sf: ts.SourceFile): ts.Node | null {
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (ts.isImportDeclaration(stmt) && !erasedTypeOnlyImport(stmt)) return stmt;
|
|
if (ts.isExportDeclaration(stmt) && !stmt.isTypeOnly) {
|
|
return stmt;
|
|
}
|
|
if (ts.isExportAssignment(stmt)) return stmt;
|
|
if (
|
|
ts.canHaveModifiers(stmt) &&
|
|
ts.getModifiers(stmt)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) === true
|
|
) {
|
|
return stmt;
|
|
}
|
|
if (
|
|
ts.isVariableStatement(stmt) &&
|
|
(stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0
|
|
) {
|
|
for (const decl of stmt.declarationList.declarations.nodes) {
|
|
const hit = bindingDeclaresCjsWrapper7(decl.name);
|
|
if (hit !== null) return hit;
|
|
}
|
|
}
|
|
if (
|
|
ts.isClassDeclaration(stmt) &&
|
|
stmt.name !== undefined &&
|
|
CJS_WRAPPER_NAMES.has(stmt.name.text)
|
|
) {
|
|
return stmt.name;
|
|
}
|
|
}
|
|
|
|
let found: ts.Node | null = null;
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (ts.isMetaProperty(node) && node.keywordToken === ts.SyntaxKind.ImportKeyword) {
|
|
found = node;
|
|
return "stop";
|
|
}
|
|
// Only await syntax needs an ancestor walk. Doing this for every node
|
|
// makes a deeply nested expression take quadratic time to classify.
|
|
if (
|
|
(ts.isAwaitExpression(node) ||
|
|
(ts.isForOfStatement(node) && node.awaitModifier !== undefined)) &&
|
|
!insideFunctionLike7(node)
|
|
) {
|
|
found = node;
|
|
return "stop";
|
|
}
|
|
return undefined;
|
|
});
|
|
return found;
|
|
}
|
|
|
|
/** True when Node would treat this file as an ES MODULE (never defining
|
|
* require/__dirname there): fixed extensions first, then an explicit
|
|
* nearest-package type, then Node's syntax markers for ambiguous .js/.ts
|
|
* files. TypeScript's external-module bit is forced for checker scoping and
|
|
* therefore intentionally plays no part in this runtime decision. */
|
|
function isNodeEsmFile7(sf: ts.SourceFile, program?: ts.Program): boolean {
|
|
const cached = program?.analysis.nodeEsmFiles.get(sf);
|
|
if (cached !== undefined) return cached;
|
|
let result: boolean;
|
|
if (sf.fileName.endsWith(".cjs") || sf.fileName.endsWith(".cts")) {
|
|
result = false;
|
|
} else if (sf.fileName.endsWith(".mjs") || sf.fileName.endsWith(".mts")) {
|
|
result = true;
|
|
} else {
|
|
const packageType = nearestPackageType(sf.fileName);
|
|
result =
|
|
packageType === "module"
|
|
? true
|
|
: packageType === "commonjs"
|
|
? false
|
|
: nodeEsmSyntaxMarker7(sf) !== null;
|
|
}
|
|
program?.analysis.nodeEsmFiles.set(sf, result);
|
|
return result;
|
|
}
|
|
|
|
/** A JavaScript source file Node treats as CommonJS (not an ES module):
|
|
* ESM namespace/default machinery must not claim it — its export surface
|
|
* is module.exports, read through the CJS interop paths and their own
|
|
* fences. */
|
|
function isCjsJsFile7(sf: ts.SourceFile, program?: ts.Program): boolean {
|
|
return isJsSourceFileName(sf.fileName) && !isNodeEsmFile7(sf, program);
|
|
}
|
|
|
|
/** The exported spelling of isCjsJsFile7 (the lowering's gate for
|
|
* module.exports surfaces — `ts.isExternalModule` is NOT the CJS test:
|
|
* tsgo marks CJS files with export assignments as external modules). */
|
|
export function isCjsJsFile(sf: ts.SourceFile, program?: ts.Program): boolean {
|
|
return isCjsJsFile7(sf, program);
|
|
}
|
|
|
|
/** The self-import TDZ fences: for `import { x } from "<self>"` (default
|
|
* and namespace forms included), any TOP-LEVEL reference lexically above
|
|
* the aliased declaration observes Node's temporal dead zone — the direct
|
|
* spelling of the same read is tsc's own TS2448, which the import
|
|
* indirection dodges, so preflight restores the bar with SC1030. Function
|
|
* aliases hoist (initialized at link — readable anywhere); references
|
|
* inside function-like bodies follow the direct spelling's existing
|
|
* policy (tsc accepts those too) and are not fenced here. Namespace
|
|
* bindings fence per MEMBER access (`self.x` above x's declaration);
|
|
* the bare namespace binding itself is never TDZ. */
|
|
function selfImportTdzFences7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
clause: ts.ImportClause,
|
|
diags: ScrDiagnostic[],
|
|
): void {
|
|
const checker = program.getTypeChecker();
|
|
const insideFunction = (node: ts.Node): boolean => {
|
|
for (let p = node.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
|
|
if (ts.isFunctionLike(p)) return true;
|
|
}
|
|
return false;
|
|
};
|
|
// The aliased declaration's TDZ horizon: the position after which reads
|
|
// are initialized. Hoisted functions have none.
|
|
const tdzEndOf = (aliased: ts.Symbol): number | null => {
|
|
const d = aliased.valueDeclaration ?? aliased.declarations[0];
|
|
if (d === undefined || ts.getSourceFileOfNode(d) !== sf) return null;
|
|
if (ts.isFunctionDeclaration(d)) return null;
|
|
return d.end;
|
|
};
|
|
const fence = (ref: ts.Identifier, name: string): void => {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1030",
|
|
{ file: sf.fileName, start: ts.tokenStartOfNode(ref), end: ref.end },
|
|
`the self-import binding '${name}' read above its declaration (the import aliases this module's OWN binding — Node initializes it when the declaration executes, so this read throws ReferenceError; move the read below the declaration)`,
|
|
),
|
|
);
|
|
};
|
|
const checkNamed = (bindingName: ts.Identifier): void => {
|
|
const sym = checker.getSymbolAtLocation(bindingName);
|
|
if (sym === undefined || !(sym.flags & ts.SymbolFlags.Alias)) return;
|
|
checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, bindingName.text));
|
|
const end = tdzEndOf(checker.getAliasedSymbol(sym));
|
|
if (end === null) return;
|
|
const visit = (node: ts.Node): void => {
|
|
if (
|
|
ts.isIdentifier(node) &&
|
|
node !== bindingName &&
|
|
node.text === bindingName.text &&
|
|
ts.tokenStartOfNode(node) < end &&
|
|
!insideFunction(node) &&
|
|
checker.getSymbolAtLocation(node) === sym
|
|
) {
|
|
fence(node, bindingName.text);
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
};
|
|
visit(sf);
|
|
};
|
|
if (clause.name !== undefined) checkNamed(clause.name);
|
|
if (clause.namedBindings !== undefined && ts.isNamedImports(clause.namedBindings)) {
|
|
for (const el of clause.namedBindings.elements.nodes) {
|
|
if (!el.isTypeOnly) checkNamed(el.name);
|
|
}
|
|
}
|
|
if (clause.namedBindings !== undefined && ts.isNamespaceImport(clause.namedBindings)) {
|
|
const nsName = clause.namedBindings.name;
|
|
const nsSym = checker.getSymbolAtLocation(nsName);
|
|
if (nsSym === undefined) return;
|
|
checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, nsName.text));
|
|
const visit = (node: ts.Node): void => {
|
|
if (
|
|
ts.isPropertyAccessExpression(node) &&
|
|
ts.isIdentifier(node.expression) &&
|
|
node.expression.text === nsName.text &&
|
|
ts.isIdentifier(node.name) &&
|
|
!insideFunction(node) &&
|
|
checker.getSymbolAtLocation(node.expression) === nsSym
|
|
) {
|
|
const memberSym = checker.getSymbolAtLocation(node.name);
|
|
if (memberSym !== undefined) {
|
|
const end = tdzEndOf(memberSym);
|
|
if (end !== null && ts.tokenStartOfNode(node) < end)
|
|
fence(node.expression, `${nsName.text}.${node.name.text}`);
|
|
}
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
};
|
|
visit(sf);
|
|
}
|
|
}
|
|
|
|
/** True when every reference to the namespace-import binding `nsName`
|
|
* (outside its own declaration) is exactly a bare expression statement's
|
|
* expression — the shape whose lowering is Node's no-op. A self-import's
|
|
* references all live in the importing file, so one file-local scan
|
|
* answers completely. */
|
|
function nsBindingUsesAreBareStatements7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
nsName: ts.Identifier,
|
|
): boolean {
|
|
const checker = program.getTypeChecker();
|
|
const bindingSym = checker.getSymbolAtLocation(nsName);
|
|
if (bindingSym === undefined) return false;
|
|
checker.prefetchSymbolNodesExact(identifierOccurrences7(sf, nsName.text));
|
|
let bareOnly = true;
|
|
const visit = (node: ts.Node): void => {
|
|
if (!bareOnly) return;
|
|
if (
|
|
ts.isIdentifier(node) &&
|
|
node !== nsName &&
|
|
node.text === nsName.text &&
|
|
checker.getSymbolAtLocation(node) === bindingSym
|
|
) {
|
|
if (
|
|
!(
|
|
node.parent !== undefined &&
|
|
ts.isExpressionStatement(node.parent) &&
|
|
node.parent.expression === node
|
|
)
|
|
) {
|
|
bareOnly = false;
|
|
return;
|
|
}
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
};
|
|
visit(sf);
|
|
return bareOnly;
|
|
}
|
|
|
|
/* ── benign-cycle admission ──────────────────────────────────────────────
|
|
* Node runs legal ESM cycles all over the ecosystem: the revisited module
|
|
* is a cache hit, and the only hazard is a READ of a binding before its
|
|
* declaration executed (TDZ ReferenceError for let/const/class, a stale
|
|
* `undefined` for var). Cycles where such a read is REACHABLE are admitted
|
|
* by the exact initialization rule (exactCycleRefusal7 below), which
|
|
* models the TDZ with initialization checks. A cycle needs no checks when
|
|
* partial initialization is provably unobservable — the DECLARATION-ONLY
|
|
* INIT WINDOW rule:
|
|
*
|
|
* 1. Every module of the cycle cluster (the strongly-connected component
|
|
* — any member may be mid-initialization while another's top level
|
|
* runs, and every module that can even NAME a cluster binding during
|
|
* the window is itself in the cluster) is an ES module whose top
|
|
* level is INERT: declarations and expressions that cannot call into
|
|
* user code (nonInertTopLevel7).
|
|
* 2. Every use of each binding the cycle-closing statement imports sits
|
|
* in a DEFERRED position — inside a function body, a parameter
|
|
* default, or an instance-field initializer (inDeferredPosition7).
|
|
*
|
|
* Together: cluster bindings are read only from function bodies, and no
|
|
* top level in the window can call a function, so the first possible read
|
|
* happens after every member initialized — the guarded %init calls then
|
|
* reproduce Node's cache-hit order exactly, and Node's TDZ/stale-slot
|
|
* outcomes are unreachable. */
|
|
|
|
/** A module edge, carrying what cycle admission needs when it turns out
|
|
* to close one. `stmt` is the importing/re-exporting statement; absent
|
|
* for require() edges, which are never admitted (their CJS home fails the
|
|
* cluster check anyway). */
|
|
export interface CycleEdge {
|
|
dep: ts.SourceFile;
|
|
stmt?: ts.ImportDeclaration | ts.ExportDeclaration;
|
|
/** An inline require() in a deferred position (a function body): Node
|
|
* evaluates the dependency when that code runs, after this module's own
|
|
* top level, so the edge orders the dependency after the module and
|
|
* never closes a cycle through the module's initialization. */
|
|
lazy?: true;
|
|
/** The inline require() call behind the edge (inline edges only). */
|
|
call?: ts.CallExpression;
|
|
}
|
|
|
|
/** True when the reference at `node` can only evaluate AFTER the module
|
|
* graph finished initializing: inside a function-like BODY, inside a
|
|
* parameter (default initializers evaluate at call time), or inside an
|
|
* INSTANCE field initializer (runs at construction, and no admitted top
|
|
* level constructs). Static field initializers, static blocks, heritage
|
|
* clauses, computed names, and decorators all run at the class statement
|
|
* itself — not deferred. */
|
|
function inDeferredPosition7(node: ts.Node): boolean {
|
|
let child: ts.Node = node;
|
|
for (
|
|
let p: ts.Node | undefined = node.parent;
|
|
p !== undefined && !ts.isSourceFile(p);
|
|
p = p.parent
|
|
) {
|
|
if (p.kind === ts.SyntaxKind.Decorator) return false;
|
|
if (ts.isClassStaticBlockDeclaration(p)) return false;
|
|
if (ts.isFunctionLike(p)) {
|
|
if ((p as { body?: ts.Node }).body === child) return true;
|
|
if (ts.isParameter(child)) return true;
|
|
}
|
|
if (
|
|
ts.isPropertyDeclaration(p) &&
|
|
p.initializer === child &&
|
|
(ts.getCombinedModifierFlags(p) & ts.ModifierFlags.Static) === 0
|
|
) {
|
|
return true;
|
|
}
|
|
child = p;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** True for identifiers in pure TYPE positions (annotations, `typeof`
|
|
* queries, interface/alias bodies) — erased at runtime, never a read. A
|
|
* CLASS `extends` heritage expression is the one TypeNode-shaped position
|
|
* that IS a runtime read. */
|
|
function inTypePosition7(node: ts.Node): boolean {
|
|
for (
|
|
let p: ts.Node | undefined = node.parent;
|
|
p !== undefined && !ts.isSourceFile(p);
|
|
p = p.parent
|
|
) {
|
|
if (ts.isTypeNode(p)) {
|
|
const heritage = p.parent;
|
|
const isClassExtends =
|
|
p.kind === ts.SyntaxKind.ExpressionWithTypeArguments &&
|
|
heritage !== undefined &&
|
|
ts.isHeritageClause(heritage) &&
|
|
heritage.token === ts.SyntaxKind.ExtendsKeyword &&
|
|
(ts.isClassDeclaration(heritage.parent) || ts.isClassExpression(heritage.parent));
|
|
if (!isClassExtends) return true;
|
|
}
|
|
if (ts.isTypeAliasDeclaration(p) || ts.isInterfaceDeclaration(p)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** The first top-level construct of `sf` that could execute USER code
|
|
* during a cycle's init window, or null when the module's top level is
|
|
* declaration-only ("inert"). The expression whitelist is deliberately
|
|
* conservative — anything that could CALL user code (directly, through a
|
|
* callback-invoking builtin, a getter, an iterator, or an implicit
|
|
* coercion of a user object) disqualifies the module's cycles. */
|
|
function nonInertTopLevel7(program: ts.Program, sf: ts.SourceFile): ts.Node | null {
|
|
const nonInert = topLevelInertness7(program);
|
|
for (const stmt of sf.statements.nodes) {
|
|
const offence = nonInert(stmt);
|
|
if (offence !== null) return offence;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** The per-statement form of nonInertTopLevel7: answers, for one
|
|
* top-level statement, the first construct that could execute user code
|
|
* while the statement runs, or null when the statement is inert. */
|
|
function topLevelInertness7(program: ts.Program): (stmt: ts.Statement) => ts.Node | null {
|
|
const checker = program.getTypeChecker();
|
|
const PRIM =
|
|
ts.TypeFlags.StringLike |
|
|
ts.TypeFlags.NumberLike |
|
|
ts.TypeFlags.BooleanLike |
|
|
ts.TypeFlags.BigIntLike |
|
|
ts.TypeFlags.ESSymbolLike |
|
|
ts.TypeFlags.EnumLike |
|
|
ts.TypeFlags.Undefined |
|
|
ts.TypeFlags.Null |
|
|
ts.TypeFlags.Void |
|
|
ts.TypeFlags.Never;
|
|
/** Coercion-safe: the expression's type is primitive in every arm, so
|
|
* ToString/ToNumber/ToPrimitive can never reach a user valueOf. */
|
|
const primitiveTyped = (e: ts.Expression): boolean => {
|
|
const t = checker.getTypeAtLocation(e);
|
|
const parts = t.isUnionType() ? ts.constituentTypes(t) : [t];
|
|
return parts.every((p) => (p.flags & PRIM) !== 0);
|
|
};
|
|
/** The identifier's symbol lives entirely in declaration files — a
|
|
* global builtin (process, WeakSet, Object, …) whose property reads and
|
|
* calls are runtime-implemented, never user code. */
|
|
const dtsRooted = (e: ts.Expression): boolean => {
|
|
let root: ts.Expression = e;
|
|
while (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root))
|
|
root = root.expression;
|
|
if (ts.isMetaProperty(root)) return true; // import.meta
|
|
if (!ts.isIdentifier(root)) return false;
|
|
let sym = checker.getSymbolAtLocation(root);
|
|
if (sym === undefined) return false;
|
|
if (sym.flags & ts.SymbolFlags.Alias) sym = checker.getAliasedSymbol(sym);
|
|
const decls = sym.declarations;
|
|
return decls.length > 0 && decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile);
|
|
};
|
|
const hasDecorator = (n: ts.Node): boolean =>
|
|
((n as { modifiers?: ts.NodeArray<ts.Node> }).modifiers?.nodes ?? []).some(
|
|
(m) => m.kind === ts.SyntaxKind.Decorator,
|
|
);
|
|
/** No function-like node anywhere in the subtree — arguments to builtin
|
|
* calls must not smuggle a callback the builtin could invoke. */
|
|
const containsFunctionLike = (n: ts.Node): boolean => {
|
|
let found = false;
|
|
ts.walkPreorder(n, (c) => {
|
|
if (ts.isFunctionLike(c) || ts.isClassExpression(c) || ts.isClassDeclaration(c)) {
|
|
found = true;
|
|
return "stop";
|
|
}
|
|
return undefined;
|
|
});
|
|
return found;
|
|
};
|
|
const inertClass = (c: ts.ClassLikeDeclaration): ts.Node | null => {
|
|
if (hasDecorator(c)) return c;
|
|
for (const h of c.heritageClauses?.nodes ?? []) {
|
|
if (h.token !== ts.SyntaxKind.ExtendsKeyword) continue;
|
|
for (const t of h.types.nodes) if (!inert(t.expression)) return t.expression;
|
|
}
|
|
for (const m of c.members.nodes) {
|
|
if (ts.isClassStaticBlockDeclaration(m)) return m;
|
|
if (hasDecorator(m)) return m;
|
|
const memberName = (m as { name?: ts.PropertyName }).name;
|
|
if (memberName !== undefined && ts.isComputedPropertyName(memberName)) {
|
|
if (!inert(memberName.expression) || !primitiveTyped(memberName.expression))
|
|
return memberName;
|
|
}
|
|
if (
|
|
ts.isPropertyDeclaration(m) &&
|
|
(ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static) !== 0 &&
|
|
m.initializer !== undefined &&
|
|
!inert(m.initializer)
|
|
) {
|
|
return m.initializer;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
const COERCING_FREE = new Set<number>([
|
|
ts.SyntaxKind.EqualsEqualsEqualsToken,
|
|
ts.SyntaxKind.ExclamationEqualsEqualsToken,
|
|
ts.SyntaxKind.AmpersandAmpersandToken,
|
|
ts.SyntaxKind.BarBarToken,
|
|
ts.SyntaxKind.QuestionQuestionToken,
|
|
ts.SyntaxKind.CommaToken,
|
|
ts.SyntaxKind.InstanceOfKeyword,
|
|
]);
|
|
const inert = (e: ts.Expression): boolean => {
|
|
if (
|
|
ts.isStringLiteral(e) ||
|
|
ts.isNumericLiteral(e) ||
|
|
ts.isBigIntLiteral(e) ||
|
|
ts.isRegularExpressionLiteral(e) ||
|
|
ts.isNoSubstitutionTemplateLiteral(e) ||
|
|
e.kind === ts.SyntaxKind.TrueKeyword ||
|
|
e.kind === ts.SyntaxKind.FalseKeyword ||
|
|
e.kind === ts.SyntaxKind.NullKeyword ||
|
|
ts.isIdentifier(e) ||
|
|
ts.isMetaProperty(e) ||
|
|
ts.isArrowFunction(e) ||
|
|
ts.isFunctionExpression(e)
|
|
) {
|
|
return true;
|
|
}
|
|
if (ts.isClassExpression(e)) return inertClass(e) === null;
|
|
if (
|
|
ts.isParenthesizedExpression(e) ||
|
|
ts.isAsExpression(e) ||
|
|
ts.isSatisfiesExpression(e) ||
|
|
ts.isNonNullExpression(e)
|
|
) {
|
|
return inert(e.expression);
|
|
}
|
|
if (ts.isPropertyAccessExpression(e)) return dtsRooted(e);
|
|
if (ts.isElementAccessExpression(e)) {
|
|
return dtsRooted(e) && inert(e.argumentExpression) && primitiveTyped(e.argumentExpression);
|
|
}
|
|
if (ts.isTemplateExpression(e)) {
|
|
return e.templateSpans.nodes.every(
|
|
(s) => inert(s.expression) && primitiveTyped(s.expression),
|
|
);
|
|
}
|
|
if (ts.isVoidExpression(e) || ts.isTypeOfExpression(e)) return inert(e.expression);
|
|
if (ts.isPrefixUnaryExpression(e)) {
|
|
if (e.operator === ts.SyntaxKind.ExclamationToken) return inert(e.operand);
|
|
if (
|
|
e.operator === ts.SyntaxKind.PlusToken ||
|
|
e.operator === ts.SyntaxKind.MinusToken ||
|
|
e.operator === ts.SyntaxKind.TildeToken
|
|
) {
|
|
return inert(e.operand) && primitiveTyped(e.operand);
|
|
}
|
|
return false;
|
|
}
|
|
if (ts.isBinaryExpression(e)) {
|
|
if (!inert(e.left) || !inert(e.right)) return false;
|
|
if (COERCING_FREE.has(e.operatorToken.kind)) return true;
|
|
return primitiveTyped(e.left) && primitiveTyped(e.right);
|
|
}
|
|
if (ts.isConditionalExpression(e))
|
|
return inert(e.condition) && inert(e.whenTrue) && inert(e.whenFalse);
|
|
if (ts.isArrayLiteralExpression(e))
|
|
return e.elements.nodes.every((el) => !ts.isSpreadElement(el) && inert(el));
|
|
if (ts.isObjectLiteralExpression(e)) {
|
|
return e.properties.nodes.every((p) => {
|
|
if (ts.isShorthandPropertyAssignment(p)) return true;
|
|
if (!ts.isPropertyAssignment(p) || ts.isComputedPropertyName(p.name)) return false;
|
|
return inert(p.initializer);
|
|
});
|
|
}
|
|
if (ts.isCallExpression(e) || ts.isNewExpression(e)) {
|
|
if (!dtsRooted(e.expression) || !ts.isIdentifier(chainRoot7(e.expression))) return false;
|
|
const args = e.arguments?.nodes ?? [];
|
|
// A CALLABLE argument is admissible when it is itself dts-rooted:
|
|
// a builtin-owned function value (the `promisify(fs.readFile)`
|
|
// at every cycle member's top level) is runtime-implemented — even
|
|
// if the builtin callee invokes it, no user code runs and no
|
|
// cluster binding is observable. Function literals and user
|
|
// callables keep the refusal.
|
|
return args.every(
|
|
(a) =>
|
|
inert(a) &&
|
|
!containsFunctionLike(a) &&
|
|
(checker.getCallSignatures(checker.getTypeAtLocation(a)).length === 0 || dtsRooted(a)),
|
|
);
|
|
}
|
|
return false;
|
|
};
|
|
return (stmt: ts.Statement): ts.Node | null => {
|
|
if (
|
|
ts.isImportDeclaration(stmt) ||
|
|
ts.isExportDeclaration(stmt) ||
|
|
ts.isImportEqualsDeclaration(stmt) ||
|
|
ts.isFunctionDeclaration(stmt) ||
|
|
ts.isInterfaceDeclaration(stmt) ||
|
|
ts.isTypeAliasDeclaration(stmt) ||
|
|
ts.isEmptyStatement(stmt) ||
|
|
(ts.getCombinedModifierFlags(stmt as unknown as ts.Declaration) &
|
|
ts.ModifierFlags.Ambient) !==
|
|
0
|
|
) {
|
|
return null;
|
|
}
|
|
if (ts.isEnumDeclaration(stmt)) {
|
|
return (
|
|
stmt.members.nodes.find((m) => m.initializer !== undefined && !inert(m.initializer)) ?? null
|
|
);
|
|
}
|
|
if (ts.isClassDeclaration(stmt)) return inertClass(stmt);
|
|
if (ts.isVariableStatement(stmt)) {
|
|
for (const d of stmt.declarationList.declarations.nodes) {
|
|
if (!ts.isIdentifier(d.name)) return d.name; // patterns can invoke getters/iterators
|
|
if (d.initializer !== undefined && !inert(d.initializer)) return d.initializer;
|
|
}
|
|
return null;
|
|
}
|
|
if (ts.isExpressionStatement(stmt)) return inert(stmt.expression) ? null : stmt;
|
|
if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
|
|
return inert(stmt.expression) ? null : stmt;
|
|
}
|
|
return stmt;
|
|
};
|
|
}
|
|
|
|
/** The head of a property/element-access chain. */
|
|
function chainRoot7(e: ts.Expression): ts.Expression {
|
|
let root: ts.Expression = e;
|
|
while (ts.isPropertyAccessExpression(root) || ts.isElementAccessExpression(root))
|
|
root = root.expression;
|
|
return root;
|
|
}
|
|
|
|
/** Identifier occurrences a binding-identity preflight scan will query.
|
|
* Gathered without checker traffic so managed deferred bodies can be
|
|
* warmed in one exact symbol batch before the semantic walk. */
|
|
function identifierOccurrences7(root: ts.Node, text: string): ts.Identifier[] {
|
|
const out: ts.Identifier[] = [];
|
|
ts.walkPreorder(root, (node) => {
|
|
if (ts.isIdentifier(node) && node.text === text) out.push(node);
|
|
return undefined;
|
|
});
|
|
return out;
|
|
}
|
|
|
|
/** The first use of a binding this cycle-closing import introduces that
|
|
* sits OUTSIDE a deferred position (a read there can observe the
|
|
* partially-initialized exporter), or null when every use defers.
|
|
* Re-export statements bind nothing locally — always null: the alias is
|
|
* link-time plumbing, never an evaluation-time read. Export specifiers
|
|
* of an imported binding are the same alias story, not reads. */
|
|
function backEdgeUseOffence7(
|
|
program: ts.Program,
|
|
stmt: ts.ImportDeclaration | ts.ExportDeclaration,
|
|
occurrences: ReadonlyMap<string, readonly ts.Identifier[]>,
|
|
): { name: string; node: ts.Node } | null {
|
|
if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined) return null;
|
|
const checker = program.getTypeChecker();
|
|
const clause = stmt.importClause;
|
|
const bindingNames: ts.Identifier[] = [];
|
|
if (clause.name !== undefined) bindingNames.push(clause.name);
|
|
if (clause.namedBindings !== undefined) {
|
|
if (ts.isNamespaceImport(clause.namedBindings)) bindingNames.push(clause.namedBindings.name);
|
|
else
|
|
for (const el of clause.namedBindings.elements.nodes)
|
|
if (!el.isTypeOnly) bindingNames.push(el.name);
|
|
}
|
|
for (const bindingName of bindingNames) {
|
|
const sym = checker.getSymbolAtLocation(bindingName);
|
|
if (sym === undefined) continue;
|
|
const references = occurrences.get(bindingName.text) ?? [];
|
|
checker.prefetchSymbolNodesExact(references);
|
|
for (const node of references) {
|
|
if (
|
|
!(node.parent !== undefined && ts.isExportSpecifier(node.parent)) &&
|
|
checker.getSymbolAtLocation(node) === sym &&
|
|
!inTypePosition7(node) &&
|
|
!inDeferredPosition7(node)
|
|
) {
|
|
return { name: bindingName.text, node };
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
export function makeCycleAdmission(
|
|
program: ts.Program,
|
|
edgesOf: (sf: ts.SourceFile) => readonly CycleEdge[],
|
|
): (importer: ts.SourceFile, e: CycleEdge) => string | null {
|
|
// Tarjan over the same edges the order walk uses (self-edges skipped —
|
|
// Node's self-reference rule makes those benign before admission is
|
|
// ever asked). State persists across lazily-added roots: a later
|
|
// strongconnect over an unvisited root composes with earlier runs
|
|
// exactly like the classic all-roots loop.
|
|
const sccOf = new Map<ts.SourceFile, ts.SourceFile[]>();
|
|
const index = new Map<ts.SourceFile, number>();
|
|
const low = new Map<ts.SourceFile, number>();
|
|
const onStack = new Set<ts.SourceFile>();
|
|
const tstack: ts.SourceFile[] = [];
|
|
let next = 0;
|
|
const strongconnect = (v: ts.SourceFile): void => {
|
|
index.set(v, next);
|
|
low.set(v, next);
|
|
next++;
|
|
tstack.push(v);
|
|
onStack.add(v);
|
|
for (const e of edgesOf(v)) {
|
|
const w = e.dep;
|
|
if (w === v) continue;
|
|
if (!index.has(w)) {
|
|
strongconnect(w);
|
|
low.set(v, Math.min(low.get(v)!, low.get(w)!));
|
|
} else if (onStack.has(w)) {
|
|
low.set(v, Math.min(low.get(v)!, index.get(w)!));
|
|
}
|
|
}
|
|
if (low.get(v) === index.get(v)) {
|
|
const comp: ts.SourceFile[] = [];
|
|
for (;;) {
|
|
const w = tstack.pop()!;
|
|
onStack.delete(w);
|
|
comp.push(w);
|
|
if (w === v) break;
|
|
}
|
|
for (const w of comp) sccOf.set(w, comp);
|
|
}
|
|
};
|
|
const lineOf = (node: ts.Node): string => {
|
|
const nsf = ts.getSourceFileOfNode(node);
|
|
return `${nsf.fileName}:${ts.getLineAndCharacterOfPosition(nsf, ts.tokenStartOfNode(node)).line + 1}`;
|
|
};
|
|
// Cluster verdict memo (keyed by the component array identity): true
|
|
// when every member is an ES module passing the inert-top-level bar.
|
|
const sccVerdict = new Map<ts.SourceFile[], boolean>();
|
|
// The exact-initialization verdict, same keying (exactCycleRefusal7).
|
|
const exactVerdict = new Map<ts.SourceFile[], string | null>();
|
|
// A module can close many cycle edges, each importing many bindings.
|
|
// Index its identifiers once for this admission pass. ASTs are immutable;
|
|
// the pass owns the index so it cannot retain a disposed program.
|
|
const bindingUses = new Map<ts.SourceFile, Map<string, ts.Identifier[]>>();
|
|
const usesOf = (sf: ts.SourceFile): Map<string, ts.Identifier[]> => {
|
|
const cached = bindingUses.get(sf);
|
|
if (cached !== undefined) return cached;
|
|
const uses = new Map<string, ts.Identifier[]>();
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (ts.isImportDeclaration(node)) return "skip";
|
|
if (ts.isIdentifier(node)) {
|
|
const references = uses.get(node.text);
|
|
if (references !== undefined) references.push(node);
|
|
else uses.set(node.text, [node]);
|
|
}
|
|
return undefined;
|
|
});
|
|
bindingUses.set(sf, uses);
|
|
return uses;
|
|
};
|
|
// The CommonJS cluster verdict, same keying (cjsCycleRefusal7).
|
|
const cjsVerdict = new Map<ts.SourceFile[], string | null>();
|
|
return (importer: ts.SourceFile, e: CycleEdge): string | null => {
|
|
if (e.stmt === undefined) {
|
|
if (!index.has(importer)) strongconnect(importer);
|
|
const comp = sccOf.get(e.dep);
|
|
if (comp === undefined || comp.length < 2 || !comp.includes(importer)) {
|
|
return "the cycle closes through a require() edge";
|
|
}
|
|
if (!cjsVerdict.has(comp)) cjsVerdict.set(comp, cjsCycleRefusal7(program, comp, lineOf));
|
|
const reason = cjsVerdict.get(comp) ?? null;
|
|
return reason === null ? null : `the cycle closes through a require() edge: ${reason}`;
|
|
}
|
|
// Cheap per-edge admission: nothing readable binds through the edge.
|
|
if (ts.isImportDeclaration(e.stmt)) {
|
|
const clause = e.stmt.importClause;
|
|
if (
|
|
clause === undefined ||
|
|
typeOnlyNamedImport(e.stmt) ||
|
|
(clause.name === undefined &&
|
|
(clause.namedBindings === undefined ||
|
|
(ts.isNamespaceImport(clause.namedBindings) &&
|
|
nsBindingUsesAreBareStatements7(program, importer, clause.namedBindings.name))))
|
|
) {
|
|
return null;
|
|
}
|
|
}
|
|
if (!index.has(importer)) strongconnect(importer);
|
|
const comp = sccOf.get(e.dep);
|
|
if (comp === undefined || comp.length < 2 || !comp.includes(importer)) {
|
|
return "the cycle's module cluster could not be analyzed";
|
|
}
|
|
if (!sccVerdict.has(comp)) {
|
|
sccVerdict.set(
|
|
comp,
|
|
comp.every((m) => !isCjsJsFile7(m, program) && nonInertTopLevel7(program, m) === null),
|
|
);
|
|
}
|
|
if (
|
|
sccVerdict.get(comp) === true &&
|
|
backEdgeUseOffence7(program, e.stmt, usesOf(importer)) === null
|
|
) {
|
|
return null;
|
|
}
|
|
// The EXACT INITIALIZATION rule: the cycle runs in Node's evaluation
|
|
// order and every binding that can be observed before its declaration
|
|
// runs carries an initialization check (cycleEarlyBindings).
|
|
if (!exactVerdict.has(comp)) {
|
|
const reason = exactCycleRefusal7(program, comp, lineOf);
|
|
exactVerdict.set(comp, reason);
|
|
if (reason === null) {
|
|
const members = program.analysis.exactCycleMembers;
|
|
for (const m of comp) members.add(m);
|
|
}
|
|
}
|
|
return exactVerdict.get(comp) ?? null;
|
|
};
|
|
}
|
|
|
|
/** The reason a strongly-connected cluster of CommonJS modules cannot be
|
|
* initialized exactly through its require() cycle, or null when it can.
|
|
* Node answers a require of a module that is still evaluating with that
|
|
* module's exports object as it stands, while the compiled bindings alias
|
|
* the exporter's final declarations. The two agree when:
|
|
* - every member settles its exports before anything can enter the
|
|
* cycle: all of its export statements come before its first top-level
|
|
* statement that can run another module's code (a require, or anything
|
|
* but literals, plain reads, function and class values, and
|
|
* standard-library globals called with literal arguments), and every
|
|
* other use of its export object is a plain member read; and
|
|
* - no member's top-level code can reach its binding of another member,
|
|
* so no member runs another member's code while the cluster is still
|
|
* initializing. Each module then initializes exactly as it would
|
|
* outside the cycle, and its own require bindings keep the acyclic
|
|
* analysis (requireEarlyReference).
|
|
* Other cycles keep the SC1016 fence. */
|
|
function cjsCycleRefusal7(
|
|
program: ts.Program,
|
|
comp: readonly ts.SourceFile[],
|
|
lineOf: (node: ts.Node) => string,
|
|
): string | null {
|
|
const members = new Set(comp);
|
|
const builtinRoot = (e: ts.Expression): boolean => {
|
|
while (ts.isPropertyAccessExpression(e)) e = e.expression;
|
|
return ts.isIdentifier(e) && !sourceBinding7(program, e);
|
|
};
|
|
const literal = (e: ts.Node): boolean =>
|
|
ts.isStringLiteralLike(e) ||
|
|
ts.isNumericLiteral(e) ||
|
|
ts.isRegularExpressionLiteral(e) ||
|
|
e.kind === ts.SyntaxKind.TrueKeyword ||
|
|
e.kind === ts.SyntaxKind.FalseKeyword ||
|
|
e.kind === ts.SyntaxKind.NullKeyword;
|
|
/** An expression whose evaluation runs no user code and requires
|
|
* nothing: literals, plain reads, function and class values, literal
|
|
* containers of those, and standard-library globals called with
|
|
* literal arguments. */
|
|
const inertExpr = (e: ts.Node): boolean => {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
if (literal(e) || ts.isIdentifier(e)) return true;
|
|
if (ts.isFunctionExpression(e) || ts.isArrowFunction(e)) return true;
|
|
if (ts.isClassExpression(e)) return classSyncParts7(e).every(inertPart);
|
|
if (ts.isObjectLiteralExpression(e)) {
|
|
return e.properties.nodes.every((p) =>
|
|
ts.isShorthandPropertyAssignment(p)
|
|
? true
|
|
: ts.isPropertyAssignment(p)
|
|
? !ts.isComputedPropertyName(p.name) && inertExpr(p.initializer)
|
|
: (ts.isMethodDeclaration(p) ||
|
|
ts.isGetAccessorDeclaration(p) ||
|
|
ts.isSetAccessorDeclaration(p)) &&
|
|
!ts.isComputedPropertyName(p.name),
|
|
);
|
|
}
|
|
if (ts.isArrayLiteralExpression(e)) {
|
|
return e.elements.nodes.every((el) => !ts.isSpreadElement(el) && inertExpr(el));
|
|
}
|
|
if (ts.isPropertyAccessExpression(e)) return builtinRoot(e);
|
|
if (ts.isVoidExpression(e)) return literal(e.expression);
|
|
if (ts.isCallExpression(e) || ts.isNewExpression(e)) {
|
|
return (
|
|
requireSpecOf7(e) === null &&
|
|
builtinRoot(e.expression) &&
|
|
(e.arguments?.nodes ?? []).every(literal)
|
|
);
|
|
}
|
|
return false;
|
|
};
|
|
const inertPart = (part: ts.Node): boolean => {
|
|
if (ts.isHeritageClause(part)) return part.types.nodes.every((t) => inertExpr(t.expression));
|
|
if (ts.isComputedPropertyName(part)) return inertExpr(part.expression);
|
|
return ts.isExpression(part) && inertExpr(part);
|
|
};
|
|
const exportObject = (e: ts.Expression): boolean =>
|
|
(ts.isIdentifier(e) && e.text === "exports" && !sourceBinding7(program, e)) ||
|
|
(isModuleExportsAccess(e) &&
|
|
ts.isIdentifier(e.expression) &&
|
|
!sourceBinding7(program, e.expression));
|
|
/** A top-level statement that only publishes inert values. */
|
|
const exportStatement = (stmt: ts.Statement): boolean => {
|
|
if (!ts.isExpressionStatement(stmt)) return false;
|
|
if (isEsModuleStamp(stmt.expression)) return true;
|
|
const cjs = cjsExportAssignmentOf(stmt);
|
|
if (cjs !== null) {
|
|
let value: ts.Expression = cjs.expr;
|
|
while (
|
|
ts.isBinaryExpression(value) &&
|
|
value.operatorToken.kind === ts.SyntaxKind.EqualsToken
|
|
) {
|
|
const left = value.left;
|
|
if (
|
|
!isModuleExportsAccess(left) &&
|
|
!(ts.isPropertyAccessExpression(left) && exportObject(left.expression))
|
|
)
|
|
return false;
|
|
value = value.right;
|
|
}
|
|
return inertExpr(value);
|
|
}
|
|
const call = stmt.expression;
|
|
return (
|
|
ts.isCallExpression(call) &&
|
|
ts.isPropertyAccessExpression(call.expression) &&
|
|
ts.isIdentifier(call.expression.expression) &&
|
|
call.expression.expression.text === "Object" &&
|
|
!sourceBinding7(program, call.expression.expression) &&
|
|
call.expression.name.text === "defineProperty" &&
|
|
call.arguments.nodes.length === 3 &&
|
|
exportObject(call.arguments.nodes[0]!) &&
|
|
ts.isStringLiteralLike(call.arguments.nodes[1]!) &&
|
|
inertExpr(call.arguments.nodes[2]!)
|
|
);
|
|
};
|
|
for (const m of comp) {
|
|
if (!isCjsJsFile7(m, program)) {
|
|
return `${m.fileName} is not a CommonJS module — require cycles are admitted between CommonJS modules only`;
|
|
}
|
|
const stmts = m.statements.nodes;
|
|
// The first statement that can run another module's code.
|
|
let firstEntry = stmts.length;
|
|
for (let i = 0; i < stmts.length; i++) {
|
|
const st = stmts[i]!;
|
|
const inert =
|
|
ts.isFunctionDeclaration(st) ||
|
|
ts.isEmptyStatement(st) ||
|
|
(ts.isExpressionStatement(st) && ts.isStringLiteral(st.expression)) ||
|
|
(ts.isClassDeclaration(st) && classSyncParts7(st).every(inertPart)) ||
|
|
(ts.isVariableStatement(st) &&
|
|
st.declarationList.declarations.nodes.every(
|
|
(d) =>
|
|
ts.isIdentifier(d.name) && (d.initializer === undefined || inertExpr(d.initializer)),
|
|
)) ||
|
|
exportStatement(st);
|
|
if (!inert) {
|
|
firstEntry = i;
|
|
break;
|
|
}
|
|
}
|
|
// Every other use of the export object must be a plain member read:
|
|
// anything else can change what a module of the cycle observes.
|
|
let stray: ts.Node | null = null;
|
|
const settled = new Set(stmts.slice(0, firstEntry).filter(exportStatement));
|
|
// A bundler export table the rewrite certified (npmStaticLiveExportTable)
|
|
// stands for the live getter object the original installed before its
|
|
// first require: the tail table settles as if it ran there.
|
|
const tail = stmts[stmts.length - 1];
|
|
if (
|
|
tail !== undefined &&
|
|
npmStaticLiveExportTable(m.fileName) &&
|
|
cjsExportAssignmentOf(tail)?.kind === "table"
|
|
)
|
|
settled.add(tail);
|
|
ts.walkPreorder(m, (n) => {
|
|
if (stray !== null) return "stop";
|
|
if (ts.isStatement(n) && settled.has(n)) return "skip";
|
|
let use: ts.Expression | null = null;
|
|
if (n.kind === ts.SyntaxKind.ThisKeyword) {
|
|
let moduleThis = true;
|
|
for (let p = n.parent; p !== undefined && !ts.isSourceFile(p); p = p.parent) {
|
|
if (
|
|
(ts.isFunctionLike(p) && !ts.isArrowFunction(p)) ||
|
|
ts.isClassDeclaration(p) ||
|
|
ts.isClassExpression(p)
|
|
) {
|
|
moduleThis = false;
|
|
break;
|
|
}
|
|
}
|
|
if (moduleThis) use = n as ts.Expression;
|
|
} else if (
|
|
ts.isIdentifier(n) &&
|
|
(n.text === "exports" || n.text === "module") &&
|
|
!(ts.isPropertyAccessExpression(n.parent) && n.parent.name === n) &&
|
|
!sourceBinding7(program, n)
|
|
) {
|
|
if (n.text === "exports") use = n;
|
|
else if (!ts.isPropertyAccessExpression(n.parent) || n.parent.expression !== n) stray = n;
|
|
else if (n.parent.name.text === "exports") use = n.parent;
|
|
}
|
|
if (use === null) return undefined;
|
|
const parent = use.parent;
|
|
const read =
|
|
ts.isPropertyAccessExpression(parent) &&
|
|
parent.expression === use &&
|
|
!(
|
|
ts.isBinaryExpression(parent.parent) &&
|
|
parent.parent.left === parent &&
|
|
parent.parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
|
|
parent.parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment
|
|
) &&
|
|
!(ts.isCallExpression(parent.parent) && parent.parent.expression === parent) &&
|
|
!ts.isDeleteExpression(parent.parent);
|
|
if (!read) stray = use;
|
|
return undefined;
|
|
});
|
|
if (stray !== null) {
|
|
return `${m.fileName} uses its exports at ${lineOf(stray)} outside the export statements that precede its first require, so a module of the cycle can observe them before they settle`;
|
|
}
|
|
// Bindings of other members must stay unreachable from top-level code.
|
|
for (const st of stmts) {
|
|
for (const req of requiresOf7(st, program)) {
|
|
if (req.decl === null) continue;
|
|
const dep = resolveImport7(program, m, req.spec, "require");
|
|
if (dep === null || !members.has(dep)) continue;
|
|
const reached = requireBindingEarlyUse7(program, m, stmts.length, req.decl, [], (id) =>
|
|
functionExportRead7(id, dep),
|
|
);
|
|
if (reached !== null) {
|
|
return `the top-level code of ${m.fileName} can use its binding '${reached.text}' of a module of the cycle (${lineOf(reached)}) while the cycle initializes`;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** True when `use` initializes a top-level const whose every other
|
|
* reference is a value of an export statement (`module.exports = { … }`
|
|
* or `exports.n = …`). */
|
|
function publishedAlias7(use: ts.Node, decl: ts.Node | undefined): boolean {
|
|
if (
|
|
decl === undefined ||
|
|
!ts.isVariableDeclaration(decl) ||
|
|
decl.initializer !== use ||
|
|
!ts.isIdentifier(decl.name)
|
|
)
|
|
return false;
|
|
const list = decl.parent;
|
|
const stmt = list?.parent;
|
|
const sf = stmt?.parent;
|
|
if (
|
|
list === undefined ||
|
|
(list.flags & ts.NodeFlags.Const) === 0 ||
|
|
stmt === undefined ||
|
|
!ts.isVariableStatement(stmt) ||
|
|
sf === undefined ||
|
|
!ts.isSourceFile(sf)
|
|
)
|
|
return false;
|
|
const alias = decl.name;
|
|
const published = new Set<ts.Node>();
|
|
for (const st of sf.statements.nodes) {
|
|
const cjs = cjsExportAssignmentOf(st);
|
|
if (cjs === null) continue;
|
|
if (cjs.kind === "member") published.add(cjs.value);
|
|
else if (cjs.obj !== null) {
|
|
for (const p of cjs.obj.properties.nodes) {
|
|
if (ts.isPropertyAssignment(p) && !ts.isComputedPropertyName(p.name))
|
|
published.add(p.initializer);
|
|
else if (ts.isShorthandPropertyAssignment(p)) published.add(p.name);
|
|
}
|
|
}
|
|
}
|
|
let kept = false;
|
|
ts.walkPreorder(sf, (n) => {
|
|
if (kept) return "stop";
|
|
if (!ts.isIdentifier(n) || n === alias || n.text !== alias.text) return undefined;
|
|
const p = n.parent;
|
|
if (
|
|
p !== undefined &&
|
|
((ts.isPropertyAccessExpression(p) && p.name === n) ||
|
|
(ts.isPropertyAssignment(p) && p.name === n))
|
|
)
|
|
return undefined;
|
|
if (!published.has(n)) kept = true;
|
|
return undefined;
|
|
});
|
|
return !kept;
|
|
}
|
|
|
|
/** True for a plain read `binding.name` (not a call, not a write, not a
|
|
* value that is stored or passed on) of the cycle member `dep` whose
|
|
* export `name` is a top-level function declaration nothing reassigns.
|
|
* Every member settles its exports before entering the cycle, so Node
|
|
* reads that same function whenever the read runs, and the compiled read
|
|
* resolves to the declaration itself. */
|
|
function functionExportRead7(id: ts.Identifier, dep: ts.SourceFile): boolean {
|
|
const access = id.parent;
|
|
if (!ts.isPropertyAccessExpression(access) || access.expression !== id) return false;
|
|
// The value the read yields: through parentheses and the right operand
|
|
// of a comma, so `(0, binding.name)(...)` is the call it spells.
|
|
let use: ts.Node = access;
|
|
for (;;) {
|
|
const p = use.parent;
|
|
if (ts.isParenthesizedExpression(p)) use = p;
|
|
else if (
|
|
ts.isBinaryExpression(p) &&
|
|
p.operatorToken.kind === ts.SyntaxKind.CommaToken &&
|
|
p.right === use
|
|
)
|
|
use = p;
|
|
else break;
|
|
}
|
|
const parent = use.parent;
|
|
// Only a use that neither runs the function nor keeps it is a read: a
|
|
// stored alias (`const f = binding.name`, `{ f: binding.name }`) or an
|
|
// argument can be called while the cycle initializes. A top-level const
|
|
// that only publishes it (`module.exports = { name: f }`, the static
|
|
// rewrite's re-export spelling) runs nothing: a module that reads the
|
|
// export back checks that read itself.
|
|
const observes =
|
|
publishedAlias7(use, parent) ||
|
|
ts.isExpressionStatement(parent) ||
|
|
ts.isTypeOfExpression(parent) ||
|
|
ts.isVoidExpression(parent) ||
|
|
(ts.isPrefixUnaryExpression(parent) && parent.operator === ts.SyntaxKind.ExclamationToken) ||
|
|
(ts.isBinaryExpression(parent) &&
|
|
(parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
|
|
parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
|
|
parent.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
|
|
parent.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken)) ||
|
|
((ts.isIfStatement(parent) || ts.isWhileStatement(parent) || ts.isDoStatement(parent)) &&
|
|
parent.expression === use) ||
|
|
(ts.isConditionalExpression(parent) && parent.condition === use);
|
|
if (!observes) return false;
|
|
const name = access.name.text;
|
|
// The exported value's identifier: a table entry or a member export.
|
|
const values: ts.Expression[] = [];
|
|
for (const stmt of dep.statements.nodes) {
|
|
if (!ts.isExpressionStatement(stmt) || !ts.isBinaryExpression(stmt.expression)) continue;
|
|
const e = stmt.expression;
|
|
if (e.operatorToken.kind !== ts.SyntaxKind.EqualsToken) continue;
|
|
if (isModuleExportsAccess(e.left)) {
|
|
if (!ts.isObjectLiteralExpression(e.right)) return false;
|
|
for (const p of e.right.properties.nodes) {
|
|
if (ts.isSpreadAssignment(p)) return false;
|
|
if (ts.isShorthandPropertyAssignment(p) && p.name.text === name)
|
|
values.push(p.name as ts.Identifier);
|
|
else if (
|
|
ts.isPropertyAssignment(p) &&
|
|
(ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) &&
|
|
p.name.text === name
|
|
)
|
|
values.push(p.initializer);
|
|
}
|
|
} else if (
|
|
ts.isPropertyAccessExpression(e.left) &&
|
|
e.left.name.text === name &&
|
|
((ts.isIdentifier(e.left.expression) && e.left.expression.text === "exports") ||
|
|
isModuleExportsAccess(e.left.expression))
|
|
) {
|
|
values.push(e.right);
|
|
}
|
|
}
|
|
const value = values.length === 1 ? values[0]! : null;
|
|
if (value === null || !ts.isIdentifier(value)) return false;
|
|
const fnName = value.text;
|
|
if (
|
|
!dep.statements.nodes.some(
|
|
(st) => ts.isFunctionDeclaration(st) && st.name?.text === fnName && st.body !== undefined,
|
|
)
|
|
)
|
|
return false;
|
|
let rebound = false;
|
|
ts.walkPreorder(dep, (n) => {
|
|
if (rebound) return "stop";
|
|
if (
|
|
(ts.isBinaryExpression(n) &&
|
|
ts.isIdentifier(n.left) &&
|
|
n.left.text === fnName &&
|
|
n.operatorToken.kind >= ts.SyntaxKind.FirstAssignment &&
|
|
n.operatorToken.kind <= ts.SyntaxKind.LastAssignment) ||
|
|
(ts.isVariableDeclaration(n) && ts.isIdentifier(n.name) && n.name.text === fnName) ||
|
|
(ts.isFunctionDeclaration(n) && n.name?.text === fnName && !ts.isSourceFile(n.parent))
|
|
)
|
|
rebound = true;
|
|
return undefined;
|
|
});
|
|
return !rebound;
|
|
}
|
|
|
|
/* ── exact cyclic initialization ─────────────────────────────────────────
|
|
* Cycles that fail the declaration-only rule still evaluate exactly like
|
|
* Node when their shape is representable: the guarded %init calls already
|
|
* run every module body in ES evaluation order (depth-first postorder,
|
|
* a module mid-evaluation answered from the cache), function declarations
|
|
* are callable from the start, and live bindings are shared globals. What
|
|
* remains is the temporal dead zone: a let/const binding read before its
|
|
* declaration ran throws ReferenceError. cycleEarlyBindings finds every
|
|
* such binding whose read CAN run early; the lowering gives each one an
|
|
* initialization flag and checks it at every read or write that can run
|
|
* before the declaration. The shapes below have no such representation
|
|
* and keep the SC1016 fence. */
|
|
|
|
/** The modules of `program` whose import cycles were admitted by the
|
|
* exact initialization rule (not the declaration-only rule). */
|
|
export function exactCycleMembers(program: ts.Program): ReadonlySet<ts.SourceFile> {
|
|
return program.analysis.exactCycleMembers;
|
|
}
|
|
|
|
/** True when the module's top level (outside every function-like body)
|
|
* contains `await` or `for await`. */
|
|
function hasTopLevelAwait7(sf: ts.SourceFile): boolean {
|
|
let found = false;
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (found) return "stop";
|
|
if (node !== sf && ts.isFunctionLike(node)) return "skip";
|
|
if (
|
|
ts.isAwaitExpression(node) ||
|
|
(ts.isForOfStatement(node) && node.awaitModifier !== undefined)
|
|
) {
|
|
found = true;
|
|
return "stop";
|
|
}
|
|
return undefined;
|
|
});
|
|
return found;
|
|
}
|
|
|
|
/** The reason a strongly-connected module cluster cannot be initialized
|
|
* exactly, or null when it can. */
|
|
function exactCycleRefusal7(
|
|
program: ts.Program,
|
|
comp: readonly ts.SourceFile[],
|
|
lineOf: (node: ts.Node) => string,
|
|
): string | null {
|
|
const members = new Set(comp);
|
|
const targetOf = (stmt: ts.ImportDeclaration | ts.ExportDeclaration): ts.SourceFile | null => {
|
|
const spec = stmt.moduleSpecifier;
|
|
if (spec === undefined || !ts.isStringLiteral(spec)) return null;
|
|
const sf = ts.getSourceFileOfNode(stmt);
|
|
return resolveImport7(program, sf, spec.text) ?? npmStaticDepSf7(program, sf, spec.text);
|
|
};
|
|
for (const m of comp) {
|
|
if (isCjsJsFile7(m, program) || /\.c[jt]s$/.test(m.fileName)) {
|
|
return `${m.fileName} is a CommonJS module — cyclic initialization covers ES modules only`;
|
|
}
|
|
if (hasTopLevelAwait7(m)) {
|
|
return `${m.fileName} uses top-level await inside the cycle`;
|
|
}
|
|
for (const stmt of m.statements.nodes) {
|
|
if (ts.isExportAssignment(stmt) && !stmt.isExportEquals) {
|
|
return `the default export expression at ${lineOf(stmt)} has no initialization state inside the cycle`;
|
|
}
|
|
if (
|
|
ts.isExportDeclaration(stmt) &&
|
|
!stmt.isTypeOnly &&
|
|
(stmt.exportClause === undefined || ts.isNamespaceExport(stmt.exportClause))
|
|
) {
|
|
const dep = targetOf(stmt);
|
|
if (dep !== null && members.has(dep)) {
|
|
return `the namespace re-export at ${lineOf(stmt)} names a module of the cycle`;
|
|
}
|
|
}
|
|
if (
|
|
ts.isImportDeclaration(stmt) &&
|
|
stmt.importClause !== undefined &&
|
|
!stmt.importClause.isTypeOnly &&
|
|
stmt.importClause.namedBindings !== undefined &&
|
|
ts.isNamespaceImport(stmt.importClause.namedBindings)
|
|
) {
|
|
const dep = targetOf(stmt);
|
|
const nsName = stmt.importClause.namedBindings.name;
|
|
if (
|
|
dep !== null &&
|
|
members.has(dep) &&
|
|
!nsBindingUsesAreBareStatements7(program, m, nsName)
|
|
) {
|
|
return `the namespace import '${nsName.text}' at ${lineOf(stmt)} names a module of the cycle`;
|
|
}
|
|
}
|
|
if (ts.isClassDeclaration(stmt) && stmt.name === undefined) {
|
|
return `the anonymous default class at ${lineOf(stmt)} has no initialization state inside the cycle`;
|
|
}
|
|
const ambient =
|
|
(ts.getCombinedModifierFlags(stmt as unknown as ts.Declaration) &
|
|
ts.ModifierFlags.Ambient) !==
|
|
0;
|
|
if (ambient) continue;
|
|
if (
|
|
ts.isEnumDeclaration(stmt) &&
|
|
(ts.getCombinedModifierFlags(stmt) & ts.ModifierFlags.Const) === 0
|
|
) {
|
|
return `the enum '${stmt.name.text}' at ${lineOf(stmt)} has no initialization state inside the cycle`;
|
|
}
|
|
if (ts.isModuleDeclaration(stmt) && !typeOnlyNamespace7(stmt)) {
|
|
return `the namespace at ${lineOf(stmt)} has no initialization state inside the cycle`;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** A module-scope binding of an exactly-initialized cycle that some read
|
|
* or write can reach before its declaration ran. */
|
|
export interface CycleEarlyBinding {
|
|
symbol: ts.Symbol;
|
|
/** The declaration's name. */
|
|
name: ts.Identifier;
|
|
kind: "lexical" | "var" | "class";
|
|
module: ts.SourceFile;
|
|
/** One reference that can run before the declaration. */
|
|
reference: ts.Identifier;
|
|
/** A reference in a position the lowering may resolve at compile time
|
|
* from the binding's type (a property key, a `typeof` operand). */
|
|
folded?: ts.Identifier;
|
|
/** Modules whose TOP-LEVEL code runs only after the declaration ran:
|
|
* modules outside the cycle and cycle members evaluated later. */
|
|
settled: ReadonlySet<ts.SourceFile>;
|
|
/** The local name each importing file gives the binding when it differs
|
|
* from the declared one, by file name: Node's ReferenceError names it. */
|
|
localNames?: ReadonlyMap<string, string>;
|
|
}
|
|
|
|
/** Every binding of the program's exactly-initialized cycles that can be
|
|
* observed before its declaration executes. `order` is the compiled module
|
|
* order; `singleRoot` is false when more than one module graph root runs
|
|
* (fork or worker entries), so a cycle can be entered at different
|
|
* members. With one root and a purely ES-module graph the evaluation order
|
|
* is static and the analysis is precise up to "user code may run": a
|
|
* binding needs its check when its declaration completes after some
|
|
* top-level code that can call user functions and a deferred position
|
|
* (function body, parameter default, instance field) references it, or
|
|
* when the top level of a cycle member evaluated before it reads it.
|
|
* Otherwise every deferred reference and every top-level reference from
|
|
* another member counts. */
|
|
export function cycleEarlyBindings(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
order: readonly ts.SourceFile[],
|
|
singleRoot: boolean,
|
|
): CycleEarlyBinding[] {
|
|
const exact = program.analysis.exactCycleMembers;
|
|
if (exact.size === 0) return [];
|
|
// Every lowering pass of one compile asks with the same inputs.
|
|
const key = `${entry.fileName}\0${order.map((sf) => sf.fileName).join("\0")}\0${singleRoot}`;
|
|
const memo = program.analysis.cycleEarlyBindings;
|
|
if (memo !== null && memo.key === key) return memo.bindings;
|
|
const bindings = computeCycleEarlyBindings7(program, entry, order, singleRoot, exact);
|
|
program.analysis.cycleEarlyBindings = { key, bindings };
|
|
return bindings;
|
|
}
|
|
|
|
function computeCycleEarlyBindings7(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
order: readonly ts.SourceFile[],
|
|
singleRoot: boolean,
|
|
exact: ReadonlySet<ts.SourceFile>,
|
|
): CycleEarlyBinding[] {
|
|
const inOrder = new Set(order);
|
|
const members = [...exact].filter((m) => inOrder.has(m));
|
|
if (members.length === 0) return [];
|
|
const memberSet = new Set(members);
|
|
const depsOf = (sf: ts.SourceFile): ts.SourceFile[] =>
|
|
orderedImportsOf(program, sf).flatMap(({ dep }) =>
|
|
dep !== null && dep !== sf && inOrder.has(dep) ? [dep] : [],
|
|
);
|
|
// Strongly-connected components among the exactly-initialized members.
|
|
const comps: ts.SourceFile[][] = [];
|
|
{
|
|
const index = new Map<ts.SourceFile, number>();
|
|
const low = new Map<ts.SourceFile, number>();
|
|
const onStack = new Set<ts.SourceFile>();
|
|
const stack: ts.SourceFile[] = [];
|
|
let next = 0;
|
|
const connect = (v: ts.SourceFile): void => {
|
|
index.set(v, next);
|
|
low.set(v, next);
|
|
next++;
|
|
stack.push(v);
|
|
onStack.add(v);
|
|
for (const w of depsOf(v)) {
|
|
if (!memberSet.has(w)) continue;
|
|
if (!index.has(w)) {
|
|
connect(w);
|
|
low.set(v, Math.min(low.get(v)!, low.get(w)!));
|
|
} else if (onStack.has(w)) {
|
|
low.set(v, Math.min(low.get(v)!, index.get(w)!));
|
|
}
|
|
}
|
|
if (low.get(v) === index.get(v)) {
|
|
const comp: ts.SourceFile[] = [];
|
|
for (;;) {
|
|
const w = stack.pop()!;
|
|
onStack.delete(w);
|
|
comp.push(w);
|
|
if (w === v) break;
|
|
}
|
|
if (comp.length > 1) comps.push(comp);
|
|
}
|
|
};
|
|
for (const m of members) if (!index.has(m)) connect(m);
|
|
}
|
|
if (comps.length === 0) return [];
|
|
// The static evaluation order: Node's depth-first postorder from the
|
|
// entry over ES import edges. Known only for one root and a graph with
|
|
// no CommonJS module (a require() evaluates its target mid-body).
|
|
const position = new Map<ts.SourceFile, number>();
|
|
if (
|
|
singleRoot &&
|
|
!order.some((sf) => isCjsJsFile7(sf, program) || /\.c[jt]s$/.test(sf.fileName))
|
|
) {
|
|
const seen = new Set<ts.SourceFile>();
|
|
const visit = (sf: ts.SourceFile): void => {
|
|
seen.add(sf);
|
|
for (const dep of depsOf(sf)) if (!seen.has(dep)) visit(dep);
|
|
position.set(sf, position.size);
|
|
};
|
|
visit(entry);
|
|
}
|
|
const checker = program.getTypeChecker();
|
|
const nonInert = topLevelInertness7(program);
|
|
const out: CycleEarlyBinding[] = [];
|
|
for (const comp of comps) {
|
|
const known = comp.every((m) => position.has(m));
|
|
const evaluation = known
|
|
? comp.slice().sort((a, b) => position.get(a)! - position.get(b)!)
|
|
: comp.slice();
|
|
const candidates = new Map<ts.Symbol, CycleCandidate7>();
|
|
const names = new Set<string>();
|
|
let dirty = !known;
|
|
evaluation.forEach((m, rank) => {
|
|
for (const stmt of m.statements.nodes) {
|
|
const offence = nonInert(stmt);
|
|
const exposed = dirty || offence !== null;
|
|
const declared: { name: ts.Identifier; kind: CycleEarlyBinding["kind"] }[] = [];
|
|
if (
|
|
ts.isVariableStatement(stmt) &&
|
|
(ts.getCombinedModifierFlags(stmt as unknown as ts.Declaration) &
|
|
ts.ModifierFlags.Ambient) ===
|
|
0
|
|
) {
|
|
const lexical =
|
|
(stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
|
|
for (const d of stmt.declarationList.declarations.nodes) {
|
|
for (const name of boundNames7(d.name)) {
|
|
declared.push({ name, kind: lexical ? "lexical" : "var" });
|
|
}
|
|
}
|
|
} else if (ts.isClassDeclaration(stmt) && stmt.name !== undefined) {
|
|
declared.push({ name: stmt.name, kind: "class" });
|
|
}
|
|
for (const { name, kind } of declared) {
|
|
const symbol = checker.getSymbolAtLocation(name);
|
|
if (symbol === undefined) continue;
|
|
candidates.set(symbol, {
|
|
symbol,
|
|
name,
|
|
kind,
|
|
module: m,
|
|
exposed,
|
|
rank,
|
|
start: ts.tokenStartOfNode(stmt),
|
|
end: stmt.end,
|
|
reference: null,
|
|
deferredReference: null,
|
|
folded: null,
|
|
localNames: new Map(),
|
|
});
|
|
names.add(name.text);
|
|
}
|
|
if (offence !== null) dirty = true;
|
|
}
|
|
});
|
|
if (candidates.size === 0) continue;
|
|
const rankOf = new Map(evaluation.map((m, i) => [m, i] as const));
|
|
// 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<string>();
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isImportDeclaration(stmt) || stmt.importClause === undefined) continue;
|
|
const clause = stmt.importClause;
|
|
const bound: ts.Identifier[] = 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.Identifier[] = [];
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (ts.isImportDeclaration(node)) return "skip";
|
|
if (ts.isIdentifier(node) && (names.has(node.text) || local.has(node.text)))
|
|
refs.push(node);
|
|
return undefined;
|
|
});
|
|
if (refs.length === 0) continue;
|
|
checker.prefetchSymbolNodesExact(refs);
|
|
for (const ref of refs) {
|
|
const parent = ref.parent;
|
|
if (parent !== undefined && ts.isExportSpecifier(parent)) continue;
|
|
if (inTypePosition7(ref)) continue;
|
|
let symbol = checker.getSymbolAtLocation(ref);
|
|
if (
|
|
parent !== undefined &&
|
|
ts.isShorthandPropertyAssignment(parent) &&
|
|
parent.name === ref
|
|
) {
|
|
symbol = checker.getShorthandAssignmentValueSymbol(parent) ?? symbol;
|
|
}
|
|
if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
|
|
symbol = checker.getAliasedSymbol(symbol);
|
|
}
|
|
const c = symbol === undefined ? undefined : candidates.get(symbol);
|
|
if (c === undefined || ref === c.name) continue;
|
|
if (c.folded === null && foldablePosition7(ref)) c.folded = ref;
|
|
if (c.reference !== null) continue;
|
|
// A class body names its own inner binding, initialized throughout.
|
|
if (
|
|
c.kind === "class" &&
|
|
sf === c.module &&
|
|
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: boolean;
|
|
if (sf === c.module) early = ts.tokenStartOfNode(ref) < c.start;
|
|
else if (!memberSet.has(sf) || !rankOf.has(sf)) early = false;
|
|
else early = !known || rankOf.get(sf)! < c.rank;
|
|
if (early) 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<ts.SourceFile>(order.filter((sf) => !rankOf.has(sf)));
|
|
if (known) for (const m of evaluation.slice(c.rank + 1)) settled.add(m);
|
|
out.push({
|
|
symbol: c.symbol,
|
|
name: c.name,
|
|
kind: c.kind,
|
|
module: c.module,
|
|
reference: c.reference,
|
|
...(c.folded !== null ? { folded: c.folded } : {}),
|
|
settled,
|
|
...(c.localNames.size > 0 ? { localNames: c.localNames } : {}),
|
|
});
|
|
}
|
|
}
|
|
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: ts.TypeChecker,
|
|
e: ts.Expression,
|
|
units: ts.Node[],
|
|
immediate: Map<ts.Node, ts.Node[]>,
|
|
): void {
|
|
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: ts.Expression = arg;
|
|
while (ts.isParenthesizedExpression(fn)) fn = fn.expression;
|
|
if (
|
|
(ts.isArrowFunction(fn) || ts.isFunctionExpression(fn)) &&
|
|
returnsOnlyClosuresOver7(checker, e.expression, index)
|
|
)
|
|
units.push(fn);
|
|
});
|
|
}
|
|
}
|
|
|
|
/** A binding of an import cycle and what the reference scan found. */
|
|
interface CycleCandidate7 {
|
|
symbol: ts.Symbol;
|
|
name: ts.Identifier;
|
|
kind: CycleEarlyBinding["kind"];
|
|
module: ts.SourceFile;
|
|
/** User code can run between the cycle's start and the end of the
|
|
* declaration (always true when the order is unknown). */
|
|
exposed: boolean;
|
|
rank: number;
|
|
start: number;
|
|
end: number;
|
|
/** A reference read at top level before the declaration ran. */
|
|
reference: ts.Identifier | null;
|
|
/** A deferred reference (function body, parameter default, instance
|
|
* field) when user code may run before the declaration completes. */
|
|
deferredReference: ts.Identifier | null;
|
|
folded: ts.Identifier | null;
|
|
localNames: Map<string, string>;
|
|
}
|
|
|
|
/** 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: ts.Program,
|
|
evaluation: readonly ts.SourceFile[],
|
|
candidates: ReadonlyMap<ts.Symbol, CycleCandidate7>,
|
|
): Map<ts.Symbol, ts.Identifier> | null {
|
|
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 as unknown as ts.Declaration) &
|
|
ts.ModifierFlags.Default) !==
|
|
0
|
|
)
|
|
return null;
|
|
}
|
|
}
|
|
const stored = new Set<ts.Node>();
|
|
const immediate = new Map<ts.Node, ts.Node[]>();
|
|
const storedNames: ts.Identifier[] = [];
|
|
const unitsOfName = new Map<ts.Identifier, ts.Node[]>();
|
|
const store = (name: ts.Identifier, units: ts.Node[]): void => {
|
|
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 as unknown as ts.Declaration) &
|
|
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: ts.Node[] = [];
|
|
storedCallables7(checker, d.initializer, units, immediate);
|
|
store(d.name, units);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const unitsBySymbol = new Map<ts.Symbol, ts.Node[]>();
|
|
const allUnits: ts.Node[] = [];
|
|
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: ts.Identifier[] = [];
|
|
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<string>();
|
|
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: ts.Identifier[] = [];
|
|
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: ts.Identifier): ts.Symbol | undefined => {
|
|
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: ts.Symbol): boolean =>
|
|
(symbol.flags & ts.SymbolFlags.ValueModule) !== 0 &&
|
|
symbol.declarations.some((d) => ts.isSourceFile(d) && members.has(d));
|
|
const declared = new Set<ts.Symbol>();
|
|
const reachedUnits = new Set<ts.Node>();
|
|
const out = new Map<ts.Symbol, ts.Identifier>();
|
|
const work: ts.Node[] = [];
|
|
const reach = (unit: ts.Node): void => {
|
|
if (reachedUnits.has(unit)) return;
|
|
reachedUnits.add(unit);
|
|
work.push(unit);
|
|
};
|
|
const visit = (root: ts.Node): void => {
|
|
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 = (): void => {
|
|
while (work.length > 0) visit(work.pop()!);
|
|
};
|
|
const declare = (name: ts.BindingName): void => {
|
|
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.
|
|
* Function declarations are callable from the module's start, so a call
|
|
* made by earlier top-level code (or by the declaration's own initializer)
|
|
* can observe the temporal dead zone. Reachability is syntactic: 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, and every other function-like in
|
|
* reachable code counts as reachable because it may be handed to a callee.
|
|
* A binding is reported only when one of its references in a deferred
|
|
* position is reachable before the declaration ran, so modules that call
|
|
* nothing early report nothing. Bindings of exactly-initialized cycles are
|
|
* covered by cycleEarlyBindings. */
|
|
export function moduleEarlyBindings(
|
|
program: ts.Program,
|
|
order: readonly ts.SourceFile[],
|
|
): CycleEarlyBinding[] {
|
|
const key = order.map((sf) => sf.fileName).join("\0");
|
|
const memo = program.analysis.moduleEarlyBindings;
|
|
if (memo !== null && memo.key === key) return memo.bindings;
|
|
const exact = program.analysis.exactCycleMembers;
|
|
const out: CycleEarlyBinding[] = [];
|
|
for (const sf of order) {
|
|
if (sf.isDeclarationFile || exact.has(sf)) continue;
|
|
out.push(...moduleEarlyBindingsOf7(program, sf, order));
|
|
}
|
|
program.analysis.moduleEarlyBindings = { key, bindings: out };
|
|
return out;
|
|
}
|
|
|
|
function moduleEarlyBindingsOf7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
order: readonly ts.SourceFile[],
|
|
): CycleEarlyBinding[] {
|
|
const ambient = (stmt: ts.Statement): boolean =>
|
|
(ts.getCombinedModifierFlags(stmt as unknown as ts.Declaration) & ts.ModifierFlags.Ambient) !==
|
|
0;
|
|
// Candidate bindings, by declaring statement.
|
|
interface Candidate {
|
|
name: ts.Identifier;
|
|
index: number;
|
|
start: number;
|
|
/** A class declaration: its own body sees the inner binding. */
|
|
cls?: ts.ClassDeclaration;
|
|
}
|
|
const candidates: Candidate[] = [];
|
|
const candidateNames = new Set<string>();
|
|
// Stored callables, by the name of the binding that stores them.
|
|
const stored = new Set<ts.Node>();
|
|
const storedBy = new Map<string, { name: ts.Identifier; units: ts.Node[] }[]>();
|
|
// Parts of a stored node that run where it is evaluated: a class's
|
|
// heritage, computed keys, decorators and static initializers, and a
|
|
// stored method's computed key.
|
|
const immediate = new Map<ts.Node, ts.Node[]>();
|
|
const store = (name: ts.Identifier, units: ts.Node[]): void => {
|
|
if (units.length === 0) return;
|
|
for (const u of units) stored.add(u);
|
|
const list = storedBy.get(name.text) ?? [];
|
|
list.push({ name, units });
|
|
storedBy.set(name.text, list);
|
|
};
|
|
const checker = program.getTypeChecker();
|
|
const storedIn = (e: ts.Expression, units: ts.Node[]): void =>
|
|
storedCallables7(checker, e, units, immediate);
|
|
sf.statements.nodes.forEach((stmt, index) => {
|
|
if (ambient(stmt)) return;
|
|
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]);
|
|
candidates.push({ name: stmt.name, index, start: ts.tokenStartOfNode(stmt), cls: stmt });
|
|
candidateNames.add(stmt.name.text);
|
|
} else if (ts.isVariableStatement(stmt)) {
|
|
const lexical = (stmt.declarationList.flags & (ts.NodeFlags.Let | ts.NodeFlags.Const)) !== 0;
|
|
for (const d of stmt.declarationList.declarations.nodes) {
|
|
if (ts.isIdentifier(d.name) && d.initializer !== undefined) {
|
|
const units: ts.Node[] = [];
|
|
storedIn(d.initializer, units);
|
|
store(d.name, units);
|
|
}
|
|
if (!lexical) continue;
|
|
for (const name of boundNames7(d.name)) {
|
|
candidates.push({ name, index, start: ts.tokenStartOfNode(stmt) });
|
|
candidateNames.add(name.text);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
if (candidates.length === 0) return [];
|
|
// Resolve every identifier that could name a candidate or a stored
|
|
// callable in one batch.
|
|
const idents: ts.Identifier[] = [];
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (ts.isImportDeclaration(node)) return "skip";
|
|
if (ts.isIdentifier(node) && (candidateNames.has(node.text) || storedBy.has(node.text)))
|
|
idents.push(node);
|
|
return undefined;
|
|
});
|
|
checker.prefetchSymbolNodesExact(idents);
|
|
const symbolOf = (id: ts.Identifier): ts.Symbol | undefined => {
|
|
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;
|
|
};
|
|
// A callback handed to a timer, a microtask queue, a promise reaction or
|
|
// a host (Node) API runs as a later job or event. Without top-level await
|
|
// the module's body completes before any job runs, so such a callback is
|
|
// never early. JavaScript builtins (array callbacks, the promise
|
|
// executor, replacers) and the host APIs that call back synchronously
|
|
// keep the conservative rule.
|
|
if (!hasTopLevelAwait7(sf)) {
|
|
const callbacks = (e: ts.Expression): void => {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
if (ts.isArrowFunction(e) || ts.isFunctionExpression(e)) stored.add(e);
|
|
else if (ts.isObjectLiteralExpression(e)) {
|
|
for (const p of e.properties.nodes) {
|
|
if (ts.isMethodDeclaration(p)) stored.add(p);
|
|
else if (ts.isPropertyAssignment(p)) callbacks(p.initializer);
|
|
}
|
|
}
|
|
};
|
|
ts.walkPreorder(sf, (node) => {
|
|
if (
|
|
(ts.isCallExpression(node) || ts.isNewExpression(node)) &&
|
|
laterJobCallee7(checker, node.expression)
|
|
) {
|
|
for (const arg of node.arguments?.nodes ?? []) callbacks(arg);
|
|
}
|
|
return undefined;
|
|
});
|
|
}
|
|
const unitsBySymbol = new Map<ts.Symbol, ts.Node[]>();
|
|
for (const list of storedBy.values()) {
|
|
for (const { name, units } of list) {
|
|
const symbol = checker.getSymbolAtLocation(name);
|
|
if (symbol === undefined) continue;
|
|
unitsBySymbol.set(symbol, [...(unitsBySymbol.get(symbol) ?? []), ...units]);
|
|
}
|
|
}
|
|
const candidateSymbols = new Map<ts.Symbol, Candidate>();
|
|
for (const c of candidates) {
|
|
const symbol = checker.getSymbolAtLocation(c.name);
|
|
if (symbol !== undefined) candidateSymbols.set(symbol, c);
|
|
}
|
|
// Walk reachable code, collecting the candidate references it holds.
|
|
const reachedUnits = new Set<ts.Node>();
|
|
const reachedRefs = new Map<ts.Symbol, ts.Identifier>();
|
|
const work: ts.Node[] = [];
|
|
const visit = (root: ts.Node): void => {
|
|
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 (!ts.isIdentifier(node)) return undefined;
|
|
if (!candidateNames.has(node.text) && !storedBy.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;
|
|
const c = candidateSymbols.get(symbol);
|
|
if (
|
|
c !== undefined &&
|
|
node !== c.name &&
|
|
!reachedRefs.has(symbol) &&
|
|
!(c.cls !== undefined && ts.tokenStartOfNode(node) >= c.cls.pos && node.end <= c.cls.end)
|
|
) {
|
|
if (inDeferredPosition7(node) || ts.tokenStartOfNode(node) < c.start)
|
|
reachedRefs.set(symbol, node);
|
|
}
|
|
for (const unit of unitsBySymbol.get(symbol) ?? []) {
|
|
if (reachedUnits.has(unit)) continue;
|
|
reachedUnits.add(unit);
|
|
work.push(unit);
|
|
}
|
|
return undefined;
|
|
});
|
|
};
|
|
const drain = (): void => {
|
|
while (work.length > 0) visit(work.pop()!);
|
|
};
|
|
const out: CycleEarlyBinding[] = [];
|
|
const settled = new Set(order.filter((m) => m !== sf));
|
|
let next = 0;
|
|
const report = (declaration: ts.Node): void => {
|
|
while (
|
|
next < candidates.length &&
|
|
ts.tokenStartOfNode(candidates[next]!.name) >= ts.tokenStartOfNode(declaration) &&
|
|
candidates[next]!.name.end <= declaration.end
|
|
) {
|
|
const c = candidates[next++]!;
|
|
const symbol = checker.getSymbolAtLocation(c.name);
|
|
const reference = symbol === undefined ? undefined : reachedRefs.get(symbol);
|
|
if (symbol === undefined || reference === undefined) continue;
|
|
out.push({
|
|
symbol,
|
|
name: c.name,
|
|
kind: c.cls !== undefined ? "class" : "lexical",
|
|
module: sf,
|
|
reference,
|
|
settled,
|
|
});
|
|
}
|
|
};
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (ts.isClassDeclaration(stmt)) {
|
|
// The binding initializes once the class definition, static
|
|
// initializers included, has run.
|
|
for (const part of classSyncParts7(stmt)) visit(part);
|
|
drain();
|
|
report(stmt);
|
|
} else if (ts.isVariableStatement(stmt)) {
|
|
// Declarators run in order: a later declarator's initializer cannot
|
|
// observe an earlier binding before it was initialized.
|
|
for (const d of stmt.declarationList.declarations.nodes) {
|
|
visit(d);
|
|
drain();
|
|
report(d);
|
|
}
|
|
} else if (!ts.isFunctionDeclaration(stmt)) visit(stmt);
|
|
drain();
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** True when the program function `callee` names reads its parameter
|
|
* `index` only inside function expressions it returns directly, and never
|
|
* through `arguments` in its own body: calling it cannot run that argument
|
|
* before the returned closure is called. */
|
|
function returnsOnlyClosuresOver7(
|
|
checker: ts.TypeChecker,
|
|
callee: ts.Expression,
|
|
index: number,
|
|
): boolean {
|
|
while (ts.isParenthesizedExpression(callee)) callee = callee.expression;
|
|
const name = ts.isIdentifier(callee)
|
|
? callee
|
|
: ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)
|
|
? callee.name
|
|
: undefined;
|
|
if (name === undefined) return false;
|
|
let symbol = checker.getSymbolAtLocation(name);
|
|
if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
|
|
symbol = checker.getAliasedSymbol(symbol);
|
|
}
|
|
const decls = symbol === undefined ? [] : symbol.declarations;
|
|
if (decls.length !== 1) return false;
|
|
const decl = decls[0]!;
|
|
if (ts.getSourceFileOfNode(decl).isDeclarationFile) return false;
|
|
let fn: ts.Node | undefined;
|
|
if (ts.isFunctionDeclaration(decl)) fn = decl;
|
|
else if (ts.isVariableDeclaration(decl) && decl.initializer !== undefined) {
|
|
let init: ts.Expression = decl.initializer;
|
|
while (ts.isParenthesizedExpression(init)) init = init.expression;
|
|
if (ts.isFunctionExpression(init) || ts.isArrowFunction(init)) fn = init;
|
|
}
|
|
if (fn === undefined) return false;
|
|
const like = fn as ts.FunctionLikeDeclaration;
|
|
const body = like.body;
|
|
const param = like.parameters.nodes[index];
|
|
if (body === undefined || !ts.isBlock(body) || param === undefined) return false;
|
|
if (!ts.isIdentifier(param.name) || param.dotDotDotToken !== undefined) return false;
|
|
if (like.parameters.nodes.slice(0, index).some((p) => p.dotDotDotToken !== undefined))
|
|
return false;
|
|
const paramName = param.name.text;
|
|
let deferred = true;
|
|
ts.walkPreorder(body, (node) => {
|
|
if (!deferred) return "stop";
|
|
if (ts.isFunctionLike(node) || ts.isClassExpression(node) || ts.isClassDeclaration(node)) {
|
|
let child: ts.Node = node;
|
|
while (ts.isParenthesizedExpression(child.parent)) child = child.parent;
|
|
const returned = ts.isReturnStatement(child.parent) && child.parent.expression === child;
|
|
const uses = (part: ts.Node): boolean => {
|
|
let found = false;
|
|
ts.walkPreorder(part, (inner) => {
|
|
if (ts.isIdentifier(inner) && inner.text === paramName) found = true;
|
|
return found ? "stop" : undefined;
|
|
});
|
|
return found;
|
|
};
|
|
// A returned closure may use the parameter; any other nested
|
|
// function could escape and run before the result is called. A
|
|
// returned class still evaluates its heritage, computed keys,
|
|
// decorators and static initializers when the callee runs.
|
|
if (returned) {
|
|
if (
|
|
(ts.isClassExpression(node) || ts.isClassDeclaration(node)) &&
|
|
classSyncParts7(node).some(uses)
|
|
)
|
|
deferred = false;
|
|
return "skip";
|
|
}
|
|
if (uses(node)) deferred = false;
|
|
return "skip";
|
|
}
|
|
if (ts.isIdentifier(node) && (node.text === paramName || node.text === "arguments")) {
|
|
if (node !== param.name) deferred = false;
|
|
}
|
|
return undefined;
|
|
});
|
|
return deferred;
|
|
}
|
|
|
|
/** The parts of a class that run where the class is evaluated: heritage
|
|
* 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: ts.Node): ts.ClassLikeDeclaration | undefined {
|
|
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 as ts.ClassLikeDeclaration;
|
|
if (ts.isPropertyDeclaration(n)) {
|
|
if (n.initializer !== child) return undefined;
|
|
return (ts.getCombinedModifierFlags(n) & ts.ModifierFlags.Static) !== 0
|
|
? (n.parent as ts.ClassLikeDeclaration)
|
|
: 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: ts.ClassLikeDeclaration): ts.Node[] {
|
|
const decorators = (n: ts.Node): ts.Node[] =>
|
|
((n as { modifiers?: ts.NodeArray<ts.Node> }).modifiers?.nodes ?? []).filter(
|
|
(m) => m.kind === ts.SyntaxKind.Decorator,
|
|
);
|
|
const parts: ts.Node[] = [...decorators(c), ...(c.heritageClauses?.nodes ?? [])];
|
|
for (const m of c.members.nodes) {
|
|
parts.push(...decorators(m));
|
|
const memberName = (m as { name?: ts.PropertyName }).name;
|
|
if (memberName !== undefined && ts.isComputedPropertyName(memberName)) parts.push(memberName);
|
|
if (ts.isClassStaticBlockDeclaration(m)) parts.push(m);
|
|
else if (
|
|
ts.isPropertyDeclaration(m) &&
|
|
m.initializer !== undefined &&
|
|
(ts.getCombinedModifierFlags(m) & ts.ModifierFlags.Static) !== 0
|
|
)
|
|
parts.push(m.initializer);
|
|
}
|
|
return parts;
|
|
}
|
|
|
|
/** An identifier or a chain of plain property reads. */
|
|
function memberChainKey7(e: ts.Expression): boolean {
|
|
while (ts.isPropertyAccessExpression(e)) e = e.expression;
|
|
return ts.isIdentifier(e);
|
|
}
|
|
|
|
/** The name a declaration node binds, if any. */
|
|
function declaredName7(node: ts.Node): ts.Node | undefined {
|
|
if (
|
|
ts.isVariableDeclaration(node) ||
|
|
ts.isFunctionDeclaration(node) ||
|
|
ts.isFunctionExpression(node) ||
|
|
ts.isClassDeclaration(node) ||
|
|
ts.isClassExpression(node) ||
|
|
ts.isBindingElement(node) ||
|
|
ts.isParameter(node)
|
|
)
|
|
return node.name;
|
|
return undefined;
|
|
}
|
|
|
|
/** A declared builtin whose callback arguments run only as later jobs or
|
|
* events: the timers, queueMicrotask, promise reactions, and Node APIs
|
|
* other than the ones that call back before returning. */
|
|
function laterJobCallee7(checker: ts.TypeChecker, callee: ts.Expression): boolean {
|
|
while (ts.isParenthesizedExpression(callee)) callee = callee.expression;
|
|
let name: ts.Identifier;
|
|
if (ts.isIdentifier(callee)) name = callee;
|
|
else if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.name)) {
|
|
name = callee.name;
|
|
} else return false;
|
|
if (SYNC_CALLBACK_HOST_APIS7.has(name.text)) return false;
|
|
let root: ts.Expression = callee;
|
|
while (ts.isPropertyAccessExpression(root)) root = root.expression;
|
|
if (ts.isIdentifier(root) && root.text === "assert") return false;
|
|
let symbol = checker.getSymbolAtLocation(name);
|
|
if (symbol !== undefined && symbol.flags & ts.SymbolFlags.Alias) {
|
|
symbol = checker.getAliasedSymbol(symbol);
|
|
}
|
|
if (symbol === undefined) return false;
|
|
const decls = symbol.declarations;
|
|
if (decls.length === 0 || !decls.every((d) => ts.getSourceFileOfNode(d).isDeclarationFile))
|
|
return false;
|
|
if (LATER_JOB_BUILTINS7.has(name.text)) return true;
|
|
// The JavaScript standard library's callbacks mostly run synchronously;
|
|
// package declarations describe user code.
|
|
return decls.every((d) => {
|
|
const file = ts.getSourceFileOfNode(d).fileName;
|
|
return isNodeTypesPath(file) || file === fallbackDtsPath();
|
|
});
|
|
}
|
|
|
|
/** Standard-library functions whose callbacks run as later jobs. */
|
|
const LATER_JOB_BUILTINS7 = new Set([
|
|
"setTimeout",
|
|
"setInterval",
|
|
"setImmediate",
|
|
"queueMicrotask",
|
|
"then",
|
|
"catch",
|
|
"finally",
|
|
]);
|
|
|
|
/** Host APIs that can invoke a callback argument before returning. */
|
|
const SYNC_CALLBACK_HOST_APIS7 = new Set([
|
|
"apply",
|
|
"bind",
|
|
"call",
|
|
"doesNotReject",
|
|
"doesNotThrow",
|
|
"emit",
|
|
"enterWith",
|
|
"exit",
|
|
"rejects",
|
|
"run",
|
|
"runInAsyncScope",
|
|
"throws",
|
|
]);
|
|
|
|
/** True for a reference whose value the lowering can take from the
|
|
* binding's checker type instead of its storage: a property key (element
|
|
* access argument, computed name, `in` operand, through parentheses,
|
|
* casts and template spans) or a `typeof` operand. */
|
|
function foldablePosition7(ref: ts.Identifier): boolean {
|
|
let child: ts.Node = ref;
|
|
for (let p: ts.Node | undefined = ref.parent; p !== undefined; p = p.parent) {
|
|
if (
|
|
ts.isParenthesizedExpression(p) ||
|
|
ts.isAsExpression(p) ||
|
|
ts.isSatisfiesExpression(p) ||
|
|
ts.isNonNullExpression(p) ||
|
|
ts.isTemplateSpan(p) ||
|
|
ts.isTemplateExpression(p)
|
|
) {
|
|
child = p;
|
|
continue;
|
|
}
|
|
if (ts.isTypeOfExpression(p)) return true;
|
|
if (ts.isElementAccessExpression(p)) return p.argumentExpression === child;
|
|
if (ts.isComputedPropertyName(p)) return true;
|
|
if (ts.isBinaryExpression(p))
|
|
return p.operatorToken.kind === ts.SyntaxKind.InKeyword && p.left === child;
|
|
return false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** The identifiers a binding name (identifier or destructuring pattern)
|
|
* declares. */
|
|
function boundNames7(name: ts.BindingName): ts.Identifier[] {
|
|
if (ts.isIdentifier(name)) return [name];
|
|
const out: ts.Identifier[] = [];
|
|
for (const el of name.elements.nodes) {
|
|
if (ts.isOmittedExpression(el) || el.name === undefined) continue;
|
|
out.push(...boundNames7(el.name));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** A namespace declaration whose body holds only types (interfaces, type
|
|
* aliases, nested type-only namespaces) — no runtime object exists. */
|
|
function typeOnlyNamespace7(decl: ts.ModuleDeclaration): boolean {
|
|
let body = decl.body;
|
|
while (body !== undefined && ts.isModuleDeclaration(body)) body = body.body;
|
|
if (body === undefined || !ts.isModuleBlock(body)) return true;
|
|
return body.statements.nodes.every(
|
|
(s) =>
|
|
ts.isInterfaceDeclaration(s) ||
|
|
ts.isTypeAliasDeclaration(s) ||
|
|
(ts.isModuleDeclaration(s) && typeOnlyNamespace7(s)),
|
|
);
|
|
}
|
|
|
|
/** Resolves an import specifier from `from` to a source file of the
|
|
* program, or null (unresolvable / outside the program). Exported (as
|
|
* resolveImport) for the lowering: CommonJS require statements lower to
|
|
* guarded %init calls of exactly the module preflight resolved here. */
|
|
function resolveImport7(
|
|
program: ts.Program,
|
|
from: ts.SourceFile,
|
|
specifier: string,
|
|
resolutionKind: "import" | "require" = "import",
|
|
): ts.SourceFile | null {
|
|
const resolved = resolveProjectModule(from.fileName, specifier);
|
|
if (resolved !== null) return program.getSourceFile(resolved) ?? null;
|
|
const npm = resolveNpmImport7(from.fileName, specifier, resolutionKind);
|
|
return npm && isNpmStaticPackage(npm.packageName)
|
|
? npmStaticProgramDep(program, npm.packageName, npm.typesFile)
|
|
: null;
|
|
}
|
|
|
|
function resolveNpmImport7(
|
|
fromFileName: string,
|
|
specifier: string,
|
|
resolutionKind: "import" | "require" = "import",
|
|
): { packageName: string; version?: string; typesFile: string } | null {
|
|
if (isRelativeSpecifier(specifier) || specifier.startsWith("node:")) {
|
|
return null;
|
|
}
|
|
// Node resolves a bare core-module name (`string_decoder`, `events`,
|
|
// `fs/promises`) to the builtin before it looks in node_modules, so an
|
|
// installed npm package of the same name never answers it. Prefix-only
|
|
// builtins (`node:test`) are listed with their prefix, so a bare `test`
|
|
// still names the package.
|
|
if (nodeBuiltinNames.has(specifier)) return null;
|
|
// --provenance-sources: a registered specifier is NOT an npm 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;
|
|
if (!isNodeModulesPath(resolved.typesFile)) {
|
|
// A workspace-linked package (the node_modules entry is a symlink into
|
|
// the project — every monorepo tool's internal-package install): Node
|
|
// resolves and runs it exactly like any installed package, so it IS an
|
|
// npm import; the realpath'd answer escaping node_modules must not
|
|
// refuse the edge. Registered so path-keyed package attribution
|
|
// (workspace-registry.ts) recognizes the package's real files. Anything else
|
|
// whose answer left node_modules stays refused.
|
|
if (resolved.workspaceDir === undefined) return null;
|
|
registerWorkspacePackage(resolved.packageName, resolved.workspaceDir);
|
|
}
|
|
return {
|
|
packageName: resolved.packageName,
|
|
...(resolved.version !== undefined ? { version: resolved.version } : {}),
|
|
typesFile: resolved.typesFile,
|
|
};
|
|
}
|
|
|
|
function locOf7(node: ts.Node): { file: string; start: number; end: number } {
|
|
const sf = ts.getSourceFileOfNode(node);
|
|
return { file: sf.fileName, start: ts.tokenStartOfNode(node), end: node.end };
|
|
}
|
|
|
|
/** The program file holding an opted-in package's resolved runtime JS:
|
|
* the file itself, or its same-stem TypeScript twin. */
|
|
function npmStaticProgramFile(program: ts.Program, resolvedFile: string): ts.SourceFile | null {
|
|
let dep = program.getSourceFile(resolvedFile) ?? null;
|
|
if (dep === null) {
|
|
// A workspace-linked package shipping its .ts SOURCE beside the
|
|
// compiled .js: the checker's resolution preferred the source (it
|
|
// outranks the sibling .js under bundler resolution), so the program
|
|
// holds the .ts twin at the same stem — the same module, in its
|
|
// richer spelling.
|
|
for (const ext of [".ts", ".tsx", ".mts", ".cts"]) {
|
|
dep = program.getSourceFile(resolvedFile.replace(/\.(js|mjs|cjs)$/, ext)) ?? null;
|
|
if (dep !== null) break;
|
|
}
|
|
}
|
|
return dep;
|
|
}
|
|
|
|
/** The PROGRAM source file an opted-in --npm-static package's resolved
|
|
* entry maps to, or null with the package marked an offender (resolution
|
|
* still answering declarations, or the file missing from the type-checked
|
|
* program — a path-identity mismatch between the two resolvers). */
|
|
function npmStaticProgramDep(
|
|
program: ts.Program,
|
|
packageName: string,
|
|
resolvedFile: string,
|
|
): ts.SourceFile | null {
|
|
if (!isJsSourceFileName(resolvedFile)) {
|
|
reportNpmStaticOffender(
|
|
packageName,
|
|
`its import resolves to '${resolvedFile}', not to runtime JavaScript`,
|
|
);
|
|
return null;
|
|
}
|
|
const dep = npmStaticProgramFile(program, resolvedFile);
|
|
if (dep === null) {
|
|
reportNpmStaticOffender(
|
|
packageName,
|
|
`its entry '${resolvedFile}' did not join the type-checked program`,
|
|
);
|
|
return null;
|
|
}
|
|
return dep;
|
|
}
|
|
|
|
/** `const process = require('node:process')` (identifier binding) and the
|
|
* bare side-effect `require('node:process')`: Node's process module IS
|
|
* the global process object, so the binding is a stdlib-global alias
|
|
* (surfaces.ts registers it; reads lower through the process surface) and
|
|
* the bare load is a no-op. These forms are exempt from the SC1010
|
|
* builtin fence; every other shape (destructuring, subpath) keeps it. */
|
|
function processModuleAliasRequire7(spec: string, decl: ts.VariableDeclaration | null): boolean {
|
|
if (spec !== "process" && spec !== "node:process") return false;
|
|
return decl === null || ts.isIdentifier(decl.name);
|
|
}
|
|
|
|
/** `import process from 'node:process'`: the ESM spelling of the same
|
|
* global-object alias as processModuleAliasRequire7. Keep this exemption
|
|
* deliberately narrow: named and namespace imports need a represented
|
|
* module namespace, while the default binding is exactly globalThis.process. */
|
|
function processModuleAliasImport7(spec: string, stmt: ts.ImportDeclaration): boolean {
|
|
if (spec !== "process" && spec !== "node:process") return false;
|
|
const clause = stmt.importClause;
|
|
return clause !== undefined && clause.name !== undefined && clause.namedBindings === undefined;
|
|
}
|
|
|
|
/** The whole TS7-lane lifecycle for one entry: spawn (or share) a tsgo
|
|
* host, build the lowering-world program, run preflight, and release its
|
|
* snapshot. The caller owns the supplied host and can reuse or close it. */
|
|
export function checkPreflightTs7(
|
|
entryPath: string,
|
|
host: ts.Ts7Host,
|
|
): { diags: ScrDiagnostic[]; moduleOrder: string[] } {
|
|
const load = loadProgram7(host, resolve(entryPath));
|
|
try {
|
|
const { diags, moduleOrder } = preflight7(load);
|
|
return { diags, moduleOrder: moduleOrder.map((sf) => sf.fileName) };
|
|
} finally {
|
|
load.disposeAll();
|
|
}
|
|
}
|
|
|
|
function preflight7(load: LoadResult): {
|
|
diags: ScrDiagnostic[];
|
|
moduleOrder: ts.SourceFile[];
|
|
startupCrash: StartupCrash | null;
|
|
inlineRequireCycleCalls: ReadonlySet<ts.Node>;
|
|
moduleEdges?: ReadonlyMap<ts.SourceFile, readonly CycleEdge[]>;
|
|
} {
|
|
const { program, entry } = load;
|
|
const diags: ScrDiagnostic[] = [...load.configDiags];
|
|
|
|
// An explicit entry can itself live in an installed package. Its own
|
|
// source files are program code, including relative barrels and sibling
|
|
// modules; their location must not erase the module graph.
|
|
// Match the full installed directory, not just the package name, and
|
|
// exclude nested installations so dependencies keep their npm policy.
|
|
const entryPackageFile = entryPackageFilePredicate(entry.fileName);
|
|
|
|
// Workspace-linked packages register BEFORE the tsc gate. Their files
|
|
// live at realpaths OUTSIDE node_modules (the monorepo-tool symlink
|
|
// shape), so nothing path-shaped marks them as npm surface — yet their
|
|
// shipped JS follows the same foreign-tsconfig rules as node_modules JS.
|
|
// The lazy
|
|
// registration inside the import-fence walk below runs AFTER errorsOf,
|
|
// too late for the gate, so one pass over the program's import edges
|
|
// registers them up front: every bare specifier any program file loads —
|
|
// import/export declarations, dynamic import("literal") (tsgo chases
|
|
// those into the program too; a CLI reaches its workspace sibling exactly
|
|
// that way), require("literal") — resolved with the own resolver,
|
|
// workspace answers recorded.
|
|
{
|
|
const supportedBuiltins = new Set<string>(SUPPORTED_NODE_MODULES);
|
|
const probed = new Set<string>();
|
|
const probe = (fromFile: string, spec: string): void => {
|
|
if (
|
|
isRelativeSpecifier(spec) ||
|
|
spec.startsWith("#") ||
|
|
spec.startsWith("node:") ||
|
|
supportedBuiltins.has(spec)
|
|
) {
|
|
return;
|
|
}
|
|
const key = `${dirname(fromFile)} ${spec}`;
|
|
if (probed.has(key)) return;
|
|
probed.add(key);
|
|
const r = resolveBareModule(fromFile, spec);
|
|
if (r !== null && r.workspaceDir !== undefined)
|
|
registerWorkspacePackage(r.packageName, r.workspaceDir);
|
|
};
|
|
for (const sf of program.getImplementationSourceFiles()) {
|
|
if (sf.isDeclarationFile || sf.fileName.endsWith(".json")) continue;
|
|
for (const specifier of moduleSourceCandidates(program, sf).specifiers)
|
|
probe(sf.fileName, specifier);
|
|
}
|
|
}
|
|
|
|
const toPassthrough = (d: ts.Diagnostic): ScrDiagnostic => {
|
|
const message = ts.flattenDiagnosticMessageText(d, "\n");
|
|
// File-less (global/options) diagnostics anchor at the entry with a
|
|
// zero span, exactly like the 5.9.3 lane's `d.start ?? 0` fallback.
|
|
const file = d.fileName ?? entry.fileName;
|
|
const start = d.fileName !== undefined ? d.pos : 0;
|
|
const end = d.fileName !== undefined ? d.end : 0;
|
|
const diag = tscPassthroughDiag(message, { file, start, end });
|
|
const hint = typeWorldHint(d, message, load);
|
|
if (hint !== null) {
|
|
diag.typeWorld = true;
|
|
diag.hint = hint;
|
|
}
|
|
return diag;
|
|
};
|
|
/* TS7 checker change (not finding 5, same discipline): tsgo types a
|
|
* NAMESPACE import as the spec's non-callable module namespace object
|
|
* even when the module is declared with the callable `export =` shape —
|
|
* 5.9.3 bound the callable value directly, so `import * as a from
|
|
* "node:assert"; a(x)` typechecked there and draws TS2349 here. Those
|
|
* callable module objects are scriptc's OWN declared surface, and calls
|
|
* through the namespace binding are fenced per site by the lowering (the
|
|
* assert-fences fixture pins the wording), so tsgo's extra TS2349 on
|
|
* exactly those callees — an identifier that is a namespace-import
|
|
* binding of a supported builtin module — is suppressed to the 5.9.3
|
|
* verdict. Nothing else rides this: any other non-callable call keeps
|
|
* tsc's voice in both lanes. */
|
|
const builtinNamespaceNames = new Map<string, Set<string>>();
|
|
const namespaceCalleeSuppressed = (p: ts.Program, d: ts.Diagnostic): boolean => {
|
|
if (d.code !== 2349 || d.fileName === undefined) return false;
|
|
let names = builtinNamespaceNames.get(d.fileName);
|
|
if (!names) {
|
|
names = new Set();
|
|
builtinNamespaceNames.set(d.fileName, names);
|
|
const sf = p.getSourceFile(d.fileName);
|
|
for (const stmt of sf?.statements?.nodes ?? []) {
|
|
if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null) continue;
|
|
const bindings = stmt.importClause?.namedBindings;
|
|
if (bindings && ts.isNamespaceImport(bindings)) names.add(bindings.name.text);
|
|
}
|
|
}
|
|
if (names.size === 0) return false;
|
|
const sf = p.getSourceFile(d.fileName);
|
|
return sf !== undefined && names.has(sf.text.slice(d.pos, d.end));
|
|
};
|
|
|
|
const npmStaticFileSuppressed = (d: ts.Diagnostic): boolean =>
|
|
d.fileName !== undefined && npmStaticPackageOfPath(d.fileName) !== null;
|
|
|
|
const unselectedPackageJsFile = (file: string): boolean =>
|
|
isJsSourceFileName(file) &&
|
|
!entryPackageFile(file) &&
|
|
npmStaticPackageOfPath(file) === null &&
|
|
(isNodeModulesPath(file) || workspacePackageOfPath(file) !== null);
|
|
const nodeModulesJsSuppressed = (d: ts.Diagnostic): boolean =>
|
|
d.fileName !== undefined && unselectedPackageJsFile(d.fileName);
|
|
/* JSDoc TYPE positions in JS files are documentation Node never reads:
|
|
* a name-resolution failure THERE (2304/2552 — the pattern's utilities.js
|
|
* spells a mapped type over a @template name it never declared) types
|
|
* as the error-any and the per-site fences apply, same stance as the
|
|
* strictness families above. A 2300 duplicate-identifier PAIR formed by
|
|
* a @typedef and a same-named class/function is the same story — the
|
|
* typedef half sits inside the comment, and the code half is suppressed
|
|
* exactly when its partner (same file, same name) was comment-side, so
|
|
* a REAL duplicate declaration (both halves in code — Node's own
|
|
* SyntaxError) keeps tsc's voice. */
|
|
const insideBlockComment = (text: string, pos: number): boolean => {
|
|
const open = text.lastIndexOf("/*", pos);
|
|
if (open < 0) return false;
|
|
const close = text.indexOf("*/", open + 2);
|
|
return close === -1 || close >= pos;
|
|
};
|
|
const jsdocTypeSuppressed = (
|
|
p: ts.Program,
|
|
d: ts.Diagnostic,
|
|
commentDup: Set<string>,
|
|
): boolean => {
|
|
if (d.fileName === undefined || !isJsSourceFileName(d.fileName)) return false;
|
|
if (d.code !== 2304 && d.code !== 2552 && d.code !== 2300 && d.code !== 1003) return false;
|
|
if (d.pos === undefined) return false;
|
|
const sf = p.getSourceFile(d.fileName);
|
|
if (!sf) return false;
|
|
if (insideBlockComment(sf.text, d.pos)) 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: ts.Program, d: ts.Diagnostic): boolean => {
|
|
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: ts.Program, d: ts.Diagnostic): boolean => {
|
|
if (d.code !== 7016 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
|
|
return false;
|
|
const sf = p.getSourceFile(d.fileName);
|
|
if (!sf) return false;
|
|
const spec = sf.text.slice(d.pos, d.end).replace(/^['"]|['"]$/g, "");
|
|
const prefix = spec.startsWith("@")
|
|
? spec.split("/").slice(0, 2).join("/")
|
|
: spec.split("/")[0]!;
|
|
return isWorkspacePackageName(prefix);
|
|
};
|
|
// A JavaScript file that TypeScript checks keeps the type errors that
|
|
// protect its JSDoc types: a value of another type reaching a typed slot,
|
|
// a call with the wrong arity, and a subclass member that does not
|
|
// match its base.
|
|
const projectCheckJs = load.typeWorld?.projectCheckJs ?? false;
|
|
const enforcedInCheckedJs = (p: ts.Program, d: ts.Diagnostic): boolean => {
|
|
if (!CHECKED_JS_ENFORCED_CODES.has(d.code) || d.fileName === undefined) return false;
|
|
const sf = p.getSourceFile(d.fileName);
|
|
return sf !== undefined && isCheckedJsSourceFile(sf, projectCheckJs);
|
|
};
|
|
const errorsOf = (p: ts.Program): ts.Diagnostic[] => keptErrors(p, ts.getPreEmitDiagnostics(p));
|
|
const keptErrors = (p: ts.Program, all: readonly ts.Diagnostic[]): ts.Diagnostic[] => {
|
|
// First pass: every comment-side 2300's (file, name) — the partners
|
|
// the second pass forgives.
|
|
const commentDup = new Set<string>();
|
|
for (const d of all) {
|
|
if (d.code !== 2300 || d.fileName === undefined || d.pos === undefined || d.end === undefined)
|
|
continue;
|
|
if (!isJsSourceFileName(d.fileName)) continue;
|
|
const sf = p.getSourceFile(d.fileName);
|
|
if (sf && insideBlockComment(sf.text, d.pos))
|
|
commentDup.add(`${d.fileName}:${sf.text.slice(d.pos, d.end)}`);
|
|
}
|
|
return all.filter(
|
|
(d) =>
|
|
d.category === ts.DiagnosticCategory.Error &&
|
|
(!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
|
|
// includes the divergence overrides (JSON.parse(): unknown, the Promise
|
|
// executor shape, ...), which are TIGHTER than the standard lib — a
|
|
// project that typechecks clean under its own tsc can still error here
|
|
// (any-typed JSON.parse results, most commonly). Those errors are OURS,
|
|
// not the project's, so they must not fail preflight: when the lowering
|
|
// world has errors, the PROJECT world (same program without the override
|
|
// declarations) is built and consulted. Clean there → preflight passes
|
|
// and the override-affected sites meet the lowerer's honest fences
|
|
// 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.
|
|
// 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) {
|
|
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
|
|
// structural preflight checker queries, so a miss cannot trigger the old
|
|
// whole-file sweep (and eagerly fetch every dead body's answers). The
|
|
// structure wave includes declaration headers and top-level code;
|
|
// reachable bodies are added by lowering's worklists.
|
|
const ambient = ambientDtsPath();
|
|
const programFiles = program
|
|
.getImplementationSourceFiles()
|
|
.filter(
|
|
(sf) =>
|
|
sf.fileName !== ambient &&
|
|
!sf.isDeclarationFile &&
|
|
!sf.fileName.endsWith(".json") &&
|
|
(!isNodeModulesPath(sf.fileName) ||
|
|
entryPackageFile(sf.fileName) ||
|
|
npmStaticPackageOfPath(sf.fileName) !== null) &&
|
|
!unselectedPackageJsFile(sf.fileName),
|
|
);
|
|
// Files reached only through `import type` / `export type … from` are
|
|
// checker input, never program modules: Node does not load them, so
|
|
// their imports and syntax must not fence the program.
|
|
const resolveRuntimeEdge = (
|
|
sf: ts.SourceFile,
|
|
spec: string,
|
|
resolutionKind?: "import" | "require",
|
|
): ts.SourceFile | null =>
|
|
resolveImport7(program, sf, spec, resolutionKind) ??
|
|
npmStaticDepSf7(program, sf, spec, resolutionKind);
|
|
const typeOnlyFiles = typeOnlyReachedFiles(
|
|
program,
|
|
entry,
|
|
programFiles,
|
|
() => [
|
|
...forkTargetPaths(program, program.getImplementationSourceFiles()),
|
|
...workerTargetPaths(program, program.getImplementationSourceFiles()),
|
|
],
|
|
resolveRuntimeEdge,
|
|
);
|
|
const runtimeFiles =
|
|
typeOnlyFiles.size === 0 ? programFiles : programFiles.filter((sf) => !typeOnlyFiles.has(sf));
|
|
const userFiles = npmStaticActive()
|
|
? planNpmStaticReexports(
|
|
program,
|
|
entry,
|
|
runtimeFiles,
|
|
[
|
|
...createRequireProgramRoots7(program),
|
|
...forkTargetPaths(program, program.getImplementationSourceFiles()),
|
|
...workerTargetPaths(program, program.getImplementationSourceFiles()),
|
|
],
|
|
resolveRuntimeEdge,
|
|
)
|
|
: runtimeFiles;
|
|
program.getTypeChecker().prefetchSourceFileStructures(userFiles);
|
|
|
|
// Unselected node_modules JS is not native program source even when
|
|
// maxNodeModuleJsDepth pulled it into the checker (nodeModulesJsSuppressed).
|
|
// Node stops at the nearest package.json even when it is malformed, and
|
|
// an explicit CommonJS scope (or .cjs/.cts extension) disables ambiguous-
|
|
// file syntax detection entirely. TypeScript's bundler checker models
|
|
// neither loader rule, so restore them before any module-edge analysis:
|
|
// one malformed-scope diagnostic per package file, and one pointed syntax
|
|
// diagnostic per CommonJS source file.
|
|
const invalidPackageConfigs = new Set<string>();
|
|
for (const sf of userFiles) {
|
|
const invalidConfig = nearestInvalidPackageJsonPath(sf.fileName);
|
|
if (invalidConfig !== null) {
|
|
if (!invalidPackageConfigs.has(invalidConfig)) {
|
|
invalidPackageConfigs.add(invalidConfig);
|
|
diags.push(
|
|
invalidPackageConfigDiag(invalidConfig, { file: sf.fileName, start: 0, end: 0 }),
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
if (!isNodeEsmFile7(sf, program)) {
|
|
const marker = nodeEsmSyntaxMarker7(sf);
|
|
if (marker !== null) diags.push(commonJsModuleSyntaxDiag(locOf7(marker)));
|
|
}
|
|
}
|
|
|
|
const ambientModules = new Set<string>(SUPPORTED_NODE_MODULES);
|
|
|
|
// Ambient `declare module "name"` declarations anywhere in the program —
|
|
// exact names and `*` patterns — so the import fence can say "type
|
|
// surface only, no runtime module" instead of the generic package story.
|
|
// Computed lazily: the scan only runs when a bare-import fence is about
|
|
// to fire.
|
|
let ambientModuleDecls: { names: Set<string>; patterns: string[] } | null = null;
|
|
const ambientDeclared = (spec: string): boolean => {
|
|
if (ambientModuleDecls === null) {
|
|
ambientModuleDecls = { names: new Set(), patterns: [] };
|
|
for (const f of program.getSourceFiles()) {
|
|
for (const s of f.statements.nodes) {
|
|
if (!ts.isModuleDeclaration(s) || !ts.isStringLiteral(s.name)) continue;
|
|
const name = s.name.text;
|
|
if (name.includes("*")) ambientModuleDecls.patterns.push(name);
|
|
else ambientModuleDecls.names.add(name);
|
|
}
|
|
}
|
|
}
|
|
if (ambientModuleDecls.names.has(spec)) return true;
|
|
return ambientModuleDecls.patterns.some((p) => {
|
|
const star = p.indexOf("*");
|
|
return (
|
|
spec.length >= p.length - 1 &&
|
|
spec.startsWith(p.slice(0, star)) &&
|
|
spec.endsWith(p.slice(star + 1))
|
|
);
|
|
});
|
|
};
|
|
|
|
// Module edges. An edge that closes a cycle is judged by the shared
|
|
// admission engine (makeCycleAdmission): admissible when nothing can
|
|
// OBSERVE the partially-initialized module through it — the importing
|
|
// statement binds nothing (side-effect import) or binds only NAMESPACE
|
|
// objects (initialized at link, never TDZ) whose every use is a bare
|
|
// expression statement (the no-op lowering; no member is ever read),
|
|
// or the cycle passes the declaration-only init window analysis (the
|
|
// benign-cycle admission block above). Node evaluates such cycles
|
|
// benignly (the revisited module is a cache hit, and no binding read
|
|
// can hit TDZ or a stale slot), so the guarded %init calls reproduce
|
|
// its order exactly. Cycles that fail both are judged by the exact
|
|
// initialization rule: admitted when every early read is modeled by an
|
|
// initialization check, fenced with SC1016 otherwise.
|
|
const edges = new Map<ts.SourceFile, CycleEdge[]>();
|
|
// Import edges Node's RESOLUTION refuses before any module evaluates —
|
|
// recorded in source order per file (interleaved with the resolved deps
|
|
// via `pos`) so the Node-order walk below can answer which refusal Node
|
|
// reports first. Each carries a fallback fence: a refusal in a module
|
|
// the entry never reaches contributes no startup crash (Node never
|
|
// resolves it), so it keeps today's compile-time diagnostic instead.
|
|
interface RefusalCandidate {
|
|
crash: StartupCrash;
|
|
fallback: ScrDiagnostic;
|
|
pos: number;
|
|
}
|
|
const refusals = new Map<ts.SourceFile, RefusalCandidate[]>();
|
|
const depPositions = new Map<ts.SourceFile, { dep: ts.SourceFile; pos: number }[]>();
|
|
for (const sf of userFiles) {
|
|
const deps: CycleEdge[] = [];
|
|
edges.set(sf, deps);
|
|
refusals.set(sf, []);
|
|
depPositions.set(sf, []);
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (ts.isImportEqualsDeclaration(stmt)) {
|
|
// The ENTITY form (`import a = A`, `import x = N.y`) is namespace
|
|
// alias plumbing — the lowerer resolves references through it and
|
|
// fences what it cannot honor (lower-namespaces.ts). Only the
|
|
// require form is a module edge, and its RUNTIME form stays fenced
|
|
// (under the forced ESNext module world tsc itself rejects it, so
|
|
// only nested/namespace-internal sites can reach the lowering's
|
|
// fence); `import type x = require(...)` is pure type surface and
|
|
// lowers to nothing.
|
|
if (ts.isExternalModuleReference(stmt.moduleReference) && !stmt.isTypeOnly) {
|
|
const spec = stmt.moduleReference.expression;
|
|
if (
|
|
spec !== undefined &&
|
|
ts.isStringLiteralLike(spec) &&
|
|
load.externalTypes.has(spec.text)
|
|
) {
|
|
diags.push(externalHostModuleDiag7(spec.text, stmt));
|
|
} else {
|
|
diags.push(
|
|
unsupportedDiag("SC1013", locOf7(stmt), "import = require(...) assignments"),
|
|
);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isExportAssignment(stmt)) {
|
|
if (stmt.isExportEquals) {
|
|
diags.push(unsupportedDiag("SC1012", locOf7(stmt), "export = assignments"));
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isExportDeclaration(stmt)) {
|
|
if (stmt.isTypeOnly || isPrunedNpmReexport(program, stmt)) continue;
|
|
if (!stmt.moduleSpecifier) continue;
|
|
const fromSpec = ts.isStringLiteral(stmt.moduleSpecifier) ? stmt.moduleSpecifier.text : "";
|
|
if (load.externalTypes.has(fromSpec)) {
|
|
diags.push(externalHostModuleDiag7(fromSpec, stmt));
|
|
continue;
|
|
}
|
|
const projectReexport = resolveImport7(program, sf, fromSpec);
|
|
if (!isRelativeSpecifier(fromSpec) && projectReexport === null) {
|
|
// NAMED re-exports from a SUPPORTED builtin pass (`export { ok }
|
|
// from "node:assert"` — a universal re-export facade facade): the
|
|
// statement binds nothing locally and evaluates nothing (builtins
|
|
// have no %init), and importers' references chase the alias to
|
|
// the builtin's own declarations exactly as if they imported the
|
|
// builtin directly — per-member support stays the lowering's
|
|
// per-site business. Star and namespace re-exports and package
|
|
// specifiers keep the fence.
|
|
if (
|
|
canonicalBuiltinModule(fromSpec) !== null &&
|
|
stmt.exportClause !== undefined &&
|
|
ts.isNamedExports(stmt.exportClause)
|
|
) {
|
|
continue;
|
|
}
|
|
// NAMED re-exports from an INSTALLED npm package (`export
|
|
// { isUrl } from "url-or-path"` — the pattern's universal facade,
|
|
// `export { visitorKeys as default } from "@glimmer/syntax"`):
|
|
// import-plus-export plumbing. The lowering owns the package
|
|
// value diagnostic when no compiled source can supply the binding.
|
|
if (
|
|
stmt.exportClause !== undefined &&
|
|
ts.isNamedExports(stmt.exportClause) &&
|
|
!fromSpec.startsWith("#") &&
|
|
resolveNpmImport7(sf.fileName, fromSpec) !== null
|
|
) {
|
|
continue;
|
|
}
|
|
diags.push(
|
|
unsupportedDiag("SC1014", locOf7(stmt), "re-exports from packages or builtin modules"),
|
|
);
|
|
continue;
|
|
}
|
|
const reDep = projectReexport;
|
|
// `export * as ns from "./m"` re-exports the module NAMESPACE
|
|
// object under a name: importers' `x.ns.member` reads resolve
|
|
// statically through the same alias machinery as `import * as ns`
|
|
// (moduleNsSymbolOf follows the chain to the module symbol), so a
|
|
// RESOLVED user module lowers; everything else keeps the fence —
|
|
// there is no namespace object to materialize.
|
|
if (stmt.exportClause && ts.isNamespaceExport(stmt.exportClause)) {
|
|
if (reDep === null || reDep.fileName.endsWith(".json") || isCjsJsFile7(reDep, program)) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
locOf7(stmt),
|
|
"namespace re-exports (export * as ns) of this module form",
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
if (reDep && !reDep.fileName.endsWith(".json")) {
|
|
deps.push({ dep: reDep, stmt });
|
|
depPositions.get(sf)!.push({ dep: reDep, pos: ts.tokenStartOfNode(stmt) });
|
|
}
|
|
continue;
|
|
}
|
|
if (!ts.isImportDeclaration(stmt)) continue;
|
|
if (erasedTypeOnlyImport(stmt)) continue;
|
|
|
|
// Import-like nodes whose specifier the parse could not shape into a
|
|
// string literal — the jsdoc `/** @import x = require(...) */`
|
|
// materialization and `import defer type * as ns` both arrive here
|
|
// with no specifier text. Neither is a runtime module edge (both are
|
|
// type-only forms), and where the form is malformed TS the SC0001
|
|
// passthrough above already names it — never a crash here.
|
|
const specNode: ts.Expression | undefined = stmt.moduleSpecifier;
|
|
if (specNode === undefined || !ts.isStringLiteral(specNode)) continue;
|
|
const spec = specNode.text;
|
|
if (load.externalTypes.has(spec)) {
|
|
diags.push(externalHostModuleDiag7(spec, stmt));
|
|
continue;
|
|
}
|
|
const isRelative = isRelativeSpecifier(spec);
|
|
const isBare = !isRelative && !ambientModules.has(spec);
|
|
// Npm packages can use the same static createRequire forms as program
|
|
// code. Preserve fallback for bundler banners that pass the require
|
|
// value around or feed it computed specifiers during initialization.
|
|
if (canonicalBuiltinModule(spec) === "module") {
|
|
const pkg = npmStaticPackageOfPath(sf.fileName);
|
|
if (pkg !== null) {
|
|
const reason = npmStaticModuleImportReason7(program, stmt);
|
|
if (reason !== null) reportNpmStaticOffender(pkg, reason);
|
|
}
|
|
}
|
|
// An import edge Node's own resolution refuses BEFORE any module
|
|
// evaluates: recorded as a startup-crash candidate (the Node-order
|
|
// walk below picks the first one Node would report; the program
|
|
// compiles to exactly that crash — buildMain) with a compile-fence
|
|
// fallback for candidates the entry never reaches. The bindings of a
|
|
// refused edge never link, so every clause fence below is skipped —
|
|
// their uses meet the lowering's own fences if the code demands
|
|
// values from them.
|
|
const refuse = (
|
|
message: string,
|
|
className: StartupCrash["className"],
|
|
fallbackFeature: string,
|
|
): void => {
|
|
refusals.get(sf)!.push({
|
|
crash: { message, className, loc: locOf7(stmt) },
|
|
fallback: unsupportedDiag("SC1010", locOf7(stmt), fallbackFeature),
|
|
pos: ts.tokenStartOfNode(stmt),
|
|
});
|
|
};
|
|
// Project modules win before npm fallback: this is the source graph
|
|
// tsgo type-checked for tsconfig paths, package imports/self-references,
|
|
// and provenance entries. Ordinary packages still answer null here.
|
|
const projDep = isBare ? resolveImport7(program, sf, spec) : null;
|
|
// "#" specifiers can never name an npm package — they are the
|
|
// imports-field family, resolved by the project arm above.
|
|
const npm =
|
|
isBare && projDep === null && !spec.startsWith("#")
|
|
? resolveNpmImport7(sf.fileName, spec)
|
|
: null;
|
|
if (npm && isNodeTypesPath(npm.typesFile)) {
|
|
diags.push(unsupportedDiag("SC1010", locOf7(stmt), unsupportedModuleFeatureOf(spec)));
|
|
continue;
|
|
}
|
|
// --npm-static: an opted-in package's import is a PROGRAM-MODULE
|
|
// edge — its resolution (types stripped) answered the shipped JS,
|
|
// which allowJs + maxNodeModuleJsDepth pulled into the program, so
|
|
// the entry joins the module order like any user module and the
|
|
// clause fences below apply to it as to program JS. A miss (the
|
|
// resolution still answers declarations, or the file never joined
|
|
// the program) marks the package an OFFENDER: the frontend's
|
|
// selection loop rebuilds without it and reports the package refusal.
|
|
let npmStaticDep: ts.SourceFile | null = null;
|
|
if (npm !== null) {
|
|
if (isNpmStaticPackage(npm.packageName)) {
|
|
npmStaticDep = npmStaticProgramDep(program, npm.packageName, npm.typesFile);
|
|
if (npmStaticDep === null) continue;
|
|
} else {
|
|
// Types resolved, but Node's RUNTIME resolution can still refuse
|
|
// the edge (a types-only package whose exports target ships no JS,
|
|
// most commonly): that program is Node's startup crash, not an
|
|
|
|
const refusal = probeNodeImportRefusal(sf.fileName, spec);
|
|
if (refusal !== null) {
|
|
refuse(
|
|
refusal.message,
|
|
"%Error",
|
|
`the '${spec}' package (its runtime resolution fails: ${refusal.message})`,
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
// PROJECT imports: tsconfig paths and package.json-mediated specifiers
|
|
// that resolve to the program's own sources. A source answer is an
|
|
// ordinary user-module edge, exactly like a relative import (the
|
|
// checker resolved the bindings the same way); a refused resolution is
|
|
// Node's startup crash with Node's exact message; what keeps a compile
|
|
// fence is unsupported builtin or types-only surface.
|
|
if (isBare && npmStaticDep === null) {
|
|
if (projDep !== null && projDep.isDeclarationFile) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1010",
|
|
locOf7(stmt),
|
|
`the '${spec}' import (it resolves only to type declarations — there is no runtime implementation to compile)`,
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
if (projDep === null) {
|
|
// node:process's default export is the global process object. It
|
|
// contributes no module-order edge; the imported binding lowers
|
|
// through stdlibGlobalNameOf exactly like the bare global.
|
|
if (processModuleAliasImport7(spec, stmt)) continue;
|
|
const nodeBuiltin = spec.startsWith("node:") || nodeBuiltinNames.has(spec);
|
|
if (nodeBuiltin) {
|
|
diags.push(unsupportedDiag("SC1010", locOf7(stmt), unsupportedModuleFeatureOf(spec)));
|
|
continue;
|
|
}
|
|
if (spec === "#") {
|
|
refuse(
|
|
`Invalid module "#" is not a valid internal imports specifier name imported from ${sf.fileName}`,
|
|
"%TypeError",
|
|
`the '#' import (Node rejects the bare '#' specifier as invalid)`,
|
|
);
|
|
continue;
|
|
}
|
|
if (spec.startsWith("#")) {
|
|
const target = packageImportTarget(sf.fileName, spec);
|
|
if (target !== null && !target.startsWith("./") && !target.startsWith("../")) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1010",
|
|
locOf7(stmt),
|
|
`package.json imports entries that map to other packages (the '${spec}' import maps to '${target}')`,
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
const pkgJson = nearestPkgJsonPath(sf.fileName);
|
|
refuse(
|
|
`Package import specifier "${spec}" is not defined${pkgJson !== null ? ` in package ${pkgJson}` : ""} imported from ${sf.fileName}`,
|
|
"%TypeError",
|
|
`the '${spec}' import (no package.json imports-field entry maps it)`,
|
|
);
|
|
continue;
|
|
}
|
|
const refusal = probeNodeImportRefusal(sf.fileName, spec);
|
|
if (refusal !== null) {
|
|
const ambientNote = ambientDeclared(spec)
|
|
? `the '${spec}' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import)`
|
|
: `the '${spec}' package (nothing installed resolves it)`;
|
|
refuse(refusal.message, "%Error", ambientNote);
|
|
continue;
|
|
}
|
|
// Runtime-resolvable (or a shape the probe stays conservative
|
|
// about) with no compilable types answer: scriptc's fence.
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1010",
|
|
locOf7(stmt),
|
|
ambientDeclared(spec)
|
|
? `the '${spec}' module (it exists only as an ambient 'declare module' type surface — there is no runtime module to import)`
|
|
: `the '${spec}' package (nothing installed resolves it)`,
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
const clause = stmt.importClause;
|
|
const dep = isRelative ? resolveImport7(program, sf, spec) : (npmStaticDep ?? projDep);
|
|
const isJson = dep !== null && dep.fileName.endsWith(".json");
|
|
// SELF-imports: the bindings alias this module's OWN declarations,
|
|
// so a TOP-LEVEL read lexically above the aliased declaration is
|
|
// Node's TDZ ReferenceError at runtime (exactly what tsc's TS2448
|
|
// refuses for the DIRECT spelling — imports are exempt from that
|
|
// check, so the fence restores the same bar). Hoisted function
|
|
// aliases initialize at link and read fine anywhere; reads inside
|
|
// function bodies keep the direct spelling's existing policy.
|
|
if (dep === sf && clause !== undefined) {
|
|
selfImportTdzFences7(program, sf, clause, diags);
|
|
}
|
|
if (clause) {
|
|
// Default imports of SUPPORTED builtins pass where the spelling is
|
|
// legal: Node's default export of a CJS builtin IS the module
|
|
// object, so the binding exposes exactly the namespace-import
|
|
// surface and the lowering keys the same tables
|
|
// (builtinNamespaceModuleOf's default-import twin). JS sources
|
|
// always (Node never asks for interop flags); TS sources when the
|
|
// project's explicit or implied synthetic-default permission accepts
|
|
// the spelling. A TS project without that permission keeps the
|
|
// SC1012 fence. The callable module objects (assert, events, test)
|
|
// stay allowed everywhere. The process default is the global process
|
|
// alias, including when combined with named builtin imports.
|
|
const syntheticDefaultsOn =
|
|
(program.getCompilerOptions() as { allowSyntheticDefaultImports?: boolean })
|
|
.allowSyntheticDefaultImports === true;
|
|
const defaultOk =
|
|
spec === "process" ||
|
|
spec === "node:process" ||
|
|
builtinDefaultImportModule(spec) !== null ||
|
|
((isJsSourceFileName(sf.fileName) || syntheticDefaultsOn) &&
|
|
canonicalBuiltinModule(spec) !== null);
|
|
if (clause.name && !isJson && dep === null && !defaultOk) {
|
|
diags.push(unsupportedDiag("SC1012", locOf7(clause.name)));
|
|
}
|
|
if (clause.namedBindings && ts.isNamedImports(clause.namedBindings) && isJson) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1012",
|
|
locOf7(clause.namedBindings),
|
|
"named imports from JSON modules",
|
|
),
|
|
);
|
|
}
|
|
if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) {
|
|
// `import * as ns from "./m"` of a RESOLVED user module lowers:
|
|
// ns.member accesses resolve statically through the checker to
|
|
// the exporter's own registrations (lower-namespaces.ts's
|
|
// module-namespace paths); the ns OBJECT as a first-class value
|
|
// fences per site. What keeps a fence here: JSON modules (their
|
|
// namespace object has no static story — default imports bake
|
|
// the data), CommonJS JS modules (Node builds their namespace
|
|
// from its lexer's static analysis, a different surface),
|
|
// and unresolved specifiers. Supported builtins pass through as
|
|
// before (their namespace members are the declared surface).
|
|
if (isJson) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
locOf7(clause.namedBindings),
|
|
"namespace imports of JSON modules",
|
|
),
|
|
);
|
|
} else if (dep !== null && isCjsJsFile7(dep, program)) {
|
|
// A CJS namespace binding whose every use is a bare expression
|
|
// statement (`cjs;` — the corpus's "the import linked"
|
|
// assertion) carries no surface question: the statement lowers
|
|
// to Node's no-op, the module still evaluates through its
|
|
// ordinary init edge, and no member is ever read through the
|
|
// lexer facade (self-imports of a CJS module included — the
|
|
// partially-built exports are never observed). Any OTHER use
|
|
// keeps the fence.
|
|
if (!nsBindingUsesAreBareStatements7(program, sf, clause.namedBindings.name)) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
locOf7(clause.namedBindings),
|
|
"namespace imports of CommonJS modules",
|
|
),
|
|
);
|
|
}
|
|
} else if (dep === null && !(!isRelative && ambientModules.has(spec))) {
|
|
diags.push(unsupportedDiag("SC1013", locOf7(clause.namedBindings)));
|
|
}
|
|
}
|
|
}
|
|
if (dep && !isJson) {
|
|
deps.push({ dep, stmt });
|
|
depPositions.get(sf)!.push({ dep, pos: ts.tokenStartOfNode(stmt) });
|
|
}
|
|
}
|
|
{
|
|
const jsRequireFile = isJsSourceFileName(sf.fileName);
|
|
const stmts = sf.statements.nodes;
|
|
// A binding that code running before the require can reach. Node
|
|
// initializes it AT the require: a const/let read earlier throws
|
|
// ReferenceError, which the lowering reproduces with an
|
|
// initialization check at every reference that can run early
|
|
// (require-initialization.ts). A var reads undefined there, which
|
|
// module aliases cannot represent; createRequire bindings have no
|
|
// checked form either.
|
|
const earlyRequireFence = (
|
|
req: RequireOccurrence7,
|
|
bindingKind: RequireCallBindingKind7,
|
|
loc: { file: string; start: number; end: number },
|
|
): boolean => {
|
|
const early = req.decl !== null ? requireEarlyReference7(program, req.decl) : null;
|
|
if (
|
|
early === null ||
|
|
(bindingKind !== "createRequire" &&
|
|
req.split === undefined &&
|
|
((req.decl!.parent?.flags ?? 0) & (ts.NodeFlags.Const | ts.NodeFlags.Let)) !== 0)
|
|
) {
|
|
return false;
|
|
}
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
loc,
|
|
bindingKind === "createRequire"
|
|
? `createRequire() binding '${early.text}' below code that can reach it (Node throws ReferenceError on any earlier access, which is not modeled — move the require above the code that can run first)`
|
|
: req.split !== undefined
|
|
? `require() binding '${early.text}' assigned below code that can reach it (Node reads undefined before the assignment runs, which is not modeled — move the assignment above the code that can run first)`
|
|
: `var require() binding '${early.text}' below code that can reach it (Node reads undefined before the require runs, which is not modeled — declare it with const or let, or move the require above the code that can run first)`,
|
|
),
|
|
);
|
|
return true;
|
|
};
|
|
for (let k = 0; k < stmts.length; k++) {
|
|
const stmt = stmts[k]!;
|
|
for (const req of requiresOf7(stmt, program)) {
|
|
const loc = {
|
|
file: sf.fileName,
|
|
start: ts.tokenStartOfNode(req.node),
|
|
end: req.node.end,
|
|
};
|
|
const bindingKind = requireCallBindingKind7(program, req.node);
|
|
// TypeScript source files join this scan only through the
|
|
// canonical createRequire bridge. Their ordinary require-shaped
|
|
// calls retain the existing checker/lowering diagnostics; JS
|
|
// files keep the full CommonJS scan.
|
|
if (!jsRequireFile && bindingKind !== "createRequire") continue;
|
|
if (isNodeEsmFile7(sf, program)) {
|
|
if (bindingKind !== "createRequire") {
|
|
diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
|
|
continue;
|
|
}
|
|
}
|
|
if (load.externalTypes.has(req.spec)) {
|
|
continue;
|
|
}
|
|
// A JSON document: the require answers its cached parsed object
|
|
// (json-require.ts), an ordinary value the binding stores, so
|
|
// every destructuring form lowers as usual. No module edge.
|
|
const jsonDep = resolveImport7(program, sf, req.spec, "require");
|
|
if (jsonDep !== null && jsonDep.fileName.endsWith(".json")) {
|
|
if (bindingKind === "createRequire") continue;
|
|
if (ts.isVariableStatement(stmt) && requiresOf7(stmt, program).length > 1) {
|
|
const others = requiresOf7(stmt, program).some((r) => {
|
|
const d = resolveImport7(program, sf, r.spec, "require");
|
|
return d === null || !d.fileName.endsWith(".json");
|
|
});
|
|
if (others) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1012",
|
|
loc,
|
|
"require() of a JSON module declared together with other require() bindings",
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
earlyRequireFence(req, bindingKind, loc);
|
|
continue;
|
|
}
|
|
if (req.decl && ts.isArrayBindingPattern(req.decl.name)) {
|
|
diags.push(unsupportedDiag("SC1012", loc, "array-destructuring require() bindings"));
|
|
continue;
|
|
}
|
|
if (req.decl && ts.isObjectBindingPattern(req.decl.name)) {
|
|
// A nested pattern of a builtin binds members of the sub-module
|
|
// its key names (`const { types: { isPromise } } =
|
|
// require("util")` — util.types IS util/types).
|
|
const builtin = canonicalBuiltinModule(req.spec);
|
|
const plainElements = (
|
|
pattern: ts.ObjectBindingPattern,
|
|
module: string | null,
|
|
): boolean =>
|
|
pattern.elements.nodes.every((e) => {
|
|
if (e.initializer !== undefined || e.dotDotDotToken !== undefined) return false;
|
|
if (e.name !== undefined && ts.isIdentifier(e.name)) return true;
|
|
// A nested pattern under a named export of a program module
|
|
// destructures that export's VALUE at the require
|
|
// (`const { codes: { ERR_X } } = require("./errors")`): the
|
|
// inner bindings are ordinary destructured storage.
|
|
if (
|
|
module === null &&
|
|
builtin === null &&
|
|
bindingKind !== "createRequire" &&
|
|
pattern === req.decl!.name &&
|
|
e.name !== undefined &&
|
|
ts.isObjectBindingPattern(e.name) &&
|
|
e.propertyName !== undefined &&
|
|
ts.isIdentifier(e.propertyName)
|
|
)
|
|
return true;
|
|
if (module === null || e.name === undefined || !ts.isObjectBindingPattern(e.name))
|
|
return false;
|
|
const key = e.propertyName;
|
|
if (key === undefined || !ts.isIdentifier(key)) return false;
|
|
const sub = canonicalBuiltinModule(`${module}/${key.text}`);
|
|
return sub !== null && plainElements(e.name, sub);
|
|
});
|
|
if (!plainElements(req.decl.name, builtin)) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1012",
|
|
loc,
|
|
builtin !== null
|
|
? "require() destructuring with defaults, rest, or nested patterns other than builtin sub-modules"
|
|
: "require() destructuring with defaults, rest, or nested patterns of program modules (JSON documents and builtin sub-modules destructure fully)",
|
|
),
|
|
);
|
|
continue;
|
|
}
|
|
}
|
|
// An npm package served as a builtin (graceful-fs as fs) is never
|
|
// a program-module edge, even when --npm-static names it.
|
|
if (npmBuiltinAliasOf(req.spec) !== null) continue;
|
|
const isRelative = isRelativeSpecifier(req.spec);
|
|
let dep = resolveImport7(program, sf, req.spec, "require");
|
|
if (dep === null && !isRelative) {
|
|
// --npm-static: a require() of an OPTED-IN package is a
|
|
// program-module edge exactly like the import-declaration
|
|
// form above (bundle dists require their workspace siblings —
|
|
// the same resolution, the same offender discipline on a
|
|
// miss).
|
|
const npmReq = !req.spec.startsWith("#")
|
|
? resolveNpmImport7(sf.fileName, req.spec, "require")
|
|
: null;
|
|
if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
|
|
dep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
|
|
if (dep === null) continue; // offender recorded — the fallback loop reloads
|
|
} else {
|
|
// createRequire's non-program targets belong to its own
|
|
// lowering, where missing packages become catchable
|
|
// MODULE_NOT_FOUND throws. Only resolved program targets are
|
|
// module-order edges in this preflight walk.
|
|
if (bindingKind === "createRequire") continue;
|
|
if (
|
|
canonicalBuiltinModule(req.spec) === null &&
|
|
!processModuleAliasRequire7(req.spec, req.decl)
|
|
) {
|
|
// A binding-less require of a package NOTHING resolves:
|
|
// Node throws MODULE_NOT_FOUND at the require site — the
|
|
// lowering compiles exactly that catchable throw (the
|
|
// optional-dependency try/require pattern), so no fence.
|
|
// Binding forms keep the fence: their downstream reads
|
|
// would need the module that never loads.
|
|
if (req.decl !== null || probeNodeRequireRefusal(sf.fileName, req.spec) === null) {
|
|
diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(req.spec)));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
if (earlyRequireFence(req, bindingKind, loc)) continue;
|
|
if (dep) deps.push({ dep });
|
|
}
|
|
}
|
|
const nestedBareRequires = nestedBareRequiresOf7(sf);
|
|
program
|
|
.getTypeChecker()
|
|
.prefetchSymbolNodesExact(
|
|
nestedBareRequires.flatMap((call) =>
|
|
ts.isIdentifier(call.expression) ? [call.expression] : [],
|
|
),
|
|
);
|
|
for (const call of nestedBareRequires) {
|
|
const spec = requireSpecOf7(call)!;
|
|
const loc = { file: sf.fileName, start: ts.tokenStartOfNode(call), end: call.end };
|
|
const bindingKind = requireCallBindingKind7(program, call);
|
|
if (!jsRequireFile && bindingKind !== "createRequire") continue;
|
|
if (isNodeEsmFile7(sf, program)) {
|
|
if (bindingKind !== "createRequire") {
|
|
diags.push(unsupportedDiag("SC1013", loc, esmRequireFeature7(bindingKind)));
|
|
continue;
|
|
}
|
|
}
|
|
if (load.externalTypes.has(spec)) {
|
|
continue;
|
|
}
|
|
if (npmBuiltinAliasOf(spec) !== null) continue;
|
|
const projectDep = resolveImport7(program, sf, spec, "require");
|
|
if (projectDep !== null) {
|
|
// A bare require of a JSON document only parses it: nothing to
|
|
// evaluate (json-require.ts creates the cached object).
|
|
if (projectDep.fileName.endsWith(".json")) continue;
|
|
deps.push({ dep: projectDep });
|
|
continue;
|
|
}
|
|
if (!isRelativeSpecifier(spec)) {
|
|
// --npm-static: opted-in packages ride the program-module edge
|
|
// (the statement-level require branch above).
|
|
const npmReq = !spec.startsWith("#")
|
|
? resolveNpmImport7(sf.fileName, spec, "require")
|
|
: null;
|
|
if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
|
|
const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
|
|
if (nDep !== null) deps.push({ dep: nDep });
|
|
continue;
|
|
}
|
|
if (bindingKind === "createRequire") continue;
|
|
if (canonicalBuiltinModule(spec) === null && !processModuleAliasRequire7(spec, null)) {
|
|
// Binding-less by construction — same require-site throw
|
|
// channel as the statement-level form above.
|
|
if (probeNodeRequireRefusal(sf.fileName, spec) === null) {
|
|
diags.push(unsupportedDiag("SC1010", loc, unsupportedModuleFeatureOf(spec)));
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
// Inline requires of program modules are module edges like the bare
|
|
// statements above (cjs-inline-require.ts lowers each to the module's
|
|
// %init at its position). Only the CommonJS global in a CommonJS file
|
|
// counts, and targets outside the compiled graph add nothing here:
|
|
// their use sites keep their existing lowering fences.
|
|
if (jsRequireFile && !isNodeEsmFile7(sf, program)) {
|
|
// A split require binding's assignment is a statement-level require
|
|
// edge (requiresOf7 above), parenthesized or not.
|
|
const splitCalls = new Set(splitRequireBindings7(program, sf).values());
|
|
for (const call of inlineRequiresOf7(sf)) {
|
|
if (requireCallBindingKind7(program, call) !== "ambient") continue;
|
|
if (splitCalls.has(call)) continue;
|
|
const spec = requireSpecOf7(call)!;
|
|
if (load.externalTypes.has(spec) || canonicalBuiltinModule(spec) !== null) continue;
|
|
const lazy = inDeferredPosition7(call);
|
|
const edgeTo = (dep: ts.SourceFile): CycleEdge =>
|
|
lazy ? { dep, lazy: true, call } : { dep, call };
|
|
const projectDep = resolveImport7(program, sf, spec, "require");
|
|
if (projectDep !== null) {
|
|
if (!projectDep.fileName.endsWith(".json")) deps.push(edgeTo(projectDep));
|
|
continue;
|
|
}
|
|
if (isRelativeSpecifier(spec) || spec.startsWith("#")) continue;
|
|
const npmReq = resolveNpmImport7(sf.fileName, spec, "require");
|
|
if (npmReq !== null && isNpmStaticPackage(npmReq.packageName)) {
|
|
const nDep = npmStaticProgramDep(program, npmReq.packageName, npmReq.typesFile);
|
|
if (nDep !== null) deps.push(edgeTo(nDep));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Node's evaluation order: depth-first postorder from the entry, each
|
|
// module once, back-edges answered from the cache (a module already
|
|
// evaluating is skipped) — which the guarded %init calls reproduce
|
|
// exactly. Cycles are admitted where Node's partially-initialized
|
|
// semantics are UNOBSERVABLE or exactly modeled (JS's partial
|
|
// initialization otherwise misbehaves without a diagnostic, so SC1016
|
|
// stays for the rest):
|
|
// - a DIRECT SELF-IMPORT (the package self-name reference resolving to
|
|
// the importing module itself — Node's self-reference rule): the
|
|
// imported bindings alias the module's OWN top-level bindings with
|
|
// identical timing, evaluation happens once — always benign;
|
|
// - a back edge the shared admission engine (makeCycleAdmission)
|
|
// clears: the cheap per-edge rule (nothing binds, or only namespace
|
|
// objects bound to bare-statement uses — no read can hit TDZ or a
|
|
// stale slot) or the DECLARATION-ONLY INIT WINDOW analysis (the
|
|
// benign-cycle admission block: every module of the cycle's
|
|
// strongly-connected component has an inert top level and the
|
|
// closing edge's bindings are used only in deferred positions, so no
|
|
// read can execute before every member initialized);
|
|
// - the EXACT INITIALIZATION rule: an ES-module cluster whose early
|
|
// reads are all let/const bindings with module storage — the
|
|
// lowering checks each one (cycleEarlyBindings) and throws Node's
|
|
// ReferenceError on a read before the declaration ran.
|
|
const cycleAdmissionReason = makeCycleAdmission(program, (sf) => {
|
|
const all = edges.get(sf) ?? [];
|
|
return all.some((e) => e.call !== undefined) ? all.filter((e) => e.call === undefined) : all;
|
|
});
|
|
const order: ts.SourceFile[] = [];
|
|
const inlineRequireCycleCalls = new Set<ts.Node>();
|
|
const state = new Map<ts.SourceFile, "visiting" | "done">();
|
|
const stack: string[] = [];
|
|
const visit = (sf: ts.SourceFile): void => {
|
|
state.set(sf, "visiting");
|
|
stack.push(sf.fileName);
|
|
for (const e of edges.get(sf) ?? []) {
|
|
if (e.dep === sf) continue; // self-import: a Node cache hit, not a cycle
|
|
if (e.lazy === true) continue; // visited after this module completes
|
|
const s = state.get(e.dep);
|
|
if (s === "done") continue;
|
|
if (s === "visiting") {
|
|
if (e.call !== undefined) {
|
|
inlineRequireCycleCalls.add(e.call);
|
|
continue;
|
|
}
|
|
// A back-edge: Node answers it from the cache (the module is
|
|
// already evaluating) — admitted by the cheap per-edge rule, the
|
|
// declaration-only init window rule, or the exact initialization
|
|
// rule.
|
|
const reason = cycleAdmissionReason(sf, e);
|
|
if (reason !== null) {
|
|
const cycleStart = stack.indexOf(e.dep.fileName);
|
|
const cycle = [...stack.slice(cycleStart), e.dep.fileName].join(" → ");
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1016",
|
|
{ file: e.dep.fileName, start: 0, end: 0 },
|
|
`circular imports (${cycle}; ${reason})`,
|
|
),
|
|
);
|
|
}
|
|
continue;
|
|
}
|
|
visit(e.dep);
|
|
}
|
|
stack.pop();
|
|
state.set(sf, "done");
|
|
order.push(sf);
|
|
// Lazy inline requires run after this module's top level: their
|
|
// modules join the order afterwards (cache hits when already loaded).
|
|
for (const e of edges.get(sf) ?? []) {
|
|
if (e.lazy === true && state.get(e.dep) === undefined) visit(e.dep);
|
|
}
|
|
};
|
|
visit(entry);
|
|
|
|
// The startup crash Node's RESOLUTION phase reports: modules resolve
|
|
// their request specifiers in source order, children linking depth-first
|
|
// as each resolves (ModuleJob.syncLink) — a preorder walk over the
|
|
// resolved edges, statement-interleaved, so the first refusal found here
|
|
// is the one Node reports. Refusal candidates in modules the entry never
|
|
// reaches keep their compile-fence fallback instead (Node never resolves
|
|
// them). A found resolution crash wins over the CJS link check below:
|
|
// Node's fetch/resolve phase runs before instantiate.
|
|
let resolveCrash: StartupCrash | null = null;
|
|
{
|
|
const seen = new Set<ts.SourceFile>();
|
|
const walk = (sf: ts.SourceFile): StartupCrash | null => {
|
|
if (seen.has(sf)) return null;
|
|
seen.add(sf);
|
|
const steps: { pos: number; dep?: ts.SourceFile; crash?: StartupCrash }[] = [
|
|
...(depPositions.get(sf) ?? []),
|
|
...(refusals.get(sf) ?? []).map((r) => ({ pos: r.pos, crash: r.crash })),
|
|
].sort((a, b) => a.pos - b.pos);
|
|
for (const step of steps) {
|
|
if (step.crash !== undefined) return step.crash;
|
|
if (step.dep !== undefined && step.dep !== sf) {
|
|
const hit = walk(step.dep);
|
|
if (hit !== null) return hit;
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
resolveCrash = walk(entry);
|
|
// The crash channel engages only for programs that OTHERWISE pass
|
|
// preflight: when any other diagnostic already fails the build, every
|
|
// refusal keeps its compile-fence fallback instead — the report names
|
|
// each import's story, so edges whose crash will never compile still
|
|
// get a diagnostic. (No reachable refusal → same: fallbacks only.)
|
|
if (resolveCrash === null || diags.length > 0) {
|
|
resolveCrash = null;
|
|
for (const cands of refusals.values()) {
|
|
for (const c of cands) diags.push(c.fallback);
|
|
}
|
|
}
|
|
}
|
|
|
|
const linkCrash =
|
|
resolveCrash !== null
|
|
? null
|
|
: earlierLinkCrash(
|
|
order,
|
|
cjsNamedImportLinkCheck(program, entry, order, diags),
|
|
esmNamedImportLinkCheck(program, entry, order, diags),
|
|
);
|
|
|
|
return {
|
|
diags,
|
|
moduleOrder: order,
|
|
startupCrash: resolveCrash ?? linkCrash,
|
|
inlineRequireCycleCalls,
|
|
moduleEdges: edges,
|
|
};
|
|
}
|
|
|
|
/* ── the CJS named-import link check ─────────────────────────────────────
|
|
* Node builds a CommonJS module's ESM facade from its LEXER (cjs-lexer.ts
|
|
* mirrors it), never from execution — so a named import the checker binds
|
|
* happily can still fail Node's instantiate phase with a SyntaxError,
|
|
* thrown before ANY module in the graph evaluates. The checker's word is
|
|
* NOT Node's word exactly here, and shipping the checker's answer would
|
|
* diverge from Node without a diagnostic (`module.exports = { a: 7 }` served `a` where
|
|
* Node refuses the program). This walk asks Node's question at compile
|
|
* time, in Node's exact ORDER, and answers with Node's exact message. */
|
|
|
|
interface BadCjsImport {
|
|
/** The export name requested from the CJS module. */
|
|
exportName: string;
|
|
/** The import specifier as written. */
|
|
spec: string;
|
|
/** The failing name token (`a` in `import { a }` / `export { a } from`,
|
|
* the PROPERTY name in the aliased forms). */
|
|
nameNode: ts.Node;
|
|
sf: ts.SourceFile;
|
|
}
|
|
|
|
/** Walks the entry's ESM instantiate graph exactly as V8 does — children
|
|
* in request order, each module's own imports checked AFTER its children
|
|
* (postorder), regular imports sorted by LOCAL name (code units), then
|
|
* `export ... from` re-exports in source order — and answers the first
|
|
* named import of a lexer-INVISIBLE CommonJS export as Node's link-time
|
|
* SyntaxError (the caller compiles the program to that startup crash).
|
|
* ESM modules OUTSIDE the instantiate graph (reached only through
|
|
* require() of an ES module from CommonJS) instantiate mid-evaluation in
|
|
* Node, where the SyntaxError interleaves with output already produced —
|
|
* not modeled: those get a pointed fence instead. */
|
|
function cjsNamedImportLinkCheck(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
moduleOrder: ts.SourceFile[],
|
|
diags: ScrDiagnostic[],
|
|
): StartupCrash | null {
|
|
const lexMemo = new Map<ts.SourceFile, Set<string>>();
|
|
// Project specifiers resolve as ever; aliases and package.json-mediated
|
|
// edges (#alias/self-name) join relative imports so
|
|
// a named import THROUGH one of a CommonJS module keeps Node's lexer
|
|
// check. Builtin/npm targets contribute nothing here — except opted-in
|
|
// --npm-static packages, whose CJS entries face Node's lexer exactly
|
|
// like program CJS files (their JS IS the program now).
|
|
const resolveEdge = (from: ts.SourceFile, spec: string): ts.SourceFile | null => {
|
|
const project = resolveImport7(program, from, spec);
|
|
if (project !== null) return project;
|
|
const npmStatic = npmStaticDepSf7(program, from, spec);
|
|
return npmStatic;
|
|
};
|
|
// Reexport targets union in only when they resolve to CommonJS program
|
|
// files (Node's cjsPreparseModuleExports rule).
|
|
const resolveCjsDep = (from: ts.SourceFile, spec: string): ts.SourceFile | null => {
|
|
const dep =
|
|
resolveImport7(program, from, spec, "require") ??
|
|
npmStaticDepSf7(program, from, spec, "require");
|
|
return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
|
|
};
|
|
// A bundler rewrite spells some lexer-visible names as accessors.
|
|
const lexWithAccessorNames = (sf: ts.SourceFile): ReturnType<typeof cjsLexedExportsOfFile> => {
|
|
const lexed = cjsLexedExportsOfFile(sf);
|
|
for (const name of npmStaticLexerVisibleNames(sf.fileName)) lexed.exports.add(name);
|
|
return lexed;
|
|
};
|
|
const visible = (dep: ts.SourceFile, name: string): boolean =>
|
|
// `default` is the module.exports binding itself — always provided.
|
|
// The program already owns native source ASTs; reuse them without
|
|
// starting another syntax session or reparsing their source text.
|
|
name === "default" ||
|
|
cjsVisibleNames(dep, lexWithAccessorNames, resolveCjsDep, lexMemo).has(name);
|
|
|
|
/** The statement's resolved LOCAL CommonJS dependency, when it is an
|
|
* import/re-export from one. */
|
|
const cjsDepOf = (sf: ts.SourceFile, spec: string): ts.SourceFile | null => {
|
|
const dep = resolveEdge(sf, spec);
|
|
return dep !== null && isCjsJsFile7(dep, program) ? dep : null;
|
|
};
|
|
|
|
/** The first lexer-invisible CJS name request of ONE module, in V8's
|
|
* check order: all regular named imports sorted by local binding name,
|
|
* then `export { x } from` elements in source order. */
|
|
const firstInvisibleOf = (sf: ts.SourceFile): BadCjsImport | null => {
|
|
const entries: {
|
|
local: string;
|
|
exportName: string;
|
|
nameNode: ts.Node;
|
|
spec: string;
|
|
dep: ts.SourceFile;
|
|
}[] = [];
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (
|
|
!ts.isImportDeclaration(stmt) ||
|
|
stmt.moduleSpecifier === undefined ||
|
|
!ts.isStringLiteral(stmt.moduleSpecifier)
|
|
)
|
|
continue;
|
|
const clause = stmt.importClause;
|
|
if (!clause || clause.phaseModifier === ts.SyntaxKind.TypeKeyword) continue;
|
|
if (!clause.namedBindings || !ts.isNamedImports(clause.namedBindings)) continue;
|
|
const spec = stmt.moduleSpecifier.text;
|
|
const dep = cjsDepOf(sf, spec);
|
|
if (dep === null) continue;
|
|
for (const e of clause.namedBindings.elements.nodes) {
|
|
if (e.isTypeOnly) continue;
|
|
const nameNode = e.propertyName ?? e.name;
|
|
entries.push({ local: e.name.text, exportName: nameNode.text, nameNode, spec, dep });
|
|
}
|
|
}
|
|
entries.sort((a, b) => (a.local < b.local ? -1 : a.local > b.local ? 1 : 0));
|
|
for (const e of entries) {
|
|
if (!visible(e.dep, e.exportName))
|
|
return { exportName: e.exportName, spec: e.spec, nameNode: e.nameNode, sf };
|
|
}
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly) continue;
|
|
if (stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
if (!stmt.exportClause || !ts.isNamedExports(stmt.exportClause)) continue;
|
|
const spec = stmt.moduleSpecifier.text;
|
|
const dep = cjsDepOf(sf, spec);
|
|
if (dep === null) continue;
|
|
for (const e of stmt.exportClause.elements.nodes) {
|
|
if (e.isTypeOnly) continue;
|
|
const nameNode = e.propertyName ?? e.name;
|
|
if (!visible(dep, nameNode.text)) return { exportName: nameNode.text, spec, nameNode, sf };
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
// The instantiate graph: from an ESM entry, every import/re-export
|
|
// request in source order, recursing into ESM dependencies only (CJS
|
|
// and JSON modules are leaves — their own requires never join V8's
|
|
// linking). A CommonJS ENTRY has no instantiate phase at all.
|
|
const visited = new Set<ts.SourceFile>();
|
|
const dfs = (sf: ts.SourceFile): BadCjsImport | null => {
|
|
if (visited.has(sf)) return null;
|
|
visited.add(sf);
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
|
|
continue;
|
|
if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt)) continue;
|
|
if (
|
|
ts.isImportDeclaration(stmt) &&
|
|
stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword
|
|
)
|
|
continue;
|
|
const specNode = stmt.moduleSpecifier;
|
|
if (specNode === undefined || !ts.isStringLiteral(specNode)) continue;
|
|
const spec = specNode.text;
|
|
const dep = resolveEdge(sf, spec);
|
|
if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program)) continue;
|
|
const bad = dfs(dep);
|
|
if (bad !== null) return bad;
|
|
}
|
|
return firstInvisibleOf(sf);
|
|
};
|
|
const bad = isNodeEsmFile7(entry, program) ? dfs(entry) : null;
|
|
|
|
// ESM modules only require() reaches: same invisibility, but Node's
|
|
// SyntaxError fires mid-evaluation at the require — a pointed fence
|
|
// instead of a mismodeled crash position.
|
|
for (const sf of moduleOrder) {
|
|
if (!isNodeEsmFile7(sf, program) || visited.has(sf)) continue;
|
|
const b = firstInvisibleOf(sf);
|
|
if (b !== null) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
locOf7(b.nameNode),
|
|
`a named import of a CommonJS export Node's lexer cannot detect, reached through require() of an ES module (Node throws its SyntaxError mid-evaluation at that require; import the CommonJS module's default and read members off it instead)`,
|
|
),
|
|
);
|
|
}
|
|
}
|
|
if (bad === null) return null;
|
|
|
|
// Node's message: V8's generic missing-export SyntaxError, rewritten to
|
|
// the CommonJS hint form only when the failing SPECIFIER STRING is also
|
|
// one of the ENTRY module's own requests and the entry's resolution of
|
|
// it is CommonJS (module_job.js consults the ROOT job's moduleRequests/
|
|
// commonJsDeps — a deep module's failure keeps the generic wording).
|
|
let flavored = false;
|
|
for (const stmt of entry.statements.nodes) {
|
|
if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
|
|
continue;
|
|
if (
|
|
ts.isImportDeclaration(stmt) &&
|
|
stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword
|
|
)
|
|
continue;
|
|
const specNode = stmt.moduleSpecifier;
|
|
if (specNode === undefined || !ts.isStringLiteral(specNode) || specNode.text !== bad.spec)
|
|
continue;
|
|
if (cjsDepOf(entry, bad.spec) !== null) {
|
|
flavored = true;
|
|
break;
|
|
}
|
|
}
|
|
const loc = locOf7(bad.nameNode);
|
|
if (!flavored) {
|
|
return {
|
|
message: `The requested module '${bad.spec}' does not provide an export named '${bad.exportName}'`,
|
|
className: "%SyntaxError",
|
|
loc,
|
|
};
|
|
}
|
|
// The destructuring hint: Node regexes the failing name's SOURCE LINE
|
|
// for its brace group (greedy, first `{` to last `}` on the line) and
|
|
// swaps ` as ` for `: ` — reproduced exactly, quirks included
|
|
// (multi-line import statements simply lose the hint).
|
|
const text = bad.sf.text;
|
|
const pos = ts.tokenStartOfNode(bad.nameNode);
|
|
const lineStart = text.lastIndexOf("\n", pos - 1) + 1;
|
|
const lineEnd = text.indexOf("\n", pos);
|
|
let line = text.slice(lineStart, lineEnd < 0 ? text.length : lineEnd);
|
|
if (line.endsWith("\r")) line = line.slice(0, -1);
|
|
const braces = /{.*}/.exec(line);
|
|
const destructuring = braces === null ? null : braces[0].replace(/\s+as\s+/g, ": ");
|
|
return {
|
|
message:
|
|
`Named export '${bad.exportName}' not found. The requested module '${bad.spec}' is a CommonJS module, which may not support all module.exports as named exports.\n` +
|
|
"CommonJS modules can always be imported via the default export, for example using:\n\n" +
|
|
`import pkg from '${bad.spec}';\n` +
|
|
(destructuring !== null ? `const ${destructuring} = pkg;\n` : ""),
|
|
className: "%SyntaxError",
|
|
loc,
|
|
};
|
|
}
|
|
|
|
/* ── the native ESM named-import link check ─────────────────────────────
|
|
* TypeScript accepts `import { Shape } from "./types.ts"` when Shape is an
|
|
* interface or type alias: the checker is answering a TYPE question. Node's
|
|
* ESM linker asks a VALUE question instead. Because Node 24's strip-only
|
|
* execution leaves that import request in the module graph, the request
|
|
* fails before any module evaluates unless the source uses `import type`.
|
|
*
|
|
* Keep this separate from cjsNamedImportLinkCheck. CommonJS exports are
|
|
* determined by Node's source lexer and have their own interop message and
|
|
* ordering rules; native ESM exports come from the resolved TypeScript
|
|
* module symbol and use Node's generic missing-export SyntaxError. */
|
|
interface BadEsmImport {
|
|
exportName: string;
|
|
spec: string;
|
|
nameNode: ts.Node;
|
|
sf: ts.SourceFile;
|
|
}
|
|
|
|
interface EsmNamedImportLinkAnalysis {
|
|
crash: StartupCrash | null;
|
|
visited: Set<ts.SourceFile>;
|
|
firstMissingOf: (sf: ts.SourceFile) => BadEsmImport | null;
|
|
}
|
|
|
|
/** Node's strip-only loader exposes an empty `default` export for a default
|
|
* interface only when the `.ts` file is in an ambiguous (typeless) package
|
|
* scope. Explicitly ESM files (`.mts` and `.mjs`) and `.ts` files in a
|
|
* `"type": "module"` package do not get that placeholder. */
|
|
function hasNodeTsDefaultInterfacePlaceholder7(sf: ts.SourceFile): boolean {
|
|
return sf.fileName.endsWith(".ts") && nearestPackageType(sf.fileName) === null;
|
|
}
|
|
|
|
/** Finds the first native-ESM link failure in the static module graph rooted
|
|
* at `entry`. This is used both for startup linking of the entry graph and
|
|
* for dynamic imports: a dynamically loaded graph rejects its import promise
|
|
* at this same link point instead of running any module body. */
|
|
function analyzeEsmNamedImportLinks(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
): EsmNamedImportLinkAnalysis {
|
|
const checker = program.getTypeChecker();
|
|
const resolveEdge = (from: ts.SourceFile, spec: string): ts.SourceFile | null => {
|
|
const project = resolveImport7(program, from, spec);
|
|
if (project !== null) return project;
|
|
return npmStaticDepSf7(program, from, spec);
|
|
};
|
|
|
|
const runtimeExport = (
|
|
dep: ts.SourceFile,
|
|
name: string,
|
|
seenModules: ReadonlySet<ts.SourceFile> = new Set(),
|
|
): ts.Symbol | undefined => {
|
|
if (seenModules.has(dep)) return undefined;
|
|
const nextSeen = new Set(seenModules);
|
|
nextSeen.add(dep);
|
|
const module = checker.getSymbolAtLocation(dep);
|
|
const exported = module?.getExports().get(ts.escapedSymbolName(name));
|
|
if (exported !== undefined) {
|
|
let resolved = exported;
|
|
const seenSymbols = new Set<ts.Symbol>();
|
|
while ((resolved.flags & ts.SymbolFlags.Alias) !== 0 && !seenSymbols.has(resolved)) {
|
|
seenSymbols.add(resolved);
|
|
resolved = checker.getAliasedSymbol(resolved);
|
|
}
|
|
if (resolved.flags & ts.SymbolFlags.Value) return resolved;
|
|
// Node's strip-only TypeScript loader materializes a direct `export
|
|
// default interface X {}` as an empty default export in an ambiguous
|
|
// `.ts` file. The checker correctly classifies the declaration as
|
|
// type-only, but the native ESM linker sees the runtime placeholder.
|
|
if (
|
|
name === "default" &&
|
|
hasNodeTsDefaultInterfacePlaceholder7(dep) &&
|
|
resolved.declarations.some(
|
|
(declaration) =>
|
|
ts.isInterfaceDeclaration(declaration) &&
|
|
ts
|
|
.getModifiers(declaration)
|
|
?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) === true &&
|
|
ts
|
|
.getModifiers(declaration)
|
|
?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) === true,
|
|
)
|
|
) {
|
|
return resolved;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
// TypeScript 7's client-side module symbol exposes the module's own
|
|
// export table but not names contributed by `export *`. Follow those
|
|
// source edges explicitly, applying the ESM ambiguity rule: the same
|
|
// resolved symbol may arrive through multiple stars, while distinct
|
|
// symbols make the name unavailable. `default` never star-reexports.
|
|
if (name === "default") return undefined;
|
|
let starExport: ts.Symbol | undefined;
|
|
for (const stmt of dep.statements.nodes) {
|
|
if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly || stmt.exportClause !== undefined)
|
|
continue;
|
|
if (stmt.moduleSpecifier === undefined || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
const target = resolveEdge(dep, stmt.moduleSpecifier.text);
|
|
if (target === null || target.fileName.endsWith(".json") || !isNodeEsmFile7(target, program))
|
|
continue;
|
|
const candidate = runtimeExport(target, name, nextSeen);
|
|
if (candidate === undefined) continue;
|
|
if (starExport !== undefined && starExport !== candidate) return undefined;
|
|
starExport = candidate;
|
|
}
|
|
return starExport;
|
|
};
|
|
|
|
const firstMissingOf = (sf: ts.SourceFile): BadEsmImport | null => {
|
|
const imports: {
|
|
local: string;
|
|
exportName: string;
|
|
spec: string;
|
|
nameNode: ts.Node;
|
|
dep: ts.SourceFile;
|
|
}[] = [];
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
const clause = stmt.importClause;
|
|
if (clause === undefined || clause.phaseModifier === ts.SyntaxKind.TypeKeyword) continue;
|
|
const spec = stmt.moduleSpecifier.text;
|
|
const dep = resolveEdge(sf, spec);
|
|
if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program)) continue;
|
|
if (clause.name !== undefined) {
|
|
imports.push({
|
|
local: clause.name.text,
|
|
exportName: "default",
|
|
spec,
|
|
nameNode: clause.name,
|
|
dep,
|
|
});
|
|
}
|
|
if (clause.namedBindings === undefined || !ts.isNamedImports(clause.namedBindings)) continue;
|
|
for (const element of clause.namedBindings.elements.nodes) {
|
|
if (element.isTypeOnly) continue;
|
|
const nameNode = element.propertyName ?? element.name;
|
|
imports.push({
|
|
local: element.name.text,
|
|
exportName: nameNode.text,
|
|
spec,
|
|
nameNode,
|
|
dep,
|
|
});
|
|
}
|
|
}
|
|
// Node checks regular named requests in local-binding order. Keeping the
|
|
// same order as the CommonJS linker matters when one statement asks for
|
|
// more than one erased TypeScript export.
|
|
imports.sort((a, b) => (a.local < b.local ? -1 : a.local > b.local ? 1 : 0));
|
|
for (const request of imports) {
|
|
if (runtimeExport(request.dep, request.exportName) === undefined) {
|
|
return {
|
|
exportName: request.exportName,
|
|
spec: request.spec,
|
|
nameNode: request.nameNode,
|
|
sf,
|
|
};
|
|
}
|
|
}
|
|
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isExportDeclaration(stmt) || stmt.isTypeOnly) continue;
|
|
const moduleSpecifier = stmt.moduleSpecifier;
|
|
const exportClause = stmt.exportClause;
|
|
if (moduleSpecifier === undefined || exportClause === undefined) continue;
|
|
if (!ts.isStringLiteral(moduleSpecifier) || !ts.isNamedExports(exportClause)) continue;
|
|
const spec = moduleSpecifier.text;
|
|
const dep = resolveEdge(sf, spec);
|
|
if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program)) continue;
|
|
for (const element of exportClause.elements.nodes) {
|
|
if (element.isTypeOnly) continue;
|
|
const nameNode = element.propertyName ?? element.name;
|
|
if (runtimeExport(dep, nameNode.text) === undefined) {
|
|
return { exportName: nameNode.text, spec, nameNode, sf };
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
};
|
|
|
|
// The ESM instantiate graph is the same depth-first graph used by the CJS
|
|
// linker: dependencies are linked before the importing module, and a
|
|
// CommonJS/JSON target is a leaf for this native-export check.
|
|
const visited = new Set<ts.SourceFile>();
|
|
const dfs = (sf: ts.SourceFile): BadEsmImport | null => {
|
|
if (visited.has(sf)) return null;
|
|
visited.add(sf);
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isImportDeclaration(stmt) && !(ts.isExportDeclaration(stmt) && !stmt.isTypeOnly))
|
|
continue;
|
|
if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt)) continue;
|
|
if (
|
|
ts.isImportDeclaration(stmt) &&
|
|
stmt.importClause?.phaseModifier === ts.SyntaxKind.TypeKeyword
|
|
)
|
|
continue;
|
|
const moduleSpecifier = stmt.moduleSpecifier;
|
|
if (moduleSpecifier === undefined || !ts.isStringLiteral(moduleSpecifier)) continue;
|
|
const dep = resolveEdge(sf, moduleSpecifier.text);
|
|
if (dep === null || dep.fileName.endsWith(".json") || !isNodeEsmFile7(dep, program)) continue;
|
|
const bad = dfs(dep);
|
|
if (bad !== null) return bad;
|
|
}
|
|
return firstMissingOf(sf);
|
|
};
|
|
|
|
// Native ESM linking itself starts only from an ESM entry. The caller
|
|
// supplies dynamic-only roots here too; each such root gets its own
|
|
// promise rejection rather than a startup crash.
|
|
const bad = isNodeEsmFile7(entry, program) ? dfs(entry) : null;
|
|
if (bad !== null) {
|
|
return {
|
|
crash: {
|
|
message: `The requested module '${bad.spec}' does not provide an export named '${bad.exportName}'`,
|
|
className: "%SyntaxError",
|
|
loc: locOf7(bad.nameNode),
|
|
},
|
|
visited,
|
|
firstMissingOf,
|
|
};
|
|
}
|
|
|
|
return { crash: null, visited, firstMissingOf };
|
|
}
|
|
|
|
export function esmNamedImportLinkCrash(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
): StartupCrash | null {
|
|
return analyzeEsmNamedImportLinks(program, entry).crash;
|
|
}
|
|
|
|
function esmNamedImportLinkCheck(
|
|
program: ts.Program,
|
|
entry: ts.SourceFile,
|
|
moduleOrder: ts.SourceFile[],
|
|
diags: ScrDiagnostic[],
|
|
): StartupCrash | null {
|
|
const analysis = analyzeEsmNamedImportLinks(program, entry);
|
|
if (analysis.crash !== null) return analysis.crash;
|
|
|
|
// A CommonJS entry can synchronously require an ESM graph. Node links that
|
|
// graph at the require site, after the CommonJS module has already begun
|
|
// evaluating, so this cannot use startupCrash (which would move the error
|
|
// before earlier output). Keep the compile-time fence used by the CJS link
|
|
// checker for the analogous mid-evaluation failure instead.
|
|
for (const sf of moduleOrder) {
|
|
if (!isNodeEsmFile7(sf, program) || analysis.visited.has(sf)) continue;
|
|
const childFailure = analysis.firstMissingOf(sf);
|
|
if (childFailure !== null) {
|
|
diags.push(
|
|
unsupportedDiag(
|
|
"SC1013",
|
|
locOf7(childFailure.nameNode),
|
|
"a named import of an unavailable export in an ES module reached through require() (Node throws its SyntaxError mid-evaluation at that require; make the import match the module's runtime exports)",
|
|
),
|
|
);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** Both named-export link checks run independently because their export
|
|
* questions are different (Node's CJS lexer versus TypeScript's value
|
|
* symbols). Their first failures still share one Node instantiate order: the
|
|
* module postorder established by preflight, then regular named imports by
|
|
* local binding name, then source-order re-exports. Pick the earlier result
|
|
* so a native ESM failure in a child cannot be hidden by a CJS failure in a
|
|
* later parent. */
|
|
function earlierLinkCrash(
|
|
moduleOrder: ts.SourceFile[],
|
|
first: StartupCrash | null,
|
|
second: StartupCrash | null,
|
|
): StartupCrash | null {
|
|
if (first === null) return second;
|
|
if (second === null) return first;
|
|
const moduleIndex = new Map(moduleOrder.map((sf, index) => [sf.fileName, index]));
|
|
const firstIndex = moduleIndex.get(first.loc.file) ?? Number.MAX_SAFE_INTEGER;
|
|
const secondIndex = moduleIndex.get(second.loc.file) ?? Number.MAX_SAFE_INTEGER;
|
|
if (firstIndex !== secondIndex) return firstIndex < secondIndex ? first : second;
|
|
if (first.loc.start !== second.loc.start) {
|
|
const sf = moduleOrder[firstIndex];
|
|
if (sf === undefined) return first.loc.start < second.loc.start ? first : second;
|
|
const rank = (crash: StartupCrash): [number, number] => {
|
|
const entries: { local: string; start: number; kind: 0 | 1 }[] = [];
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
|
|
const clause = stmt.importClause;
|
|
if (clause?.phaseModifier === ts.SyntaxKind.TypeKeyword) continue;
|
|
if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) {
|
|
for (const element of clause.namedBindings.elements.nodes) {
|
|
if (!element.isTypeOnly) {
|
|
entries.push({
|
|
local: element.name.text,
|
|
start: ts.tokenStartOfNode(element.propertyName ?? element.name),
|
|
kind: 0,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
entries.sort((a, b) => (a.local < b.local ? -1 : a.local > b.local ? 1 : 0));
|
|
const direct = entries.findIndex((entry) => entry.start === crash.loc.start);
|
|
if (direct >= 0) return [0, direct];
|
|
let reexport = 0;
|
|
for (const stmt of sf.statements.nodes) {
|
|
const exportClause = ts.isExportDeclaration(stmt) ? stmt.exportClause : undefined;
|
|
if (
|
|
!ts.isExportDeclaration(stmt) ||
|
|
stmt.isTypeOnly ||
|
|
exportClause === undefined ||
|
|
!ts.isNamedExports(exportClause)
|
|
)
|
|
continue;
|
|
for (const element of exportClause.elements.nodes) {
|
|
if (
|
|
!element.isTypeOnly &&
|
|
ts.tokenStartOfNode(element.propertyName ?? element.name) === crash.loc.start
|
|
) {
|
|
return [1, reexport];
|
|
}
|
|
if (!element.isTypeOnly) reexport++;
|
|
}
|
|
}
|
|
return [2, crash.loc.start];
|
|
};
|
|
const firstRank = rank(first);
|
|
const secondRank = rank(second);
|
|
if (firstRank[0] !== secondRank[0]) return firstRank[0] < secondRank[0] ? first : second;
|
|
return firstRank[1] <= secondRank[1] ? first : second;
|
|
}
|
|
return first;
|
|
}
|
|
|
|
/* node's builtin-module name list, for the SC1010 wording decision ("the
|
|
* 'fs' module" vs the generic package message) — shared verbatim with the
|
|
* retired 5.9.3 lane's builtinModules use. */
|
|
const nodeBuiltinNames: ReadonlySet<string> = new Set(builtinModules);
|
|
|
|
/* ── the lowering-facing surface ─────────────────────────────────────────
|
|
* A family of world-typed helpers the LOWERING imports (require
|
|
* recognizers, the CJS export-identity analysis, ordered imports,
|
|
* resolution, locations), exported under the names the 5.9.3 program.ts
|
|
* established (the phase-2 port kept every spelling); the world-neutral
|
|
* helpers re-export from their focused modules. */
|
|
|
|
export { ambientDtsPath, fallbackDtsPath, isNodeTypesPath, overridesDtsPath } from "./dts-paths.js";
|
|
|
|
export {
|
|
builtinDefaultImportModule,
|
|
canonicalBuiltinModule,
|
|
npmBuiltinAliasOf,
|
|
SUPPORTED_BUILTIN_MODULES,
|
|
} from "./builtin-modules.js";
|
|
|
|
export { npmPackageNameOf, workspacePackageOfPath } from "./workspace-registry.js";
|
|
|
|
export {
|
|
requireSpecOf7 as requireSpecOf,
|
|
isRequireStatement7 as isRequireStatement,
|
|
requiresOf7 as requiresOf,
|
|
splitRequireCallOf7 as splitRequireCallOf,
|
|
isNodeEsmFile7 as isNodeEsmFile,
|
|
resolveImport7 as resolveImport,
|
|
resolveNpmImport7 as resolveNpmImport,
|
|
locOf7 as locOf,
|
|
requireEarlyReference7 as requireEarlyReference,
|
|
inDeferredPosition7 as inDeferredPosition,
|
|
};
|
|
|
|
/** True for JavaScript source files (.js/.mjs/.cjs) — the files whose
|
|
* types come entirely from inference (checkJs + JSDoc) and whose classes
|
|
* declare fields by constructor assignment. */
|
|
export function isJsSourceFile(sf: ts.SourceFile): boolean {
|
|
return isJsSourceFileName(sf.fileName);
|
|
}
|
|
|
|
/** True for a JavaScript file of the program that TypeScript type-checks:
|
|
* one with a `// @ts-check` comment before its first statement, or any
|
|
* file of a project whose tsconfig sets `checkJs` unless the file has a
|
|
* `// @ts-nocheck` comment. Files under node_modules are never checked. */
|
|
export function isCheckedJsSourceFile(sf: ts.SourceFile, projectCheckJs: boolean): boolean {
|
|
if (!isJsSourceFile(sf) || isNodeModulesPath(sf.fileName)) return false;
|
|
let checked = projectCheckJs;
|
|
const head = sf.text.slice(
|
|
0,
|
|
(sf.statements.nodes.length === 0 ? undefined : ts.tokenStartOfNode(sf.statements.nodes[0]!)) ??
|
|
sf.text.length,
|
|
);
|
|
for (const line of head.split("\n")) {
|
|
const directive = /^\s*\/\/\s*@ts-(no)?check\b/.exec(line);
|
|
if (directive) checked = directive[1] === undefined;
|
|
}
|
|
return checked;
|
|
}
|
|
|
|
export function orderedImportsOf(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
): { stmt: ts.Statement; dep: ts.SourceFile | null }[] {
|
|
const out: { stmt: ts.Statement; dep: ts.SourceFile | null }[] = [];
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (ts.isExportDeclaration(stmt) && isPrunedNpmReexport(program, stmt)) continue;
|
|
if (ts.isExportDeclaration(stmt) && (stmt.isTypeOnly || !stmt.moduleSpecifier)) continue;
|
|
if (!ts.isImportDeclaration(stmt) && !ts.isExportDeclaration(stmt)) continue;
|
|
if (ts.isImportDeclaration(stmt) && erasedTypeOnlyImport(stmt)) continue;
|
|
if (!stmt.moduleSpecifier || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
const spec = stmt.moduleSpecifier.text;
|
|
// Every project edge (relative, tsconfig alias, #alias, or self-name)
|
|
// resolves to the same dep so the importer's %init header calls theirs.
|
|
// Builtin and npm bare specifiers stay null — EXCEPT opted-in --npm-static
|
|
// packages, whose entries are program modules the header must init.
|
|
const dep = resolveImport7(program, sf, spec) ?? npmStaticDepSf7(program, sf, spec);
|
|
const isJson = dep !== null && dep.fileName.endsWith(".json");
|
|
out.push({ stmt, dep: isJson ? null : dep });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
/** The files a compiled program can load: the module order closed over
|
|
* every literal require() and import() call it contains (deferred and
|
|
* nested ones included) and, for opted-in package JavaScript, over every
|
|
* import and export declaration as well. A package file outside this set
|
|
* is reachable only through types, so whatever it spells cannot affect
|
|
* the compiled program. Null when a reachable file loads a computed
|
|
* specifier: then any file may load. */
|
|
export function npmStaticLoadableFiles(
|
|
program: ts.Program,
|
|
moduleOrder: readonly ts.SourceFile[],
|
|
): Set<string> | null {
|
|
const seen = new Set<ts.SourceFile>();
|
|
const work: ts.SourceFile[] = [];
|
|
const add = (sf: ts.SourceFile | null | undefined): void => {
|
|
if (sf === null || sf === undefined || seen.has(sf) || sf.isDeclarationFile) return;
|
|
seen.add(sf);
|
|
work.push(sf);
|
|
};
|
|
for (const sf of moduleOrder) add(sf);
|
|
let computed = false;
|
|
while (work.length > 0 && !computed) {
|
|
const sf = work.pop()!;
|
|
const packageJs =
|
|
npmStaticPackageOfPath(sf.fileName) !== null && isJsSourceFileName(sf.fileName);
|
|
const follow = (spec: string, kind: "import" | "require"): void => {
|
|
if (canonicalBuiltinModule(spec) !== null) return;
|
|
add(resolveImport7(program, sf, spec, kind) ?? npmStaticDepSf7(program, sf, spec, kind));
|
|
};
|
|
ts.walkPreorder(sf, (n) => {
|
|
if (computed) return "stop";
|
|
if (ts.isCallExpression(n)) {
|
|
const isImport = n.expression.kind === ts.SyntaxKind.ImportKeyword;
|
|
const isRequire = ts.isIdentifier(n.expression) && n.expression.text === "require";
|
|
if (!isImport && !isRequire) return undefined;
|
|
const arg = n.arguments.nodes[0];
|
|
if (arg !== undefined && ts.isStringLiteralLike(arg))
|
|
follow(arg.text, isImport ? "import" : "require");
|
|
else if (packageJs || isImport) computed = true;
|
|
} else if (
|
|
packageJs &&
|
|
(ts.isImportDeclaration(n) || ts.isExportDeclaration(n)) &&
|
|
n.moduleSpecifier !== undefined &&
|
|
ts.isStringLiteral(n.moduleSpecifier)
|
|
) {
|
|
follow(n.moduleSpecifier.text, "import");
|
|
}
|
|
return undefined;
|
|
});
|
|
}
|
|
return computed ? null : new Set([...seen].map((sf) => sf.fileName.split("\\").join("/")));
|
|
}
|
|
|
|
/** The program source file a bare specifier reaches when it names an
|
|
* opted-in --npm-static package (the shipped-JS entry preflight admitted
|
|
* as a module edge), else null. No offender reporting here — preflight
|
|
* already classified the import; this is the lookup the module-order and
|
|
* lowering paths share. */
|
|
export function npmStaticDepSf7(
|
|
program: ts.Program,
|
|
sf: ts.SourceFile,
|
|
spec: string,
|
|
resolutionKind: "import" | "require" = "import",
|
|
): ts.SourceFile | null {
|
|
if (!npmStaticActive() || isRelativeSpecifier(spec)) return null;
|
|
if (spec.startsWith("node:") || spec.startsWith("#")) return null;
|
|
const npm = resolveNpmImport7(sf.fileName, spec, resolutionKind);
|
|
if (npm === null || !isNpmStaticPackage(npm.packageName)) return null;
|
|
if (!isJsSourceFileName(npm.typesFile)) return null;
|
|
return program.getSourceFile(npm.typesFile) ?? null;
|
|
}
|
|
|
|
/** True when `expr` is the `module.exports` property access. */
|
|
export function isModuleExportsAccess(expr: ts.Expression): expr is ts.PropertyAccessExpression {
|
|
return (
|
|
ts.isPropertyAccessExpression(expr) &&
|
|
!expr.questionDotToken &&
|
|
ts.isIdentifier(expr.expression) &&
|
|
expr.expression.text === "module" &&
|
|
expr.name.text === "exports"
|
|
);
|
|
}
|
|
|
|
/** Classifies a statement as a CommonJS EXPORT assignment:
|
|
* - table: `module.exports = { ... }` — the whole export table at once
|
|
* (obj is null when the RHS is not an object literal — the
|
|
* recognized-but-unsupported form, fenced by the caller);
|
|
* - member: `exports.f = <expr>` / `module.exports.f = <expr>`.
|
|
* Null for everything else. Callers gate on top-level position in a JS
|
|
* module file — these forms anywhere else keep their generic fences. */
|
|
export function cjsExportAssignmentOf(stmt: ts.Statement):
|
|
| {
|
|
kind: "table";
|
|
obj: ts.ObjectLiteralExpression | null;
|
|
expr: ts.BinaryExpression;
|
|
/** `exports = module.exports = value`: the `exports` binding names
|
|
* the new value too, so later `exports.f =` members attach to it. */
|
|
rebindsExports?: true;
|
|
}
|
|
| { kind: "member"; name: ts.MemberName; value: ts.Expression; expr: ts.BinaryExpression }
|
|
| null {
|
|
if (!ts.isExpressionStatement(stmt)) return null;
|
|
const e = stmt.expression;
|
|
if (!ts.isBinaryExpression(e) || e.operatorToken.kind !== ts.SyntaxKind.EqualsToken) return null;
|
|
if (isModuleExportsAccess(e.left)) {
|
|
return { kind: "table", obj: ts.isObjectLiteralExpression(e.right) ? e.right : null, expr: e };
|
|
}
|
|
if (ts.isIdentifier(e.left) && e.left.text === "exports") {
|
|
let inner: ts.Expression = e.right;
|
|
while (ts.isParenthesizedExpression(inner)) inner = inner.expression;
|
|
if (
|
|
ts.isBinaryExpression(inner) &&
|
|
inner.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
|
|
isModuleExportsAccess(inner.left) &&
|
|
// `exports = module.exports = {}` is the fresh-table reset, which the
|
|
// export walk handles on its own.
|
|
!ts.isObjectLiteralExpression(inner.right)
|
|
) {
|
|
return { kind: "table", obj: null, expr: inner, rebindsExports: true };
|
|
}
|
|
}
|
|
if (ts.isPropertyAccessExpression(e.left) && !e.left.questionDotToken) {
|
|
const recv = e.left.expression;
|
|
const isExports = ts.isIdentifier(recv) && recv.text === "exports";
|
|
if (isExports || isModuleExportsAccess(recv)) {
|
|
return { kind: "member", name: e.left.name, value: e.right, expr: e };
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** The tsc VOID-INIT PREAMBLE (`exports.a = exports.b = void 0;` with the
|
|
* real `exports.a = a;` further down; every tsc-emitted dist file opens its
|
|
* exports this way): when every name in the chain has a later real
|
|
* assignment, the export takes its value there and the preamble lowers to
|
|
* nothing. Returns those later assignments by name, or null when this is
|
|
* not such a preamble (a preamble with no later real assignment keeps the
|
|
* ordinary path: the export IS undefined then). */
|
|
export function cjsVoidInitPreambleReals(
|
|
cjs: Extract<ReturnType<typeof cjsExportAssignmentOf>, { kind: "member" }>,
|
|
): Map<string, Extract<ReturnType<typeof cjsExportAssignmentOf>, { kind: "member" }>> | null {
|
|
if (!ts.isIdentifier(cjs.name)) return null;
|
|
const isExportsMember = (e: ts.Expression): e is ts.PropertyAccessExpression =>
|
|
ts.isPropertyAccessExpression(e) &&
|
|
ts.isIdentifier(e.name) &&
|
|
((ts.isIdentifier(e.expression) && e.expression.text === "exports") ||
|
|
(ts.isPropertyAccessExpression(e.expression) &&
|
|
ts.isIdentifier(e.expression.expression) &&
|
|
e.expression.expression.text === "module" &&
|
|
ts.isIdentifier(e.expression.name) &&
|
|
e.expression.name.text === "exports"));
|
|
const isVoid = (e: ts.Expression): boolean => {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
return (
|
|
e.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(e) && e.text === "undefined")
|
|
);
|
|
};
|
|
// chains: `exports.a = exports.b = void 0;` collects every name
|
|
const names: string[] = [cjs.name.text];
|
|
let tail: ts.Expression = cjs.value;
|
|
while (
|
|
ts.isBinaryExpression(tail) &&
|
|
tail.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
|
|
isExportsMember(tail.left)
|
|
) {
|
|
names.push((tail.left.name as ts.Identifier).text);
|
|
tail = tail.right;
|
|
}
|
|
if (!isVoid(tail)) return null;
|
|
const sf = ts.getSourceFileOfNode(cjs.expr);
|
|
const myPos = ts.tokenStartOfNode(cjs.expr);
|
|
const reals = new Map<
|
|
string,
|
|
Extract<ReturnType<typeof cjsExportAssignmentOf>, { kind: "member" }>
|
|
>();
|
|
for (const name of names) {
|
|
const real = sf.statements.nodes
|
|
.map((s) => cjsExportAssignmentOf(s))
|
|
.find(
|
|
(other) =>
|
|
other?.kind === "member" &&
|
|
ts.isIdentifier(other.name) &&
|
|
other.name.text === name &&
|
|
ts.tokenStartOfNode(other.expr) > myPos &&
|
|
!isVoid(other.value),
|
|
);
|
|
if (real?.kind !== "member") return null;
|
|
reals.set(name, real);
|
|
}
|
|
return reals;
|
|
}
|
|
|
|
/** The members and shared value of a CHAINED member export
|
|
* `exports.a = exports.b = module.exports.c = value` (outermost name
|
|
* first), or null when the assignment is not a chain of at least two
|
|
* identifier-named export members or its value is undefined. */
|
|
export function cjsExportChainOf(
|
|
e: ts.BinaryExpression,
|
|
): { names: ts.Identifier[]; value: ts.Expression } | null {
|
|
const names: ts.Identifier[] = [];
|
|
let cur: ts.Expression = e;
|
|
for (;;) {
|
|
while (ts.isParenthesizedExpression(cur)) cur = cur.expression;
|
|
if (!ts.isBinaryExpression(cur) || cur.operatorToken.kind !== ts.SyntaxKind.EqualsToken) break;
|
|
const left = cur.left;
|
|
if (
|
|
!ts.isPropertyAccessExpression(left) ||
|
|
left.questionDotToken ||
|
|
!ts.isIdentifier(left.name)
|
|
)
|
|
break;
|
|
const recv = left.expression;
|
|
if (!((ts.isIdentifier(recv) && recv.text === "exports") || isModuleExportsAccess(recv))) break;
|
|
names.push(left.name);
|
|
cur = cur.right;
|
|
}
|
|
// tsc's `exports.a = exports.b = void 0;` preamble is not a value chain
|
|
// (the export-statement lowering owns it).
|
|
const isVoid =
|
|
cur.kind === ts.SyntaxKind.VoidExpression || (ts.isIdentifier(cur) && cur.text === "undefined");
|
|
return names.length >= 2 && !isVoid ? { names, value: cur } : null;
|
|
}
|
|
|
|
/** Why Node would DISCARD this CommonJS export statement, or null when it
|
|
* survives (Node's export-object identity rules — checker-free, pure
|
|
* AST): `module.exports = {...}` REPLACES the export object, so members
|
|
* attached before it (either spelling), any earlier table, and
|
|
* `exports.f =` after it (exports still references the replaced object)
|
|
* are never seen by importers. Lowering fences these instead of shipping
|
|
* the checker's everything-is-live answer — the checker/runtime split
|
|
* would otherwise diverge from Node without a diagnostic. */
|
|
export function cjsExportDiscardReason(stmt: ts.Statement): string | null {
|
|
const sf = stmt.parent;
|
|
if (!ts.isSourceFile(sf)) return null;
|
|
const mine = cjsExportAssignmentOf(stmt);
|
|
if (!mine) return null;
|
|
const stmts = sf.statements.nodes;
|
|
let lastTable = -1;
|
|
for (let i = 0; i < stmts.length; i++) {
|
|
if (cjsExportAssignmentOf(stmts[i]!)?.kind === "table") lastTable = i;
|
|
}
|
|
if (lastTable < 0) return null;
|
|
const myIdx = stmts.indexOf(stmt as never);
|
|
if (mine.kind === "table") {
|
|
return myIdx < lastTable
|
|
? "multiple 'module.exports =' assignments (Node keeps only the last one — this table is discarded)"
|
|
: null;
|
|
}
|
|
if (myIdx < lastTable) {
|
|
return "export members attached before a 'module.exports =' assignment (Node replaces the export object — importers never see this member; attach it to module.exports AFTER the table)";
|
|
}
|
|
const left = mine.expr.left as ts.PropertyAccessExpression;
|
|
const last = cjsExportAssignmentOf(stmts[lastTable]!);
|
|
if (last?.kind === "table" && last.rebindsExports === true) return null;
|
|
return ts.isIdentifier(left.expression) && left.expression.text === "exports"
|
|
? "'exports.f =' after a 'module.exports =' assignment ('exports' still references the replaced object — Node discards this member; write module.exports.f instead)"
|
|
: null;
|
|
}
|
|
|
|
/** The object literal a `module.exports = <expr>` statement's RHS
|
|
* RESOLVES to (syntactically): the literal itself; `new Proxy(target,
|
|
* handler)` — Node programs export identity-forwarding proxies over a
|
|
* table, and the TARGET is the table (traps cannot run in a compiled
|
|
* program: every member access is statically resolved against the
|
|
* target's own type); or an identifier naming a top-level const whose
|
|
* initializer is the literal. Null for everything else. */
|
|
export function cjsExportTargetLiteral(
|
|
e: ts.Expression,
|
|
sf: ts.SourceFile,
|
|
): ts.ObjectLiteralExpression | null {
|
|
while (ts.isParenthesizedExpression(e)) e = e.expression;
|
|
if (ts.isObjectLiteralExpression(e)) return e;
|
|
if (
|
|
ts.isNewExpression(e) &&
|
|
ts.isIdentifier(e.expression) &&
|
|
e.expression.text === "Proxy" &&
|
|
(e.arguments?.nodes.length ?? 0) >= 1
|
|
) {
|
|
return cjsExportTargetLiteral(e.arguments!.nodes[0]!, sf);
|
|
}
|
|
if (ts.isIdentifier(e)) {
|
|
for (const stmt of sf.statements.nodes) {
|
|
if (!ts.isVariableStatement(stmt)) continue;
|
|
if ((stmt.declarationList.flags & ts.NodeFlags.Const) === 0) continue;
|
|
for (const d of stmt.declarationList.declarations.nodes) {
|
|
if (
|
|
d.name !== undefined &&
|
|
ts.isIdentifier(d.name) &&
|
|
d.name.text === e.text &&
|
|
d.initializer
|
|
) {
|
|
let init: ts.Expression = d.initializer;
|
|
while (ts.isParenthesizedExpression(init)) init = init.expression;
|
|
return ts.isObjectLiteralExpression(init) ? init : null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** The class expression a JS module's WHOLE export is (`module.exports =
|
|
* class …{}`): the kept (last) top-level `module.exports =` statement's
|
|
* paren-unwrapped RHS when it is a class expression, together with the
|
|
* statement it sits in (in-file `module.exports` reads gate on source
|
|
* order against it). Null when the kept export is anything else. */
|
|
export function cjsClassExprWholeExportOf(
|
|
sf: ts.SourceFile,
|
|
): { classExpr: ts.ClassExpression; stmt: ts.Statement } | null {
|
|
let last: { classExpr: ts.ClassExpression; stmt: ts.Statement } | null = null;
|
|
for (const stmt of sf.statements.nodes) {
|
|
const cjs = cjsExportAssignmentOf(stmt);
|
|
if (!cjs || cjs.kind !== "table") continue;
|
|
let rhs: ts.Expression = cjs.expr.right;
|
|
while (ts.isParenthesizedExpression(rhs)) rhs = rhs.expression;
|
|
// Any LATER table replaces the export object — a non-class one takes
|
|
// the class answer back off the table.
|
|
last = ts.isClassExpression(rhs) ? { classExpr: rhs, stmt } : null;
|
|
}
|
|
return last;
|
|
}
|
|
|
|
/** True when `obj` is the effective export-table literal of a JS module:
|
|
* the object literal of a top-level `module.exports = { ... }` statement
|
|
* directly, OR the RESOLVED TARGET of the module's kept `module.exports =`
|
|
* statement (the identifier/Proxy forms — see cjsExportTargetLiteral).
|
|
* The gate for the CJS export-property alias re-resolution
|
|
* (resolveValueSymbol) and the accessor-read lift. */
|
|
export function isCjsExportTableLiteral(obj: ts.ObjectLiteralExpression): boolean {
|
|
const assign = obj.parent;
|
|
if (
|
|
ts.isBinaryExpression(assign) &&
|
|
assign.right === obj &&
|
|
isModuleExportsAccess(assign.left) &&
|
|
ts.isExpressionStatement(assign.parent) &&
|
|
ts.isSourceFile(assign.parent.parent)
|
|
) {
|
|
return isJsSourceFile(assign.parent.parent);
|
|
}
|
|
const decl = obj.parent;
|
|
if (!ts.isVariableDeclaration(decl) || decl.initializer !== obj) return false;
|
|
const sf = ts.getSourceFileOfNode(obj);
|
|
if (!isJsSourceFile(sf)) return false;
|
|
for (const stmt of sf.statements.nodes) {
|
|
const cjs = cjsExportAssignmentOf(stmt);
|
|
if (cjs?.kind === "table" && cjsExportDiscardReason(stmt) === null) {
|
|
return cjsExportTargetLiteral(cjs.expr.right, sf) === obj;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** Names other runtimes and the DOM declare that scriptc's type world
|
|
* (the ES2025 library plus Node types) does not. */
|
|
const FOREIGN_RUNTIME_GLOBALS = new Set(["Deno", "Bun"]);
|
|
const DOM_GLOBALS = new Set([
|
|
"window",
|
|
"document",
|
|
"navigator",
|
|
"location",
|
|
"localStorage",
|
|
"sessionStorage",
|
|
"HTMLElement",
|
|
"Element",
|
|
"Document",
|
|
"Window",
|
|
"BodyInit",
|
|
"HeadersInit",
|
|
"RequestInfo",
|
|
"XMLHttpRequest",
|
|
"requestAnimationFrame",
|
|
]);
|
|
/** Root identifiers whose members the bundled Node fallback declares. */
|
|
const NODE_GLOBAL_ROOTS = new Set(["process", "Buffer", "console", "globalThis"]);
|
|
|
|
/** A hint when a TypeScript error comes from scriptc's own type world rather
|
|
* than from the project: a library member newer than ES2025, a global of
|
|
* another runtime or of the DOM, a Node member the bundled fallback types
|
|
* leave out, or the strictNullChecks scriptc enforces. Null otherwise. */
|
|
function typeWorldHint(d: ts.Diagnostic, message: string, load: LoadResult): string | null {
|
|
const world = load.typeWorld;
|
|
if (world === undefined) return null;
|
|
const quoted = /'([^']+)'/.exec(message)?.[1];
|
|
// TS2304/TS2552: Cannot find name; TS2580/TS2591/TS2592: missing type
|
|
// packages; TS2583: needs a newer library.
|
|
if (d.code === 2304 || d.code === 2552 || d.code === 2583) {
|
|
if (quoted !== undefined && FOREIGN_RUNTIME_GLOBALS.has(quoted)) {
|
|
return `'${quoted}' is another runtime's global; scriptc's type world declares the ES2025 library and Node only — feature-test it through globalThis instead, e.g. '(globalThis as { ${quoted}?: unknown }).${quoted}' (the native program runs as Node would, where it is undefined)`;
|
|
}
|
|
if (quoted !== undefined && DOM_GLOBALS.has(quoted)) {
|
|
return `'${quoted}' comes from the DOM library, which scriptc's type world does not include (it checks with the ES2025 library and Node types regardless of the project's "lib") — declare the shape you need locally, or move browser-only code out of the program`;
|
|
}
|
|
if (d.code === 2583) {
|
|
return `scriptc checks with the ES2025 library regardless of the project's "lib" setting, and '${quoted ?? "this name"}' comes from a newer library that does not compile yet`;
|
|
}
|
|
}
|
|
// TS2339/TS2550/TS2551: property does not exist (2550: on this lib).
|
|
if (d.code === 2339 || d.code === 2550 || d.code === 2551) {
|
|
const typeText = /on type '([^']+)'/.exec(message)?.[1] ?? "";
|
|
const newerLib =
|
|
world.projectLib !== null &&
|
|
world.projectLib.some((lib) => /esnext|es202[6-9]|es20[3-9]\d/i.test(lib));
|
|
if (d.code === 2550 || (newerLib && /^[A-Z][A-Za-z0-9]*(?:Constructor)?$/.test(typeText))) {
|
|
return `scriptc checks with the ES2025 library regardless of the project's "lib" setting, and '${quoted ?? "this member"}' comes from a newer library that does not compile yet — use an ES2025 equivalent here`;
|
|
}
|
|
if (world.nodeFallback && d.fileName !== undefined) {
|
|
const root = receiverRoot(load.program.getSourceFile(d.fileName)?.text ?? "", d.pos);
|
|
if (
|
|
root !== null &&
|
|
(NODE_GLOBAL_ROOTS.has(root) || importsNodeBuiltin(load, d.fileName, root))
|
|
) {
|
|
return `the project has no @types/node, so scriptc types Node with its bundled declarations, which list only the members that compile natively — '${quoted ?? "this member"}' does not compile natively yet (https://scriptc.dev/limitations); installing @types/node turns this into a located refusal with a hint`;
|
|
}
|
|
}
|
|
}
|
|
if (world.forcedStrictNullChecks && /\b(?:null|undefined)\b/.test(message)) {
|
|
return `the project disables strictNullChecks, which scriptc always enables — this error appears only under strict null checks; narrow the value (or enable "strictNullChecks" in the project to see the same errors from its own tsc)`;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/** The root identifier of the property access whose member name starts at
|
|
* `pos` (`process.version` → `process`), or null. */
|
|
function receiverRoot(text: string, pos: number): string | null {
|
|
let i = pos - 1;
|
|
while (i >= 0 && /\s/.test(text[i]!)) i--;
|
|
if (text[i] !== ".") return null;
|
|
i--;
|
|
if (text[i] === "?") i--;
|
|
let root: string | null = null;
|
|
for (;;) {
|
|
while (i >= 0 && /\s/.test(text[i]!)) i--;
|
|
let j = i;
|
|
while (j >= 0 && /[\w$]/.test(text[j]!)) j--;
|
|
if (j === i) return root;
|
|
root = text.slice(j + 1, i + 1);
|
|
i = j;
|
|
while (i >= 0 && /\s/.test(text[i]!)) i--;
|
|
if (text[i] !== ".") return root;
|
|
i--;
|
|
if (text[i] === "?") i--;
|
|
}
|
|
}
|
|
|
|
/** Whether `name` is bound in `fileName` by an import of a Node builtin. */
|
|
function importsNodeBuiltin(load: LoadResult, fileName: string, name: string): boolean {
|
|
const sf = load.program.getSourceFile(fileName);
|
|
for (const stmt of sf?.statements?.nodes ?? []) {
|
|
if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier)) continue;
|
|
if (canonicalBuiltinModule(stmt.moduleSpecifier.text) === null) continue;
|
|
const clause = stmt.importClause;
|
|
if (clause?.name?.text === name) return true;
|
|
const bindings = clause?.namedBindings;
|
|
if (bindings && ts.isNamespaceImport(bindings) && bindings.name.text === name) return true;
|
|
if (
|
|
bindings &&
|
|
ts.isNamedImports(bindings) &&
|
|
bindings.elements.nodes.some((e) => e.name.text === name)
|
|
)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|