@blumintinc/eslint-plugin-blumint 1.21.1 → 1.21.3

package/lib/index.js

@@ -224,7 +224,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.21.1',
+        version: '1.21.3',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-boolean-naming-prefixes.js

@@ -44,6 +44,25 @@ const DEFAULT_OPTIONS = {
     enforceForPropertySignatures: false,
 };
 const BOOLEANISH_BINARY_OPERATORS = new Set(['===', '!==', '==', '!=', '>', '<', '>=', '<=', 'in', 'instanceof']);
+/**
+ * The operators that spell a DEFAULTED value: `left OP fallback` yields the
+ * left operand when it is present and the right operand only as a default. What
+ * makes such an initializer boolean is its operands, never which of the two
+ * joins them — `||` and `??` differ solely in which absent-ish left values hand
+ * over to the fallback.
+ *
+ * Both spellings must be read, because they are interconvertible under this
+ * plugin's own recommended config: `prefer-nullish-coalescing-boolean-props`
+ * rewrites `||` to `??` under `--fix`, so recognizing only `||` lets a sibling
+ * rule's fixer silence this one on every binding it touches.
+ *
+ * `&&` is deliberately excluded. Its right operand is the RESULT when the left
+ * is truthy rather than a default, so the fallback screen below — "a
+ * non-boolean literal on the right means the value is not a boolean" — would
+ * read the wrong operand. Conjunctions keep their own both-operand analysis,
+ * which already classifies `user && user.isActive` as boolean.
+ */
+const BOOLEAN_FALLBACK_OPERATORS = new Set(['||', '??']);
 /**
  * The name a class member key declares, for both spellings of privacy.
  *
@@ -429,7 +448,9 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     BOOLEANISH_BINARY_OPERATORS.has(init.operator)) {
                     return true;
                 }
-                // Check for logical expressions (&&)
+                // Conjunctions classify from BOTH operands rather than through the
+                // fallback screen below, which is why `&&` is kept out of
+                // `BOOLEAN_FALLBACK_OPERATORS`.
                 if (init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
                     init.operator === '&&') {
                     const left = evaluateBooleanishExpression(init.left);
@@ -447,11 +468,12 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     }
                     return false;
                 }
-                // Special case for logical OR (||) - only consider it boolean if:
+                // Special case for a defaulted value (`||`, `??`) - only consider it
+                // boolean if:
                 // 1. It's used with boolean literals or
                 // 2. It's not used with array/object literals as fallbacks
                 if (init.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    init.operator === '||') {
+                    BOOLEAN_FALLBACK_OPERATORS.has(init.operator)) {
                     // Check if right side is a non-boolean literal (array, object, string, number)
                     const rightSide = init.right;
                     if (rightSide.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
@@ -1051,9 +1073,10 @@ exports.enforceBooleanNamingPrefixes = (0, createRule_1.createRule)({
                     return (!isGlobalBooleanCall(value) &&
                         calleeReturnEvaluation(value.callee.name) === 'indeterminate');
                 }
-                // `isFoo(x) || fallback` reaches booleanness through its left operand.
+                // `isFoo(x) || fallback` reaches booleanness through its left operand,
+                // and so does the `??` spelling of the same default.
                 if (value.type === utils_1.AST_NODE_TYPES.LogicalExpression &&
-                    value.operator === '||') {
+                    BOOLEAN_FALLBACK_OPERATORS.has(value.operator)) {
                     return restsOnName(value.left);
                 }
                 return false;

package/lib/rules/enforce-centralized-mock-firestore.d.ts

@@ -1 +1,2 @@
-export declare const enforceCentralizedMockFirestore: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"useCentralizedMockFirestore", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+import { TSESLint } from '@typescript-eslint/utils';
+export declare const enforceCentralizedMockFirestore: TSESLint.RuleModule<"useCentralizedMockFirestore", [], TSESLint.RuleListener>;

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -14,6 +14,35 @@ const importRemoval_1 = require("../utils/importRemoval");
  */
 const MOCK_FIRESTORE_MODULE = '__test-utils__/mockFirestore';
 const MOCK_FIRESTORE_PATH = `../../../../../${MOCK_FIRESTORE_MODULE}`;
