mirror of
https://github.com/openclaw/openclaw.git
synced 2026-08-02 08:21:35 +00:00
4516 lines
155 KiB
JavaScript
4516 lines
155 KiB
JavaScript
#!/usr/bin/env node
|
|
|
|
// Guards database-first state ownership by blocking legacy store writes in runtime code.
|
|
import { promises as fs } from "node:fs";
|
|
import path from "node:path";
|
|
import ts from "typescript";
|
|
import {
|
|
explicitUndefinedLegacyObjectPropertyValue,
|
|
mergeConditionalLegacyObjectPropertyValue,
|
|
mergeConditionalLiteralTexts,
|
|
mergeExhaustiveLiteralTexts,
|
|
mergeLegacyObjectPropertyValues,
|
|
mergeLegacyPathBranchAssignments,
|
|
} from "./lib/legacy-store-path-domain.mjs";
|
|
import { resolveRepoRoot, runAsScript, toLine, unwrapExpression } from "./lib/ts-guard-utils.mjs";
|
|
|
|
const databaseFirstLegacyStoreSourceRoots = ["src", "extensions", "packages"];
|
|
const databaseFirstNativeSourceRoots = ["apps/macos/Sources/OpenClaw"];
|
|
const nativeLegacyPortGuardianMigrationPath =
|
|
"apps/macos/Sources/OpenClaw/PortGuardianRecordStore.swift";
|
|
const nativeLegacyPortGuardianFilenamePattern = /\bport-guard\.(?:json|lock)\b/u;
|
|
const unknownComputedPropertyName = "\0";
|
|
|
|
const legacyWriteCallees = new Set([
|
|
"appendFile",
|
|
"appendFileSync",
|
|
"cp",
|
|
"cpSync",
|
|
"copyFile",
|
|
"copyFileSync",
|
|
"createWriteStream",
|
|
"open",
|
|
"openSync",
|
|
"rm",
|
|
"rmSync",
|
|
"unlink",
|
|
"unlinkSync",
|
|
"rename",
|
|
"renameSync",
|
|
"writeFile",
|
|
"writeFileSync",
|
|
]);
|
|
|
|
const fsModuleSpecifiers = new Set(["node:fs", "node:fs/promises", "fs", "fs/promises"]);
|
|
|
|
const helperWriteCallees = new Set([
|
|
"acquireFileLock",
|
|
"appendRegularFile",
|
|
"appendRegularFileSync",
|
|
"replaceFileAtomic",
|
|
"replaceFileAtomicSync",
|
|
"saveJsonFile",
|
|
"writeJson",
|
|
"writeJsonAtomic",
|
|
"writeJsonFileAtomically",
|
|
"writeJsonSync",
|
|
"writeTextAtomic",
|
|
"withFileLock",
|
|
]);
|
|
|
|
const fsSafeStoreFactoryCallees = new Set([
|
|
"fileStore",
|
|
"fileStoreSync",
|
|
"privateFileStore",
|
|
"privateFileStoreSync",
|
|
"root",
|
|
]);
|
|
const fsSafeJsonStoreFactoryCallees = new Set(["jsonStore"]);
|
|
|
|
const fsSafeStoreWriteMethods = new Set([
|
|
"append",
|
|
"copyIn",
|
|
"create",
|
|
"createJson",
|
|
"mkdir",
|
|
"move",
|
|
"openWritable",
|
|
"remove",
|
|
"write",
|
|
"writeJson",
|
|
"writeStream",
|
|
"writeText",
|
|
]);
|
|
const fsSafeJsonStoreWriteMethods = new Set(["update", "updateOr", "write"]);
|
|
|
|
const helperWriteModulePattern =
|
|
/(?:^|\/)(?:file-lock|fs-safe|json-files|json-store|private-file-store|replace-file)(?:\.[cm]?[jt]s)?$/u;
|
|
const fsSafePackageModulePattern = /^@openclaw\/fs-safe(?:\/(?:root|store))?$/u;
|
|
|
|
const bridgeMarkerPattern = /\btranscriptLocator\b|sqlite-transcript:\/\//u;
|
|
|
|
// The restart handoff must survive its one cutover migration without leaving
|
|
// filesystem fallback imports in the steady-state runtime owner.
|
|
const legacyRestartSentinelMigrationPath = "src/infra/state-migrations.restart-sentinel.ts";
|
|
const legacyRestartSentinelPreflightPath = "src/cli/program/config-guard.ts";
|
|
const legacyRestartSentinelRuntimePath = "src/infra/restart-sentinel.ts";
|
|
const legacyRestartSentinelPreflightFilenames = new Set([
|
|
"restart-sentinel.json",
|
|
"restart-sentinel.json.doctor-importing",
|
|
]);
|
|
const legacyRestartSentinelFilenamePattern =
|
|
/(?:^|[/\\])restart-sentinel\.json(?:\.doctor-importing)?$/u;
|
|
const legacyRestartSentinelRuntimeImportSpecifiers = new Set([
|
|
"fs",
|
|
"fs/promises",
|
|
"node:fs",
|
|
"node:fs/promises",
|
|
"node:path",
|
|
"path",
|
|
]);
|
|
const legacyExecApprovalsMigrationPath = "src/infra/state-migrations.exec-approvals.ts";
|
|
const legacyExecApprovalsConfigPath = "src/infra/exec-approvals-config.ts";
|
|
const legacyExecApprovalsRuntimePath = "src/infra/exec-approvals-store.ts";
|
|
// Stable oc:// URI identity, not a filesystem path; see the owning module.
|
|
const stableExecApprovalsPolicyUriPath = "extensions/policy/src/exec-approvals-uri.ts";
|
|
const legacyExecApprovalsFilenamePattern =
|
|
/(?:^|[/\\])exec-approvals\.json(?:\.doctor-importing)?$/u;
|
|
|
|
const legacyStorePatterns = [
|
|
/\bsessions\.json\b/u,
|
|
/\.trajectory\.jsonl\b/u,
|
|
/\.acp-stream\.jsonl\b/u,
|
|
/\bacp\/event-ledger\.json\b/u,
|
|
/\bcache\/[^"'`]*\.json\b/u,
|
|
/\bagents\/[^"'`]+\/agent\/(?:auth|models)\.json\b/u,
|
|
/\b(?:credentials\/oauth|github-copilot\.token|openrouter-models|auth-profiles|auth-state|exec-approvals|(?:openclaw-)?workspace-state)\.json\b/u,
|
|
// Dynamic template spans resolve to `*`, so the start alternative also
|
|
// catches `${workspaceKey}.attested` and `${workspaceDir}.attested`.
|
|
/(?:^|[/\\])[^/\\"'`]+\.attested\b/u,
|
|
/\btui\/last-session\.json\b/u,
|
|
/\bcommitments\/commitments\.json\b/u,
|
|
/\bmedia\/outgoing\/records\/[^"'`]*\.json\b/u,
|
|
/\bpush\/(?:apns-registrations|web-push-subscriptions|vapid-keys)\.json\b/u,
|
|
/\bmcp-oauth\/[^"'`]*\.json\b/u,
|
|
/\bnode\.json\b/u,
|
|
/\bidentity\/device\.json\b/u,
|
|
/\bsubagents\/runs\.json\b/u,
|
|
/\btmp\/skill-uploads\b/u,
|
|
/\b(?:crestodian|openclaw)\/rescue-pending\/[^"'`]*\.json\b/u,
|
|
/\bcron\/(?:runs\/[^"'`]+\.jsonl|jobs\.json|jobs-state\.json)\b/u,
|
|
/\b(?:process-leases|session-toggles|known-users|msteams-conversations|msteams-polls|msteams-sso-tokens|bot-storage|sync-store|thread-bindings|inbound-dedupe|startup-verification|storage-meta|crypto-idb-snapshot|command-deploy-cache|plugin-binding-approvals|plugins\/installs|config-health|port-guard|restart-sentinel|gateway-restart-intent|gateway-supervisor-restart-handoff)\.json\b/u,
|
|
/\b(?:calls|ref-index|config-audit|audit\/(?:file-transfer|openclaw|system-agent|crestodian))\.jsonl\b/u,
|
|
/\b(?:reply-cache|sent-echoes|events|claims)\.jsonl\b/u,
|
|
/\bplugin-state\/state\.sqlite\b/u,
|
|
/\btasks\/(?:runs\.sqlite|flows\/registry\.sqlite)\b/u,
|
|
/\bopenclaw-state\.sqlite\b/u,
|
|
/\bopenclaw-native-hook-relays\b/u,
|
|
/(?:^|\/)(?:meta|file-meta)\.json$/u,
|
|
/(?:^|\/)viewer\.html$/u,
|
|
/(?:^|\/)qmd\/embed\.lock(?:\.lock)?$/u,
|
|
/(?:^|\/)qmd-write\.lock(?:\.lock)?$/u,
|
|
];
|
|
|
|
const allowedRuntimeMigrationPaths = [
|
|
"src/commands/doctor/",
|
|
"src/commands/doctor-usage-cost-cache.ts",
|
|
"src/infra/session-state-migration.ts",
|
|
"src/infra/state-migrations.ts",
|
|
"src/infra/state-migrations.acp-replay.ts",
|
|
"src/infra/state-migrations.tui-last-session.ts",
|
|
"src/infra/state-migrations.commitments.ts",
|
|
"src/infra/state-migrations.managed-outgoing-images.ts",
|
|
"src/infra/state-migrations.apns.ts",
|
|
"src/infra/state-migrations.mcp-oauth.ts",
|
|
legacyExecApprovalsMigrationPath,
|
|
legacyRestartSentinelMigrationPath,
|
|
"src/infra/state-migrations.workspace-setup.ts",
|
|
"src/infra/state-migrations.web-push.ts",
|
|
"src/infra/state-migrations.node-host.ts",
|
|
"src/infra/state-migrations.device-identity.ts",
|
|
"src/infra/state-migrations.subagent-registry.ts",
|
|
"src/infra/state-migrations.rescue-pending.ts",
|
|
"src/commands/session-state-migration.ts",
|
|
"src/commands/doctor-state-migrations.test.ts",
|
|
];
|
|
|
|
const allowedFixturePaths = new Set(["extensions/qa-lab/src/providers/shared/auth-store.ts"]);
|
|
|
|
const allowedCurrentLegacyWriteViolations = [];
|
|
|
|
const sourceFileExtensions = new Set([".cjs", ".cts", ".js", ".mjs", ".mts", ".ts", ".tsx"]);
|
|
|
|
const sourceTestSuffixes = [
|
|
".e2e-harness.js",
|
|
".e2e-harness.mjs",
|
|
".e2e-harness.ts",
|
|
".test-fixtures.js",
|
|
".test-fixtures.mjs",
|
|
".test-fixtures.ts",
|
|
".test-helper.js",
|
|
".test-helper.mjs",
|
|
".test-helper.ts",
|
|
".test-helpers.js",
|
|
".test-helpers.mjs",
|
|
".test-helpers.ts",
|
|
".test-harness.js",
|
|
".test-harness.mjs",
|
|
".test-harness.ts",
|
|
".test-mocks.js",
|
|
".test-mocks.mjs",
|
|
".test-mocks.ts",
|
|
".test-support.js",
|
|
".test-support.mjs",
|
|
".test-support.ts",
|
|
".test-utils.js",
|
|
".test-utils.mjs",
|
|
".test-utils.ts",
|
|
".test.js",
|
|
".test.mjs",
|
|
".test.ts",
|
|
"test-fixtures.js",
|
|
"test-fixtures.mjs",
|
|
"test-fixtures.ts",
|
|
"test-helper.js",
|
|
"test-helper.mjs",
|
|
"test-helper.ts",
|
|
"test-helpers.js",
|
|
"test-helpers.mjs",
|
|
"test-helpers.ts",
|
|
"test-harness.js",
|
|
"test-harness.mjs",
|
|
"test-harness.ts",
|
|
"test-mocks.js",
|
|
"test-mocks.mjs",
|
|
"test-mocks.ts",
|
|
"test-support.js",
|
|
"test-support.mjs",
|
|
"test-support.ts",
|
|
"test-utils.js",
|
|
"test-utils.mjs",
|
|
"test-utils.ts",
|
|
];
|
|
|
|
function isAllowedLegacyOwnerPath(relativePath) {
|
|
return (
|
|
allowedFixturePaths.has(relativePath) ||
|
|
allowedRuntimeMigrationPaths.some((allowed) => relativePath.startsWith(allowed)) ||
|
|
/^extensions\/[^/]+\/(?:doctor-contract-api|legacy-state-migrations-api)\.ts$/u.test(
|
|
relativePath,
|
|
)
|
|
);
|
|
}
|
|
|
|
function normalizedSourceText(sourceFile, node) {
|
|
return node.getText(sourceFile).replace(/\s+/gu, " ");
|
|
}
|
|
|
|
function lastScope(scopes) {
|
|
return scopes[scopes.length - 1];
|
|
}
|
|
|
|
function scopeForRead(scopes, name) {
|
|
return scopes.findLast((scope) => scope.has(name));
|
|
}
|
|
|
|
function scopeForWrite(scopes, name) {
|
|
return scopeForRead(scopes, name) ?? lastScope(scopes);
|
|
}
|
|
|
|
function currentLegacyWriteViolationAllowances(relativePath = null) {
|
|
const allowances = new Map();
|
|
const relativePrefix = typeof relativePath === "string" ? relativePath.concat(":") : null;
|
|
for (const fingerprint of allowedCurrentLegacyWriteViolations) {
|
|
if (relativePrefix !== null && !fingerprint.startsWith(relativePrefix)) {
|
|
continue;
|
|
}
|
|
allowances.set(fingerprint, (allowances.get(fingerprint) ?? 0) + 1);
|
|
}
|
|
return allowances;
|
|
}
|
|
|
|
function currentLegacyWriteViolationPath(fingerprint) {
|
|
const marker = ":legacy store filesystem write:";
|
|
const markerIndex = fingerprint.indexOf(marker);
|
|
return markerIndex === -1 ? null : fingerprint.slice(0, markerIndex);
|
|
}
|
|
|
|
function consumeAllowedCurrentLegacyViolation(
|
|
allowances,
|
|
relativePath,
|
|
sourceFile,
|
|
fingerprintNode,
|
|
kind,
|
|
) {
|
|
const fingerprint = `${relativePath}:${kind}:${normalizedSourceText(sourceFile, fingerprintNode)}`;
|
|
const remaining = allowances.get(fingerprint) ?? 0;
|
|
if (remaining === 0) {
|
|
return false;
|
|
}
|
|
if (remaining === 1) {
|
|
allowances.delete(fingerprint);
|
|
} else {
|
|
allowances.set(fingerprint, remaining - 1);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function isSourceFile(filePath) {
|
|
return sourceFileExtensions.has(path.extname(filePath));
|
|
}
|
|
|
|
function isGeneratedAssetSourceFile(filePath) {
|
|
const normalized = filePath.replaceAll(path.sep, "/");
|
|
return (
|
|
/(?:^|\/)extensions\/[^/]+\/(?:assets|dist)\/.+\.[cm]?js$/u.test(normalized) ||
|
|
/(?:^|\/)packages\/[^/]+\/dist\/.+\.[cm]?js$/u.test(normalized)
|
|
);
|
|
}
|
|
|
|
function isGeneratedAssetSourcePath(filePath) {
|
|
return (
|
|
/(?:^|\/)extensions\/[^/]+\/(?:assets|dist)(?:\/|$)/u.test(
|
|
filePath.replaceAll(path.sep, "/"),
|
|
) || /(?:^|\/)packages\/[^/]+\/dist(?:\/|$)/u.test(filePath.replaceAll(path.sep, "/"))
|
|
);
|
|
}
|
|
|
|
function isTestLikeSourceFile(filePath) {
|
|
return sourceTestSuffixes.some((suffix) => filePath.endsWith(suffix));
|
|
}
|
|
|
|
async function collectSourceFiles(targetPath) {
|
|
let stat;
|
|
try {
|
|
stat = await fs.stat(targetPath);
|
|
} catch (error) {
|
|
if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
|
|
return [];
|
|
}
|
|
throw error;
|
|
}
|
|
|
|
if (stat.isFile()) {
|
|
return isSourceFile(targetPath) &&
|
|
!isTestLikeSourceFile(targetPath) &&
|
|
!isGeneratedAssetSourceFile(targetPath)
|
|
? [targetPath]
|
|
: [];
|
|
}
|
|
|
|
const entries = await fs.readdir(targetPath, { withFileTypes: true });
|
|
const files = [];
|
|
for (const entry of entries) {
|
|
if (entry.name === "node_modules") {
|
|
continue;
|
|
}
|
|
const entryPath = path.join(targetPath, entry.name);
|
|
if (isGeneratedAssetSourcePath(entryPath)) {
|
|
continue;
|
|
}
|
|
if (entry.isDirectory()) {
|
|
files.push(...(await collectSourceFiles(entryPath)));
|
|
continue;
|
|
}
|
|
if (
|
|
entry.isFile() &&
|
|
isSourceFile(entryPath) &&
|
|
!isTestLikeSourceFile(entryPath) &&
|
|
!isGeneratedAssetSourceFile(entryPath)
|
|
) {
|
|
files.push(entryPath);
|
|
}
|
|
}
|
|
return files;
|
|
}
|
|
|
|
export async function collectDatabaseFirstLegacyStoreSourceFiles(sourceRoots) {
|
|
return (await Promise.all(sourceRoots.map((root) => collectSourceFiles(root)))).flat();
|
|
}
|
|
|
|
async function collectNativeSourceFiles(targetPath) {
|
|
let stat;
|
|
try {
|
|
stat = await fs.stat(targetPath);
|
|
} catch (error) {
|
|
if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
|
|
return [];
|
|
}
|
|
throw error;
|
|
}
|
|
if (stat.isFile()) {
|
|
return path.extname(targetPath) === ".swift" ? [targetPath] : [];
|
|
}
|
|
const entries = await fs.readdir(targetPath, { withFileTypes: true });
|
|
const files = [];
|
|
for (const entry of entries) {
|
|
const entryPath = path.join(targetPath, entry.name);
|
|
if (entry.isDirectory()) {
|
|
files.push(...(await collectNativeSourceFiles(entryPath)));
|
|
} else if (entry.isFile() && path.extname(entryPath) === ".swift") {
|
|
files.push(entryPath);
|
|
}
|
|
}
|
|
return files;
|
|
}
|
|
|
|
export function collectDatabaseFirstNativeLegacyStoreViolations(content, relativePath) {
|
|
if (relativePath === nativeLegacyPortGuardianMigrationPath) {
|
|
return [];
|
|
}
|
|
return content
|
|
.split("\n")
|
|
.flatMap((line, index) =>
|
|
nativeLegacyPortGuardianFilenamePattern.test(line)
|
|
? [{ kind: "legacy PortGuardian file reference", line: index + 1 }]
|
|
: [],
|
|
);
|
|
}
|
|
|
|
function importSource(node) {
|
|
const moduleSpecifier = node.moduleSpecifier;
|
|
return ts.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : "";
|
|
}
|
|
|
|
function isLegacyRestartSentinelPreflightDetection(node, relativePath) {
|
|
if (
|
|
relativePath !== legacyRestartSentinelPreflightPath ||
|
|
!legacyRestartSentinelPreflightFilenames.has(node.text)
|
|
) {
|
|
return false;
|
|
}
|
|
const joinCall = node.parent;
|
|
if (
|
|
!ts.isCallExpression(joinCall) ||
|
|
joinCall.arguments.length !== 2 ||
|
|
joinCall.arguments[1] !== node ||
|
|
!ts.isPropertyAccessExpression(joinCall.expression) ||
|
|
!ts.isIdentifier(joinCall.expression.expression) ||
|
|
joinCall.expression.expression.text !== "path" ||
|
|
joinCall.expression.name.text !== "join" ||
|
|
!ts.isIdentifier(joinCall.arguments[0]) ||
|
|
joinCall.arguments[0].text !== "stateDir"
|
|
) {
|
|
return false;
|
|
}
|
|
const paths = joinCall.parent;
|
|
if (!ts.isArrayLiteralExpression(paths)) {
|
|
return false;
|
|
}
|
|
const someAccess = paths.parent;
|
|
if (
|
|
!ts.isPropertyAccessExpression(someAccess) ||
|
|
someAccess.expression !== paths ||
|
|
someAccess.name.text !== "some"
|
|
) {
|
|
return false;
|
|
}
|
|
const someCall = someAccess.parent;
|
|
return (
|
|
ts.isCallExpression(someCall) &&
|
|
someCall.arguments.length === 1 &&
|
|
ts.isIdentifier(someCall.arguments[0]) &&
|
|
someCall.arguments[0].text === "fileOrDirExists"
|
|
);
|
|
}
|
|
|
|
function collectLegacyRestartSentinelBoundaryViolations(sourceFile, relativePath) {
|
|
if (relativePath === legacyRestartSentinelMigrationPath) {
|
|
return [];
|
|
}
|
|
|
|
const violations = [];
|
|
const seen = new Set();
|
|
function add(node, kind) {
|
|
const line = toLine(sourceFile, node);
|
|
const key = `${line}:${kind}`;
|
|
if (seen.has(key)) {
|
|
return;
|
|
}
|
|
seen.add(key);
|
|
violations.push({ kind, line });
|
|
}
|
|
|
|
function visit(node) {
|
|
if (
|
|
ts.isStringLiteralLike(node) &&
|
|
legacyRestartSentinelFilenamePattern.test(node.text) &&
|
|
!isLegacyRestartSentinelPreflightDetection(node, relativePath)
|
|
) {
|
|
add(node, "legacy restart sentinel reference");
|
|
}
|
|
if (
|
|
relativePath === legacyRestartSentinelRuntimePath &&
|
|
ts.isImportDeclaration(node) &&
|
|
legacyRestartSentinelRuntimeImportSpecifiers.has(importSource(node))
|
|
) {
|
|
add(node, "legacy restart sentinel filesystem import");
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
}
|
|
visit(sourceFile);
|
|
return violations;
|
|
}
|
|
|
|
function collectLegacyExecApprovalsBoundaryViolations(sourceFile, relativePath) {
|
|
if (
|
|
relativePath === legacyExecApprovalsMigrationPath ||
|
|
relativePath === legacyExecApprovalsConfigPath ||
|
|
relativePath === stableExecApprovalsPolicyUriPath
|
|
) {
|
|
return [];
|
|
}
|
|
|
|
const violations = [];
|
|
function visit(node) {
|
|
if (ts.isStringLiteralLike(node) && legacyExecApprovalsFilenamePattern.test(node.text)) {
|
|
violations.push({
|
|
kind: "legacy exec approvals reference",
|
|
line: toLine(sourceFile, node),
|
|
});
|
|
}
|
|
if (
|
|
relativePath === legacyExecApprovalsRuntimePath &&
|
|
ts.isImportDeclaration(node) &&
|
|
legacyRestartSentinelRuntimeImportSpecifiers.has(importSource(node))
|
|
) {
|
|
violations.push({
|
|
kind: "legacy exec approvals filesystem import",
|
|
line: toLine(sourceFile, node),
|
|
});
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
}
|
|
visit(sourceFile);
|
|
return violations;
|
|
}
|
|
|
|
function isHelperWriteModuleSource(source) {
|
|
return (
|
|
source === "openclaw/plugin-sdk/file-access-runtime" ||
|
|
source === "openclaw/plugin-sdk/security-runtime" ||
|
|
fsSafePackageModulePattern.test(source) ||
|
|
helperWriteModulePattern.test(source)
|
|
);
|
|
}
|
|
|
|
function collectCreateRequireBindings(sourceFile) {
|
|
const bindings = new Set();
|
|
function visit(node) {
|
|
if (ts.isImportDeclaration(node) && ["node:module", "module"].includes(importSource(node))) {
|
|
const namedBindings = node.importClause?.namedBindings;
|
|
if (namedBindings && ts.isNamedImports(namedBindings)) {
|
|
for (const element of namedBindings.elements) {
|
|
const importedName = element.propertyName?.text ?? element.name.text;
|
|
if (importedName === "createRequire") {
|
|
bindings.add(element.name.text);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
}
|
|
visit(sourceFile);
|
|
return bindings;
|
|
}
|
|
|
|
function isFsRequireExpression(expression, isRequireName = (name) => name === "require") {
|
|
const call = unwrapExpression(expression);
|
|
if (!ts.isCallExpression(call) || !ts.isIdentifier(unwrapExpression(call.expression))) {
|
|
return false;
|
|
}
|
|
const requireName = unwrapExpression(call.expression).text;
|
|
const [specifier] = call.arguments;
|
|
return (
|
|
isRequireName(requireName) &&
|
|
specifier &&
|
|
ts.isStringLiteralLike(specifier) &&
|
|
fsModuleSpecifiers.has(specifier.text)
|
|
);
|
|
}
|
|
|
|
function unwrapAwaitExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
return ts.isAwaitExpression(unwrapped) ? unwrapExpression(unwrapped.expression) : unwrapped;
|
|
}
|
|
|
|
function isFsDynamicImportExpression(expression) {
|
|
const call = unwrapAwaitExpression(expression);
|
|
if (!ts.isCallExpression(call) || call.expression.kind !== ts.SyntaxKind.ImportKeyword) {
|
|
return false;
|
|
}
|
|
const [specifier] = call.arguments;
|
|
return (
|
|
specifier !== undefined &&
|
|
ts.isStringLiteralLike(specifier) &&
|
|
fsModuleSpecifiers.has(specifier.text)
|
|
);
|
|
}
|
|
|
|
function collectFsBindings(sourceFile) {
|
|
const fsModuleBindings = new Set();
|
|
const fsWriteAliases = new Map();
|
|
const fsSafeStoreFactoryAliases = new Map();
|
|
|
|
for (const statement of sourceFile.statements) {
|
|
if (!ts.isImportDeclaration(statement)) {
|
|
continue;
|
|
}
|
|
const source = importSource(statement);
|
|
const clause = statement.importClause;
|
|
if (!clause) {
|
|
continue;
|
|
}
|
|
if (clause.name && fsModuleSpecifiers.has(source)) {
|
|
fsModuleBindings.add(clause.name.text);
|
|
}
|
|
const namedBindings = clause.namedBindings;
|
|
if (!namedBindings) {
|
|
continue;
|
|
}
|
|
if (ts.isNamespaceImport(namedBindings)) {
|
|
if (fsModuleSpecifiers.has(source)) {
|
|
fsModuleBindings.add(namedBindings.name.text);
|
|
}
|
|
if (isHelperWriteModuleSource(source)) {
|
|
for (const helperName of helperWriteCallees) {
|
|
fsWriteAliases.set(`${namedBindings.name.text}.${helperName}`, helperName);
|
|
}
|
|
for (const factoryName of [
|
|
...fsSafeStoreFactoryCallees,
|
|
...fsSafeJsonStoreFactoryCallees,
|
|
]) {
|
|
fsSafeStoreFactoryAliases.set(`${namedBindings.name.text}.${factoryName}`, factoryName);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
for (const element of namedBindings.elements) {
|
|
const importedName = element.propertyName?.text ?? element.name.text;
|
|
if (fsModuleSpecifiers.has(source) && importedName === "promises") {
|
|
fsModuleBindings.add(element.name.text);
|
|
}
|
|
if (fsModuleSpecifiers.has(source) && legacyWriteCallees.has(importedName)) {
|
|
fsWriteAliases.set(element.name.text, importedName);
|
|
}
|
|
if (isHelperWriteModuleSource(source) && helperWriteCallees.has(importedName)) {
|
|
fsWriteAliases.set(element.name.text, importedName);
|
|
}
|
|
if (
|
|
isHelperWriteModuleSource(source) &&
|
|
(fsSafeStoreFactoryCallees.has(importedName) ||
|
|
fsSafeJsonStoreFactoryCallees.has(importedName))
|
|
) {
|
|
fsSafeStoreFactoryAliases.set(element.name.text, importedName);
|
|
}
|
|
}
|
|
}
|
|
|
|
return { fsModuleBindings, fsWriteAliases, fsSafeStoreFactoryAliases };
|
|
}
|
|
|
|
function templateCandidateText(current) {
|
|
let text = current.head.text;
|
|
for (const span of current.templateSpans) {
|
|
text += `*${span.literal.text}`;
|
|
}
|
|
return text || "*";
|
|
}
|
|
|
|
function legacyCandidateTexts(sourceFile, node) {
|
|
const candidates = node.pos >= 0 && node.end >= 0 ? [node.getText(sourceFile)] : [];
|
|
const stringSegments = [];
|
|
|
|
function binaryExpressionCandidateText(current) {
|
|
if (current.operatorToken.kind !== ts.SyntaxKind.PlusToken) {
|
|
return null;
|
|
}
|
|
const left = pathSegmentCandidateText(current.left);
|
|
const right = pathSegmentCandidateText(current.right);
|
|
if (!left && !right) {
|
|
return null;
|
|
}
|
|
return `${left ?? "*"}${right ?? "*"}`;
|
|
}
|
|
|
|
function pathSegmentCandidateText(current) {
|
|
const unwrapped = unwrapExpression(current);
|
|
if (ts.isStringLiteralLike(unwrapped)) {
|
|
return unwrapped.text;
|
|
}
|
|
if (ts.isTemplateExpression(unwrapped)) {
|
|
return templateCandidateText(unwrapped);
|
|
}
|
|
if (ts.isBinaryExpression(unwrapped)) {
|
|
return binaryExpressionCandidateText(unwrapped);
|
|
}
|
|
return "*";
|
|
}
|
|
|
|
if (candidates.length === 0) {
|
|
const syntheticPathSegment = pathSegmentCandidateText(node);
|
|
if (syntheticPathSegment !== "*") {
|
|
candidates.push(syntheticPathSegment);
|
|
}
|
|
}
|
|
|
|
function maybeAddCallPathCandidate(current) {
|
|
if (!ts.isCallExpression(current) || current.arguments.length < 2) {
|
|
return;
|
|
}
|
|
const segments = current.arguments.map((argument) => pathSegmentCandidateText(argument));
|
|
if (!segments.some((segment) => segment !== "*")) {
|
|
return;
|
|
}
|
|
candidates.push(segments.join("/"));
|
|
}
|
|
|
|
function visit(current) {
|
|
maybeAddCallPathCandidate(current);
|
|
if (ts.isStringLiteralLike(current)) {
|
|
stringSegments.push(current.text);
|
|
}
|
|
ts.forEachChild(current, visit);
|
|
}
|
|
visit(node);
|
|
if (stringSegments.length > 1) {
|
|
candidates.push(stringSegments.join("/"));
|
|
}
|
|
return candidates;
|
|
}
|
|
|
|
/**
|
|
* Finds database-first legacy-store violations in one TypeScript/JavaScript source file.
|
|
*/
|
|
export function collectDatabaseFirstLegacyStoreViolations(
|
|
content,
|
|
inputRelativePath = "source.ts",
|
|
scanOptions = {},
|
|
) {
|
|
const relativePath = inputRelativePath.replaceAll("\\", "/");
|
|
const sourceFile = ts.createSourceFile(relativePath, content, ts.ScriptTarget.Latest, true);
|
|
const boundaryViolations = [
|
|
...collectLegacyRestartSentinelBoundaryViolations(sourceFile, relativePath),
|
|
...collectLegacyExecApprovalsBoundaryViolations(sourceFile, relativePath),
|
|
];
|
|
if (isAllowedLegacyOwnerPath(relativePath)) {
|
|
return boundaryViolations;
|
|
}
|
|
|
|
const currentLegacyWriteAllowances =
|
|
scanOptions.currentLegacyWriteAllowances ?? currentLegacyWriteViolationAllowances(relativePath);
|
|
const createRequireBindings = collectCreateRequireBindings(sourceFile);
|
|
const { fsModuleBindings, fsWriteAliases, fsSafeStoreFactoryAliases } =
|
|
collectFsBindings(sourceFile);
|
|
const violations = [...boundaryViolations];
|
|
const seenViolations = new Set(
|
|
boundaryViolations.map((violation) => `${violation.line}:${violation.kind}`),
|
|
);
|
|
const fsModuleBindingScopes = [new Map([...fsModuleBindings].map((name) => [name, true]))];
|
|
const fsModulePropertyScopes = [new Map()];
|
|
const fsWriteAliasScopes = [fsWriteAliases];
|
|
const fsSafeStoreFactoryAliasScopes = [fsSafeStoreFactoryAliases];
|
|
const fsSafeStoreScopes = [new Map()];
|
|
const fsSafeJsonStoreScopes = [new Map()];
|
|
const requireAliasScopes = [new Map([["require", true]])];
|
|
const createRequireShadowScopes = [new Set()];
|
|
const legacyPathScopes = [new Map()];
|
|
const literalTextScopes = [new Map()];
|
|
const staticExpressionScopes = [new Map()];
|
|
const knownUndefinedScopes = [new Map()];
|
|
const legacyKnownObjectLiteralScopes = [new Map()];
|
|
const legacyObjectPropertyScopes = [new Map()];
|
|
const wrapperFunctionScopes = [new Map()];
|
|
const conditionalExecutionScopes = [false];
|
|
const branchEffectScopes = [];
|
|
const activeWrapperNodes = new Set();
|
|
const intrinsicWrapperCalls = new WeakSet();
|
|
const wrapperCallSites = [];
|
|
const wrapperExecutionScopeIndexes = [];
|
|
let definitionScanDepth = 0;
|
|
const lexicalScopeStacks = [
|
|
[fsWriteAliasScopes, Map],
|
|
[fsSafeStoreFactoryAliasScopes, Map],
|
|
[fsSafeStoreScopes, Map],
|
|
[fsSafeJsonStoreScopes, Map],
|
|
[fsModuleBindingScopes, Map],
|
|
[fsModulePropertyScopes, Map],
|
|
[requireAliasScopes, Map],
|
|
[createRequireShadowScopes, Set],
|
|
[legacyPathScopes, Map],
|
|
[literalTextScopes, Map],
|
|
[staticExpressionScopes, Map],
|
|
[knownUndefinedScopes, Map],
|
|
[legacyKnownObjectLiteralScopes, Map],
|
|
[legacyObjectPropertyScopes, Map],
|
|
[wrapperFunctionScopes, Map],
|
|
];
|
|
|
|
function withLexicalScope(isConditional, visitScope) {
|
|
for (const [scopes, Scope] of lexicalScopeStacks) {
|
|
scopes.push(new Scope());
|
|
}
|
|
conditionalExecutionScopes.push(isConditional);
|
|
try {
|
|
return visitScope();
|
|
} finally {
|
|
conditionalExecutionScopes.pop();
|
|
for (let index = lexicalScopeStacks.length - 1; index >= 0; index--) {
|
|
lexicalScopeStacks[index][0].pop();
|
|
}
|
|
}
|
|
}
|
|
|
|
function addViolation(node, kind, fingerprintNode = node) {
|
|
const callSite = kind === "legacy store filesystem write" ? wrapperCallSites[0] : null;
|
|
const reportedNode = callSite ?? node;
|
|
const line = toLine(sourceFile, reportedNode);
|
|
if (
|
|
consumeAllowedCurrentLegacyViolation(
|
|
currentLegacyWriteAllowances,
|
|
relativePath,
|
|
sourceFile,
|
|
callSite ?? fingerprintNode,
|
|
kind,
|
|
)
|
|
) {
|
|
return;
|
|
}
|
|
const key = `${line}:${kind}`;
|
|
if (seenViolations.has(key)) {
|
|
return;
|
|
}
|
|
seenViolations.add(key);
|
|
violations.push({ kind, line });
|
|
}
|
|
|
|
function resolveRequireAlias(name) {
|
|
return scopeForRead(requireAliasScopes, name)?.get(name) === true;
|
|
}
|
|
|
|
function isNodeRequireName(name) {
|
|
return resolveRequireAlias(name);
|
|
}
|
|
|
|
function isCreateRequireShadowed(name) {
|
|
return createRequireShadowScopes.some((scope) => scope.has(name));
|
|
}
|
|
|
|
function isCreateRequireExpression(expression) {
|
|
const call = unwrapExpression(expression);
|
|
return (
|
|
ts.isCallExpression(call) &&
|
|
ts.isIdentifier(unwrapExpression(call.expression)) &&
|
|
createRequireBindings.has(unwrapExpression(call.expression).text) &&
|
|
!isCreateRequireShadowed(unwrapExpression(call.expression).text)
|
|
);
|
|
}
|
|
|
|
function isRequireAliasExpression(expression) {
|
|
const value = unwrapExpression(expression);
|
|
return (
|
|
isCreateRequireExpression(value) ||
|
|
(ts.isIdentifier(value) && resolveRequireAlias(value.text))
|
|
);
|
|
}
|
|
|
|
function resolveFsModuleBinding(name) {
|
|
return scopeForRead(fsModuleBindingScopes, name)?.get(name) === true;
|
|
}
|
|
|
|
function resolveFsModuleProperty(pathParts) {
|
|
const fullPath = pathParts.join(".");
|
|
const prefixes = pathParts.map((_, index) => pathParts.slice(0, index + 1).join("."));
|
|
for (let index = fsModulePropertyScopes.length - 1; index >= 0; index--) {
|
|
const scope = fsModulePropertyScopes[index];
|
|
if (scope.has(fullPath)) {
|
|
return scope.get(fullPath) === true;
|
|
}
|
|
for (const prefix of prefixes) {
|
|
if (scope.get(prefix) === false) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function resolveFsWriteAlias(name) {
|
|
return scopeForRead(fsWriteAliasScopes, name)?.get(name) ?? null;
|
|
}
|
|
|
|
function resolveFsSafeStoreFactoryAlias(name) {
|
|
return scopeForRead(fsSafeStoreFactoryAliasScopes, name)?.get(name) ?? null;
|
|
}
|
|
|
|
function resolveFsSafeStore(name) {
|
|
const value = lookupFsSafeStore(name);
|
|
return value === true;
|
|
}
|
|
|
|
function lookupFsSafeStore(name) {
|
|
const scope = scopeForRead(fsSafeStoreScopes, name);
|
|
return scope ? scope.get(name) === true : null;
|
|
}
|
|
|
|
function resolveFsSafeJsonStore(name) {
|
|
const value = lookupFsSafeJsonStore(name);
|
|
return value === true;
|
|
}
|
|
|
|
function lookupFsSafeJsonStore(name) {
|
|
const scope = scopeForRead(fsSafeJsonStoreScopes, name);
|
|
return scope ? scope.get(name) === true : null;
|
|
}
|
|
|
|
function lookupKnownLegacyObjectLiteral(name) {
|
|
for (let index = legacyKnownObjectLiteralScopes.length - 1; index >= 0; index--) {
|
|
const scope = legacyKnownObjectLiteralScopes[index];
|
|
if (scope.has(name)) {
|
|
return scope.get(name) === true;
|
|
}
|
|
if (legacyPathScopes[index].has(name)) {
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isKnownLegacyObjectLiteralExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
return (
|
|
ts.isObjectLiteralExpression(unwrapped) ||
|
|
(ts.isIdentifier(unwrapped) && lookupKnownLegacyObjectLiteral(unwrapped.text))
|
|
);
|
|
}
|
|
|
|
function markKnownLegacyObjectLiteral(
|
|
name,
|
|
initializer,
|
|
targetScope = lastScope(legacyKnownObjectLiteralScopes),
|
|
) {
|
|
targetScope.set(name, isKnownLegacyObjectLiteralExpression(initializer));
|
|
}
|
|
|
|
function createBranchEffects() {
|
|
return {
|
|
fsIdentifierAssignments: new Map(),
|
|
fsSafePropertyAssignments: new Map(),
|
|
identifierAssignments: new Map(),
|
|
propertyAssignments: new Map(),
|
|
wrapperAssignments: new Map(),
|
|
};
|
|
}
|
|
|
|
function objectPropertyKey(objectName, propertyName) {
|
|
return `${objectName}.${propertyName}`;
|
|
}
|
|
|
|
function shadowObjectPropertyScopes(scopes, objectName, value, targetScope = lastScope(scopes)) {
|
|
const prefix = `${objectName}.`;
|
|
for (const scope of scopes) {
|
|
for (const name of scope.keys()) {
|
|
if (name.startsWith(prefix)) {
|
|
targetScope.set(name, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function visitObjectLiteralProperties(objectName, initializer, onProperty, onSpread = null) {
|
|
const objectLiteral = unwrapExpression(initializer);
|
|
if (!ts.isObjectLiteralExpression(objectLiteral)) {
|
|
return;
|
|
}
|
|
for (const property of objectLiteral.properties) {
|
|
if (ts.isSpreadAssignment(property)) {
|
|
onSpread?.(unwrapExpression(property.expression));
|
|
continue;
|
|
}
|
|
const isAssignment = ts.isPropertyAssignment(property);
|
|
const name = isAssignment
|
|
? propertyNameText(property.name)
|
|
: ts.isShorthandPropertyAssignment(property)
|
|
? property.name.text
|
|
: null;
|
|
if (name) {
|
|
onProperty(`${objectName}.${name}`, isAssignment ? property.initializer : property.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveLegacyPathIdentifier(name) {
|
|
return scopeForRead(legacyPathScopes, name)?.get(name) === true;
|
|
}
|
|
|
|
function resolveLiteralTextIdentifier(name) {
|
|
return scopeForRead(literalTextScopes, name)?.get(name) ?? [];
|
|
}
|
|
|
|
function resolveStaticExpression(name) {
|
|
return scopeForRead(staticExpressionScopes, name)?.get(name) ?? null;
|
|
}
|
|
|
|
function resolveKnownUndefinedIdentifier(name) {
|
|
return scopeForRead(knownUndefinedScopes, name)?.get(name) === true;
|
|
}
|
|
|
|
function requireAliasWriteTarget(name) {
|
|
for (let index = requireAliasScopes.length - 1; index >= 0; index--) {
|
|
const scope = requireAliasScopes[index];
|
|
if (scope.has(name)) {
|
|
return { index, scope };
|
|
}
|
|
}
|
|
return { index: requireAliasScopes.length - 1, scope: lastScope(requireAliasScopes) };
|
|
}
|
|
|
|
function expressionLiteralCandidateTexts(node) {
|
|
const candidates = legacyCandidateTexts(sourceFile, node);
|
|
const segmentOptions = [];
|
|
|
|
function combineSegmentOptions(left, right) {
|
|
const joined = left.flatMap((leftOption) =>
|
|
right.map((rightOption) => `${leftOption}${rightOption}`),
|
|
);
|
|
return joined.length > 32 ? joined.slice(0, 32) : joined;
|
|
}
|
|
|
|
function expressionSegmentOptions(current) {
|
|
const unwrapped = unwrapExpression(current);
|
|
if (ts.isStringLiteralLike(unwrapped)) {
|
|
return [unwrapped.text];
|
|
}
|
|
if (ts.isTemplateExpression(unwrapped)) {
|
|
let joined = [unwrapped.head.text];
|
|
for (const span of unwrapped.templateSpans) {
|
|
joined = combineSegmentOptions(joined, expressionSegmentOptions(span.expression));
|
|
joined = combineSegmentOptions(joined, [span.literal.text]);
|
|
}
|
|
return joined.length > 0 ? joined : ["*"];
|
|
}
|
|
if (
|
|
ts.isBinaryExpression(unwrapped) &&
|
|
unwrapped.operatorToken.kind === ts.SyntaxKind.PlusToken
|
|
) {
|
|
return combineSegmentOptions(
|
|
expressionSegmentOptions(unwrapped.left),
|
|
expressionSegmentOptions(unwrapped.right),
|
|
);
|
|
}
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
const texts = resolveLiteralTextIdentifier(unwrapped.text);
|
|
return texts.length > 0 ? texts : ["*"];
|
|
}
|
|
return ["*"];
|
|
}
|
|
|
|
function maybeAddCallLiteralCandidate(current) {
|
|
if (!ts.isCallExpression(current) || current.arguments.length < 2) {
|
|
return;
|
|
}
|
|
const argumentOptions = current.arguments.map((argument) =>
|
|
expressionSegmentOptions(argument),
|
|
);
|
|
if (!argumentOptions.some((options) => options.some((option) => option !== "*"))) {
|
|
return;
|
|
}
|
|
let joined = [""];
|
|
for (const options of argumentOptions) {
|
|
joined = joined.flatMap((prefix) =>
|
|
options.map((option) => (prefix.length === 0 ? option : `${prefix}/${option}`)),
|
|
);
|
|
if (joined.length > 32) {
|
|
joined = joined.slice(0, 32);
|
|
}
|
|
}
|
|
candidates.push(...joined);
|
|
}
|
|
|
|
function visitCandidate(current) {
|
|
maybeAddCallLiteralCandidate(current);
|
|
if (ts.isStringLiteralLike(current)) {
|
|
segmentOptions.push([current.text]);
|
|
return;
|
|
}
|
|
if (ts.isIdentifier(current)) {
|
|
const texts = resolveLiteralTextIdentifier(current.text);
|
|
if (texts.length > 0) {
|
|
segmentOptions.push(texts);
|
|
}
|
|
}
|
|
ts.forEachChild(current, visitCandidate);
|
|
}
|
|
const expressionOptions = expressionSegmentOptions(node);
|
|
if (expressionOptions.some((option) => option !== "*")) {
|
|
candidates.push(...expressionOptions);
|
|
}
|
|
visitCandidate(node);
|
|
if (segmentOptions.length > 1) {
|
|
let joined = [""];
|
|
for (const options of segmentOptions) {
|
|
joined = joined.flatMap((prefix) =>
|
|
options.map((option) => (prefix.length === 0 ? option : `${prefix}/${option}`)),
|
|
);
|
|
if (joined.length > 32) {
|
|
joined = joined.slice(0, 32);
|
|
}
|
|
}
|
|
candidates.push(...joined);
|
|
}
|
|
return candidates;
|
|
}
|
|
|
|
function expressionTextContainsLegacyStore(node) {
|
|
return expressionLiteralCandidateTexts(node).some((text) =>
|
|
legacyStorePatterns.some((pattern) => pattern.test(text)),
|
|
);
|
|
}
|
|
|
|
function literalTextsFromExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isStringLiteralLike(unwrapped)) {
|
|
return [unwrapped.text];
|
|
}
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return resolveLiteralTextIdentifier(unwrapped.text);
|
|
}
|
|
return [];
|
|
}
|
|
|
|
function arrayLiteralElementAt(expression, index) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (!ts.isArrayLiteralExpression(unwrapped)) {
|
|
return null;
|
|
}
|
|
const element = unwrapped.elements[index];
|
|
return element && !ts.isSpreadElement(element) ? element : null;
|
|
}
|
|
|
|
function legacyObjectPropertyRewriteValues(objectName, initializer, existingScope) {
|
|
const values = new Map();
|
|
markLegacyObjectProperties(objectName, initializer, values, null);
|
|
if (isKnownLegacyObjectLiteralExpression(initializer)) {
|
|
const descendantPrefix = `${objectName}.`;
|
|
for (const key of existingScope.keys()) {
|
|
if (key.startsWith(descendantPrefix) && !values.has(key)) {
|
|
values.set(key, explicitUndefinedLegacyObjectPropertyValue);
|
|
}
|
|
}
|
|
}
|
|
return values;
|
|
}
|
|
|
|
function lookupLegacyObjectProperty(
|
|
objectName,
|
|
propertyName,
|
|
maxScopeIndex = legacyObjectPropertyScopes.length - 1,
|
|
) {
|
|
const result = lookupLegacyObjectPropertyEntry(objectName, propertyName, maxScopeIndex);
|
|
if (result.found) {
|
|
return result.value === true;
|
|
}
|
|
if (result.objectKnown) {
|
|
return result.objectValue ? null : false;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function lookupLegacyObjectPropertyEntry(
|
|
objectName,
|
|
propertyName,
|
|
maxScopeIndex = legacyObjectPropertyScopes.length - 1,
|
|
) {
|
|
const key = objectPropertyKey(objectName, propertyName);
|
|
for (
|
|
let index = Math.min(maxScopeIndex, legacyObjectPropertyScopes.length - 1);
|
|
index >= 0;
|
|
index--
|
|
) {
|
|
const propertyScope = legacyObjectPropertyScopes[index];
|
|
if (propertyScope.has(key)) {
|
|
return { found: true, value: propertyScope.get(key) };
|
|
}
|
|
if (legacyPathScopes[index].has(objectName)) {
|
|
return {
|
|
found: false,
|
|
objectKnown: true,
|
|
objectValue: legacyPathScopes[index].get(objectName) === true,
|
|
};
|
|
}
|
|
}
|
|
return { found: false, objectKnown: false, objectValue: false };
|
|
}
|
|
|
|
function lookupScopedLegacyObjectPropertyEntry(
|
|
objectName,
|
|
propertyPath,
|
|
propertyScope,
|
|
knownObjectLiteralScope,
|
|
) {
|
|
const propertyName = propertyPath.join(".");
|
|
const key = objectPropertyKey(objectName, propertyName);
|
|
if (propertyScope.has(key)) {
|
|
return { found: true, value: propertyScope.get(key) };
|
|
}
|
|
const parentPath = propertyPath.slice(0, -1).join(".");
|
|
const parentKey = parentPath ? objectPropertyKey(objectName, parentPath) : objectName;
|
|
if (knownObjectLiteralScope.get(parentKey) === true) {
|
|
return { found: false, objectKnown: true, objectValue: false };
|
|
}
|
|
return { found: false, objectKnown: false, objectValue: false };
|
|
}
|
|
|
|
function legacyObjectPropertyValueFromExpression(expression) {
|
|
return isKnownUndefinedExpression(expression)
|
|
? explicitUndefinedLegacyObjectPropertyValue
|
|
: expressionContainsLegacyStore(expression);
|
|
}
|
|
|
|
function elementAccessNames(expression) {
|
|
const argument = unwrapExpression(expression);
|
|
if (ts.isStringLiteral(argument) || ts.isNumericLiteral(argument)) {
|
|
return [argument.text];
|
|
}
|
|
return ts.isIdentifier(argument) ? resolveLiteralTextIdentifier(argument.text) : [];
|
|
}
|
|
|
|
function elementAccessName(expression) {
|
|
const names = elementAccessNames(expression);
|
|
return names.length === 1 ? names[0] : null;
|
|
}
|
|
|
|
function propertyAccessPath(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return [unwrapped.text];
|
|
}
|
|
if (ts.isPropertyAccessExpression(unwrapped)) {
|
|
const parentPath = propertyAccessPath(unwrapped.expression);
|
|
return parentPath ? [...parentPath, unwrapped.name.text] : null;
|
|
}
|
|
if (ts.isElementAccessExpression(unwrapped)) {
|
|
const propertyName = elementAccessName(unwrapped.argumentExpression);
|
|
if (!propertyName) {
|
|
return null;
|
|
}
|
|
const parentPath = propertyAccessPath(unwrapped.expression);
|
|
return parentPath ? [...parentPath, propertyName] : null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function legacyObjectPropertyWriteTarget(objectName, propertyName) {
|
|
const key = objectPropertyKey(objectName, propertyName);
|
|
for (let index = legacyObjectPropertyScopes.length - 1; index >= 0; index--) {
|
|
const propertyScope = legacyObjectPropertyScopes[index];
|
|
if (propertyScope.has(key) || legacyPathScopes[index].has(objectName)) {
|
|
return { index, scope: propertyScope };
|
|
}
|
|
}
|
|
return {
|
|
index: legacyObjectPropertyScopes.length - 1,
|
|
scope: lastScope(legacyObjectPropertyScopes),
|
|
};
|
|
}
|
|
|
|
function legacyIdentifierWriteScopes(name) {
|
|
for (let index = legacyPathScopes.length - 1; index >= 0; index--) {
|
|
if (legacyPathScopes[index].has(name)) {
|
|
return {
|
|
index,
|
|
pathScope: legacyPathScopes[index],
|
|
propertyScope: legacyObjectPropertyScopes[index],
|
|
wrapperScope: wrapperFunctionScopes[index],
|
|
};
|
|
}
|
|
}
|
|
return {
|
|
index: legacyPathScopes.length - 1,
|
|
pathScope: lastScope(legacyPathScopes),
|
|
propertyScope: lastScope(legacyObjectPropertyScopes),
|
|
wrapperScope: lastScope(wrapperFunctionScopes),
|
|
};
|
|
}
|
|
|
|
function isConditionallyExecutedScope(node) {
|
|
const parent = node.parent;
|
|
return Boolean(
|
|
(ts.isBlock(node) &&
|
|
parent &&
|
|
((ts.isIfStatement(parent) &&
|
|
(parent.thenStatement === node || parent.elseStatement === node)) ||
|
|
(ts.isIterationStatement(parent, false) && parent.statement === node) ||
|
|
(ts.isTryStatement(parent) && parent.tryBlock === node))) ||
|
|
ts.isCaseBlock(node) ||
|
|
ts.isCatchClause(node),
|
|
);
|
|
}
|
|
|
|
function expressionContainsLegacyStore(node) {
|
|
if (expressionTextContainsLegacyStore(node)) {
|
|
return true;
|
|
}
|
|
let found = false;
|
|
function visitExpression(current) {
|
|
if (found) {
|
|
return;
|
|
}
|
|
if (
|
|
ts.isIdentifier(current) &&
|
|
!(ts.isPropertyAccessExpression(current.parent) && current.parent.name === current) &&
|
|
resolveLegacyPathIdentifier(current.text)
|
|
) {
|
|
found = true;
|
|
return;
|
|
}
|
|
const propertyAccess = rootedPropertyAccessCandidates(current);
|
|
if (propertyAccess?.propertyPaths.some((propertyPath) => propertyPath.length > 0)) {
|
|
const propertyValue = lookupLegacyObjectPropertyCandidates(propertyAccess);
|
|
if (propertyValue !== null) {
|
|
found = propertyValue;
|
|
return;
|
|
}
|
|
}
|
|
ts.forEachChild(current, visitExpression);
|
|
}
|
|
visitExpression(node);
|
|
return found;
|
|
}
|
|
|
|
function visitWithChildScope(node) {
|
|
withLexicalScope(
|
|
lastScope(conditionalExecutionScopes) || isConditionallyExecutedScope(node),
|
|
() => {
|
|
if ("statements" in node) {
|
|
registerHoistedWrapperFunctions(node.statements);
|
|
}
|
|
ts.forEachChild(node, visit);
|
|
},
|
|
);
|
|
}
|
|
|
|
function registerFsBindingParameter(name) {
|
|
if (ts.isIdentifier(name)) {
|
|
lastScope(fsModuleBindingScopes).set(name.text, true);
|
|
return;
|
|
}
|
|
if (!ts.isObjectBindingPattern(name)) {
|
|
return;
|
|
}
|
|
for (const element of name.elements) {
|
|
const importedName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (importedName === "promises") {
|
|
if (ts.isIdentifier(element.name)) {
|
|
lastScope(fsModuleBindingScopes).set(element.name.text, true);
|
|
} else if (ts.isObjectBindingPattern(element.name)) {
|
|
registerFsPromisesBindingParameter(element.name);
|
|
}
|
|
}
|
|
if (importedName && legacyWriteCallees.has(importedName) && ts.isIdentifier(element.name)) {
|
|
lastScope(fsWriteAliasScopes).set(element.name.text, importedName);
|
|
}
|
|
}
|
|
}
|
|
|
|
function registerFsPromisesBindingParameter(name) {
|
|
if (!ts.isObjectBindingPattern(name)) {
|
|
return;
|
|
}
|
|
for (const element of name.elements) {
|
|
const importedName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (importedName && legacyWriteCallees.has(importedName) && ts.isIdentifier(element.name)) {
|
|
lastScope(fsWriteAliasScopes).set(element.name.text, importedName);
|
|
}
|
|
if (ts.isObjectBindingPattern(element.name)) {
|
|
registerFsPromisesBindingParameter(element.name);
|
|
}
|
|
}
|
|
}
|
|
|
|
function visitFunctionLike(node, fsBindingParameterIndexes = new Set()) {
|
|
withLexicalScope(false, () => {
|
|
if (node.name && ts.isIdentifier(node.name)) {
|
|
markFsWriteAliasShadows(node.name);
|
|
markFsSafeStoreShadows(node.name);
|
|
markFsModuleBindingShadows(node.name);
|
|
markFsModulePropertyShadows(node.name);
|
|
markCreateRequireShadows(node.name);
|
|
lastScope(wrapperFunctionScopes).set(node.name.text, wrapperRecordForNode(node));
|
|
}
|
|
node.parameters.forEach((parameter, index) => {
|
|
for (const name of bindingPatternNames(parameter.name)) {
|
|
lastScope(legacyPathScopes).set(name, false);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(name, false);
|
|
lastScope(knownUndefinedScopes).set(name, false);
|
|
lastScope(literalTextScopes).set(name, null);
|
|
lastScope(wrapperFunctionScopes).set(name, null);
|
|
lastScope(requireAliasScopes).set(name, false);
|
|
}
|
|
markFsWriteAliasShadows(parameter.name);
|
|
markFsSafeStoreShadows(parameter.name);
|
|
markFsModuleBindingShadows(parameter.name);
|
|
markFsModulePropertyShadows(parameter.name);
|
|
markCreateRequireShadows(parameter.name);
|
|
registerFsModuleTypeProperties(parameter.name, parameter.type);
|
|
if (fsBindingParameterIndexes.has(index)) {
|
|
registerFsBindingParameter(parameter.name);
|
|
}
|
|
});
|
|
definitionScanDepth += 1;
|
|
try {
|
|
ts.forEachChild(node, visit);
|
|
} finally {
|
|
definitionScanDepth -= 1;
|
|
}
|
|
});
|
|
}
|
|
|
|
function dynamicFsImportThenCallback(node) {
|
|
const callee = unwrapExpression(node.expression);
|
|
if (
|
|
!ts.isPropertyAccessExpression(callee) ||
|
|
callee.name.text !== "then" ||
|
|
!isFsDynamicImportExpression(callee.expression)
|
|
) {
|
|
return null;
|
|
}
|
|
const [callback] = node.arguments;
|
|
return callback && ts.isFunctionLike(callback) ? callback : null;
|
|
}
|
|
|
|
function isFsModuleExpression(expression) {
|
|
const receiver = unwrapExpression(expression);
|
|
if (
|
|
isFsRequireExpression(receiver, isNodeRequireName) ||
|
|
isFsDynamicImportExpression(receiver)
|
|
) {
|
|
return true;
|
|
}
|
|
if (ts.isIdentifier(receiver)) {
|
|
return resolveFsModuleBinding(receiver.text);
|
|
}
|
|
const receiverPath = propertyAccessPath(receiver);
|
|
if (receiverPath && resolveFsModuleProperty(receiverPath)) {
|
|
return true;
|
|
}
|
|
return (
|
|
ts.isPropertyAccessExpression(receiver) &&
|
|
receiver.name.text === "promises" &&
|
|
(isFsRequireExpression(receiver.expression, isNodeRequireName) ||
|
|
isFsDynamicImportExpression(receiver.expression) ||
|
|
(ts.isIdentifier(receiver.expression) &&
|
|
resolveFsModuleBinding(receiver.expression.text)) ||
|
|
(propertyAccessPath(receiver.expression) &&
|
|
resolveFsModuleProperty(propertyAccessPath(receiver.expression))))
|
|
);
|
|
}
|
|
|
|
function legacyFsWriteName(expression, aliases = null) {
|
|
const callee = unwrapExpression(expression);
|
|
if (ts.isPropertyAccessExpression(callee)) {
|
|
const aliasedName = callExpressionName(callee);
|
|
const writeAlias = aliasedName ? resolveFsWriteAlias(aliasedName) : null;
|
|
if (writeAlias) {
|
|
return writeAlias;
|
|
}
|
|
return legacyWriteCallees.has(callee.name.text) && isFsModuleExpression(callee.expression)
|
|
? callee.name.text
|
|
: null;
|
|
}
|
|
if (ts.isElementAccessExpression(callee)) {
|
|
const aliasedName = callExpressionName(callee);
|
|
const writeAlias = aliasedName ? resolveFsWriteAlias(aliasedName) : null;
|
|
if (writeAlias) {
|
|
return writeAlias;
|
|
}
|
|
const writeName = elementAccessName(callee.argumentExpression);
|
|
return writeName &&
|
|
legacyWriteCallees.has(writeName) &&
|
|
isFsModuleExpression(callee.expression)
|
|
? writeName
|
|
: null;
|
|
}
|
|
if (!ts.isIdentifier(callee)) {
|
|
return null;
|
|
}
|
|
return aliases && aliases.has(callee.text)
|
|
? aliases.get(callee.text)
|
|
: resolveFsWriteAlias(callee.text);
|
|
}
|
|
|
|
function fsSafeStoreFactoryAliasName(expression) {
|
|
const callee = unwrapExpression(expression);
|
|
if (ts.isIdentifier(callee)) {
|
|
return resolveFsSafeStoreFactoryAlias(callee.text);
|
|
}
|
|
const name = callExpressionName(callee);
|
|
return name ? resolveFsSafeStoreFactoryAlias(name) : null;
|
|
}
|
|
|
|
function isFsSafeStoreFactoryCall(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
const call = ts.isAwaitExpression(unwrapped)
|
|
? unwrapExpression(unwrapped.expression)
|
|
: unwrapped;
|
|
if (!ts.isCallExpression(call)) {
|
|
return false;
|
|
}
|
|
const callee = unwrapExpression(call.expression);
|
|
if (ts.isPropertyAccessExpression(callee) || ts.isElementAccessExpression(callee)) {
|
|
const methodName = ts.isPropertyAccessExpression(callee)
|
|
? callee.name.text
|
|
: elementAccessName(callee.argumentExpression);
|
|
if (methodName === "root" && isFsSafeStoreExpression(callee.expression)) {
|
|
return true;
|
|
}
|
|
}
|
|
const name = callExpressionName(call.expression);
|
|
const factoryName = name ? resolveFsSafeStoreFactoryAlias(name) : null;
|
|
return Boolean(factoryName && fsSafeStoreFactoryCallees.has(factoryName));
|
|
}
|
|
|
|
function isFsSafeStoreExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (isFsSafeStoreFactoryCall(unwrapped)) {
|
|
return true;
|
|
}
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return resolveFsSafeStore(unwrapped.text);
|
|
}
|
|
const receiverPath = propertyAccessPath(unwrapped);
|
|
if (receiverPath) {
|
|
return resolveFsSafeStore(receiverPath.join("."));
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function objectFilePathContainsLegacyStore(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return lookupLegacyObjectProperty(unwrapped.text, "filePath") === true;
|
|
}
|
|
if (!ts.isObjectLiteralExpression(unwrapped)) {
|
|
return expressionContainsLegacyStore(unwrapped);
|
|
}
|
|
return objectLiteralPropertyContainsLegacyStore(unwrapped, "filePath");
|
|
}
|
|
|
|
function expressionContainsFsSafeJsonStoreLegacyPath(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return resolveFsSafeJsonStore(unwrapped.text);
|
|
}
|
|
const receiverPath = propertyAccessPath(unwrapped);
|
|
if (receiverPath && resolveFsSafeJsonStore(receiverPath.join("."))) {
|
|
return true;
|
|
}
|
|
if (!ts.isCallExpression(unwrapped)) {
|
|
return false;
|
|
}
|
|
const callName = callExpressionName(unwrapped.expression);
|
|
const factoryName = callName ? resolveFsSafeStoreFactoryAlias(callName) : null;
|
|
if (factoryName && fsSafeJsonStoreFactoryCallees.has(factoryName)) {
|
|
const options = unwrapped.arguments[0];
|
|
return options ? objectFilePathContainsLegacyStore(options) : false;
|
|
}
|
|
const callee = unwrapExpression(unwrapped.expression);
|
|
if (!ts.isPropertyAccessExpression(callee) && !ts.isElementAccessExpression(callee)) {
|
|
return false;
|
|
}
|
|
const methodName = ts.isPropertyAccessExpression(callee)
|
|
? callee.name.text
|
|
: elementAccessName(callee.argumentExpression);
|
|
if (methodName !== "json" || !isFsSafeStoreExpression(callee.expression)) {
|
|
return false;
|
|
}
|
|
const pathArgument = unwrapped.arguments[0];
|
|
return pathArgument ? pathArgumentContainsLegacyStore(pathArgument) : false;
|
|
}
|
|
|
|
function fsSafeJsonStoreWriteContainsLegacyStore(call) {
|
|
const callee = unwrapExpression(call.expression);
|
|
if (!ts.isPropertyAccessExpression(callee) && !ts.isElementAccessExpression(callee)) {
|
|
return false;
|
|
}
|
|
const methodName = ts.isPropertyAccessExpression(callee)
|
|
? callee.name.text
|
|
: elementAccessName(callee.argumentExpression);
|
|
if (!methodName || !fsSafeJsonStoreWriteMethods.has(methodName)) {
|
|
return false;
|
|
}
|
|
return expressionContainsFsSafeJsonStoreLegacyPath(callee.expression);
|
|
}
|
|
|
|
function fsSafeStoreWritePathArguments(call) {
|
|
const callee = unwrapExpression(call.expression);
|
|
if (!ts.isPropertyAccessExpression(callee) && !ts.isElementAccessExpression(callee)) {
|
|
return [];
|
|
}
|
|
const methodName = ts.isPropertyAccessExpression(callee)
|
|
? callee.name.text
|
|
: elementAccessName(callee.argumentExpression);
|
|
if (!methodName || !fsSafeStoreWriteMethods.has(methodName)) {
|
|
return [];
|
|
}
|
|
if (!isFsSafeStoreExpression(callee.expression)) {
|
|
return [];
|
|
}
|
|
if (methodName === "move") {
|
|
return [...call.arguments].slice(0, 2);
|
|
}
|
|
return call.arguments[0] ? [call.arguments[0]] : [];
|
|
}
|
|
|
|
function markFsWriteAliasShadows(name) {
|
|
for (const bindingName of bindingPatternNames(name)) {
|
|
if (resolveFsWriteAlias(bindingName)) {
|
|
lastScope(fsWriteAliasScopes).set(bindingName, null);
|
|
}
|
|
shadowVisibleFsWriteObjectAliases(bindingName);
|
|
}
|
|
}
|
|
|
|
function markFsSafeStoreShadows(name) {
|
|
for (const bindingName of bindingPatternNames(name)) {
|
|
if (resolveFsSafeStoreFactoryAlias(bindingName)) {
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(bindingName, null);
|
|
}
|
|
shadowObjectPropertyScopes(fsSafeStoreFactoryAliasScopes, bindingName, null);
|
|
if (resolveFsSafeStore(bindingName)) {
|
|
lastScope(fsSafeStoreScopes).set(bindingName, false);
|
|
}
|
|
if (resolveFsSafeJsonStore(bindingName)) {
|
|
lastScope(fsSafeJsonStoreScopes).set(bindingName, false);
|
|
}
|
|
shadowObjectPropertyScopes(fsSafeStoreScopes, bindingName, false);
|
|
shadowObjectPropertyScopes(fsSafeJsonStoreScopes, bindingName, false);
|
|
}
|
|
}
|
|
|
|
function markFsModuleBindingShadows(name) {
|
|
for (const bindingName of bindingPatternNames(name)) {
|
|
if (resolveFsModuleBinding(bindingName)) {
|
|
lastScope(fsModuleBindingScopes).set(bindingName, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
function markFsModulePropertyShadows(name) {
|
|
for (const bindingName of bindingPatternNames(name)) {
|
|
clearFsModuleObjectProperties(lastScope(fsModulePropertyScopes), bindingName);
|
|
}
|
|
}
|
|
|
|
function markCreateRequireShadows(name) {
|
|
for (const bindingName of bindingPatternNames(name)) {
|
|
if (createRequireBindings.has(bindingName)) {
|
|
createRequireShadowScopes[createRequireShadowScopes.length - 1].add(bindingName);
|
|
}
|
|
}
|
|
}
|
|
|
|
function isFsModuleTypeNode(type) {
|
|
return Boolean(
|
|
type &&
|
|
/\btypeof\s+import\s*\(\s*["'](?:node:fs|node:fs\/promises|fs|fs\/promises)["']\s*\)/u.test(
|
|
type.getText(sourceFile),
|
|
),
|
|
);
|
|
}
|
|
|
|
function fsModulePropertyPathsFromType(type) {
|
|
const paths = [];
|
|
if (!type || !ts.isTypeLiteralNode(type)) {
|
|
return paths;
|
|
}
|
|
for (const member of type.members) {
|
|
if (!ts.isPropertySignature(member) || !member.type) {
|
|
continue;
|
|
}
|
|
const propertyName = propertyNameText(member.name);
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
if (isFsModuleTypeNode(member.type)) {
|
|
paths.push([propertyName]);
|
|
}
|
|
for (const nestedPath of fsModulePropertyPathsFromType(member.type)) {
|
|
paths.push([propertyName, ...nestedPath]);
|
|
}
|
|
}
|
|
return paths;
|
|
}
|
|
|
|
function registerFsModuleTypeProperties(name, type) {
|
|
if (!ts.isIdentifier(name) || !type) {
|
|
return;
|
|
}
|
|
if (isFsModuleTypeNode(type)) {
|
|
lastScope(fsModuleBindingScopes).set(name.text, true);
|
|
}
|
|
for (const pathParts of fsModulePropertyPathsFromType(type)) {
|
|
lastScope(fsModulePropertyScopes).set([name.text, ...pathParts].join("."), true);
|
|
}
|
|
}
|
|
|
|
function collectFsWriteAliasesFromBinding(node) {
|
|
collectFsWriteAliasesFromBindingInto(node, lastScope(fsWriteAliasScopes));
|
|
}
|
|
|
|
function clearFsWriteObjectAliases(scope, objectName) {
|
|
shadowObjectPropertyScopes([scope], objectName, null, scope);
|
|
}
|
|
|
|
function shadowVisibleFsWriteObjectAliases(objectName) {
|
|
shadowObjectPropertyScopes(fsWriteAliasScopes, objectName, null);
|
|
}
|
|
|
|
function setFsWriteObjectAlias(scope, name, writeName, conditionalWrite) {
|
|
if (writeName) {
|
|
scope.set(name, writeName);
|
|
} else if (!conditionalWrite) {
|
|
scope.set(name, null);
|
|
}
|
|
}
|
|
|
|
function registerFsWriteObjectAliases(
|
|
objectName,
|
|
initializer,
|
|
scope = lastScope(fsWriteAliasScopes),
|
|
conditionalWrite = false,
|
|
) {
|
|
visitObjectLiteralProperties(objectName, initializer, (name, value) => {
|
|
setFsWriteObjectAlias(scope, name, legacyFsWriteName(value), conditionalWrite);
|
|
});
|
|
}
|
|
|
|
function clearFsSafeStoreObjectAliases(storeScope, jsonStoreScope, objectName) {
|
|
shadowObjectPropertyScopes([storeScope], objectName, false, storeScope);
|
|
shadowObjectPropertyScopes([jsonStoreScope], objectName, false, jsonStoreScope);
|
|
}
|
|
|
|
function shadowVisibleFsSafeStoreObjectAliases(objectName) {
|
|
shadowObjectPropertyScopes(fsSafeStoreScopes, objectName, false);
|
|
shadowObjectPropertyScopes(fsSafeJsonStoreScopes, objectName, false);
|
|
}
|
|
|
|
function setFsSafeStoreObjectAlias(
|
|
storeScope,
|
|
jsonStoreScope,
|
|
name,
|
|
isStore,
|
|
isJsonStore,
|
|
conditionalWrite,
|
|
) {
|
|
if (isStore) {
|
|
storeScope.set(name, true);
|
|
} else if (!conditionalWrite) {
|
|
storeScope.set(name, false);
|
|
}
|
|
if (isJsonStore) {
|
|
jsonStoreScope.set(name, true);
|
|
} else if (!conditionalWrite) {
|
|
jsonStoreScope.set(name, false);
|
|
}
|
|
}
|
|
|
|
function copyFsSafeStoreObjectAliases(
|
|
targetName,
|
|
sourceName,
|
|
storeScope = lastScope(fsSafeStoreScopes),
|
|
jsonStoreScope = lastScope(fsSafeJsonStoreScopes),
|
|
) {
|
|
const sourcePrefix = `${sourceName}.`;
|
|
for (let index = fsSafeStoreScopes.length - 1; index >= 0; index--) {
|
|
const sourceStoreScope = fsSafeStoreScopes[index];
|
|
const sourceJsonStoreScope = fsSafeJsonStoreScopes[index];
|
|
let copied = false;
|
|
for (const [key, value] of sourceStoreScope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
storeScope.set(`${targetName}.${key.slice(sourcePrefix.length)}`, value);
|
|
copied = true;
|
|
}
|
|
}
|
|
for (const [key, value] of sourceJsonStoreScope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
jsonStoreScope.set(`${targetName}.${key.slice(sourcePrefix.length)}`, value);
|
|
copied = true;
|
|
}
|
|
}
|
|
if (copied || sourceStoreScope.has(sourceName) || sourceJsonStoreScope.has(sourceName)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function registerFsSafeStoreObjectAliases(
|
|
objectName,
|
|
initializer,
|
|
storeScope = lastScope(fsSafeStoreScopes),
|
|
jsonStoreScope = lastScope(fsSafeJsonStoreScopes),
|
|
conditionalWrite = false,
|
|
) {
|
|
visitObjectLiteralProperties(
|
|
objectName,
|
|
initializer,
|
|
(name, value) => {
|
|
setFsSafeStoreObjectAlias(
|
|
storeScope,
|
|
jsonStoreScope,
|
|
name,
|
|
isFsSafeStoreExpression(value),
|
|
expressionContainsFsSafeJsonStoreLegacyPath(value),
|
|
conditionalWrite,
|
|
);
|
|
if (ts.isObjectLiteralExpression(unwrapExpression(value))) {
|
|
registerFsSafeStoreObjectAliases(
|
|
name,
|
|
value,
|
|
storeScope,
|
|
jsonStoreScope,
|
|
conditionalWrite,
|
|
);
|
|
}
|
|
},
|
|
(spreadExpression) => {
|
|
if (ts.isIdentifier(spreadExpression)) {
|
|
copyFsSafeStoreObjectAliases(
|
|
objectName,
|
|
spreadExpression.text,
|
|
storeScope,
|
|
jsonStoreScope,
|
|
);
|
|
} else if (ts.isObjectLiteralExpression(spreadExpression)) {
|
|
registerFsSafeStoreObjectAliases(
|
|
objectName,
|
|
spreadExpression,
|
|
storeScope,
|
|
jsonStoreScope,
|
|
conditionalWrite,
|
|
);
|
|
}
|
|
},
|
|
);
|
|
}
|
|
|
|
function setFsModuleObjectProperty(scope, name, isFsModule, conditionalWrite) {
|
|
if (isFsModule) {
|
|
scope.set(name, true);
|
|
} else if (!conditionalWrite) {
|
|
scope.set(name, false);
|
|
}
|
|
}
|
|
|
|
function clearFsModuleObjectProperties(scope, objectName) {
|
|
scope.set(objectName, false);
|
|
shadowObjectPropertyScopes([scope], objectName, false, scope);
|
|
}
|
|
|
|
function registerFsModuleObjectProperties(
|
|
objectName,
|
|
initializer,
|
|
scope = lastScope(fsModulePropertyScopes),
|
|
conditionalWrite = false,
|
|
) {
|
|
visitObjectLiteralProperties(objectName, initializer, (name, value) => {
|
|
setFsModuleObjectProperty(scope, name, isFsModuleExpression(value), conditionalWrite);
|
|
});
|
|
}
|
|
|
|
function collectFsModuleBindingsFromBinding(node) {
|
|
if (
|
|
!ts.isVariableDeclaration(node) ||
|
|
!ts.isObjectBindingPattern(node.name) ||
|
|
!node.initializer ||
|
|
!isFsBindingExpression(node.initializer)
|
|
) {
|
|
return;
|
|
}
|
|
for (const element of node.name.elements) {
|
|
const propertyName = element.propertyName;
|
|
const bindingName = element.name;
|
|
const importedName = propertyName
|
|
? propertyNameText(propertyName)
|
|
: ts.isIdentifier(bindingName)
|
|
? bindingName.text
|
|
: null;
|
|
if (importedName === "promises" && ts.isIdentifier(bindingName)) {
|
|
lastScope(fsModuleBindingScopes).set(bindingName.text, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
function isFsBindingExpression(expression) {
|
|
const initializer = unwrapExpression(expression);
|
|
if (
|
|
isFsRequireExpression(initializer, isNodeRequireName) ||
|
|
isFsDynamicImportExpression(initializer)
|
|
) {
|
|
return true;
|
|
}
|
|
if (ts.isIdentifier(initializer)) {
|
|
return resolveFsModuleBinding(initializer.text);
|
|
}
|
|
return (
|
|
ts.isPropertyAccessExpression(initializer) &&
|
|
initializer.name.text === "promises" &&
|
|
(isFsRequireExpression(initializer.expression, isNodeRequireName) ||
|
|
isFsDynamicImportExpression(initializer.expression) ||
|
|
(ts.isIdentifier(initializer.expression) &&
|
|
resolveFsModuleBinding(initializer.expression.text)))
|
|
);
|
|
}
|
|
|
|
function collectFsWriteAliasesFromBindingInto(
|
|
node,
|
|
aliases,
|
|
isFsBinding = isFsBindingExpression,
|
|
) {
|
|
if (
|
|
!ts.isVariableDeclaration(node) ||
|
|
!ts.isObjectBindingPattern(node.name) ||
|
|
!node.initializer
|
|
) {
|
|
return;
|
|
}
|
|
if (!isFsBinding(node.initializer)) {
|
|
return;
|
|
}
|
|
collectFsWriteAliasesFromPattern(node.name, aliases);
|
|
}
|
|
|
|
function collectFsWriteAliasesFromPattern(pattern, aliases) {
|
|
for (const element of pattern.elements) {
|
|
const propertyName = element.propertyName;
|
|
const bindingName = element.name;
|
|
const importedName = propertyName
|
|
? propertyNameText(propertyName)
|
|
: ts.isIdentifier(bindingName)
|
|
? bindingName.text
|
|
: null;
|
|
if (!importedName) {
|
|
continue;
|
|
}
|
|
if (legacyWriteCallees.has(importedName) && ts.isIdentifier(bindingName)) {
|
|
aliases.set(bindingName.text, importedName);
|
|
}
|
|
if (importedName === "promises" && ts.isObjectBindingPattern(bindingName)) {
|
|
collectFsWriteAliasesFromPattern(bindingName, aliases);
|
|
}
|
|
}
|
|
}
|
|
|
|
function markArrayBindingPatternFromForOf(initializer, expression) {
|
|
if (!ts.isVariableDeclarationList(initializer)) {
|
|
return;
|
|
}
|
|
const declaration = initializer.declarations[0];
|
|
if (!declaration || !ts.isArrayBindingPattern(declaration.name)) {
|
|
return;
|
|
}
|
|
const iterable = unwrapExpression(expression);
|
|
if (!ts.isArrayLiteralExpression(iterable)) {
|
|
return;
|
|
}
|
|
|
|
declaration.name.elements.forEach((bindingElement, index) => {
|
|
if (ts.isOmittedExpression(bindingElement) || !ts.isIdentifier(bindingElement.name)) {
|
|
return;
|
|
}
|
|
|
|
const elementsAtIndex = iterable.elements
|
|
.map((element) => arrayLiteralElementAt(element, index))
|
|
.filter(Boolean);
|
|
if (elementsAtIndex.length === 0) {
|
|
return;
|
|
}
|
|
|
|
lastScope(legacyPathScopes).set(
|
|
bindingElement.name.text,
|
|
elementsAtIndex.some((element) => expressionContainsLegacyStore(element)),
|
|
);
|
|
lastScope(literalTextScopes).set(
|
|
bindingElement.name.text,
|
|
mergeExhaustiveLiteralTexts(
|
|
[],
|
|
elementsAtIndex.flatMap((element) => literalTextsFromExpression(element)),
|
|
),
|
|
);
|
|
});
|
|
}
|
|
|
|
function pathArgumentsForFsWrite(name, args) {
|
|
if (
|
|
name === "appendRegularFile" ||
|
|
name === "appendRegularFileSync" ||
|
|
name === "replaceFileAtomic" ||
|
|
name === "replaceFileAtomicSync"
|
|
) {
|
|
const first = args[0];
|
|
if (!first || !ts.isObjectLiteralExpression(unwrapExpression(first))) {
|
|
return first ? [first] : [];
|
|
}
|
|
const objectArg = unwrapExpression(first);
|
|
return objectArg.properties.flatMap((property) => {
|
|
if (ts.isPropertyAssignment(property)) {
|
|
const key = property.name;
|
|
const propertyName =
|
|
ts.isIdentifier(key) || ts.isStringLiteral(key) || ts.isNumericLiteral(key)
|
|
? key.text
|
|
: null;
|
|
return propertyName === "filePath" ? [property.initializer] : [];
|
|
}
|
|
if (ts.isShorthandPropertyAssignment(property) && property.name.text === "filePath") {
|
|
return [property.name];
|
|
}
|
|
return [];
|
|
});
|
|
}
|
|
if (
|
|
name === "saveJsonFile" ||
|
|
name === "writeJson" ||
|
|
name === "writeJsonAtomic" ||
|
|
name === "writeJsonFileAtomically" ||
|
|
name === "writeJsonSync" ||
|
|
name === "writeTextAtomic"
|
|
) {
|
|
return args.slice(0, 1);
|
|
}
|
|
if (name === "copyFile" || name === "copyFileSync" || name === "cp" || name === "cpSync") {
|
|
return args.slice(1, 2);
|
|
}
|
|
if (name === "rename" || name === "renameSync") {
|
|
return args.slice(0, 2);
|
|
}
|
|
return args.slice(0, 1);
|
|
}
|
|
|
|
function openFlagsMayWrite(flags) {
|
|
if (!flags) {
|
|
return false;
|
|
}
|
|
const unwrapped = unwrapExpression(flags);
|
|
if (ts.isStringLiteralLike(unwrapped)) {
|
|
return /[wa+]/u.test(unwrapped.text);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function fsWriteCallMayWrite(name, args) {
|
|
if (name === "open" || name === "openSync") {
|
|
return openFlagsMayWrite(args[1]);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function propertyNameText(name) {
|
|
if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) {
|
|
return name.text;
|
|
}
|
|
if (ts.isComputedPropertyName(name)) {
|
|
return elementAccessName(name.expression);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function isVarVariableDeclaration(node) {
|
|
return (
|
|
ts.isVariableDeclarationList(node.parent) &&
|
|
(node.parent.flags & ts.NodeFlags.BlockScoped) === 0
|
|
);
|
|
}
|
|
|
|
function isAmbientVariableDeclaration(node) {
|
|
let current = node.parent;
|
|
while (current && !ts.isSourceFile(current)) {
|
|
const modifiers = ts.canHaveModifiers(current) ? (ts.getModifiers(current) ?? []) : [];
|
|
if (modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DeclareKeyword)) {
|
|
return true;
|
|
}
|
|
current = current.parent;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function isTypeSyntaxNode(node) {
|
|
return node.kind >= ts.SyntaxKind.FirstTypeNode && node.kind <= ts.SyntaxKind.LastTypeNode;
|
|
}
|
|
|
|
function objectLiteralPropertyLegacyValue(objectLiteral, propertyName) {
|
|
let result = null;
|
|
for (const property of objectLiteral.properties) {
|
|
if (ts.isSpreadAssignment(property)) {
|
|
const spreadExpression = unwrapExpression(property.expression);
|
|
if (ts.isIdentifier(spreadExpression)) {
|
|
const propertyValue = lookupLegacyObjectProperty(spreadExpression.text, propertyName);
|
|
if (propertyValue !== null) {
|
|
result = propertyValue;
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isObjectLiteralExpression(spreadExpression)) {
|
|
const propertyValue = objectLiteralPropertyLegacyValue(spreadExpression, propertyName);
|
|
if (propertyValue !== null) {
|
|
result = propertyValue;
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isPropertyAssignment(property) && propertyNameText(property.name) === propertyName) {
|
|
result = expressionContainsLegacyStore(property.initializer);
|
|
continue;
|
|
}
|
|
if (ts.isShorthandPropertyAssignment(property) && property.name.text === propertyName) {
|
|
result = expressionContainsLegacyStore(property.name);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function objectLiteralPropertyContainsLegacyStore(objectLiteral, propertyName) {
|
|
return objectLiteralPropertyLegacyValue(objectLiteral, propertyName) === true;
|
|
}
|
|
|
|
function clearLegacyObjectProperties(scope, objectName) {
|
|
const prefix = `${objectName}.`;
|
|
for (const key of scope.keys()) {
|
|
if (key.startsWith(prefix)) {
|
|
scope.delete(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
function clearKnownLegacyObjectLiterals(scope, objectName) {
|
|
const prefix = `${objectName}.`;
|
|
for (const key of scope.keys()) {
|
|
if (key.startsWith(prefix)) {
|
|
scope.delete(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
function legacyObjectPropertiesFromAssignment(
|
|
objectName,
|
|
initializer,
|
|
existingScope = new Map(),
|
|
) {
|
|
return legacyObjectPropertyRewriteValues(objectName, initializer, existingScope);
|
|
}
|
|
|
|
function legacyKnownObjectLiteralsFromAssignment(objectName, initializer) {
|
|
const knownObjectLiterals = new Map();
|
|
markLegacyObjectProperties(objectName, initializer, new Map(), knownObjectLiterals);
|
|
return knownObjectLiterals;
|
|
}
|
|
|
|
function branchIdentifierAssignmentKey(index, name) {
|
|
return `${index}:${name}`;
|
|
}
|
|
|
|
function branchPropertyAssignmentKey(index, objectName, propertyName) {
|
|
return `${index}:${objectPropertyKey(objectName, propertyName)}`;
|
|
}
|
|
|
|
function branchWrapperAssignmentKey(index, name) {
|
|
return `${index}:${name}`;
|
|
}
|
|
|
|
function recordBranchIdentifierAssignment(
|
|
index,
|
|
name,
|
|
value,
|
|
initializer,
|
|
literalTexts,
|
|
objectProperties = null,
|
|
knownUndefined = isKnownUndefinedExpression(initializer),
|
|
) {
|
|
const effects = lastScope(branchEffectScopes);
|
|
if (!effects) {
|
|
return;
|
|
}
|
|
effects.identifierAssignments.set(branchIdentifierAssignmentKey(index, name), {
|
|
index,
|
|
knownUndefined,
|
|
knownObjectLiteral: isKnownLegacyObjectLiteralExpression(initializer),
|
|
knownObjectLiterals: legacyKnownObjectLiteralsFromAssignment(name, initializer),
|
|
literalTexts,
|
|
name,
|
|
value,
|
|
objectProperties: objectProperties ?? legacyObjectPropertiesFromAssignment(name, initializer),
|
|
});
|
|
const prefix = `${index}:${name}.`;
|
|
for (const key of effects.propertyAssignments.keys()) {
|
|
if (key.startsWith(prefix)) {
|
|
effects.propertyAssignments.delete(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
function recordBranchPropertyAssignment(
|
|
index,
|
|
objectName,
|
|
propertyName,
|
|
value,
|
|
knownObjectLiteral = false,
|
|
) {
|
|
const effects = lastScope(branchEffectScopes);
|
|
if (!effects) {
|
|
return;
|
|
}
|
|
const identifierAssignment = effects.identifierAssignments.get(
|
|
branchIdentifierAssignmentKey(index, objectName),
|
|
);
|
|
const propertyKey = objectPropertyKey(objectName, propertyName);
|
|
if (identifierAssignment) {
|
|
identifierAssignment.objectProperties.set(propertyKey, value);
|
|
identifierAssignment.knownObjectLiterals.set(propertyKey, knownObjectLiteral);
|
|
return;
|
|
}
|
|
effects.propertyAssignments.set(branchPropertyAssignmentKey(index, objectName, propertyName), {
|
|
index,
|
|
objectName,
|
|
propertyName,
|
|
value,
|
|
knownObjectLiteral,
|
|
});
|
|
}
|
|
|
|
function recordBranchWrapperAssignment(index, name, value) {
|
|
const effects = lastScope(branchEffectScopes);
|
|
if (!effects) {
|
|
return;
|
|
}
|
|
effects.wrapperAssignments.set(branchWrapperAssignmentKey(index, name), {
|
|
index,
|
|
name,
|
|
value: cloneWrapperFunctionValue(value),
|
|
});
|
|
}
|
|
|
|
function recordBranchWrapperObjectRewrite(index, objectName, initializer) {
|
|
const fact = factFromExpression(initializer);
|
|
if (!fact.knownObject) {
|
|
return;
|
|
}
|
|
const retained = new Set(
|
|
[...fact.wrappers.keys()].map((key) => `${objectName}${key.slice(fact.root.length)}`),
|
|
);
|
|
const prefix = `${objectName}.`;
|
|
for (const scope of wrapperFunctionScopes) {
|
|
for (const name of scope.keys()) {
|
|
if (name.startsWith(prefix) && !retained.has(name)) {
|
|
recordBranchWrapperAssignment(index, name, null);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function recordBranchFsIdentifierAssignment(
|
|
index,
|
|
name,
|
|
moduleValue,
|
|
writeAlias,
|
|
fsSafeFactoryAlias,
|
|
fsSafeStoreValue,
|
|
fsSafeJsonStoreValue,
|
|
requireAlias,
|
|
) {
|
|
const effects = lastScope(branchEffectScopes);
|
|
if (!effects) {
|
|
return;
|
|
}
|
|
effects.fsIdentifierAssignments.set(branchIdentifierAssignmentKey(index, name), {
|
|
fsSafeFactoryAlias,
|
|
fsSafeJsonStoreValue,
|
|
fsSafeStoreValue,
|
|
index,
|
|
moduleValue,
|
|
name,
|
|
requireAlias,
|
|
writeAlias,
|
|
});
|
|
}
|
|
|
|
function recordBranchFsSafePropertyAssignment(
|
|
index,
|
|
objectName,
|
|
propertyName,
|
|
storeValue,
|
|
jsonStoreValue,
|
|
) {
|
|
const effects = lastScope(branchEffectScopes);
|
|
if (!effects) {
|
|
return;
|
|
}
|
|
effects.fsSafePropertyAssignments.set(
|
|
branchPropertyAssignmentKey(index, objectName, propertyName),
|
|
{
|
|
index,
|
|
jsonStoreValue,
|
|
objectName,
|
|
propertyName,
|
|
storeValue,
|
|
},
|
|
);
|
|
}
|
|
|
|
function recordBranchFsSafeObjectPropertyAssignment(
|
|
index,
|
|
objectName,
|
|
propertyName,
|
|
initializer,
|
|
storeValue,
|
|
jsonStoreValue,
|
|
) {
|
|
const assignmentRoot = objectPropertyKey(objectName, propertyName);
|
|
const storeAssignments = new Map([[assignmentRoot, storeValue]]);
|
|
const jsonStoreAssignments = new Map([[assignmentRoot, jsonStoreValue]]);
|
|
const descendantPrefix = `${assignmentRoot}.`;
|
|
for (const scope of fsSafeStoreScopes) {
|
|
for (const key of scope.keys()) {
|
|
if (key.startsWith(descendantPrefix)) {
|
|
storeAssignments.set(key, false);
|
|
}
|
|
}
|
|
}
|
|
for (const scope of fsSafeJsonStoreScopes) {
|
|
for (const key of scope.keys()) {
|
|
if (key.startsWith(descendantPrefix)) {
|
|
jsonStoreAssignments.set(key, false);
|
|
}
|
|
}
|
|
}
|
|
registerFsSafeStoreObjectAliases(
|
|
assignmentRoot,
|
|
initializer,
|
|
storeAssignments,
|
|
jsonStoreAssignments,
|
|
);
|
|
const assignmentKeys = new Set([...storeAssignments.keys(), ...jsonStoreAssignments.keys()]);
|
|
for (const key of assignmentKeys) {
|
|
recordBranchFsSafePropertyAssignment(
|
|
index,
|
|
objectName,
|
|
key.slice(`${objectName}.`.length),
|
|
storeAssignments.get(key) === true,
|
|
jsonStoreAssignments.get(key) === true,
|
|
);
|
|
}
|
|
}
|
|
|
|
function mergeWrapperAssignmentValues(left, right) {
|
|
const records = [
|
|
...wrapperRecords(left).map(cloneWrapperRecord),
|
|
...wrapperRecords(right).map(cloneWrapperRecord),
|
|
];
|
|
if (records.length === 0) {
|
|
return null;
|
|
}
|
|
return records.length === 1 ? records[0] : records;
|
|
}
|
|
|
|
function mergeExhaustiveBranchEffects(thenEffects, elseEffects) {
|
|
const mergedIdentifierNames = new Set();
|
|
const parentEffect = lastScope(branchEffectScopes);
|
|
const applyToTargetScopes = !lastScope(conditionalExecutionScopes) && !parentEffect;
|
|
for (const [key, thenAssignment] of thenEffects.fsIdentifierAssignments) {
|
|
const elseAssignment = elseEffects.fsIdentifierAssignments.get(key);
|
|
if (!elseAssignment || thenAssignment.index >= legacyPathScopes.length) {
|
|
continue;
|
|
}
|
|
const { index, name } = thenAssignment;
|
|
const mergedModuleValue =
|
|
thenAssignment.moduleValue === true || elseAssignment.moduleValue === true;
|
|
const mergedWriteAlias = thenAssignment.writeAlias ?? elseAssignment.writeAlias;
|
|
const mergedFsSafeFactoryAlias =
|
|
thenAssignment.fsSafeFactoryAlias ?? elseAssignment.fsSafeFactoryAlias;
|
|
const mergedFsSafeStoreValue =
|
|
thenAssignment.fsSafeStoreValue === true || elseAssignment.fsSafeStoreValue === true;
|
|
const mergedFsSafeJsonStoreValue =
|
|
thenAssignment.fsSafeJsonStoreValue === true ||
|
|
elseAssignment.fsSafeJsonStoreValue === true;
|
|
const mergedRequireAlias =
|
|
thenAssignment.requireAlias === true || elseAssignment.requireAlias === true;
|
|
if (applyToTargetScopes) {
|
|
fsModuleBindingScopes[index].set(name, mergedModuleValue);
|
|
fsWriteAliasScopes[index].set(name, mergedWriteAlias);
|
|
fsSafeStoreFactoryAliasScopes[index].set(name, mergedFsSafeFactoryAlias);
|
|
fsSafeStoreScopes[index].set(name, mergedFsSafeStoreValue);
|
|
fsSafeJsonStoreScopes[index].set(name, mergedFsSafeJsonStoreValue);
|
|
requireAliasScopes[index].set(name, mergedRequireAlias);
|
|
}
|
|
lastScope(fsModuleBindingScopes).set(name, mergedModuleValue);
|
|
lastScope(fsWriteAliasScopes).set(name, mergedWriteAlias);
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(name, mergedFsSafeFactoryAlias);
|
|
lastScope(fsSafeStoreScopes).set(name, mergedFsSafeStoreValue);
|
|
lastScope(fsSafeJsonStoreScopes).set(name, mergedFsSafeJsonStoreValue);
|
|
lastScope(requireAliasScopes).set(name, mergedRequireAlias);
|
|
if (parentEffect) {
|
|
parentEffect.fsIdentifierAssignments.set(branchIdentifierAssignmentKey(index, name), {
|
|
fsSafeFactoryAlias: mergedFsSafeFactoryAlias,
|
|
fsSafeJsonStoreValue: mergedFsSafeJsonStoreValue,
|
|
fsSafeStoreValue: mergedFsSafeStoreValue,
|
|
index,
|
|
moduleValue: mergedModuleValue,
|
|
name,
|
|
requireAlias: mergedRequireAlias,
|
|
writeAlias: mergedWriteAlias,
|
|
});
|
|
}
|
|
}
|
|
for (const [key, thenAssignment] of thenEffects.identifierAssignments) {
|
|
const elseAssignment = elseEffects.identifierAssignments.get(key);
|
|
if (!elseAssignment || thenAssignment.index >= legacyPathScopes.length) {
|
|
continue;
|
|
}
|
|
const { index, name } = thenAssignment;
|
|
mergedIdentifierNames.add(branchIdentifierAssignmentKey(index, name));
|
|
const merged = mergeLegacyPathBranchAssignments(thenAssignment, elseAssignment);
|
|
if (applyToTargetScopes) {
|
|
const pathScope = legacyPathScopes[index];
|
|
const literalScope = literalTextScopes[index];
|
|
const knownUndefinedScope = knownUndefinedScopes[index];
|
|
const propertyScope = legacyObjectPropertyScopes[index];
|
|
const knownObjectLiteralScope = legacyKnownObjectLiteralScopes[index];
|
|
clearKnownLegacyObjectLiterals(knownObjectLiteralScope, name);
|
|
knownObjectLiteralScope.set(name, merged.knownObjectLiteral);
|
|
for (const [knownObjectLiteralKey, value] of merged.knownObjectLiterals) {
|
|
knownObjectLiteralScope.set(knownObjectLiteralKey, value);
|
|
}
|
|
pathScope.set(name, merged.value);
|
|
knownUndefinedScope.set(name, merged.knownUndefined);
|
|
literalScope.set(name, merged.literalTexts);
|
|
clearLegacyObjectProperties(propertyScope, name);
|
|
for (const [propertyKey, value] of merged.objectProperties) {
|
|
propertyScope.set(propertyKey, value);
|
|
}
|
|
}
|
|
clearKnownLegacyObjectLiterals(lastScope(legacyKnownObjectLiteralScopes), name);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(name, merged.knownObjectLiteral);
|
|
for (const [knownObjectLiteralKey, value] of merged.knownObjectLiterals) {
|
|
lastScope(legacyKnownObjectLiteralScopes).set(knownObjectLiteralKey, value);
|
|
}
|
|
lastScope(legacyPathScopes).set(name, merged.value);
|
|
lastScope(knownUndefinedScopes).set(name, merged.knownUndefined);
|
|
lastScope(literalTextScopes).set(name, merged.literalTexts);
|
|
clearLegacyObjectProperties(lastScope(legacyObjectPropertyScopes), name);
|
|
for (const [propertyKey, value] of merged.objectProperties) {
|
|
lastScope(legacyObjectPropertyScopes).set(propertyKey, value);
|
|
}
|
|
if (parentEffect) {
|
|
parentEffect.identifierAssignments.set(branchIdentifierAssignmentKey(index, name), {
|
|
index,
|
|
...merged,
|
|
literalTexts: merged.literalTexts ?? [],
|
|
name,
|
|
});
|
|
}
|
|
}
|
|
for (const [key, thenAssignment] of thenEffects.fsSafePropertyAssignments) {
|
|
const elseAssignment = elseEffects.fsSafePropertyAssignments.get(key);
|
|
if (!elseAssignment || thenAssignment.index >= legacyPathScopes.length) {
|
|
continue;
|
|
}
|
|
const mergedStoreValue =
|
|
thenAssignment.storeValue === true || elseAssignment.storeValue === true;
|
|
const mergedJsonStoreValue =
|
|
thenAssignment.jsonStoreValue === true || elseAssignment.jsonStoreValue === true;
|
|
const propertyKey = objectPropertyKey(thenAssignment.objectName, thenAssignment.propertyName);
|
|
if (applyToTargetScopes) {
|
|
fsSafeStoreScopes[thenAssignment.index].set(propertyKey, mergedStoreValue);
|
|
fsSafeJsonStoreScopes[thenAssignment.index].set(propertyKey, mergedJsonStoreValue);
|
|
}
|
|
lastScope(fsSafeStoreScopes).set(propertyKey, mergedStoreValue);
|
|
lastScope(fsSafeJsonStoreScopes).set(propertyKey, mergedJsonStoreValue);
|
|
if (parentEffect) {
|
|
recordBranchFsSafePropertyAssignment(
|
|
thenAssignment.index,
|
|
thenAssignment.objectName,
|
|
thenAssignment.propertyName,
|
|
mergedStoreValue,
|
|
mergedJsonStoreValue,
|
|
);
|
|
}
|
|
}
|
|
for (const [key, thenAssignment] of thenEffects.propertyAssignments) {
|
|
const elseAssignment = elseEffects.propertyAssignments.get(key);
|
|
if (!elseAssignment || thenAssignment.index >= legacyPathScopes.length) {
|
|
continue;
|
|
}
|
|
const identifierKey = branchIdentifierAssignmentKey(
|
|
thenAssignment.index,
|
|
thenAssignment.objectName,
|
|
);
|
|
if (mergedIdentifierNames.has(identifierKey)) {
|
|
continue;
|
|
}
|
|
const mergedValue = mergeLegacyObjectPropertyValues(
|
|
thenAssignment.value,
|
|
elseAssignment.value,
|
|
);
|
|
const mergedKnownObjectLiteral =
|
|
thenAssignment.knownObjectLiteral && elseAssignment.knownObjectLiteral;
|
|
const propertyKey = objectPropertyKey(thenAssignment.objectName, thenAssignment.propertyName);
|
|
if (applyToTargetScopes) {
|
|
legacyObjectPropertyScopes[thenAssignment.index].set(propertyKey, mergedValue);
|
|
legacyKnownObjectLiteralScopes[thenAssignment.index].set(
|
|
propertyKey,
|
|
mergedKnownObjectLiteral,
|
|
);
|
|
}
|
|
lastScope(legacyObjectPropertyScopes).set(propertyKey, mergedValue);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(propertyKey, mergedKnownObjectLiteral);
|
|
if (parentEffect) {
|
|
recordBranchPropertyAssignment(
|
|
thenAssignment.index,
|
|
thenAssignment.objectName,
|
|
thenAssignment.propertyName,
|
|
mergedValue,
|
|
mergedKnownObjectLiteral,
|
|
);
|
|
}
|
|
}
|
|
for (const [key, thenAssignment] of thenEffects.wrapperAssignments) {
|
|
const elseAssignment = elseEffects.wrapperAssignments.get(key);
|
|
if (!elseAssignment || thenAssignment.index >= legacyPathScopes.length) {
|
|
continue;
|
|
}
|
|
const { index, name } = thenAssignment;
|
|
const mergedValue = mergeWrapperAssignmentValues(thenAssignment.value, elseAssignment.value);
|
|
if (applyToTargetScopes) {
|
|
wrapperFunctionScopes[index].set(name, cloneWrapperFunctionValue(mergedValue));
|
|
}
|
|
lastScope(wrapperFunctionScopes).set(name, cloneWrapperFunctionValue(mergedValue));
|
|
if (parentEffect) {
|
|
parentEffect.wrapperAssignments.set(branchWrapperAssignmentKey(index, name), {
|
|
index,
|
|
name,
|
|
value: cloneWrapperFunctionValue(mergedValue),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
function markLegacyObjectProperties(
|
|
objectName,
|
|
initializer,
|
|
targetScope = lastScope(legacyObjectPropertyScopes),
|
|
knownObjectLiteralScope = lastScope(legacyKnownObjectLiteralScopes),
|
|
) {
|
|
const objectLiteral = unwrapExpression(initializer);
|
|
if (ts.isIdentifier(objectLiteral)) {
|
|
copyLegacyObjectProperties(objectName, objectLiteral.text, targetScope);
|
|
if (knownObjectLiteralScope) {
|
|
copyKnownLegacyObjectLiterals(objectName, objectLiteral.text, knownObjectLiteralScope);
|
|
}
|
|
return;
|
|
}
|
|
if (!ts.isObjectLiteralExpression(objectLiteral)) {
|
|
knownObjectLiteralScope?.set(objectName, false);
|
|
return;
|
|
}
|
|
knownObjectLiteralScope?.set(objectName, true);
|
|
for (const property of objectLiteral.properties) {
|
|
if (ts.isPropertyAssignment(property)) {
|
|
const resolvedNames = ts.isComputedPropertyName(property.name)
|
|
? elementAccessNames(property.name.expression)
|
|
: [propertyNameText(property.name)].filter(Boolean);
|
|
const names = resolvedNames.length > 0 ? resolvedNames : [unknownComputedPropertyName];
|
|
for (const name of names) {
|
|
const propertyKey = `${objectName}.${name}`;
|
|
const unknownComputed = name === unknownComputedPropertyName;
|
|
if (!unknownComputed) {
|
|
clearLegacyObjectProperties(targetScope, propertyKey);
|
|
if (knownObjectLiteralScope) {
|
|
clearKnownLegacyObjectLiterals(knownObjectLiteralScope, propertyKey);
|
|
}
|
|
}
|
|
const propertyValue = legacyObjectPropertyValueFromExpression(property.initializer);
|
|
targetScope.set(
|
|
propertyKey,
|
|
unknownComputed
|
|
? targetScope.get(propertyKey) === true || propertyValue
|
|
: propertyValue,
|
|
);
|
|
const propertyInitializer = unwrapExpression(property.initializer);
|
|
if (ts.isIdentifier(propertyInitializer)) {
|
|
copyLegacyObjectProperties(propertyKey, propertyInitializer.text, targetScope);
|
|
if (knownObjectLiteralScope) {
|
|
copyKnownLegacyObjectLiterals(
|
|
propertyKey,
|
|
propertyInitializer.text,
|
|
knownObjectLiteralScope,
|
|
);
|
|
}
|
|
} else {
|
|
knownObjectLiteralScope?.set(
|
|
propertyKey,
|
|
isKnownLegacyObjectLiteralExpression(property.initializer),
|
|
);
|
|
}
|
|
if (ts.isObjectLiteralExpression(propertyInitializer)) {
|
|
markLegacyObjectProperties(
|
|
propertyKey,
|
|
property.initializer,
|
|
targetScope,
|
|
knownObjectLiteralScope,
|
|
);
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isShorthandPropertyAssignment(property)) {
|
|
const propertyKey = `${objectName}.${property.name.text}`;
|
|
targetScope.set(propertyKey, legacyObjectPropertyValueFromExpression(property.name));
|
|
copyLegacyObjectProperties(propertyKey, property.name.text, targetScope);
|
|
if (knownObjectLiteralScope) {
|
|
copyKnownLegacyObjectLiterals(propertyKey, property.name.text, knownObjectLiteralScope);
|
|
}
|
|
continue;
|
|
}
|
|
if (ts.isSpreadAssignment(property)) {
|
|
const spreadExpression = unwrapExpression(property.expression);
|
|
if (ts.isIdentifier(spreadExpression)) {
|
|
copyLegacyObjectProperties(objectName, spreadExpression.text, targetScope);
|
|
if (knownObjectLiteralScope) {
|
|
copyKnownLegacyObjectLiterals(
|
|
objectName,
|
|
spreadExpression.text,
|
|
knownObjectLiteralScope,
|
|
);
|
|
}
|
|
} else if (ts.isObjectLiteralExpression(spreadExpression)) {
|
|
markLegacyObjectProperties(
|
|
objectName,
|
|
spreadExpression,
|
|
targetScope,
|
|
knownObjectLiteralScope,
|
|
);
|
|
} else {
|
|
knownObjectLiteralScope?.set(objectName, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function copyLegacyObjectProperties(
|
|
targetName,
|
|
sourceName,
|
|
targetScope = lastScope(legacyObjectPropertyScopes),
|
|
) {
|
|
const sourcePrefix = `${sourceName}.`;
|
|
for (let index = legacyObjectPropertyScopes.length - 1; index >= 0; index--) {
|
|
const scope = legacyObjectPropertyScopes[index];
|
|
const copiedEntries = [];
|
|
for (const [key, value] of scope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
copiedEntries.push([`${targetName}.${key.slice(sourcePrefix.length)}`, value]);
|
|
}
|
|
}
|
|
copiedEntries.sort((left, right) => left[0].length - right[0].length);
|
|
for (const [key, value] of copiedEntries) {
|
|
clearLegacyObjectProperties(targetScope, key);
|
|
targetScope.set(key, value);
|
|
}
|
|
const copied = copiedEntries.length > 0;
|
|
if (copied || legacyPathScopes[index].has(sourceName)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function copyKnownLegacyObjectLiterals(
|
|
targetName,
|
|
sourceName,
|
|
targetScope = lastScope(legacyKnownObjectLiteralScopes),
|
|
) {
|
|
targetScope.set(targetName, lookupKnownLegacyObjectLiteral(sourceName));
|
|
const sourcePrefix = `${sourceName}.`;
|
|
for (let index = legacyKnownObjectLiteralScopes.length - 1; index >= 0; index--) {
|
|
const scope = legacyKnownObjectLiteralScopes[index];
|
|
const copiedEntries = [];
|
|
for (const [key, value] of scope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
copiedEntries.push([`${targetName}.${key.slice(sourcePrefix.length)}`, value]);
|
|
}
|
|
}
|
|
copiedEntries.sort((left, right) => left[0].length - right[0].length);
|
|
for (const [key, value] of copiedEntries) {
|
|
clearKnownLegacyObjectLiterals(targetScope, key);
|
|
targetScope.set(key, value);
|
|
}
|
|
const copied = copiedEntries.length > 0;
|
|
if (copied || scope.has(sourceName) || legacyPathScopes[index].has(sourceName)) {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
function copyScopedLegacyObjectProperties(targetName, sourceName, sourceScope) {
|
|
const sourcePrefix = `${sourceName}.`;
|
|
const copiedEntries = [];
|
|
for (const [key, value] of sourceScope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
copiedEntries.push([`${targetName}.${key.slice(sourcePrefix.length)}`, value]);
|
|
}
|
|
}
|
|
copiedEntries.sort((left, right) => left[0].length - right[0].length);
|
|
for (const [key, value] of copiedEntries) {
|
|
clearLegacyObjectProperties(lastScope(legacyObjectPropertyScopes), key);
|
|
lastScope(legacyObjectPropertyScopes).set(key, value);
|
|
}
|
|
}
|
|
|
|
function copyScopedKnownLegacyObjectLiterals(targetName, sourceName, sourceScope) {
|
|
lastScope(legacyKnownObjectLiteralScopes).set(targetName, sourceScope.get(sourceName) === true);
|
|
const sourcePrefix = `${sourceName}.`;
|
|
const copiedEntries = [];
|
|
for (const [key, value] of sourceScope) {
|
|
if (key.startsWith(sourcePrefix)) {
|
|
copiedEntries.push([`${targetName}.${key.slice(sourcePrefix.length)}`, value]);
|
|
}
|
|
}
|
|
copiedEntries.sort((left, right) => left[0].length - right[0].length);
|
|
for (const [key, value] of copiedEntries) {
|
|
clearKnownLegacyObjectLiterals(lastScope(legacyKnownObjectLiteralScopes), key);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(key, value);
|
|
}
|
|
}
|
|
|
|
function bindingPatternNames(name) {
|
|
const names = [];
|
|
function visitName(current) {
|
|
if (ts.isIdentifier(current)) {
|
|
names.push(current.text);
|
|
return;
|
|
}
|
|
if (ts.isObjectBindingPattern(current) || ts.isArrayBindingPattern(current)) {
|
|
for (const element of current.elements) {
|
|
if (ts.isBindingElement(element)) {
|
|
visitName(element.name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
visitName(name);
|
|
return names;
|
|
}
|
|
|
|
function markLegacyPathsFromObjectBinding(bindingPattern, sourceName, propertyPath = []) {
|
|
for (const element of bindingPattern.elements) {
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
const nextPath = [...propertyPath, propertyName];
|
|
if (ts.isIdentifier(element.name)) {
|
|
const trackedPropertyEntry = lookupLegacyObjectPropertyEntry(
|
|
sourceName,
|
|
nextPath.join("."),
|
|
);
|
|
const usesDefaultInitializer = trackedPropertyEntry.found
|
|
? trackedPropertyEntry.value === explicitUndefinedLegacyObjectPropertyValue
|
|
: trackedPropertyEntry.objectKnown;
|
|
const trackedPropertyValue = trackedPropertyEntry.found
|
|
? trackedPropertyEntry.value === explicitUndefinedLegacyObjectPropertyValue
|
|
? null
|
|
: trackedPropertyEntry.value === true
|
|
: null;
|
|
const propertyValue =
|
|
trackedPropertyValue === null
|
|
? element.initializer
|
|
? expressionContainsLegacyStore(element.initializer)
|
|
: false
|
|
: trackedPropertyValue;
|
|
lastScope(legacyPathScopes).set(element.name.text, propertyValue);
|
|
lastScope(knownUndefinedScopes).set(
|
|
element.name.text,
|
|
usesDefaultInitializer
|
|
? element.initializer
|
|
? isKnownUndefinedExpression(element.initializer)
|
|
: true
|
|
: false,
|
|
);
|
|
const sourcePropertyName = `${sourceName}.${nextPath.join(".")}`;
|
|
copyLegacyObjectProperties(element.name.text, sourcePropertyName);
|
|
copyKnownLegacyObjectLiterals(element.name.text, sourcePropertyName);
|
|
lastScope(wrapperFunctionScopes).set(
|
|
element.name.text,
|
|
cloneWrapperFunctionValue(resolveWrapperFunction(sourcePropertyName)),
|
|
);
|
|
continue;
|
|
}
|
|
if (ts.isObjectBindingPattern(element.name)) {
|
|
markLegacyPathsFromObjectBinding(element.name, sourceName, nextPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
function markLegacyPathsFromInlineObjectBinding(bindingPattern, initializer, propertyPath = []) {
|
|
const sourceName = "<inline-object-binding>";
|
|
const propertyScope = new Map();
|
|
const knownObjectLiteralScope = new Map();
|
|
markLegacyObjectProperties(sourceName, initializer, propertyScope, knownObjectLiteralScope);
|
|
function visitBinding(currentBindingPattern, currentPath) {
|
|
for (const element of currentBindingPattern.elements) {
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
const nextPath = [...currentPath, propertyName];
|
|
if (ts.isIdentifier(element.name)) {
|
|
const trackedPropertyEntry = lookupScopedLegacyObjectPropertyEntry(
|
|
sourceName,
|
|
nextPath,
|
|
propertyScope,
|
|
knownObjectLiteralScope,
|
|
);
|
|
const usesDefaultInitializer = trackedPropertyEntry.found
|
|
? trackedPropertyEntry.value === explicitUndefinedLegacyObjectPropertyValue
|
|
: trackedPropertyEntry.objectKnown;
|
|
const propertyValue = trackedPropertyEntry.found
|
|
? trackedPropertyEntry.value === explicitUndefinedLegacyObjectPropertyValue
|
|
? element.initializer
|
|
? expressionContainsLegacyStore(element.initializer)
|
|
: false
|
|
: trackedPropertyEntry.value === true
|
|
: trackedPropertyEntry.objectKnown && element.initializer
|
|
? expressionContainsLegacyStore(element.initializer)
|
|
: false;
|
|
lastScope(legacyPathScopes).set(element.name.text, propertyValue);
|
|
lastScope(knownUndefinedScopes).set(
|
|
element.name.text,
|
|
usesDefaultInitializer
|
|
? element.initializer
|
|
? isKnownUndefinedExpression(element.initializer)
|
|
: true
|
|
: false,
|
|
);
|
|
const sourcePropertyName = objectPropertyKey(sourceName, nextPath.join("."));
|
|
copyScopedLegacyObjectProperties(element.name.text, sourcePropertyName, propertyScope);
|
|
copyScopedKnownLegacyObjectLiterals(
|
|
element.name.text,
|
|
sourcePropertyName,
|
|
knownObjectLiteralScope,
|
|
);
|
|
continue;
|
|
}
|
|
if (ts.isObjectBindingPattern(element.name)) {
|
|
visitBinding(element.name, nextPath);
|
|
}
|
|
}
|
|
}
|
|
visitBinding(bindingPattern, propertyPath);
|
|
}
|
|
|
|
function markFsSafeStoresFromObjectBinding(bindingPattern, sourceName, propertyPath = []) {
|
|
for (const element of bindingPattern.elements) {
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
const nextPath = [...propertyPath, propertyName];
|
|
if (ts.isIdentifier(element.name)) {
|
|
const key = `${sourceName}.${nextPath.join(".")}`;
|
|
const trackedStore = lookupFsSafeStore(key);
|
|
const trackedJsonStore = lookupFsSafeJsonStore(key);
|
|
lastScope(fsSafeStoreScopes).set(
|
|
element.name.text,
|
|
trackedStore ??
|
|
(element.initializer ? isFsSafeStoreExpression(element.initializer) : false),
|
|
);
|
|
lastScope(fsSafeJsonStoreScopes).set(
|
|
element.name.text,
|
|
trackedJsonStore ??
|
|
(element.initializer
|
|
? expressionContainsFsSafeJsonStoreLegacyPath(element.initializer)
|
|
: false),
|
|
);
|
|
continue;
|
|
}
|
|
if (ts.isObjectBindingPattern(element.name)) {
|
|
markFsSafeStoresFromObjectBinding(element.name, sourceName, nextPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
function markFsSafeFactoryAliasesFromObjectBinding(bindingPattern, sourceName) {
|
|
for (const element of bindingPattern.elements) {
|
|
if (!ts.isIdentifier(element.name)) {
|
|
continue;
|
|
}
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: element.name.text;
|
|
const factoryAlias = propertyName
|
|
? resolveFsSafeStoreFactoryAlias(`${sourceName}.${propertyName}`)
|
|
: null;
|
|
if (factoryAlias) {
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(element.name.text, factoryAlias);
|
|
}
|
|
}
|
|
}
|
|
|
|
function registerTrackedObjectMethods({
|
|
objectName,
|
|
initializer,
|
|
directSourceName = () => null,
|
|
spreadSourceName = directSourceName,
|
|
onAlias = () => {},
|
|
onUnknownSpread = () => {},
|
|
onSpread = onAlias,
|
|
onPropertyName = () => {},
|
|
onMethod,
|
|
onIdentifier,
|
|
onNested,
|
|
onOther = () => {},
|
|
}) {
|
|
const objectLiteral = unwrapExpression(initializer);
|
|
const directSource = directSourceName(objectLiteral);
|
|
if (directSource) {
|
|
onAlias(objectName, directSource);
|
|
return;
|
|
}
|
|
if (!ts.isObjectLiteralExpression(objectLiteral)) {
|
|
return;
|
|
}
|
|
|
|
for (const property of objectLiteral.properties) {
|
|
if (ts.isSpreadAssignment(property)) {
|
|
const sourceName = spreadSourceName(unwrapExpression(property.expression));
|
|
if (sourceName) {
|
|
onSpread(objectName, sourceName);
|
|
} else {
|
|
onUnknownSpread(objectName);
|
|
}
|
|
continue;
|
|
}
|
|
|
|
const propertyName =
|
|
ts.isMethodDeclaration(property) || ts.isPropertyAssignment(property)
|
|
? propertyNameText(property.name)
|
|
: ts.isShorthandPropertyAssignment(property)
|
|
? property.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
const key = `${objectName}.${propertyName}`;
|
|
onPropertyName(propertyName, key);
|
|
if (ts.isMethodDeclaration(property)) {
|
|
onMethod(key, property);
|
|
continue;
|
|
}
|
|
if (ts.isShorthandPropertyAssignment(property)) {
|
|
onIdentifier(key, property.name.text, property.name);
|
|
continue;
|
|
}
|
|
|
|
const propertyInitializer = unwrapExpression(property.initializer);
|
|
if (ts.isFunctionExpression(propertyInitializer) || ts.isArrowFunction(propertyInitializer)) {
|
|
onMethod(key, propertyInitializer);
|
|
continue;
|
|
}
|
|
if (ts.isIdentifier(propertyInitializer)) {
|
|
onIdentifier(key, propertyInitializer.text, property.initializer);
|
|
continue;
|
|
}
|
|
const hasNestedObject = ts.isObjectLiteralExpression(propertyInitializer);
|
|
if (hasNestedObject) {
|
|
onNested(key, propertyInitializer);
|
|
}
|
|
onOther(key, property.initializer, hasNestedObject);
|
|
}
|
|
}
|
|
|
|
function wrapperRecordForNode(node) {
|
|
return {
|
|
environment: lexicalScopeStacks.map(([scopes]) => [...scopes]),
|
|
node,
|
|
};
|
|
}
|
|
|
|
function registerWrapperFunction(name, node) {
|
|
lastScope(wrapperFunctionScopes).set(name, wrapperRecordForNode(node));
|
|
}
|
|
|
|
function setWrapperFunctionValue(scope, name, value, conditionalWrite) {
|
|
if (value) {
|
|
if (conditionalWrite && scope.has(name)) {
|
|
scope.set(name, [...wrapperRecords(scope.get(name)), ...wrapperRecords(value)]);
|
|
} else {
|
|
scope.set(name, value);
|
|
}
|
|
} else if (!conditionalWrite) {
|
|
scope.set(name, null);
|
|
}
|
|
}
|
|
|
|
function clearWrapperObjectMethods(scope, objectName) {
|
|
shadowObjectPropertyScopes([scope], objectName, null, scope);
|
|
}
|
|
|
|
function clearWrapperObjectMethod(scope, methodName) {
|
|
scope.set(methodName, null);
|
|
clearWrapperObjectMethods(scope, methodName);
|
|
}
|
|
|
|
function shadowVisibleWrapperObjectMethods(objectName) {
|
|
shadowObjectPropertyScopes(wrapperFunctionScopes, objectName, null);
|
|
}
|
|
|
|
function copyWrapperObjectMethods(
|
|
targetName,
|
|
sourceName,
|
|
scope = lastScope(wrapperFunctionScopes),
|
|
conditionalWrite = false,
|
|
) {
|
|
const sourcePrefix = `${sourceName}.`;
|
|
let copiedCount = 0;
|
|
const visibleScopeIndexes = [];
|
|
for (let index = wrapperFunctionScopes.length - 1; index >= 0; index--) {
|
|
visibleScopeIndexes.push(index);
|
|
if (wrapperFunctionScopes[index].has(sourceName) || legacyPathScopes[index].has(sourceName)) {
|
|
break;
|
|
}
|
|
}
|
|
for (const index of visibleScopeIndexes.toReversed()) {
|
|
const sourceScope = wrapperFunctionScopes[index];
|
|
for (const [name, value] of sourceScope) {
|
|
if (!name.startsWith(sourcePrefix)) {
|
|
continue;
|
|
}
|
|
setWrapperFunctionValue(
|
|
scope,
|
|
`${targetName}.${name.slice(sourcePrefix.length)}`,
|
|
cloneWrapperFunctionValue(value),
|
|
conditionalWrite,
|
|
);
|
|
copiedCount += 1;
|
|
}
|
|
}
|
|
return copiedCount;
|
|
}
|
|
|
|
function registerWrapperObjectMethods(
|
|
objectName,
|
|
initializer,
|
|
scope = lastScope(wrapperFunctionScopes),
|
|
conditionalWrite = false,
|
|
) {
|
|
const seenProperties = new Set();
|
|
const remember = (key, value) => setWrapperFunctionValue(scope, key, value, conditionalWrite);
|
|
const copy = (targetName, sourceName) =>
|
|
copyWrapperObjectMethods(targetName, sourceName, scope, conditionalWrite);
|
|
|
|
registerTrackedObjectMethods({
|
|
objectName,
|
|
initializer,
|
|
onUnknownSpread: () => clearWrapperObjectMethods(scope, objectName),
|
|
onSpread: (targetName, sourceName) => {
|
|
if (copy(targetName, sourceName) === 0 && !lookupKnownLegacyObjectLiteral(sourceName)) {
|
|
clearWrapperObjectMethods(scope, targetName);
|
|
}
|
|
},
|
|
spreadSourceName: (expression) =>
|
|
ts.isIdentifier(expression) ? expression.text : callExpressionName(expression),
|
|
onPropertyName: (propertyName, key) => {
|
|
if (seenProperties.has(propertyName)) {
|
|
clearWrapperObjectMethod(scope, key);
|
|
}
|
|
seenProperties.add(propertyName);
|
|
},
|
|
onMethod: (key, method) => remember(key, wrapperRecordForNode(method)),
|
|
onIdentifier: (key, identifier) => {
|
|
const wrapper = resolveWrapperFunction(identifier);
|
|
if (wrapper) {
|
|
remember(key, cloneWrapperFunctionValue(wrapper));
|
|
}
|
|
copy(key, identifier);
|
|
},
|
|
onNested: (key, nested) => registerWrapperObjectMethods(key, nested, scope, conditionalWrite),
|
|
onOther: (key, value) => {
|
|
const wrapper = resolveWrapperExpression(value);
|
|
if (wrapper) {
|
|
remember(key, cloneWrapperFunctionValue(wrapper));
|
|
}
|
|
},
|
|
});
|
|
}
|
|
function wrapperRecords(value) {
|
|
if (!value) {
|
|
return [];
|
|
}
|
|
return Array.isArray(value) ? value : [value];
|
|
}
|
|
|
|
function cloneWrapperRecord(record) {
|
|
return {
|
|
environment: record.environment.map((scopes) => [...scopes]),
|
|
node: record.node,
|
|
};
|
|
}
|
|
|
|
function cloneWrapperFunctionValue(value) {
|
|
if (!value) {
|
|
return null;
|
|
}
|
|
const records = wrapperRecords(value).map(cloneWrapperRecord);
|
|
return Array.isArray(value) ? records : records[0];
|
|
}
|
|
|
|
function registerHoistedWrapperFunctions(statements) {
|
|
for (const statement of statements) {
|
|
if (ts.isFunctionDeclaration(statement) && statement.name) {
|
|
bindIdentifierFact(statement.name.text, undefinedFact());
|
|
registerWrapperFunction(statement.name.text, statement);
|
|
continue;
|
|
}
|
|
if (
|
|
ts.isVariableStatement(statement) &&
|
|
(statement.declarationList.flags & ts.NodeFlags.BlockScoped) !== 0
|
|
) {
|
|
for (const declaration of statement.declarationList.declarations) {
|
|
for (const name of bindingPatternNames(declaration.name)) {
|
|
bindIdentifierFact(name, undefinedFact());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function resolveWrapperFunction(name) {
|
|
for (let index = wrapperFunctionScopes.length - 1; index >= 0; index--) {
|
|
const wrapperScope = wrapperFunctionScopes[index];
|
|
if (wrapperScope.has(name)) {
|
|
return wrapperScope.get(name);
|
|
}
|
|
if (legacyPathScopes[index].has(name)) {
|
|
return null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
function resolveWrapperExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
return resolveWrapperFunction(unwrapped.text);
|
|
}
|
|
const name = callExpressionName(unwrapped);
|
|
return name ? resolveWrapperFunction(name) : null;
|
|
}
|
|
|
|
function pathArgumentContainsLegacyStore(argument) {
|
|
return expressionContainsLegacyStore(argument);
|
|
}
|
|
|
|
function isUndefinedExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
return (
|
|
(ts.isIdentifier(unwrapped) && unwrapped.text === "undefined") ||
|
|
ts.isVoidExpression(unwrapped)
|
|
);
|
|
}
|
|
|
|
function isKnownUndefinedExpression(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
return (
|
|
isUndefinedExpression(unwrapped) ||
|
|
(ts.isIdentifier(unwrapped) && resolveKnownUndefinedIdentifier(unwrapped.text))
|
|
);
|
|
}
|
|
|
|
function callExpressionName(expression) {
|
|
const callee = unwrapExpression(expression);
|
|
const pathParts = propertyAccessPath(callee);
|
|
return pathParts ? pathParts.join(".") : null;
|
|
}
|
|
|
|
function rootedPropertyAccessPath(expression) {
|
|
const access = rootedPropertyAccessCandidates(expression);
|
|
if (!access || access.propertyPaths.length !== 1 || access.propertyPaths[0].includes(null)) {
|
|
return null;
|
|
}
|
|
return { rootName: access.rootName, properties: access.propertyPaths[0] };
|
|
}
|
|
|
|
function rootedPropertyAccessCandidates(expression) {
|
|
const properties = [];
|
|
let current = unwrapExpression(expression);
|
|
while (true) {
|
|
if (ts.isPropertyAccessExpression(current)) {
|
|
properties.unshift([current.name.text]);
|
|
current = unwrapExpression(current.expression);
|
|
continue;
|
|
}
|
|
if (ts.isElementAccessExpression(current)) {
|
|
const propertyNames = elementAccessNames(current.argumentExpression);
|
|
properties.unshift(propertyNames.length > 0 ? propertyNames : [null]);
|
|
current = unwrapExpression(current.expression);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
if (!ts.isIdentifier(current)) {
|
|
return null;
|
|
}
|
|
let propertyPaths = [[]];
|
|
let truncated = false;
|
|
for (const names of properties) {
|
|
const nextPaths = [];
|
|
outer: for (const propertyPath of propertyPaths) {
|
|
for (const name of names) {
|
|
if (nextPaths.length === 31) {
|
|
truncated = true;
|
|
break outer;
|
|
}
|
|
nextPaths.push([...propertyPath, name]);
|
|
}
|
|
}
|
|
propertyPaths = nextPaths;
|
|
}
|
|
if (truncated) {
|
|
propertyPaths.push(properties.map(() => null));
|
|
}
|
|
return { rootName: current.text, propertyPaths };
|
|
}
|
|
|
|
function lookupLegacyObjectPropertyCandidates({ rootName, propertyPaths }) {
|
|
let unresolved = false;
|
|
for (const propertyPath of propertyPaths) {
|
|
if (!propertyPath.includes(null)) {
|
|
let foundPrefix = false;
|
|
for (let length = propertyPath.length; length > 0; length--) {
|
|
const entry = lookupLegacyObjectPropertyEntry(
|
|
rootName,
|
|
propertyPath.slice(0, length).join("."),
|
|
);
|
|
if (entry.found) {
|
|
foundPrefix = true;
|
|
if (entry.value === true) {
|
|
return true;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
unresolved ||= !foundPrefix && resolveLegacyPathIdentifier(rootName);
|
|
continue;
|
|
}
|
|
const prefix = `${rootName}.`;
|
|
let rootIsLegacy = false;
|
|
for (let length = propertyPath.length; length > 0; length--) {
|
|
const candidate = propertyPath.slice(0, length);
|
|
const seen = new Set();
|
|
let matched = false;
|
|
for (let index = legacyObjectPropertyScopes.length - 1; index >= 0; index--) {
|
|
for (const [key, value] of legacyObjectPropertyScopes[index]) {
|
|
if (!key.startsWith(prefix) || seen.has(key)) {
|
|
continue;
|
|
}
|
|
const parts = key.slice(prefix.length).split(".");
|
|
if (
|
|
parts.length === candidate.length &&
|
|
candidate.every((part, partIndex) => part === null || part === parts[partIndex])
|
|
) {
|
|
seen.add(key);
|
|
matched = true;
|
|
if (value === true) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
if (legacyPathScopes[index].has(rootName)) {
|
|
rootIsLegacy ||= legacyPathScopes[index].get(rootName) === true;
|
|
break;
|
|
}
|
|
}
|
|
if (matched) {
|
|
break;
|
|
}
|
|
}
|
|
unresolved ||= rootIsLegacy;
|
|
}
|
|
return unresolved ? null : false;
|
|
}
|
|
|
|
function copyFactEntries(target, source, fromRoot, toRoot) {
|
|
for (const [key, value] of source) {
|
|
if (key === fromRoot || key.startsWith(`${fromRoot}.`)) {
|
|
target.set(`${toRoot}${key.slice(fromRoot.length)}`, value);
|
|
}
|
|
}
|
|
}
|
|
|
|
function expressionProducesLegacyPath(expression) {
|
|
const node = unwrapExpression(expression);
|
|
if (ts.isIdentifier(node)) {
|
|
return resolveLegacyPathIdentifier(node.text);
|
|
}
|
|
if (ts.isObjectLiteralExpression(node) || ts.isArrayLiteralExpression(node)) {
|
|
return false;
|
|
}
|
|
if (ts.isConditionalExpression(node)) {
|
|
return (
|
|
expressionProducesLegacyPath(node.whenTrue) || expressionProducesLegacyPath(node.whenFalse)
|
|
);
|
|
}
|
|
if (ts.isBinaryExpression(node)) {
|
|
const operator = node.operatorToken.kind;
|
|
if (
|
|
operator === ts.SyntaxKind.AmpersandAmpersandToken ||
|
|
operator === ts.SyntaxKind.CommaToken ||
|
|
(operator >= ts.SyntaxKind.FirstAssignment && operator <= ts.SyntaxKind.LastAssignment)
|
|
) {
|
|
return expressionProducesLegacyPath(node.right);
|
|
}
|
|
if (
|
|
operator !== ts.SyntaxKind.BarBarToken &&
|
|
operator !== ts.SyntaxKind.QuestionQuestionToken &&
|
|
operator !== ts.SyntaxKind.PlusToken
|
|
) {
|
|
return false;
|
|
}
|
|
return (
|
|
expressionTextContainsLegacyStore(node) ||
|
|
expressionProducesLegacyPath(node.left) ||
|
|
expressionProducesLegacyPath(node.right)
|
|
);
|
|
}
|
|
const access = rootedPropertyAccessCandidates(node);
|
|
if (access?.propertyPaths.some((propertyPath) => propertyPath.length > 0)) {
|
|
const value = lookupLegacyObjectPropertyCandidates(access);
|
|
return value ?? resolveLegacyPathIdentifier(access.rootName);
|
|
}
|
|
if (ts.isTemplateExpression(node)) {
|
|
return (
|
|
expressionTextContainsLegacyStore(node) ||
|
|
node.templateSpans.some((span) => expressionProducesLegacyPath(span.expression))
|
|
);
|
|
}
|
|
if (ts.isCallExpression(node)) {
|
|
const receiver =
|
|
ts.isPropertyAccessExpression(node.expression) ||
|
|
ts.isElementAccessExpression(node.expression)
|
|
? node.expression.expression
|
|
: null;
|
|
return (
|
|
expressionTextContainsLegacyStore(node) ||
|
|
(receiver ? expressionProducesLegacyPath(receiver) : false) ||
|
|
[...node.arguments].some(expressionProducesLegacyPath)
|
|
);
|
|
}
|
|
return expressionTextContainsLegacyStore(node);
|
|
}
|
|
|
|
function factExpressionAlternatives(expression) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isSatisfiesExpression(unwrapped) || ts.isAwaitExpression(unwrapped)) {
|
|
return factExpressionAlternatives(unwrapped.expression);
|
|
}
|
|
if (ts.isConditionalExpression(unwrapped)) {
|
|
return [unwrapped.whenTrue, unwrapped.whenFalse].flatMap(factExpressionAlternatives);
|
|
}
|
|
if (ts.isBinaryExpression(unwrapped)) {
|
|
const operator = unwrapped.operatorToken.kind;
|
|
if (
|
|
operator === ts.SyntaxKind.CommaToken ||
|
|
(operator >= ts.SyntaxKind.FirstAssignment && operator <= ts.SyntaxKind.LastAssignment)
|
|
) {
|
|
return factExpressionAlternatives(unwrapped.right);
|
|
}
|
|
if (
|
|
[
|
|
ts.SyntaxKind.AmpersandAmpersandToken,
|
|
ts.SyntaxKind.BarBarToken,
|
|
ts.SyntaxKind.QuestionQuestionToken,
|
|
].includes(operator)
|
|
) {
|
|
return [unwrapped.left, unwrapped.right].flatMap(factExpressionAlternatives);
|
|
}
|
|
}
|
|
if (
|
|
ts.isCallExpression(unwrapped) &&
|
|
callExpressionName(unwrapped.expression) === "Promise.resolve" &&
|
|
unwrapped.arguments[0]
|
|
) {
|
|
return factExpressionAlternatives(unwrapped.arguments[0]);
|
|
}
|
|
if (ts.isNewExpression(unwrapped) && unwrapped.arguments?.length) {
|
|
return unwrapped.arguments.flatMap(factExpressionAlternatives);
|
|
}
|
|
return [unwrapped];
|
|
}
|
|
|
|
function mergeExpressionFacts(facts, expression) {
|
|
const mergeMap = (name, merge) => {
|
|
const result = new Map();
|
|
for (const fact of facts) {
|
|
for (const [key, value] of fact[name]) {
|
|
result.set(key, result.has(key) ? merge(result.get(key), value) : value);
|
|
}
|
|
}
|
|
return result;
|
|
};
|
|
const properties = new Map();
|
|
const propertyKeys = new Set(facts.flatMap((fact) => [...fact.properties.keys()]));
|
|
for (const key of propertyKeys) {
|
|
for (const fact of facts) {
|
|
const value = fact.properties.has(key)
|
|
? fact.properties.get(key)
|
|
: fact.knownObject
|
|
? explicitUndefinedLegacyObjectPropertyValue
|
|
: fact.legacyPath
|
|
? true
|
|
: undefined;
|
|
if (value !== undefined) {
|
|
properties.set(
|
|
key,
|
|
properties.has(key)
|
|
? mergeLegacyObjectPropertyValues(properties.get(key), value)
|
|
: value,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
root: "<argument>",
|
|
expression,
|
|
fsModule: facts.some((fact) => fact.fsModule),
|
|
fsModules: mergeMap("fsModules", (left, right) => left === true || right === true),
|
|
fsSafeFactory: facts.find((fact) => fact.fsSafeFactory)?.fsSafeFactory ?? null,
|
|
fsWrite: facts.find((fact) => fact.fsWrite)?.fsWrite ?? null,
|
|
fsWrites: mergeMap("fsWrites", (left, right) => left ?? right),
|
|
jsonStore: facts.some((fact) => fact.jsonStore),
|
|
jsonStores: mergeMap("jsonStores", (left, right) => left === true || right === true),
|
|
knownObject: facts.every((fact) => fact.knownObject),
|
|
knownObjects: mergeMap("knownObjects", (left, right) => left === true && right === true),
|
|
knownUndefined: facts.every((fact) => fact.knownUndefined),
|
|
legacyPath: facts.some((fact) => fact.legacyPath),
|
|
literalTexts: [...new Set(facts.flatMap((fact) => fact.literalTexts))],
|
|
properties,
|
|
requireAlias: facts.some((fact) => fact.requireAlias),
|
|
store: facts.some((fact) => fact.store),
|
|
stores: mergeMap("stores", (left, right) => left === true || right === true),
|
|
wrapper: facts.map((fact) => fact.wrapper).reduce(mergeWrapperAssignmentValues, null),
|
|
wrappers: mergeMap("wrappers", mergeWrapperAssignmentValues),
|
|
possiblyUndefined: facts.some((fact) => fact.possiblyUndefined ?? fact.knownUndefined),
|
|
};
|
|
}
|
|
|
|
function factFromExpression(expression) {
|
|
const alternatives = factExpressionAlternatives(expression);
|
|
const bounded = alternatives.length > 32 ? alternatives.slice(0, 31) : alternatives;
|
|
const facts = bounded.map(atomicFactFromExpression);
|
|
if (bounded.length !== alternatives.length) {
|
|
const discarded = alternatives.slice(31);
|
|
facts.push(mergeExpressionFacts(discarded.map(atomicFactFromExpression), expression));
|
|
}
|
|
return facts.length === 1 && alternatives[0] === expression
|
|
? facts[0]
|
|
: mergeExpressionFacts(facts, expression);
|
|
}
|
|
|
|
function atomicFactFromExpression(expression) {
|
|
const root = "<argument>";
|
|
const properties = new Map();
|
|
const knownObjects = new Map();
|
|
const fsWrites = new Map();
|
|
const stores = new Map();
|
|
const jsonStores = new Map();
|
|
const fsModules = new Map();
|
|
const wrappers = new Map();
|
|
markLegacyObjectProperties(root, expression, properties, knownObjects);
|
|
registerFsWriteObjectAliases(root, expression, fsWrites);
|
|
registerFsSafeStoreObjectAliases(root, expression, stores, jsonStores);
|
|
registerFsModuleObjectProperties(root, expression, fsModules);
|
|
const unwrapped = unwrapExpression(expression);
|
|
const wrapperSource = callExpressionName(unwrapped);
|
|
registerWrapperObjectMethods(root, expression, wrappers);
|
|
if (wrapperSource) {
|
|
copyWrapperObjectMethods(root, wrapperSource, wrappers);
|
|
}
|
|
return {
|
|
root,
|
|
expression,
|
|
fsModule: isFsBindingExpression(expression),
|
|
fsModules,
|
|
fsSafeFactory: fsSafeStoreFactoryAliasName(expression),
|
|
fsWrite: legacyFsWriteName(expression),
|
|
fsWrites,
|
|
jsonStore: expressionContainsFsSafeJsonStoreLegacyPath(expression),
|
|
jsonStores,
|
|
knownObject: knownObjects.get(root) === true,
|
|
knownObjects,
|
|
knownUndefined: isKnownUndefinedExpression(expression),
|
|
legacyPath: expressionProducesLegacyPath(expression),
|
|
literalTexts: ts.isIdentifier(unwrapped)
|
|
? resolveLiteralTextIdentifier(unwrapped.text)
|
|
: literalTextsFromExpression(expression),
|
|
properties,
|
|
requireAlias: isRequireAliasExpression(expression),
|
|
store: isFsSafeStoreExpression(expression),
|
|
stores,
|
|
wrapper:
|
|
ts.isFunctionExpression(unwrapped) || ts.isArrowFunction(unwrapped)
|
|
? wrapperRecordForNode(unwrapped)
|
|
: cloneWrapperFunctionValue(resolveWrapperExpression(expression)),
|
|
wrappers,
|
|
};
|
|
}
|
|
|
|
function undefinedFact() {
|
|
return {
|
|
root: "<argument>",
|
|
expression: null,
|
|
fsModule: false,
|
|
fsModules: new Map(),
|
|
fsSafeFactory: null,
|
|
fsWrite: null,
|
|
fsWrites: new Map(),
|
|
jsonStore: false,
|
|
jsonStores: new Map(),
|
|
knownObject: false,
|
|
knownObjects: new Map(),
|
|
knownUndefined: true,
|
|
legacyPath: false,
|
|
literalTexts: [],
|
|
properties: new Map(),
|
|
requireAlias: false,
|
|
store: false,
|
|
stores: new Map(),
|
|
wrapper: null,
|
|
wrappers: new Map(),
|
|
};
|
|
}
|
|
|
|
function propertyFact(fact, propertyName) {
|
|
const root = `${fact.root}.${propertyName}`;
|
|
const value = fact.properties.get(root);
|
|
const missing =
|
|
value === undefined &&
|
|
!fact.wrappers.has(root) &&
|
|
!fact.fsWrites.has(root) &&
|
|
!fact.fsModules.has(root) &&
|
|
!fact.stores.has(root) &&
|
|
!fact.jsonStores.has(root) &&
|
|
!fact.knownObjects.has(root);
|
|
if (missing && fact.knownObject) {
|
|
return undefinedFact();
|
|
}
|
|
const result = undefinedFact();
|
|
result.root = root;
|
|
result.knownUndefined = value === explicitUndefinedLegacyObjectPropertyValue;
|
|
if (missing) {
|
|
result.knownUndefined = false;
|
|
}
|
|
result.legacyPath = value === true || (missing && !fact.knownObject && fact.legacyPath);
|
|
result.knownObject = fact.knownObjects.get(root) === true;
|
|
result.fsModule =
|
|
fact.fsModules.get(root) === true || (fact.fsModule && propertyName === "promises");
|
|
result.fsWrite =
|
|
fact.fsWrites.get(root) ??
|
|
(fact.fsModule && legacyWriteCallees.has(propertyName) ? propertyName : null);
|
|
result.store = fact.stores.get(root) === true;
|
|
result.jsonStore = fact.jsonStores.get(root) === true;
|
|
result.wrapper = cloneWrapperFunctionValue(fact.wrappers.get(root));
|
|
for (const name of [
|
|
"fsModules",
|
|
"fsWrites",
|
|
"stores",
|
|
"jsonStores",
|
|
"knownObjects",
|
|
"properties",
|
|
"wrappers",
|
|
]) {
|
|
result[name] = fact[name];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
function bindObjectPatternFact(pattern, sourceFact) {
|
|
for (const element of pattern.elements) {
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
let nextFact = propertyFact(sourceFact, propertyName);
|
|
if (nextFact.knownUndefined && element.initializer) {
|
|
visit(element.initializer);
|
|
nextFact = factFromExpression(element.initializer);
|
|
}
|
|
if (ts.isIdentifier(element.name)) {
|
|
bindIdentifierFact(element.name.text, nextFact);
|
|
} else if (ts.isObjectBindingPattern(element.name)) {
|
|
bindObjectPatternFact(element.name, nextFact);
|
|
}
|
|
}
|
|
}
|
|
|
|
function bindObjectPatternWrappers(pattern, sourceFact) {
|
|
for (const element of pattern.elements) {
|
|
const propertyName = element.propertyName
|
|
? propertyNameText(element.propertyName)
|
|
: ts.isIdentifier(element.name)
|
|
? element.name.text
|
|
: null;
|
|
if (!propertyName) {
|
|
continue;
|
|
}
|
|
let nextFact = propertyFact(sourceFact, propertyName);
|
|
if (nextFact.knownUndefined && element.initializer) {
|
|
nextFact = factFromExpression(element.initializer);
|
|
}
|
|
if (ts.isIdentifier(element.name)) {
|
|
lastScope(wrapperFunctionScopes).set(
|
|
element.name.text,
|
|
cloneWrapperFunctionValue(nextFact.wrapper),
|
|
);
|
|
} else if (ts.isObjectBindingPattern(element.name)) {
|
|
bindObjectPatternWrappers(element.name, nextFact);
|
|
}
|
|
}
|
|
}
|
|
|
|
function bindIdentifierFact(name, fact, type = null) {
|
|
shadowObjectPropertyScopes(fsModulePropertyScopes, name, false);
|
|
shadowObjectPropertyScopes(fsWriteAliasScopes, name, null);
|
|
shadowObjectPropertyScopes(fsSafeStoreScopes, name, false);
|
|
shadowObjectPropertyScopes(fsSafeJsonStoreScopes, name, false);
|
|
shadowObjectPropertyScopes(wrapperFunctionScopes, name, null);
|
|
if (createRequireBindings.has(name)) {
|
|
lastScope(createRequireShadowScopes).add(name);
|
|
}
|
|
lastScope(fsModuleBindingScopes).set(name, fact.fsModule);
|
|
lastScope(fsModulePropertyScopes).set(name, false);
|
|
copyFactEntries(lastScope(fsModulePropertyScopes), fact.fsModules, fact.root, name);
|
|
registerFsModuleTypeProperties(ts.factory.createIdentifier(name), type);
|
|
lastScope(fsWriteAliasScopes).set(name, fact.fsWrite);
|
|
copyFactEntries(lastScope(fsWriteAliasScopes), fact.fsWrites, fact.root, name);
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(name, fact.fsSafeFactory);
|
|
lastScope(fsSafeStoreScopes).set(name, fact.store);
|
|
lastScope(fsSafeJsonStoreScopes).set(name, fact.jsonStore);
|
|
copyFactEntries(lastScope(fsSafeStoreScopes), fact.stores, fact.root, name);
|
|
copyFactEntries(lastScope(fsSafeJsonStoreScopes), fact.jsonStores, fact.root, name);
|
|
lastScope(requireAliasScopes).set(name, fact.requireAlias);
|
|
lastScope(legacyPathScopes).set(name, fact.legacyPath);
|
|
lastScope(literalTextScopes).set(name, fact.literalTexts);
|
|
lastScope(staticExpressionScopes).set(name, fact.expression);
|
|
lastScope(knownUndefinedScopes).set(name, fact.knownUndefined);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(name, fact.knownObject);
|
|
copyFactEntries(lastScope(legacyKnownObjectLiteralScopes), fact.knownObjects, fact.root, name);
|
|
copyFactEntries(lastScope(legacyObjectPropertyScopes), fact.properties, fact.root, name);
|
|
lastScope(wrapperFunctionScopes).set(name, cloneWrapperFunctionValue(fact.wrapper));
|
|
copyFactEntries(lastScope(wrapperFunctionScopes), fact.wrappers, fact.root, name);
|
|
}
|
|
|
|
function bindParameter(parameter, fact) {
|
|
if (ts.isIdentifier(parameter.name)) {
|
|
bindIdentifierFact(parameter.name.text, fact, parameter.type);
|
|
return;
|
|
}
|
|
if (ts.isObjectBindingPattern(parameter.name)) {
|
|
bindObjectPatternFact(parameter.name, fact);
|
|
return;
|
|
}
|
|
for (const name of bindingPatternNames(parameter.name)) {
|
|
bindIdentifierFact(name, undefinedFact());
|
|
}
|
|
if (ts.isArrayBindingPattern(parameter.name)) {
|
|
const array = fact.expression ? unwrapExpression(fact.expression) : null;
|
|
if (array && ts.isArrayLiteralExpression(array)) {
|
|
parameter.name.elements.forEach((element, elementIndex) => {
|
|
if (!ts.isBindingElement(element) || !ts.isIdentifier(element.name)) {
|
|
return;
|
|
}
|
|
const value = array.elements[elementIndex];
|
|
if (value && !ts.isOmittedExpression(value) && !ts.isSpreadElement(value)) {
|
|
bindIdentifierFact(element.name.text, factFromExpression(value));
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
function withWrapperEnvironment(record, run) {
|
|
const savedScopes = lexicalScopeStacks.map(([scopes]) => [...scopes]);
|
|
for (let index = 0; index < lexicalScopeStacks.length; index++) {
|
|
const scopes = lexicalScopeStacks[index][0];
|
|
scopes.splice(0, scopes.length, ...record.environment[index]);
|
|
}
|
|
branchEffectScopes.push(null);
|
|
try {
|
|
return run();
|
|
} finally {
|
|
for (let index = 0; index < lexicalScopeStacks.length; index++) {
|
|
const scopes = lexicalScopeStacks[index][0];
|
|
scopes.splice(0, scopes.length, ...savedScopes[index]);
|
|
}
|
|
branchEffectScopes.pop();
|
|
}
|
|
}
|
|
|
|
function spreadArgumentFacts(expression, seen = new Set()) {
|
|
const unwrapped = unwrapExpression(expression);
|
|
if (ts.isSatisfiesExpression(unwrapped) || ts.isAwaitExpression(unwrapped)) {
|
|
return spreadArgumentFacts(unwrapped.expression, seen);
|
|
}
|
|
if (ts.isIdentifier(unwrapped)) {
|
|
const resolved = !seen.has(unwrapped.text) && resolveStaticExpression(unwrapped.text);
|
|
return resolved ? spreadArgumentFacts(resolved, new Set([...seen, unwrapped.text])) : null;
|
|
}
|
|
if (ts.isConditionalExpression(unwrapped)) {
|
|
const left = spreadArgumentFacts(unwrapped.whenTrue, seen);
|
|
const right = spreadArgumentFacts(unwrapped.whenFalse, seen);
|
|
return left && right
|
|
? Array.from({ length: Math.max(left.length, right.length) }, (_, index) =>
|
|
mergeExpressionFacts(
|
|
[left[index] ?? undefinedFact(), right[index] ?? undefinedFact()],
|
|
expression,
|
|
),
|
|
)
|
|
: null;
|
|
}
|
|
if (!ts.isArrayLiteralExpression(unwrapped)) {
|
|
return null;
|
|
}
|
|
const facts = [];
|
|
for (const element of unwrapped.elements) {
|
|
if (ts.isOmittedExpression(element)) {
|
|
facts.push(undefinedFact());
|
|
} else if (ts.isSpreadElement(element)) {
|
|
const nested = spreadArgumentFacts(element.expression, seen);
|
|
if (!nested) {
|
|
return null;
|
|
}
|
|
facts.push(...nested);
|
|
} else {
|
|
facts.push(factFromExpression(element));
|
|
}
|
|
}
|
|
return facts;
|
|
}
|
|
|
|
function wrapperArgumentFacts(call, parameterCount) {
|
|
const facts = [];
|
|
let ambiguous = false;
|
|
let ambiguousStart = 0;
|
|
for (const argument of call.arguments) {
|
|
const expanded = ts.isSpreadElement(argument)
|
|
? spreadArgumentFacts(argument.expression)
|
|
: [factFromExpression(argument)];
|
|
if (!expanded) {
|
|
ambiguousStart = ambiguous ? ambiguousStart : facts.length;
|
|
ambiguous = true;
|
|
}
|
|
const next = expanded ?? [factFromExpression(argument.expression)];
|
|
if (!ambiguous) {
|
|
facts.push(...next);
|
|
continue;
|
|
}
|
|
for (let index = ambiguousStart; index < parameterCount; index++) {
|
|
facts[index] = mergeExpressionFacts([facts[index] ?? undefinedFact(), ...next], argument);
|
|
}
|
|
}
|
|
return facts;
|
|
}
|
|
|
|
function executeWrapper(record, call) {
|
|
if (activeWrapperNodes.has(record.node)) {
|
|
return;
|
|
}
|
|
const argumentFacts = wrapperArgumentFacts(call, record.node.parameters.length);
|
|
activeWrapperNodes.add(record.node);
|
|
wrapperCallSites.push(call.expression);
|
|
try {
|
|
withWrapperEnvironment(record, () =>
|
|
withLexicalScope(false, () => {
|
|
wrapperExecutionScopeIndexes.push(wrapperFunctionScopes.length - 1);
|
|
try {
|
|
if (record.node.name && ts.isIdentifier(record.node.name)) {
|
|
bindIdentifierFact(record.node.name.text, {
|
|
...undefinedFact(),
|
|
knownUndefined: false,
|
|
wrapper: record,
|
|
});
|
|
}
|
|
record.node.parameters.forEach((parameter, index) => {
|
|
const supplied = argumentFacts[index] ?? undefinedFact();
|
|
const possiblyUndefined = supplied.possiblyUndefined ?? supplied.knownUndefined;
|
|
if (possiblyUndefined && parameter.initializer) {
|
|
visit(parameter.initializer);
|
|
}
|
|
const fact =
|
|
possiblyUndefined && parameter.initializer
|
|
? supplied.knownUndefined
|
|
? factFromExpression(parameter.initializer)
|
|
: mergeExpressionFacts(
|
|
[supplied, factFromExpression(parameter.initializer)],
|
|
supplied.expression,
|
|
)
|
|
: supplied;
|
|
bindParameter(parameter, fact);
|
|
});
|
|
if (record.node.body) {
|
|
visit(record.node.body);
|
|
}
|
|
} finally {
|
|
wrapperExecutionScopeIndexes.pop();
|
|
}
|
|
}),
|
|
);
|
|
} finally {
|
|
wrapperCallSites.pop();
|
|
activeWrapperNodes.delete(record.node);
|
|
}
|
|
}
|
|
|
|
function promoteVarBinding(name) {
|
|
const targetIndex = lastScope(wrapperExecutionScopeIndexes);
|
|
if (targetIndex === undefined || targetIndex === wrapperFunctionScopes.length - 1) {
|
|
return;
|
|
}
|
|
for (const [scopes] of lexicalScopeStacks) {
|
|
const source = lastScope(scopes);
|
|
const target = scopes[targetIndex];
|
|
if (!(source instanceof Map) || !(target instanceof Map)) {
|
|
continue;
|
|
}
|
|
for (const [key, value] of source) {
|
|
if (key !== name && !key.startsWith(`${name}.`)) {
|
|
continue;
|
|
}
|
|
if (scopes === wrapperFunctionScopes) {
|
|
target.set(key, mergeWrapperAssignmentValues(target.get(key), value));
|
|
} else if (scopes === fsWriteAliasScopes || scopes === fsSafeStoreFactoryAliasScopes) {
|
|
target.set(key, target.get(key) ?? value);
|
|
} else if (
|
|
scopes === fsModuleBindingScopes ||
|
|
scopes === fsSafeStoreScopes ||
|
|
scopes === fsSafeJsonStoreScopes ||
|
|
scopes === requireAliasScopes ||
|
|
scopes === legacyPathScopes
|
|
) {
|
|
target.set(key, target.get(key) === true || value === true);
|
|
} else {
|
|
target.set(key, value);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function visitInConditionalExecution(node, branchEffects = null) {
|
|
withLexicalScope(true, () => {
|
|
branchEffectScopes.push(branchEffects);
|
|
try {
|
|
visit(node);
|
|
} finally {
|
|
branchEffectScopes.pop();
|
|
}
|
|
});
|
|
}
|
|
|
|
function visit(node) {
|
|
if (isTypeSyntaxNode(node)) {
|
|
return;
|
|
}
|
|
if (node === sourceFile) {
|
|
registerHoistedWrapperFunctions(sourceFile.statements);
|
|
}
|
|
|
|
if (ts.isIfStatement(node)) {
|
|
visit(node.expression);
|
|
const thenEffects = node.elseStatement ? createBranchEffects() : null;
|
|
const elseEffects = node.elseStatement ? createBranchEffects() : null;
|
|
visitInConditionalExecution(node.thenStatement, thenEffects);
|
|
if (node.elseStatement) {
|
|
visitInConditionalExecution(node.elseStatement, elseEffects);
|
|
mergeExhaustiveBranchEffects(thenEffects, elseEffects);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (ts.isWhileStatement(node)) {
|
|
visit(node.expression);
|
|
visitInConditionalExecution(node.statement);
|
|
return;
|
|
}
|
|
|
|
if (ts.isDoStatement(node)) {
|
|
visitInConditionalExecution(node.statement);
|
|
visit(node.expression);
|
|
return;
|
|
}
|
|
|
|
if (ts.isForStatement(node)) {
|
|
withLexicalScope(false, () => {
|
|
if (node.initializer) {
|
|
visit(node.initializer);
|
|
}
|
|
if (node.condition) {
|
|
visit(node.condition);
|
|
}
|
|
if (node.incrementor) {
|
|
visitInConditionalExecution(node.incrementor);
|
|
}
|
|
visitInConditionalExecution(node.statement);
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (ts.isForInStatement(node) || ts.isForOfStatement(node)) {
|
|
visit(node.expression);
|
|
withLexicalScope(true, () => {
|
|
visit(node.initializer);
|
|
if (ts.isForOfStatement(node)) {
|
|
markArrayBindingPatternFromForOf(node.initializer, node.expression);
|
|
}
|
|
visit(node.statement);
|
|
});
|
|
return;
|
|
}
|
|
|
|
if (ts.isFunctionLike(node)) {
|
|
if (ts.isFunctionDeclaration(node) && node.name) {
|
|
registerWrapperFunction(node.name.text, node);
|
|
}
|
|
if (wrapperCallSites.length === 0) {
|
|
visitFunctionLike(node);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (ts.isCallExpression(node)) {
|
|
const callback = dynamicFsImportThenCallback(node);
|
|
if (callback) {
|
|
visitFunctionLike(callback, new Set([0]));
|
|
for (const argument of node.arguments.slice(1)) {
|
|
visit(argument);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (
|
|
ts.isBlock(node) ||
|
|
ts.isModuleBlock(node) ||
|
|
ts.isCaseBlock(node) ||
|
|
ts.isCatchClause(node)
|
|
) {
|
|
visitWithChildScope(node);
|
|
return;
|
|
}
|
|
|
|
if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
|
|
const fact = node.initializer ? factFromExpression(node.initializer) : undefinedFact();
|
|
if (node.initializer) {
|
|
fact.legacyPath = expressionContainsLegacyStore(node.initializer);
|
|
} else {
|
|
fact.knownUndefined = !isAmbientVariableDeclaration(node);
|
|
}
|
|
bindIdentifierFact(node.name.text, fact, node.type);
|
|
}
|
|
if (ts.isVariableDeclaration(node) && !ts.isIdentifier(node.name)) {
|
|
const isFsAliasBinding =
|
|
node.initializer &&
|
|
ts.isObjectBindingPattern(node.name) &&
|
|
isFsBindingExpression(node.initializer);
|
|
collectFsModuleBindingsFromBinding(node);
|
|
collectFsWriteAliasesFromBinding(node);
|
|
markFsSafeStoreShadows(node.name);
|
|
if (!isFsAliasBinding) {
|
|
markFsWriteAliasShadows(node.name);
|
|
markFsModuleBindingShadows(node.name);
|
|
markFsModulePropertyShadows(node.name);
|
|
markCreateRequireShadows(node.name);
|
|
}
|
|
for (const name of bindingPatternNames(node.name)) {
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(name, null);
|
|
lastScope(fsSafeStoreScopes).set(name, false);
|
|
lastScope(fsSafeJsonStoreScopes).set(name, false);
|
|
lastScope(requireAliasScopes).set(name, false);
|
|
lastScope(legacyPathScopes).set(name, false);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(name, false);
|
|
lastScope(knownUndefinedScopes).set(name, false);
|
|
lastScope(literalTextScopes).set(name, null);
|
|
lastScope(wrapperFunctionScopes).set(name, null);
|
|
}
|
|
if (ts.isObjectBindingPattern(node.name) && node.initializer) {
|
|
bindObjectPatternFact(node.name, factFromExpression(node.initializer));
|
|
}
|
|
if (
|
|
ts.isObjectBindingPattern(node.name) &&
|
|
node.initializer &&
|
|
ts.isIdentifier(node.initializer)
|
|
) {
|
|
markLegacyPathsFromObjectBinding(node.name, node.initializer.text);
|
|
markFsSafeStoresFromObjectBinding(node.name, node.initializer.text);
|
|
markFsSafeFactoryAliasesFromObjectBinding(node.name, node.initializer.text);
|
|
} else if (
|
|
ts.isObjectBindingPattern(node.name) &&
|
|
node.initializer &&
|
|
rootedPropertyAccessPath(node.initializer)?.properties.length > 0
|
|
) {
|
|
const propertyAccess = rootedPropertyAccessPath(node.initializer);
|
|
const sourceName = objectPropertyKey(
|
|
propertyAccess.rootName,
|
|
propertyAccess.properties.join("."),
|
|
);
|
|
markLegacyPathsFromObjectBinding(node.name, sourceName);
|
|
markFsSafeStoresFromObjectBinding(node.name, sourceName);
|
|
markFsSafeFactoryAliasesFromObjectBinding(node.name, sourceName);
|
|
} else if (
|
|
ts.isObjectBindingPattern(node.name) &&
|
|
node.initializer &&
|
|
ts.isObjectLiteralExpression(unwrapExpression(node.initializer))
|
|
) {
|
|
markLegacyPathsFromInlineObjectBinding(node.name, node.initializer);
|
|
}
|
|
if (ts.isObjectBindingPattern(node.name) && node.initializer) {
|
|
bindObjectPatternWrappers(node.name, factFromExpression(node.initializer));
|
|
}
|
|
}
|
|
if (ts.isVariableDeclaration(node) && isVarVariableDeclaration(node)) {
|
|
for (const name of bindingPatternNames(node.name)) {
|
|
promoteVarBinding(name);
|
|
}
|
|
}
|
|
if (
|
|
ts.isBinaryExpression(node) &&
|
|
node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
|
|
ts.isIdentifier(node.left)
|
|
) {
|
|
const { index, pathScope, propertyScope, wrapperScope } = legacyIdentifierWriteScopes(
|
|
node.left.text,
|
|
);
|
|
const nextPathValue = expressionContainsLegacyStore(node.right);
|
|
const nextLiteralTexts = literalTextsFromExpression(node.right);
|
|
const nextKnownUndefined = isKnownUndefinedExpression(node.right);
|
|
const nextFsModuleValue = isFsBindingExpression(node.right);
|
|
const nextFsWriteAlias = legacyFsWriteName(node.right);
|
|
const nextFsSafeFactoryAlias = fsSafeStoreFactoryAliasName(node.right);
|
|
const nextFsSafeStoreValue = isFsSafeStoreExpression(node.right);
|
|
const nextFsSafeJsonStoreValue = expressionContainsFsSafeJsonStoreLegacyPath(node.right);
|
|
const nextRequireAlias = isRequireAliasExpression(node.right);
|
|
const conditionalWrite =
|
|
lastScope(conditionalExecutionScopes) && !conditionalExecutionScopes[index];
|
|
pathScope.set(
|
|
node.left.text,
|
|
conditionalWrite ? pathScope.get(node.left.text) === true || nextPathValue : nextPathValue,
|
|
);
|
|
const literalScope = scopeForWrite(literalTextScopes, node.left.text);
|
|
literalScope.set(
|
|
node.left.text,
|
|
conditionalWrite
|
|
? mergeConditionalLiteralTexts(literalScope.get(node.left.text), nextLiteralTexts)
|
|
: nextLiteralTexts,
|
|
);
|
|
scopeForWrite(staticExpressionScopes, node.left.text).set(
|
|
node.left.text,
|
|
conditionalWrite ? null : node.right,
|
|
);
|
|
const knownUndefinedScope = scopeForWrite(knownUndefinedScopes, node.left.text);
|
|
knownUndefinedScope.set(
|
|
node.left.text,
|
|
conditionalWrite
|
|
? knownUndefinedScope.get(node.left.text) === true || nextKnownUndefined
|
|
: nextKnownUndefined,
|
|
);
|
|
if (conditionalWrite) {
|
|
const nextPropertyScope = legacyObjectPropertyRewriteValues(
|
|
node.left.text,
|
|
node.right,
|
|
propertyScope,
|
|
);
|
|
recordBranchIdentifierAssignment(
|
|
index,
|
|
node.left.text,
|
|
nextPathValue,
|
|
node.right,
|
|
nextLiteralTexts,
|
|
nextPropertyScope,
|
|
);
|
|
for (const [key, value] of nextPropertyScope) {
|
|
const mergedValue = mergeConditionalLegacyObjectPropertyValue(
|
|
propertyScope.get(key),
|
|
value,
|
|
);
|
|
if (mergedValue !== null) {
|
|
propertyScope.set(key, mergedValue);
|
|
}
|
|
}
|
|
legacyKnownObjectLiteralScopes[index].set(
|
|
node.left.text,
|
|
legacyKnownObjectLiteralScopes[index].get(node.left.text) === true &&
|
|
isKnownLegacyObjectLiteralExpression(node.right),
|
|
);
|
|
lastScope(legacyPathScopes).set(node.left.text, nextPathValue);
|
|
markKnownLegacyObjectLiteral(node.left.text, node.right);
|
|
clearLegacyObjectProperties(lastScope(legacyObjectPropertyScopes), node.left.text);
|
|
markLegacyObjectProperties(
|
|
node.left.text,
|
|
node.right,
|
|
lastScope(legacyObjectPropertyScopes),
|
|
);
|
|
} else {
|
|
scopeForWrite(fsModuleBindingScopes, node.left.text).set(node.left.text, nextFsModuleValue);
|
|
scopeForWrite(fsWriteAliasScopes, node.left.text).set(node.left.text, nextFsWriteAlias);
|
|
scopeForWrite(fsSafeStoreFactoryAliasScopes, node.left.text).set(
|
|
node.left.text,
|
|
nextFsSafeFactoryAlias,
|
|
);
|
|
scopeForWrite(fsSafeStoreScopes, node.left.text).set(node.left.text, nextFsSafeStoreValue);
|
|
scopeForWrite(fsSafeJsonStoreScopes, node.left.text).set(
|
|
node.left.text,
|
|
nextFsSafeJsonStoreValue,
|
|
);
|
|
const requireAliasTarget = requireAliasWriteTarget(node.left.text);
|
|
requireAliasTarget.scope.set(node.left.text, nextRequireAlias);
|
|
markFsModulePropertyShadows(node.left);
|
|
clearLegacyObjectProperties(propertyScope, node.left.text);
|
|
markKnownLegacyObjectLiteral(
|
|
node.left.text,
|
|
node.right,
|
|
legacyKnownObjectLiteralScopes[index],
|
|
);
|
|
markLegacyObjectProperties(
|
|
node.left.text,
|
|
node.right,
|
|
propertyScope,
|
|
legacyKnownObjectLiteralScopes[index],
|
|
);
|
|
clearFsWriteObjectAliases(fsWriteAliasScopes[index], node.left.text);
|
|
registerFsWriteObjectAliases(node.left.text, node.right, fsWriteAliasScopes[index]);
|
|
clearFsSafeStoreObjectAliases(
|
|
fsSafeStoreScopes[index],
|
|
fsSafeJsonStoreScopes[index],
|
|
node.left.text,
|
|
);
|
|
registerFsSafeStoreObjectAliases(
|
|
node.left.text,
|
|
node.right,
|
|
fsSafeStoreScopes[index],
|
|
fsSafeJsonStoreScopes[index],
|
|
);
|
|
registerFsModuleObjectProperties(node.left.text, node.right, fsModulePropertyScopes[index]);
|
|
clearWrapperObjectMethods(wrapperScope, node.left.text);
|
|
registerWrapperObjectMethods(node.left.text, node.right, wrapperScope);
|
|
}
|
|
if (conditionalWrite) {
|
|
const fsModuleScope = fsModuleBindingScopes[index];
|
|
const fsWriteScope = fsWriteAliasScopes[index];
|
|
const fsSafeFactoryAliasScope = fsSafeStoreFactoryAliasScopes[index];
|
|
const fsSafeStoreScope = fsSafeStoreScopes[index];
|
|
const fsSafeJsonStoreScope = fsSafeJsonStoreScopes[index];
|
|
fsModuleScope.set(
|
|
node.left.text,
|
|
fsModuleScope.get(node.left.text) === true || nextFsModuleValue,
|
|
);
|
|
fsWriteScope.set(node.left.text, fsWriteScope.get(node.left.text) ?? nextFsWriteAlias);
|
|
fsSafeFactoryAliasScope.set(
|
|
node.left.text,
|
|
fsSafeFactoryAliasScope.get(node.left.text) ?? nextFsSafeFactoryAlias,
|
|
);
|
|
fsSafeStoreScope.set(
|
|
node.left.text,
|
|
fsSafeStoreScope.get(node.left.text) === true || nextFsSafeStoreValue,
|
|
);
|
|
fsSafeJsonStoreScope.set(
|
|
node.left.text,
|
|
fsSafeJsonStoreScope.get(node.left.text) === true || nextFsSafeJsonStoreValue,
|
|
);
|
|
requireAliasScopes[index].set(
|
|
node.left.text,
|
|
requireAliasScopes[index].get(node.left.text) === true || nextRequireAlias,
|
|
);
|
|
lastScope(fsModuleBindingScopes).set(node.left.text, nextFsModuleValue);
|
|
lastScope(fsWriteAliasScopes).set(node.left.text, nextFsWriteAlias);
|
|
lastScope(fsSafeStoreFactoryAliasScopes).set(node.left.text, nextFsSafeFactoryAlias);
|
|
lastScope(fsSafeStoreScopes).set(node.left.text, nextFsSafeStoreValue);
|
|
lastScope(fsSafeJsonStoreScopes).set(node.left.text, nextFsSafeJsonStoreValue);
|
|
lastScope(requireAliasScopes).set(node.left.text, nextRequireAlias);
|
|
recordBranchFsIdentifierAssignment(
|
|
index,
|
|
node.left.text,
|
|
nextFsModuleValue,
|
|
nextFsWriteAlias,
|
|
nextFsSafeFactoryAlias,
|
|
nextFsSafeStoreValue,
|
|
nextFsSafeJsonStoreValue,
|
|
nextRequireAlias,
|
|
);
|
|
registerFsWriteObjectAliases(node.left.text, node.right, fsWriteAliasScopes[index], true);
|
|
registerFsSafeStoreObjectAliases(
|
|
node.left.text,
|
|
node.right,
|
|
fsSafeStoreScopes[index],
|
|
fsSafeJsonStoreScopes[index],
|
|
true,
|
|
);
|
|
registerFsModuleObjectProperties(
|
|
node.left.text,
|
|
node.right,
|
|
fsModulePropertyScopes[index],
|
|
true,
|
|
);
|
|
shadowVisibleFsWriteObjectAliases(node.left.text);
|
|
registerFsWriteObjectAliases(node.left.text, node.right);
|
|
registerFsSafeStoreObjectAliases(node.left.text, node.right);
|
|
registerFsModuleObjectProperties(node.left.text, node.right);
|
|
registerWrapperObjectMethods(node.left.text, node.right, wrapperScope, true);
|
|
recordBranchWrapperObjectRewrite(index, node.left.text, node.right);
|
|
shadowVisibleWrapperObjectMethods(node.left.text);
|
|
registerWrapperObjectMethods(node.left.text, node.right);
|
|
}
|
|
const assignedWrapper =
|
|
ts.isFunctionExpression(node.right) || ts.isArrowFunction(node.right)
|
|
? wrapperRecordForNode(node.right)
|
|
: cloneWrapperFunctionValue(resolveWrapperExpression(node.right));
|
|
if (conditionalWrite) {
|
|
recordBranchWrapperAssignment(index, node.left.text, assignedWrapper);
|
|
}
|
|
setWrapperFunctionValue(wrapperScope, node.left.text, assignedWrapper, conditionalWrite);
|
|
const wrapperObjectSource = callExpressionName(node.right);
|
|
if (wrapperObjectSource) {
|
|
copyWrapperObjectMethods(
|
|
node.left.text,
|
|
wrapperObjectSource,
|
|
wrapperScope,
|
|
conditionalWrite,
|
|
);
|
|
}
|
|
}
|
|
if (
|
|
ts.isBinaryExpression(node) &&
|
|
node.operatorToken.kind === ts.SyntaxKind.EqualsToken &&
|
|
rootedPropertyAccessPath(node.left)?.properties.length > 0
|
|
) {
|
|
const propertyAccess = rootedPropertyAccessPath(node.left);
|
|
const propertyName = propertyAccess.properties.join(".");
|
|
const target = legacyObjectPropertyWriteTarget(propertyAccess.rootName, propertyName);
|
|
const key = objectPropertyKey(propertyAccess.rootName, propertyName);
|
|
const nextValue = legacyObjectPropertyValueFromExpression(node.right);
|
|
const nextKnownObjectLiteral = isKnownLegacyObjectLiteralExpression(node.right);
|
|
const rewriteValues = legacyObjectPropertyRewriteValues(key, node.right, target.scope);
|
|
const conditionalPropertyWrite =
|
|
lastScope(conditionalExecutionScopes) && !conditionalExecutionScopes[target.index];
|
|
if (conditionalPropertyWrite) {
|
|
const previousKnownObjectLiteral = lookupKnownLegacyObjectLiteral(key);
|
|
clearKnownLegacyObjectLiterals(legacyKnownObjectLiteralScopes[target.index], key);
|
|
legacyKnownObjectLiteralScopes[target.index].set(
|
|
key,
|
|
previousKnownObjectLiteral && nextKnownObjectLiteral,
|
|
);
|
|
const previousValue = target.scope.has(key)
|
|
? target.scope.get(key)
|
|
: lookupKnownLegacyObjectLiteral(propertyAccess.rootName)
|
|
? explicitUndefinedLegacyObjectPropertyValue
|
|
: undefined;
|
|
const mergedValue = mergeConditionalLegacyObjectPropertyValue(previousValue, nextValue);
|
|
if (mergedValue !== null) {
|
|
target.scope.set(key, mergedValue);
|
|
}
|
|
} else {
|
|
target.scope.set(key, nextValue);
|
|
clearKnownLegacyObjectLiterals(legacyKnownObjectLiteralScopes[target.index], key);
|
|
legacyKnownObjectLiteralScopes[target.index].set(key, nextKnownObjectLiteral);
|
|
}
|
|
if (!conditionalPropertyWrite) {
|
|
clearLegacyObjectProperties(target.scope, key);
|
|
for (const [propertyKey, value] of rewriteValues) {
|
|
target.scope.set(propertyKey, value);
|
|
}
|
|
}
|
|
if (conditionalPropertyWrite) {
|
|
for (const [propertyKey, value] of rewriteValues) {
|
|
const mergedValue = mergeConditionalLegacyObjectPropertyValue(
|
|
target.scope.get(propertyKey),
|
|
value,
|
|
);
|
|
if (mergedValue !== null) {
|
|
target.scope.set(propertyKey, mergedValue);
|
|
recordBranchPropertyAssignment(
|
|
target.index,
|
|
propertyAccess.rootName,
|
|
propertyKey.slice(`${propertyAccess.rootName}.`.length),
|
|
value,
|
|
);
|
|
}
|
|
}
|
|
lastScope(legacyObjectPropertyScopes).set(key, nextValue);
|
|
clearKnownLegacyObjectLiterals(lastScope(legacyKnownObjectLiteralScopes), key);
|
|
lastScope(legacyKnownObjectLiteralScopes).set(key, nextKnownObjectLiteral);
|
|
clearLegacyObjectProperties(lastScope(legacyObjectPropertyScopes), key);
|
|
for (const [propertyKey, value] of rewriteValues) {
|
|
lastScope(legacyObjectPropertyScopes).set(propertyKey, value);
|
|
}
|
|
recordBranchPropertyAssignment(
|
|
target.index,
|
|
propertyAccess.rootName,
|
|
propertyName,
|
|
nextValue,
|
|
nextKnownObjectLiteral,
|
|
);
|
|
}
|
|
const wrapperTarget = legacyIdentifierWriteScopes(propertyAccess.rootName);
|
|
const conditionalWrapperWrite =
|
|
lastScope(conditionalExecutionScopes) && !conditionalExecutionScopes[wrapperTarget.index];
|
|
setFsWriteObjectAlias(
|
|
fsWriteAliasScopes[wrapperTarget.index],
|
|
key,
|
|
legacyFsWriteName(node.right),
|
|
conditionalWrapperWrite,
|
|
);
|
|
setFsModuleObjectProperty(
|
|
fsModulePropertyScopes[wrapperTarget.index],
|
|
key,
|
|
isFsModuleExpression(node.right),
|
|
conditionalWrapperWrite,
|
|
);
|
|
if (!conditionalWrapperWrite) {
|
|
clearFsSafeStoreObjectAliases(
|
|
fsSafeStoreScopes[wrapperTarget.index],
|
|
fsSafeJsonStoreScopes[wrapperTarget.index],
|
|
key,
|
|
);
|
|
}
|
|
setFsSafeStoreObjectAlias(
|
|
fsSafeStoreScopes[wrapperTarget.index],
|
|
fsSafeJsonStoreScopes[wrapperTarget.index],
|
|
key,
|
|
isFsSafeStoreExpression(node.right),
|
|
expressionContainsFsSafeJsonStoreLegacyPath(node.right),
|
|
conditionalWrapperWrite,
|
|
);
|
|
if (!conditionalWrapperWrite) {
|
|
registerFsSafeStoreObjectAliases(
|
|
key,
|
|
node.right,
|
|
fsSafeStoreScopes[wrapperTarget.index],
|
|
fsSafeJsonStoreScopes[wrapperTarget.index],
|
|
);
|
|
}
|
|
if (conditionalWrapperWrite) {
|
|
lastScope(fsWriteAliasScopes).set(key, legacyFsWriteName(node.right));
|
|
lastScope(fsModulePropertyScopes).set(key, isFsModuleExpression(node.right));
|
|
shadowVisibleFsSafeStoreObjectAliases(key);
|
|
lastScope(fsSafeStoreScopes).set(key, isFsSafeStoreExpression(node.right));
|
|
lastScope(fsSafeJsonStoreScopes).set(
|
|
key,
|
|
expressionContainsFsSafeJsonStoreLegacyPath(node.right),
|
|
);
|
|
registerFsSafeStoreObjectAliases(key, node.right);
|
|
recordBranchFsSafeObjectPropertyAssignment(
|
|
wrapperTarget.index,
|
|
propertyAccess.rootName,
|
|
propertyName,
|
|
node.right,
|
|
isFsSafeStoreExpression(node.right),
|
|
expressionContainsFsSafeJsonStoreLegacyPath(node.right),
|
|
);
|
|
}
|
|
const assignedWrapper =
|
|
ts.isFunctionExpression(node.right) || ts.isArrowFunction(node.right)
|
|
? wrapperRecordForNode(node.right)
|
|
: cloneWrapperFunctionValue(resolveWrapperExpression(node.right));
|
|
if (conditionalWrapperWrite) {
|
|
lastScope(wrapperFunctionScopes).set(key, assignedWrapper);
|
|
recordBranchWrapperAssignment(wrapperTarget.index, key, assignedWrapper);
|
|
recordBranchWrapperObjectRewrite(wrapperTarget.index, key, node.right);
|
|
} else {
|
|
clearWrapperObjectMethods(wrapperTarget.wrapperScope, key);
|
|
}
|
|
setWrapperFunctionValue(
|
|
wrapperTarget.wrapperScope,
|
|
key,
|
|
assignedWrapper,
|
|
conditionalWrapperWrite,
|
|
);
|
|
registerWrapperObjectMethods(
|
|
key,
|
|
node.right,
|
|
wrapperTarget.wrapperScope,
|
|
conditionalWrapperWrite,
|
|
);
|
|
}
|
|
|
|
if (ts.isCallExpression(node)) {
|
|
const fsWriteName = legacyFsWriteName(node.expression);
|
|
const filePathOptionsWrite =
|
|
fsWriteName === "appendRegularFile" ||
|
|
fsWriteName === "appendRegularFileSync" ||
|
|
fsWriteName === "replaceFileAtomic" ||
|
|
fsWriteName === "replaceFileAtomicSync";
|
|
if (
|
|
fsWriteName &&
|
|
fsWriteCallMayWrite(fsWriteName, [...node.arguments]) &&
|
|
(filePathOptionsWrite
|
|
? node.arguments[0] && objectFilePathContainsLegacyStore(node.arguments[0])
|
|
: pathArgumentsForFsWrite(fsWriteName, [...node.arguments]).some((argument) =>
|
|
pathArgumentContainsLegacyStore(argument),
|
|
))
|
|
) {
|
|
addViolation(node.expression, "legacy store filesystem write", node);
|
|
}
|
|
if (
|
|
fsSafeStoreWritePathArguments(node).some((argument) =>
|
|
pathArgumentContainsLegacyStore(argument),
|
|
)
|
|
) {
|
|
addViolation(node.expression, "legacy store filesystem write", node);
|
|
}
|
|
if (fsSafeJsonStoreWriteContainsLegacyStore(node)) {
|
|
addViolation(node.expression, "legacy store filesystem write", node);
|
|
}
|
|
const wrapperName = callExpressionName(node.expression);
|
|
const wrapperRecord = wrapperName ? resolveWrapperFunction(wrapperName) : null;
|
|
if (!intrinsicWrapperCalls.has(node) || wrapperCallSites.length === 0) {
|
|
const violationCount = violations.length;
|
|
for (const record of wrapperRecords(wrapperRecord)) {
|
|
executeWrapper(record, node);
|
|
}
|
|
if (definitionScanDepth > 0 && violations.length > violationCount) {
|
|
intrinsicWrapperCalls.add(node);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (
|
|
(ts.isStringLiteralLike(node) || ts.isIdentifier(node) || ts.isTemplateExpression(node)) &&
|
|
bridgeMarkerPattern.test(node.getText(sourceFile))
|
|
) {
|
|
addViolation(node, "legacy transcript bridge marker");
|
|
}
|
|
|
|
ts.forEachChild(node, visit);
|
|
}
|
|
|
|
visit(sourceFile);
|
|
if (
|
|
scanOptions.enforceCurrentLegacyAllowlist &&
|
|
!scanOptions.currentLegacyWriteAllowances &&
|
|
currentLegacyWriteAllowances.size > 0
|
|
) {
|
|
violations.push({ kind: "stale current legacy write allowlist", line: 1 });
|
|
}
|
|
return violations;
|
|
}
|
|
|
|
/**
|
|
* Runs the database-first legacy-store guard.
|
|
*/
|
|
export async function main() {
|
|
const repoRoot = resolveRepoRoot(import.meta.url);
|
|
const sourceRoots = databaseFirstLegacyStoreSourceRoots.map((root) => path.join(repoRoot, root));
|
|
const files = await collectDatabaseFirstLegacyStoreSourceFiles(sourceRoots);
|
|
const nativeSourceRoots = databaseFirstNativeSourceRoots.map((root) => path.join(repoRoot, root));
|
|
const nativeFiles = (await Promise.all(nativeSourceRoots.map(collectNativeSourceFiles))).flat();
|
|
const violations = [];
|
|
const currentLegacyWriteAllowances = currentLegacyWriteViolationAllowances();
|
|
|
|
for (const filePath of files) {
|
|
const relativePath = path.relative(repoRoot, filePath).replaceAll(path.sep, "/");
|
|
const content = await fs.readFile(filePath, "utf8");
|
|
for (const violation of collectDatabaseFirstLegacyStoreViolations(content, relativePath, {
|
|
currentLegacyWriteAllowances,
|
|
})) {
|
|
violations.push(`${relativePath}:${violation.line} ${violation.kind}`);
|
|
}
|
|
}
|
|
for (const fingerprint of currentLegacyWriteAllowances.keys()) {
|
|
const relativePath = currentLegacyWriteViolationPath(fingerprint) ?? "<unknown>";
|
|
violations.push(`${relativePath}:1 stale current legacy write allowlist`);
|
|
}
|
|
for (const filePath of nativeFiles) {
|
|
const relativePath = path.relative(repoRoot, filePath).replaceAll(path.sep, "/");
|
|
const content = await fs.readFile(filePath, "utf8");
|
|
for (const violation of collectDatabaseFirstNativeLegacyStoreViolations(
|
|
content,
|
|
relativePath,
|
|
)) {
|
|
violations.push(`${relativePath}:${violation.line} ${violation.kind}`);
|
|
}
|
|
}
|
|
|
|
if (violations.length === 0) {
|
|
console.log("Database-first legacy-store guard passed.");
|
|
return;
|
|
}
|
|
|
|
console.error("Found database-first legacy-store guard violations:");
|
|
for (const violation of violations.toSorted()) {
|
|
console.error(`- ${violation}`);
|
|
}
|
|
console.error(
|
|
"Runtime state/cache writes must use the shared or per-agent SQLite stores. Keep legacy file import/removal under doctor or migration owners.",
|
|
);
|
|
process.exit(1);
|
|
}
|
|
|
|
runAsScript(import.meta.url, main);
|