Skip to content

Commit 01fc1ed

Browse files
vincentkocvincentkoc
authored
refactor(scripts): extract legacy-store path domain (#104894)
1 parent 63e00eb commit 01fc1ed

2 files changed

Lines changed: 122 additions & 124 deletions

File tree

‎scripts/check-database-first-legacy-stores.mjs‎

Lines changed: 23 additions & 124 deletions
Original file line numberDiff line numberDiff line change
@@ -4,6 +4,14 @@
44
import { promises as fs } from "node:fs";
55
import path from "node:path";
66
import ts from "typescript";
7+
import {
8+
explicitUndefinedLegacyObjectPropertyValue,
9+
mergeConditionalLegacyObjectPropertyValue,
10+
mergeConditionalLiteralTexts,
11+
mergeExhaustiveLiteralTexts,
12+
mergeLegacyObjectPropertyValues,
13+
mergeLegacyPathBranchAssignments,
14+
} from "./lib/legacy-store-path-domain.mjs";
715
import { resolveRepoRoot, runAsScript, toLine, unwrapExpression } from "./lib/ts-guard-utils.mjs";
816

917
const databaseFirstLegacyStoreSourceRoots = ["src", "extensions", "packages"];
@@ -1049,42 +1057,6 @@ export function collectDatabaseFirstLegacyStoreViolations(
10491057
return element && !ts.isSpreadElement(element) ? element : null;
10501058
}
10511059

1052-
function mergeConditionalLiteralTexts(previous, next) {
1053-
if (next.length === 0) {
1054-
return previous ?? null;
1055-
}
1056-
return [...new Set([...(previous ?? []), ...next])];
1057-
}
1058-
1059-
function mergeExhaustiveLiteralTexts(left, right) {
1060-
if (left.length === 0 && right.length === 0) {
1061-
return null;
1062-
}
1063-
return [...new Set([...left, ...right])];
1064-
}
1065-
1066-
function mergeLegacyObjectPropertyValues(left, right) {
1067-
if (left === true || right === true) {
1068-
return true;
1069-
}
1070-
if (
1071-
left === explicitUndefinedLegacyObjectPropertyValue ||
1072-
right === explicitUndefinedLegacyObjectPropertyValue ||
1073-
left === undefined ||
1074-
right === undefined
1075-
) {
1076-
return explicitUndefinedLegacyObjectPropertyValue;
1077-
}
1078-
return false;
1079-
}
1080-
1081-
function mergeConditionalLegacyObjectPropertyValue(previous, next) {
1082-
if (previous === undefined && next === false) {
1083-
return null;
1084-
}
1085-
return mergeLegacyObjectPropertyValues(previous, next);
1086-
}
1087-
10881060
function legacyObjectPropertyRewriteValues(objectName, initializer, existingScope) {
10891061
const values = new Map();
10901062
markLegacyObjectProperties(objectName, initializer, values, null);
@@ -1099,34 +1071,6 @@ export function collectDatabaseFirstLegacyStoreViolations(
10991071
return values;
11001072
}
11011073

1102-
function branchAssignmentPropertyValue(assignment, propertyKey) {
1103-
if (assignment.objectProperties.has(propertyKey)) {
1104-
return { known: true, value: assignment.objectProperties.get(propertyKey) };
1105-
}
1106-
if (assignment.knownObjectLiteral) {
1107-
return { known: true, value: explicitUndefinedLegacyObjectPropertyValue };
1108-
}
1109-
return { known: false, value: null };
1110-
}
1111-
1112-
function mergeBranchLegacyObjectPropertyValue(leftAssignment, rightAssignment, propertyKey) {
1113-
const left = branchAssignmentPropertyValue(leftAssignment, propertyKey);
1114-
const right = branchAssignmentPropertyValue(rightAssignment, propertyKey);
1115-
if (!left.known && !right.known) {
1116-
return null;
1117-
}
1118-
if (left.value === true || right.value === true) {
1119-
return true;
1120-
}
1121-
if (
1122-
left.value === explicitUndefinedLegacyObjectPropertyValue ||
1123-
right.value === explicitUndefinedLegacyObjectPropertyValue
1124-
) {
1125-
return explicitUndefinedLegacyObjectPropertyValue;
1126-
}
1127-
return left.known && right.known ? false : null;
1128-
}
1129-
11301074
function lookupLegacyObjectProperty(
11311075
objectName,
11321076
propertyName,
@@ -2236,9 +2180,6 @@ export function collectDatabaseFirstLegacyStoreViolations(
22362180
const unknownObjectLiteralPropertyInitializer = Symbol(
22372181
"unknown object literal property initializer",
22382182
);
2239-
const explicitUndefinedLegacyObjectPropertyValue = Symbol(
2240-
"explicit undefined legacy object property value",
2241-
);
22422183
const explicitUndefinedNestedWrapperValue = Symbol("explicit undefined nested wrapper value");
22432184
const knownObjectLiteralNestedWrapperValue = Symbol("known object literal nested wrapper value");
22442185
const unknownNestedWrapperObjectValue = Symbol("unknown nested wrapper object value");
@@ -2634,86 +2575,44 @@ export function collectDatabaseFirstLegacyStoreViolations(
26342575
}
26352576
const { index, name } = thenAssignment;
26362577
mergedIdentifierNames.add(branchIdentifierAssignmentKey(index, name));
2637-
const mergedValue = thenAssignment.value === true || elseAssignment.value === true;
2638-
const propertyKeys = new Set([
2639-
...thenAssignment.objectProperties.keys(),
2640-
...elseAssignment.objectProperties.keys(),
2641-
]);
2642-
const mergedProperties = new Map();
2643-
for (const propertyKey of propertyKeys) {
2644-
const mergedPropertyValue = mergeBranchLegacyObjectPropertyValue(
2645-
thenAssignment,
2646-
elseAssignment,
2647-
propertyKey,
2648-
);
2649-
if (mergedPropertyValue !== null) {
2650-
mergedProperties.set(propertyKey, mergedPropertyValue);
2651-
}
2652-
}
2653-
const mergedKnownObjectLiteral =
2654-
thenAssignment.knownObjectLiteral && elseAssignment.knownObjectLiteral;
2655-
const mergedKnownUndefined = thenAssignment.knownUndefined || elseAssignment.knownUndefined;
2656-
const knownObjectLiteralKeys = new Set([
2657-
...thenAssignment.knownObjectLiterals.keys(),
2658-
...elseAssignment.knownObjectLiterals.keys(),
2659-
]);
2660-
const mergedKnownObjectLiterals = new Map();
2661-
for (const knownObjectLiteralKey of knownObjectLiteralKeys) {
2662-
mergedKnownObjectLiterals.set(
2663-
knownObjectLiteralKey,
2664-
thenAssignment.knownObjectLiterals.get(knownObjectLiteralKey) === true &&
2665-
elseAssignment.knownObjectLiterals.get(knownObjectLiteralKey) === true,
2666-
);
2667-
}
2578+
const merged = mergeLegacyPathBranchAssignments(thenAssignment, elseAssignment);
26682579
if (applyToTargetScopes) {
26692580
const pathScope = legacyPathScopes[index];
26702581
const literalScope = literalTextScopes[index];
26712582
const knownUndefinedScope = knownUndefinedScopes[index];
26722583
const propertyScope = legacyObjectPropertyScopes[index];
26732584
const knownObjectLiteralScope = legacyKnownObjectLiteralScopes[index];
26742585
clearKnownLegacyObjectLiterals(knownObjectLiteralScope, name);
2675-
knownObjectLiteralScope.set(name, mergedKnownObjectLiteral);
2676-
for (const [knownObjectLiteralKey, value] of mergedKnownObjectLiterals) {
2586+
knownObjectLiteralScope.set(name, merged.knownObjectLiteral);
2587+
for (const [knownObjectLiteralKey, value] of merged.knownObjectLiterals) {
26772588
knownObjectLiteralScope.set(knownObjectLiteralKey, value);
26782589
}
2679-
pathScope.set(name, mergedValue);
2680-
knownUndefinedScope.set(name, mergedKnownUndefined);
2681-
literalScope.set(
2682-
name,
2683-
mergeExhaustiveLiteralTexts(thenAssignment.literalTexts, elseAssignment.literalTexts),
2684-
);
2590+
pathScope.set(name, merged.value);
2591+
knownUndefinedScope.set(name, merged.knownUndefined);
2592+
literalScope.set(name, merged.literalTexts);
26852593
clearLegacyObjectProperties(propertyScope, name);
2686-
for (const [propertyKey, value] of mergedProperties) {
2594+
for (const [propertyKey, value] of merged.objectProperties) {
26872595
propertyScope.set(propertyKey, value);
26882596
}
26892597
}
26902598
clearKnownLegacyObjectLiterals(currentLegacyKnownObjectLiteralScope(), name);
2691-
currentLegacyKnownObjectLiteralScope().set(name, mergedKnownObjectLiteral);
2692-
for (const [knownObjectLiteralKey, value] of mergedKnownObjectLiterals) {
2599+
currentLegacyKnownObjectLiteralScope().set(name, merged.knownObjectLiteral);
2600+
for (const [knownObjectLiteralKey, value] of merged.knownObjectLiterals) {
26932601
currentLegacyKnownObjectLiteralScope().set(knownObjectLiteralKey, value);
26942602
}
2695-
currentLegacyPathScope().set(name, mergedValue);
2696-
currentKnownUndefinedScope().set(name, mergedKnownUndefined);
2697-
currentLiteralTextScope().set(
2698-
name,
2699-
mergeExhaustiveLiteralTexts(thenAssignment.literalTexts, elseAssignment.literalTexts),
2700-
);
2603+
currentLegacyPathScope().set(name, merged.value);
2604+
currentKnownUndefinedScope().set(name, merged.knownUndefined);
2605+
currentLiteralTextScope().set(name, merged.literalTexts);
27012606
clearLegacyObjectProperties(currentLegacyObjectPropertyScope(), name);
2702-
for (const [propertyKey, value] of mergedProperties) {
2607+
for (const [propertyKey, value] of merged.objectProperties) {
27032608
currentLegacyObjectPropertyScope().set(propertyKey, value);
27042609
}
27052610
if (parentEffect) {
27062611
parentEffect.identifierAssignments.set(branchIdentifierAssignmentKey(index, name), {
27072612
index,
2708-
knownUndefined: mergedKnownUndefined,
2709-
knownObjectLiteral: mergedKnownObjectLiteral,
2710-
knownObjectLiterals: mergedKnownObjectLiterals,
2711-
literalTexts:
2712-
mergeExhaustiveLiteralTexts(thenAssignment.literalTexts, elseAssignment.literalTexts) ??
2713-
[],
2613+
...merged,
2614+
literalTexts: merged.literalTexts ?? [],
27142615
name,
2715-
value: mergedValue,
2716-
objectProperties: mergedProperties,
27172616
});
27182617
}
27192618
}

‎scripts/lib/legacy-store-path-domain.mjs‎

Lines changed: 99 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,99 @@
1+
export const explicitUndefinedLegacyObjectPropertyValue = Symbol(
2+
"explicit undefined legacy object property value",
3+
);
4+
5+
export function mergeConditionalLiteralTexts(previous, next) {
6+
if (next.length === 0) {
7+
return previous ?? null;
8+
}
9+
return [...new Set([...(previous ?? []), ...next])];
10+
}
11+
12+
export function mergeExhaustiveLiteralTexts(left, right) {
13+
if (left.length === 0 && right.length === 0) {
14+
return null;
15+
}
16+
return [...new Set([...left, ...right])];
17+
}
18+
19+
export function mergeLegacyObjectPropertyValues(left, right) {
20+
if (left === true || right === true) {
21+
return true;
22+
}
23+
if (
24+
left === explicitUndefinedLegacyObjectPropertyValue ||
25+
right === explicitUndefinedLegacyObjectPropertyValue ||
26+
left === undefined ||
27+
right === undefined
28+
) {
29+
return explicitUndefinedLegacyObjectPropertyValue;
30+
}
31+
return false;
32+
}
33+
34+
export function mergeConditionalLegacyObjectPropertyValue(previous, next) {
35+
if (previous === undefined && next === false) {
36+
return null;
37+
}
38+
return mergeLegacyObjectPropertyValues(previous, next);
39+
}
40+
41+
function branchAssignmentPropertyValue(assignment, propertyKey) {
42+
if (assignment.objectProperties.has(propertyKey)) {
43+
return { known: true, value: assignment.objectProperties.get(propertyKey) };
44+
}
45+
if (assignment.knownObjectLiteral) {
46+
return { known: true, value: explicitUndefinedLegacyObjectPropertyValue };
47+
}
48+
return { known: false, value: null };
49+
}
50+
51+
function mergeBranchLegacyObjectPropertyValue(leftAssignment, rightAssignment, propertyKey) {
52+
const left = branchAssignmentPropertyValue(leftAssignment, propertyKey);
53+
const right = branchAssignmentPropertyValue(rightAssignment, propertyKey);
54+
if (!left.known && !right.known) {
55+
return null;
56+
}
57+
if (left.value === true || right.value === true) {
58+
return true;
59+
}
60+
if (
61+
left.value === explicitUndefinedLegacyObjectPropertyValue ||
62+
right.value === explicitUndefinedLegacyObjectPropertyValue
63+
) {
64+
return explicitUndefinedLegacyObjectPropertyValue;
65+
}
66+
return left.known && right.known ? false : null;
67+
}
68+
69+
export function mergeLegacyPathBranchAssignments(left, right) {
70+
const propertyKeys = new Set([...left.objectProperties.keys(), ...right.objectProperties.keys()]);
71+
const objectProperties = new Map();
72+
for (const propertyKey of propertyKeys) {
73+
const value = mergeBranchLegacyObjectPropertyValue(left, right, propertyKey);
74+
if (value !== null) {
75+
objectProperties.set(propertyKey, value);
76+
}
77+
}
78+
79+
const knownObjectLiteralKeys = new Set([
80+
...left.knownObjectLiterals.keys(),
81+
...right.knownObjectLiterals.keys(),
82+
]);
83+
const knownObjectLiterals = new Map();
84+
for (const key of knownObjectLiteralKeys) {
85+
knownObjectLiterals.set(
86+
key,
87+
left.knownObjectLiterals.get(key) === true && right.knownObjectLiterals.get(key) === true,
88+
);
89+
}
90+
91+
return {
92+
knownObjectLiteral: left.knownObjectLiteral && right.knownObjectLiteral,
93+
knownObjectLiterals,
94+
knownUndefined: left.knownUndefined || right.knownUndefined,
95+
literalTexts: mergeExhaustiveLiteralTexts(left.literalTexts, right.literalTexts),
96+
objectProperties,
97+
value: left.value === true || right.value === true,
98+
};
99+
}

0 commit comments

Comments
 (0)