+/**
+ * The name the centralized module actually exports, and therefore the exact
+ * text the fixer emits and the exact text every emitted-name comparison is
+ * made against. Detection normalizes (see {@link isMockFirestoreName});
+ * emission cannot — `import { MOCK_FIRESTORE } from …` would import a name the
+ * shared module does not export, and rewriting a reference to anything but
+ * this spelling leaves it unbound.
+ */
+const MOCK_FIRESTORE_EXPORT = 'mockFirestore';
+/**
+ * The local mock's name reduced to the one form every spelling of it shares:
+ * separators dropped and case folded.
+ *
+ * A mock must not be able to hide behind its spelling. `global-const-style` —
+ * also `recommended: 'error'`, also fixable — renames module constants into
+ * SCREAMING_SNAKE_CASE, so the composed config walks a `mockFirestore` out of
+ * this rule's view by turning it into `MOCK_FIRESTORE`; a hand-written
+ * `MOCK_FIRESTORE` is equally invisible with no fixer involved (#2307).
+ */
+const MOCK_FIRESTORE_BINDING = 'mockfirestore';
+/**
+ * Whether an identifier names the local mock, comparing whole identifiers
+ * rather than substrings. `mockFirestoreAdmin`, `MOCK_FIRESTORE_ADMIN` and
+ * `firestoreMock` name something else, and claiming them is another rule's
+ * business.
+ */
+function isMockFirestoreName(name) {
+    return name.replace(/[_-]/g, '').toLowerCase() === MOCK_FIRESTORE_BINDING;
+}
 const SOURCE_EXTENSION = /\.(?:ts|tsx|js|jsx)$/;
 /**
  * The module every other file is told to import from is the one module that
@@ -48,16 +77,23 @@ const isCentralizedMockModule = (filename) => {
  * safest. `global-const-style` and `renameFixes` withhold their fixes on the
  * same grounds.
  *
- * Only `ExportNamedDeclaration` can front a flagged node: `export default`
- * takes an expression, never a `const`, and a class property — the other shape
- * this rule flags — belongs to its class rather than to the module, so
+ * Both export forms can front a flagged node. `export default` takes an
+ * expression rather than a `const`, but it does take a FUNCTION declaration,
+ * and `export default function mockFirestore() {}` makes the module's default
+ * export the very thing being retired — the same cross-file contract break
+ * under a different name. A class property is on neither surface: it belongs
+ * to its class rather than to the module, so
  * `export default class { mockFirestore = … }` exports nothing by that name.
  */
+const EXPORT_FRONTS = new Set([
+    utils_1.AST_NODE_TYPES.ExportNamedDeclaration,
+    utils_1.AST_NODE_TYPES.ExportDefaultDeclaration,
+]);
 function isExportedDeclaration(node) {
     const statement = node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration
         ? node.parent
         : node;
-    return statement.parent?.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration;
+    return (!!statement.parent && EXPORT_FRONTS.has(statement.parent.type));
 }
 function isHorizontalWhitespace(character) {
     return character === ' ' || character === '\t';
@@ -112,34 +148,30 @@ const STATEMENT_CONTAINERS = new Set([
     utils_1.AST_NODE_TYPES.TSModuleBlock,
 ]);
 /**
- * The declaration when it stands as a statement of its own, and nothing
- * otherwise.
+ * Whether the node stands as a statement of its own, and so may give up the
+ * whole line it occupies.
  *
- * An `export const` is deliberately not widened to the `export` that fronts it:
- * swallowing the keyword retires the name from the module's export surface, so
- * such a declaration has no retirable statement at all and its enclosing
- * `ExportNamedDeclaration` is absent from `STATEMENT_CONTAINERS` for that
- * reason. `isExportedDeclaration` refuses the same shape ahead of this call and
- * covers the multi-declarator form this branch never sees.
+ * An `export`ed declaration is deliberately not widened to the `export` that
+ * fronts it: swallowing the keyword retires the name from the module's export
+ * surface, so such a declaration has no retirable statement at all and the
+ * export node types are absent from `STATEMENT_CONTAINERS` for that reason.
+ * `isExportedDeclaration` refuses the same shape ahead of this call and covers
+ * the multi-declarator form this branch never sees.
  */
-function retirableStatement(declaration) {
-    return declaration.parent &&
-        STATEMENT_CONTAINERS.has(declaration.parent.type)
-        ? declaration
-        : undefined;
+function isRetirableStatement(node) {
+    return !!node.parent && STATEMENT_CONTAINERS.has(node.parent.type);
 }
 function retiredSpan(node) {
     const parent = node.parent;
     if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
         const { declarations } = parent;
         if (declarations.length === 1) {
-            const statement = retirableStatement(parent);
-            if (!statement) {
+            if (!isRetirableStatement(parent)) {
                 return undefined;
             }
             return {
-                start: statement.range[0],
-                end: statement.range[1],
+                start: parent.range[0],
+                end: parent.range[1],
                 whole: true,
             };
         }
@@ -162,6 +194,15 @@ function retiredSpan(node) {
         }
         return undefined;
     }
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration) {
+        // A function declaration nested anywhere but a statement position — the
+        // body of an `if` under Annex B, say — cannot be excised without leaving
+        // the enclosing construct malformed, so it forfeits the fix like any other
+        // unretirable shape.
+        return isRetirableStatement(node)
+            ? { start: node.range[0], end: node.range[1], whole: true }
+            : undefined;
+    }
     if (node.type === utils_1.AST_NODE_TYPES.PropertyDefinition) {
         return { start: node.range[0], end: node.range[1], whole: true };
     }
@@ -195,9 +236,23 @@ const retirementCarriesOrphan = (variables, removed) => variables.every((variabl
     : null;
 /**
  * Collapses edits that touch, so an overlap can never rewrite a range twice.
+ *
+ * Identical edits are dropped rather than merged: two visitors can reach the
+ * same reference — a renamed destructured binding is both a tracked call site
+ * and a retired binding's reference — and merging concatenates the texts, which
+ * would emit `mockFirestoremockFirestore` in place of the name.
  */
 function mergeEdits(edits) {
-    const sorted = [...edits].sort((a, b) => a.start - b.start || a.end - b.end);
+    const seen = new Set();
+    const unique = edits.filter((edit) => {
+        const key = `${edit.start}:${edit.end}:${edit.text}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+    const sorted = [...unique].sort((a, b) => a.start - b.start || a.end - b.end);
     const merged = [];
     for (const edit of sorted) {
         const last = merged[merged.length - 1];
@@ -230,6 +285,29 @@ function importPlacement(sourceCode, anchor, edits) {
     const enclosing = edits.find((edit) => edit.start < offset && offset < edit.end);
     return enclosing ? { kind: 'index', index: enclosing.start } : placement;
 }
+/**
+ * Whether a binding spelled exactly `mockFirestore` outlives the retirement in
+ * the scope the injected import binds into.
+ *
+ * Normalized detection is what puts this within reach: a local spelled
+ * `MOCK_FIRESTORE` is retired while an unrelated `mockFirestore` — a function
+ * declaration, an import of the same name from somewhere else — is left
+ * standing, and the two meet only once the import lands, so the emitted file
+ * redeclares the name. The fix is withheld and the report stands, which still
+ * surfaces the local mock for a human to retire (#2307).
+ */
+function collidesWithSurvivingBinding(sourceCode, removed) {
+    const globalScope = sourceCode.scopeManager?.globalScope;
+    if (!globalScope) {
+        return false;
+    }
+    const scopes = [
+        globalScope,
+        ...globalScope.childScopes.filter((scope) => scope.type === 'module'),
+    ];
+    return scopes.some((scope) => scope.variables.some((variable) => variable.name === MOCK_FIRESTORE_EXPORT &&
+        variable.defs.some((definition) => !isWithinAny(definition.name.range, removed))));
+}
 exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
     name: 'enforce-centralized-mock-firestore',
     meta: {
@@ -271,10 +349,17 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                     hasCentralizedImport = true;
                     // Check for renamed imports
                     for (const specifier of node.specifiers) {
+                        // Both comparisons stay EXACT. `imported` names the shared
+                        // module's export surface, which spells the mock one way; a
+                        // normalized match here would treat `import { MOCK_FIRESTORE }`
+                        // as the shared mock and rewrite its call sites to a name the
+                        // module never exported. `local` is compared against the text the
+                        // fixer emits, and a binding differing only in case is still a
+                        // different binding that the rewrite has to reach.
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                             specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            specifier.imported.name === 'mockFirestore' &&
-                            specifier.local.name !== 'mockFirestore') {
+                            specifier.imported.name === MOCK_FIRESTORE_EXPORT &&
+                            specifier.local.name !== MOCK_FIRESTORE_EXPORT) {
                             customMockFirestoreNames.add(specifier.local.name);
                         }
                     }
@@ -282,18 +367,19 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
             },
             VariableDeclarator(node) {
                 if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.id.name === 'mockFirestore') {
+                    isMockFirestoreName(node.id.name)) {
                     mockFirestoreNodes.add(node);
                 }
                 else if (node.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
                     for (const prop of node.id.properties) {
                         if (prop.type === utils_1.AST_NODE_TYPES.Property &&
                             prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            prop.key.name === 'mockFirestore') {
+                            isMockFirestoreName(prop.key.name)) {
                             mockFirestoreNodes.add(node);
-                            // Track renamed destructured imports
+                            // Track renamed destructured imports. The comparison is against
+                            // the emitted name, so any other spelling needs rewriting.
                             if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                prop.value.name !== 'mockFirestore') {
+                                prop.value.name !== MOCK_FIRESTORE_EXPORT) {
                                 customMockFirestoreNames.add(prop.value.name);
                             }
                             break;
@@ -301,9 +387,21 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                     }
                 }
             },
+            // A local mock declared as a function is the same ad-hoc local mock as one
+            // declared as a `const` holding an arrow, which this rule already retires.
+            // Spelling and declaration FORM are two doors into the same hiding place:
+            // leaving this one open costs more than the missed report, because a file
+            // whose other local mock IS flagged loses its fix outright — the injected
+            // `import { mockFirestore }` would redeclare the surviving function, so
+            // `collidesWithSurvivingBinding` withholds the whole rewrite (#2307).
+            FunctionDeclaration(node) {
+                if (node.id && isMockFirestoreName(node.id.name)) {
+                    mockFirestoreNodes.add(node);
+                }
+            },
             PropertyDefinition(node) {
                 if (node.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.key.name === 'mockFirestore') {
+                    isMockFirestoreName(node.key.name)) {
                     mockFirestoreNodes.add(node);
                 }
             },
@@ -325,11 +423,12 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                         for (const prop of parent.id.properties) {
                             if (prop.type === utils_1.AST_NODE_TYPES.Property &&
                                 prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                prop.key.name === 'mockFirestore') {
+                                isMockFirestoreName(prop.key.name)) {
                                 mockFirestoreNodes.add(parent);
-                                // Track renamed destructured imports
+                                // Track renamed destructured imports. The comparison is
+                                // against the emitted name, as above.
                                 if (prop.value.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    prop.value.name !== 'mockFirestore') {
+                                    prop.value.name !== MOCK_FIRESTORE_EXPORT) {
                                     customMockFirestoreNames.add(prop.value.name);
                                 }
                                 break;
@@ -338,8 +437,14 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                     }
                 }
             },
-            // Handle complex object destructuring
-            'ObjectPattern > Property > ObjectPattern > Property > ObjectPattern > Property[key.name="mockFirestore"]'(node) {
+            // Handle complex object destructuring. The name test lives in the body
+            // rather than in the selector because an esquery attribute match is
+            // literal, and this one has to normalize like every other detection site.
+            'ObjectPattern > Property > ObjectPattern > Property > ObjectPattern > Property'(node) {
+                if (node.key.type !== utils_1.AST_NODE_TYPES.Identifier ||
+                    !isMockFirestoreName(node.key.name)) {
+                    return;
+                }
                 let current = node;
                 while (current.parent) {
                     if (current.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
@@ -353,13 +458,23 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
             MemberExpression(node) {
                 if (node.object.type === utils_1.AST_NODE_TYPES.ThisExpression &&
                     node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.property.name === 'mockFirestore') {
+                    isMockFirestoreName(node.property.name)) {
                     thisExpressions.push(node);
                 }
             },
             'Program:exit'() {
                 if (mockFirestoreNodes.size > 0) {
                     const sourceCode = context.getSourceCode();
+                    // The bindings a flagged declaration introduces that are the local
+                    // mock under a spelling other than the imported one. Filtering by
+                    // name keeps a sibling of the same pattern — the `mocks` of
+                    // `const { mocks: { firestore: { MOCK_FIRESTORE } } }` — out of the
+                    // rewrite, since `getDeclaredVariables` answers for the whole
+                    // declarator rather than for the matched property.
+                    const renamedMockBindings = () => Array.from(mockFirestoreNodes).flatMap((node) => context
+                        .getDeclaredVariables(node)
+                        .filter((variable) => variable.name !== MOCK_FIRESTORE_EXPORT &&
+                        isMockFirestoreName(variable.name)));
                     // Report only once for the entire file
                     context.report({
                         node: Array.from(mockFirestoreNodes)[0],
@@ -405,15 +520,35 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                                 return null;
                             }
                             const orphanRemovals = orphaned.map(([start, end]) => ({ start, end, text: '' }));
+                            const deletedRanges = [...removals, ...orphanRemovals].map(({ start, end }) => [start, end]);
+                            if (!hasCentralizedImport &&
+                                collidesWithSurvivingBinding(sourceCode, deletedRanges)) {
+                                return null;
+                            }
                             // Replace custom mockFirestore references with the standard one
                             const replacements = [];
+                            // Every reference to a retired binding whose spelling is not
+                            // the imported one would be left unbound by the retirement, so
+                            // the fix rewrites all of them — not merely the call sites the
+                            // rename tracking above covers. `const MOCK_FIRESTORE = …` is
+                            // replaced by `import { mockFirestore }`, and a surviving
+                            // `MOCK_FIRESTORE` reference names nothing (#2307).
+                            for (const variable of renamedMockBindings()) {
+                                for (const reference of variable.references) {
+                                    replacements.push({
+                                        start: reference.identifier.range[0],
+                                        end: reference.identifier.range[1],
+                                        text: MOCK_FIRESTORE_EXPORT,
+                                    });
+                                }
+                            }
                             // Add replacements for custom mockFirestore names
                             customMockFirestoreCallExpressions.forEach((node) => {
                                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     replacements.push({
                                         start: node.callee.range[0],
                                         end: node.callee.range[1],
-                                        text: 'mockFirestore',
+                                        text: MOCK_FIRESTORE_EXPORT,
                                     });
                                 }
                             });
@@ -422,7 +557,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                                 replacements.push({
                                     start: expr.range[0],
                                     end: expr.range[1],
-                                    text: 'mockFirestore',
+                                    text: MOCK_FIRESTORE_EXPORT,
                                 });
                             });
                             // A reference inside a deleted range goes away with it, so
@@ -448,7 +583,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                                 // and above a `#!` shebang it leaves the file unparseable.
                                 const anchor = (0, importInsertion_1.importInsertionAnchor)(sourceCode);
                                 const indent = (0, importInsertion_1.importAnchorIndent)(sourceCode, anchor);
-                                fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, importPlacement(sourceCode, anchor, edits), `${indent}import { mockFirestore } from '${MOCK_FIRESTORE_PATH}';\n`));
+                                fixes.push((0, importInsertion_1.insertAtImportAnchor)(sourceCode, fixer, importPlacement(sourceCode, anchor, edits), `${indent}import { ${MOCK_FIRESTORE_EXPORT} } from '${MOCK_FIRESTORE_PATH}';\n`));
                             }
                             return fixes;
                         },

package/lib/rules/enforce-fieldpath-syntax-in-docsetter.js

@@ -349,31 +349,96 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
             const separator = `\n${landingIndent}`;
             return [...commentTexts, printedEntries.join(`,${separator}`)].join(separator);
         }
+        // Keys the rewritten literal writes, counted. A flattening fix replaces the
+        // property whole, so a dropped plan contributes its own key back rather than
+        // its entries.
+        function countEmittedKeys(plans, dropped, keptKeys) {
+            const counts = new Map();
+            const count = (key) => counts.set(key, (counts.get(key) ?? 0) + 1);
+            for (const key of keptKeys) {
+                count(key);
+            }
+            for (const plan of plans) {
+                if (dropped.has(plan)) {
+                    count(plan.key);
+                    continue;
+                }
+                for (const entry of plan.entries) {
+                    count(entry.key);
+                }
+            }
+            return counts;
+        }
+        // Flattening synthesizes a dot-path key that the enclosing literal may
+        // already write: `{ 'roles.contributor': a, roles: { contributor: b } }`
+        // flattens onto its own sibling. Emitting it spells the same key twice,
+        // which is TS1117, and the input carries no answer to which value should
+        // win, so the property is left for a human to resolve while the report
+        // stands (#2303). A spread between the two does not separate them, since it
+        // writes no statically known key of its own.
+        //
+        // The whole property is dropped rather than the colliding entry alone: the
+        // fix rewrites the property as one span, so emitting only its clean leaves
+        // would delete the colliding leaf's value outright — silent data loss in
+        // place of a duplicate key.
+        //
+        // Dropping a plan restores its own key to the literal, which can collide in
+        // turn with a key another plan flattens into, so the decision is taken to a
+        // fixpoint. Dropping only ever grows the set, which is what terminates it.
+        function dropCollidingPlans(plans, keptKeys) {
+            const dropped = new Set();
+            let settled = false;
+            while (!settled) {
+                settled = true;
+                const counts = countEmittedKeys(plans, dropped, keptKeys);
+                for (const plan of plans) {
+                    if (dropped.has(plan)) {
+                        continue;
+                    }
+                    if (plan.entries.some((entry) => (counts.get(entry.key) ?? 0) > 1)) {
+                        dropped.add(plan);
+                        settled = false;
+                    }
+                }
+            }
+            return dropped;
+        }
         // Replace only the properties that actually need flattening, leaving every
         // other property, its comments, and the original indentation untouched
         function buildFieldPathFixes(node, sourceCode, fixer) {
-            const fixes = [];
+            const plans = [];
+            // Keys the literal keeps as written, which the synthesized keys must not
+            // land on
+            const keptKeys = [];
             for (const property of node.properties) {
-                if (property.type !== utils_1.AST_NODE_TYPES.Property ||
-                    property.computed ||
-                    property.method ||
-                    property.kind !== 'init' ||
-                    property.value.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                // A spread or a computed key writes nothing knowable statically, so it
+                // is neither flattened nor comparable against a synthesized key
+                if (property.type !== utils_1.AST_NODE_TYPES.Property || property.computed) {
                     continue;
                 }
                 const keyText = getPropertyKeyText(property);
+                if (keyText === undefined) {
+                    continue;
+                }
                 // Root-level numeric keys model array-style buckets rather than
                 // Firestore document fields, so they are never flattened
-                if (keyText === undefined || isNumericKey(property)) {
-                    continue;
+                const entries = !property.method &&
+                    property.kind === 'init' &&
+                    property.value.type === utils_1.AST_NODE_TYPES.ObjectExpression &&
+                    !isNumericKey(property)
+                    ? collectFieldPathEntries(property.value, keyText, sourceCode)
+                    : null;
+                if (entries) {
+                    plans.push({ property, key: keyText, entries });
                 }
-                const entries = collectFieldPathEntries(property.value, keyText, sourceCode);
-                if (!entries) {
-                    continue;
+                else {
+                    keptKeys.push(keyText);
                 }
-                fixes.push(fixer.replaceTextRange(property.range, renderFlattenedProperty(property, entries, sourceCode)));
             }
-            return fixes;
+            const dropped = dropCollidingPlans(plans, keptKeys);
+            return plans
+                .filter((plan) => !dropped.has(plan))
+                .map((plan) => fixer.replaceTextRange(plan.property.range, renderFlattenedProperty(plan.property, plan.entries, sourceCode)));
         }
         function getPropertyKeyText(property) {
             if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {