@blumintinc/eslint-plugin-blumint 1.20.32 → 1.20.34

package/lib/rules/enforce-microdiff.js

@@ -6,6 +6,28 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const DIFF_NAME = 'diff';
 const MICRODIFF_MODULE = 'microdiff';
+/**
+ * The names a competing library's diff export is conventionally bound to. They
+ * are candidates for a report, never proof of one: what a call resolves to
+ * decides.
+ */
+const DIFF_FUNCTION_NAMES = new Set([
+    'deepDiff',
+    'fastDiff',
+    'diffArrays',
+    'detailedDiff',
+    // 'fastDeepEqual' and 'isEqual' stay out: they are allowed alternatives.
+]);
+/**
+ * The exports of a competing library whose call sites this rule rewrites,
+ * whatever local name the import binds them to.
+ */
+const COMPETING_DIFF_EXPORTS = new Set(['diff', 'diffArrays', 'detailedDiff']);
+/** Diff libraries this rule permits, whose calls are tracked but never reported. */
+const ALLOWED_DIFF_MODULES = new Set([
+    'fast-deep-equal',
+    'fast-deep-equal/es6',
+]);
 /**
  * The libraries this rule replaces. Every fix retires the whole import
  * declaration of one of these, which is what makes the names it binds available
@@ -75,6 +97,75 @@ function collectClaimableSpecifiers(program) {
     });
     return claimable;
 }
+/**
+ * The competing library's import declaration a name resolves to, or null for
+ * every other binding.
+ *
+ * A callee matched by name alone proves nothing on its own: `detailedDiff` is
+ * as likely to be the file's own function, a local variable, or a parameter as
+ * it is to be `deep-object-diff`'s export. Reporting those renames a call to
+ * `diff` that nothing binds while the local definition it was calling survives,
+ * so only a name the import handler is about to retire earns a report. The
+ * declaration is the one whose rewrite makes the emitted `diff` resolvable,
+ * which is what pairs the call fix with the import fix in the same pass.
+ *
+ * Resolution keys on the *local* name a specifier binds, so an alias that
+ * renames a competing export onto one of these names is covered, while an alias
+ * that renames it away (`detailedDiff as dd`) is left to `toImportedDiffSource`,
+ * which resolves to the specifier itself under whatever name it is bound.
+ */
+function toCompetingDiffImport(variable) {
+    if (!variable) {
+        return null;
+    }
+    for (const def of variable.defs) {
+        if (def.type !== 'ImportBinding') {
+            continue;
+        }
+        const declaration = def.parent;
+        if (!declaration ||
+            declaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            declaration.importKind === 'type') {
+            continue;
+        }
+        const specifier = def.node;
+        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+            specifier.importKind === 'type') {
+            continue;
+        }
+        if (!COMPETING_DIFF_MODULES.has(String(declaration.source.value))) {
+            continue;
+        }
+        return declaration;
+    }
+    return null;
+}
+/**
+ * The module a name is imported from, when the name resolves to one of the
+ * specifiers the import handler tracked, and null for every other binding.
+ *
+ * Tracking keys on the specifier node rather than on the local name because
+ * names collide and bindings do not: a parameter, a nested `const`, or a
+ * function declaration that shadows the imported name answers its own calls.
+ * Rewriting one of those to `diff` swaps in microdiff's structural change list
+ * for whatever the shadow computed — a substitution that compiles cleanly and
+ * leaves the shadow unused, so nothing downstream flags it.
+ */
+function toImportedDiffSource(variable, importedSpecifiers) {
+    if (!variable) {
+        return null;
+    }
+    for (const def of variable.defs) {
+        if (def.type !== 'ImportBinding') {
+            continue;
+        }
+        const source = importedSpecifiers.get(def.node);
+        if (source !== undefined) {
+            return source;
+        }
+    }
+    return null;
+}
 /**
  * Whether a bare `diff` written at `scope` reaches microdiff's function.
  * Resolving through the scope chain catches both failure modes: a module-scope
@@ -110,8 +201,17 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
     create(context) {
         const sourceCode = context.sourceCode;
         const importedDiffLibraries = new Map();
-        const importedFunctions = new Map(); // Map of imported function names to their sources
+        // The diff specifiers this file imports, keyed by node so a call site can
+        // ask whether the binding it resolves to is one of them.
+        const importedDiffSpecifiers = new Map();
+        // The local names those specifiers bind: a cheap gate that keeps calls with
+        // no relation to a diff library off the scope chain.
+        const importedDiffNames = new Set();
         const reportedNodes = new Set();
+        function trackImportedDiff(specifier, importSource) {
+            importedDiffSpecifiers.set(specifier, importSource);
+            importedDiffNames.add(specifier.local.name);
+        }
         /**
          * Whether the fix may emit a bare `diff` at `node`. The AST is read at fix
          * time so the answer stays correct under multi-pass `--fix`, where an
@@ -180,12 +280,10 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                     // Track imported function names and their sources
                     node.specifiers.forEach((specifier) => {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            (specifier.imported.name === 'diff' ||
-                                specifier.imported.name === 'diffArrays' ||
-                                specifier.imported.name === 'detailedDiff')) {
-                            // Track the local name (which could be different due to renaming)
-                            const localName = specifier.local.name;
-                            importedFunctions.set(localName, importSource);
+                            COMPETING_DIFF_EXPORTS.has(specifier.imported.name)) {
+                            // Track the specifier itself, so renaming the export and
+                            // shadowing the local name both stay accounted for
+                            trackImportedDiff(specifier, importSource);
                         }
                         // Removed the fast-deep-equal handling since it's now allowed
                     });
@@ -212,25 +310,18 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                         },
                     });
                     // Check if importing a diff function or a known equality library
-                    const hasDiffImport = node.specifiers.some((specifier) => {
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-                            return (specifier.imported.name === 'diff' ||
-                                specifier.imported.name === 'diffArrays' ||
-                                specifier.imported.name === 'detailedDiff');
-                        }
-                        return false;
-                    });
+                    const hasDiffImport = node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        COMPETING_DIFF_EXPORTS.has(specifier.imported.name));
                     if (hasDiffImport) {
                         importedDiffLibraries.set(importSource, node);
                     }
                 }
                 // Special handling for fast-deep-equal: track it but don't report it
-                if (importSource === 'fast-deep-equal' ||
-                    importSource === 'fast-deep-equal/es6') {
+                if (ALLOWED_DIFF_MODULES.has(importSource)) {
                     // Track imported function names for later reference
                     node.specifiers.forEach((specifier) => {
                         if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                            importedFunctions.set(specifier.local.name, importSource);
+                            trackImportedDiff(specifier, importSource);
                         }
                     });
                     // Add to importedDiffLibraries for tracking but don't report
@@ -247,45 +338,21 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 // Check for direct calls to imported diff functions
                 if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
                     const name = callee.name;
-                    // Check if this is a function we specifically imported from a diff library
-                    if (importedFunctions.has(name)) {
-                        usedImportNames.add(name);
-                        // Get the source of the imported function
-                        const importSource = importedFunctions.get(name);
-                        // Skip reporting if it's from fast-deep-equal
-                        if (importSource === 'fast-deep-equal' ||
-                            importSource === 'fast-deep-equal/es6') {
-                            return;
-                        }
-                        // Report it if it's from any other tracked library
-                        reportedNodes.add(node);
-                        context.report({
-                            node,
-                            messageId: 'enforceMicrodiff',
-                            fix(fixer) {
-                                if (!canEmitDiffAt(node)) {
-                                    return null;
-                                }
-                                return fixer.replaceText(callee, DIFF_NAME);
-                            },
-                        });
-                        return;
-                    }
-                    // Check known diff function names
-                    const isDiffFunction = [
-                        'deepDiff',
-                        'fastDiff',
-                        'diffArrays',
-                        'detailedDiff',
-                        // Removed 'fastDeepEqual' and 'isEqual' as they are allowed alternatives
-                    ].includes(name);
-                    if (isDiffFunction) {
-                        // Track this import name as used
-                        usedImportNames.add(name);
-                        // Check if we have at least 2 arguments that are objects or arrays
-                        if (node.arguments.length >= 2 &&
-                            isObjectOrArrayType(node.arguments[0]) &&
-                            isObjectOrArrayType(node.arguments[1])) {
+                    const isDiffFunctionName = DIFF_FUNCTION_NAMES.has(name);
+                    if (importedDiffNames.has(name) || isDiffFunctionName) {
+                        // Both paths below ask what the callee binds, so the scope chain is
+                        // walked once for the name they share.
+                        const calleeVariable = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), name);
+                        // Check if this call resolves to a function we specifically
+                        // imported from a diff library
+                        const importSource = toImportedDiffSource(calleeVariable, importedDiffSpecifiers);
+                        if (importSource) {
+                            usedImportNames.add(name);
+                            // Skip reporting if it's from fast-deep-equal
+                            if (ALLOWED_DIFF_MODULES.has(importSource)) {
+                                return;
+                            }
+                            // Report it if it's from any other tracked library
                             reportedNodes.add(node);
                             context.report({
                                 node,
@@ -294,10 +361,38 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                     if (!canEmitDiffAt(node)) {
                                         return null;
                                     }
-                                    // When handling fast-diff and similar libraries, need to ensure the function name is replaced
                                     return fixer.replaceText(callee, DIFF_NAME);
                                 },
                             });
+                            return;
+                        }
+                        if (isDiffFunctionName) {
+                            // The name is only a candidate until the scope chain says what it
+                            // binds: a local function, variable, parameter, or an import from
+                            // anywhere but a competing diff library keeps its call untouched.
+                            const competingImport = toCompetingDiffImport(calleeVariable);
+                            if (!competingImport) {
+                                return;
+                            }
+                            // Track this import name as used
+                            usedImportNames.add(name);
+                            // Check if we have at least 2 arguments that are objects or arrays
+                            if (node.arguments.length >= 2 &&
+                                isObjectOrArrayType(node.arguments[0]) &&
+                                isObjectOrArrayType(node.arguments[1])) {
+                                reportedNodes.add(node);
+                                context.report({
+                                    node,
+                                    messageId: 'enforceMicrodiff',
+                                    fix(fixer) {
+                                        if (!canEmitDiffAt(node)) {
+                                            return null;
+                                        }
+                                        // When handling fast-diff and similar libraries, need to ensure the function name is replaced
+                                        return fixer.replaceText(callee, DIFF_NAME);
+                                    },
+                                });
+                            }
                         }
                     }
                 }
@@ -308,19 +403,19 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                     const property = callee.property;
                     if (property.type === utils_1.AST_NODE_TYPES.Identifier &&
                         ['difference', 'differenceBy', 'differenceWith'].includes(property.name)) {
+                        // Report only. lodash's difference family returns the elements of
+                        // its first array that have no match in the second — a subset of
+                        // the input — while microdiff's `diff` returns a structural change
+                        // list of `{type, path, value}` records. No mechanical rewrite
+                        // preserves the meaning of the call, and the extra iteratee or
+                        // comparator argument has no counterpart in `diff(a, b)`, whose
+                        // third parameter is an options object. Replacing the call would
+                        // silently change what the surrounding code receives, so the author
+                        // converts it.
                         reportedNodes.add(node);
                         context.report({
                             node,
                             messageId: 'enforceMicrodiff',
-                            fix(fixer) {
-                                if (!canEmitDiffAt(node)) {
-                                    return null;
-                                }
-                                // Replace with microdiff
-                                return fixer.replaceText(node, `${DIFF_NAME}(${node.arguments
-                                    .map((arg) => sourceCode.getText(arg))
-                                    .join(', ')})`);
-                            },
                         });
                     }
                 }

package/lib/rules/fast-deep-equal-over-microdiff.js

@@ -29,6 +29,15 @@ function bindsFastDeepEqual(variable) {
                 FAST_DEEP_EQUAL_MODULES.has(declaration.source.value));
         }));
 }
+/**
+ * Whether two edits touch the same characters. ESLint sorts the fixes of one
+ * report and asserts each starts at or after the end of the previous one, so
+ * abutting ranges are fine while overlapping ranges throw and discard every
+ * message for the file.
+ */
+function rangesOverlap(a, b) {
+    return a[0] < b[1] && b[0] < a[1];
+}
 exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
     name: 'fast-deep-equal-over-microdiff',
     meta: {
@@ -301,25 +310,133 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             return undefined;
         }
         /**
-         * Get the indentation at the start of the current line for a node
+         * The call's own text with nothing but the callee name swapped for the
+         * fast-deep-equal name. Slicing the original text keeps the argument list —
+         * including its formatting and any comments inside it — byte-identical,
+         * which matters when the call has to be re-emitted at another position.
+         */
+        function renameCallee(diffCall) {
+            const callText = sourceCode.getText(diffCall);
+            const start = diffCall.range[0];
+            return (callText.slice(0, diffCall.callee.range[0] - start) +
+                fastDeepEqualImportName +
+                callText.slice(diffCall.callee.range[1] - start));
+        }
+        /**
+         * The `const changes = diff(...)` statement behind a `changes.length`
+         * comparison, when nothing but the comparison reads it — so inlining the
+         * call makes the statement dead. A statement declaring more than one
+         * variable stays: dropping it would take the other declarators with it.
+         */
+        function findRedundantDeclaration(node) {
+            const lengthIdentifier = getLengthIdentifierFromNode(node);
+            if (!lengthIdentifier || !isVariableOnlyUsedForLength(lengthIdentifier)) {
+                return undefined;
+            }
+            const variable = findVariableInScopeChain(lengthIdentifier);
+            const defNode = variable?.defs?.[0]?.node;
+            if (!defNode || defNode.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                return undefined;
+            }
+            const declaration = defNode.parent;
+            if (declaration?.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
+                declaration.declarations.length !== 1) {
+                return undefined;
+            }
+            return declaration;
+        }
+        /**
+         * The span to delete for a redundant declaration. A declaration that owns
+         * its whole line takes the line with it, leaving no blank line behind.
+         * Otherwise only its own node range goes: a line-wide span would swallow
+         * whatever shares the line — the comparison this same report rewrites (an
+         * overlap ESLint refuses), the `;` separating a `for` header's clauses, or a
+         * trailing directive that governs the surviving next line.
          */
-        function getLineBaseIndent(node) {
+        function redundantDeclarationRange(declaration) {
             const text = sourceCode.text;
-            const start = node.range?.[0] ?? sourceCode.getIndexFromLoc(node.loc.start);
-            const lineStart = text.lastIndexOf('\n', start - 1) + 1;
-            let i = lineStart;
-            let indent = '';
-            while (i < text.length) {
-                const ch = text[i];
-                if (ch === ' ' || ch === '\t') {
-                    indent += ch;
-                    i++;
-                }
-                else {
-                    break;
-                }
+            const [start, end] = declaration.range;
+            const startOfLine = text.lastIndexOf('\n', start - 1) + 1;
+            const nextNewline = text.indexOf('\n', end);
+            const lineEnd = nextNewline === -1 ? text.length : nextNewline;
+            const isBlank = (slice) => /^[ \t]*$/.test(slice);
+            // A comment counts as content, so it keeps its line rather than riding
+            // along with the statement being deleted.
+            if (isBlank(text.slice(startOfLine, start)) &&
+                isBlank(text.slice(end, lineEnd))) {
+                return [startOfLine, nextNewline === -1 ? end : nextNewline + 1];
+            }
+            // The blanks between the declaration and what follows it on the line go
+            // too, so the surviving statement keeps its original spacing.
+            let removalEnd = end;
+            while (removalEnd < lineEnd && isBlank(text[removalEnd])) {
+                removalEnd++;
+            }
+            if (removalEnd < lineEnd) {
+                return [start, removalEnd];
+            }
+            // Nothing but the line break follows, so the blanks in front of the
+            // declaration would be left behind as trailing whitespace.
+            let removalStart = start;
+            while (removalStart > startOfLine && isBlank(text[removalStart - 1])) {
+                removalStart--;
+            }
+            return [removalStart, removalEnd];
+        }
+        /**
+         * The edits that turn the comparison itself into a fast-deep-equal call.
+         */
+        function createComparisonFixes(fixer, node, diffCall, isEquality) {
+            // Comparing a call in place — `diff(a, b).length === 0` — is rewritten by
+            // splicing the two ranges that actually change: the callee name and the
+            // `.length` comparison tail (plus the `!`/`0 ===` head). Re-emitting the
+            // argument list instead destroyed everything between the arguments, and a
+            // dropped `eslint-disable` comment silently re-enables the rule it was
+            // suppressing.
+            const isCallInPlace = diffCall.range[0] >= node.range[0] &&
+                diffCall.range[1] <= node.range[1];
+            if (!isCallInPlace) {
+                // `changes.length === 0` compares a call declared elsewhere, so that
+                // call moves to the comparison's position and its text has to be
+                // re-emitted — verbatim, so its comments move with it.
+                const call = renameCallee(diffCall);
+                return [fixer.replaceText(node, isEquality ? call : `!${call}`)];
+            }
+            const fixes = [];
+            const headRange = [node.range[0], diffCall.range[0]];
+            if (!isEquality) {
+                fixes.push(fixer.replaceTextRange(headRange, '!'));
+            }
+            else if (headRange[0] !== headRange[1]) {
+                fixes.push(fixer.removeRange(headRange));
+            }
+            fixes.push(fixer.replaceText(diffCall.callee, fastDeepEqualImportName));
+            fixes.push(fixer.removeRange([diffCall.range[1], node.range[1]]));
+            return fixes;
+        }
+        /**
+         * The `import ... from 'fast-deep-equal'` edit, scheduled at most once per
+         * file. Claiming the carrier slot is a side effect, so this runs last —
+         * after every reason to decline the fix has been ruled out — otherwise a
+         * declining violation takes the import down with it and leaves the
+         * surviving violations' `isEqual(...)` calls unbound.
+         */
+        function planFastDeepEqualImport(fixer) {
+            if (hasFastDeepEqualImport || plannedFastDeepEqualImport) {
+                return [];
+            }
+            plannedFastDeepEqualImport = true;
+            const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+            const microdiffImport = importDeclarations.find((declaration) => declaration.source.value === 'microdiff');
+            const anchor = microdiffImport ?? importDeclarations[importDeclarations.length - 1];
+            if (anchor) {
+                return [
+                    fixer.insertTextAfter(anchor, `\nimport ${fastDeepEqualImportName} from 'fast-deep-equal';`),
+                ];
             }
-            return indent;
+            return [
+                fixer.insertTextBeforeRange([0, 0], `import ${fastDeepEqualImportName} from 'fast-deep-equal';\n`),
+            ];
         }
         /**
          * Create a fix for replacing microdiff equality check with fast-deep-equal
@@ -343,77 +460,31 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             if (existingBinding && !bindsFastDeepEqual(existingBinding)) {
                 return null;
             }
-            const args = diffCall.arguments;
-            if (args.length !== 2) {
+            if (diffCall.arguments.length !== 2) {
                 return null; // Can't fix if not exactly 2 arguments
             }
-            const arg1 = sourceCode.getText(args[0]);
-            const arg2 = sourceCode.getText(args[1]);
-            const fixes = [];
-            // Add import if needed (only once across all fixes in this file)
-            if (!hasFastDeepEqualImport && !plannedFastDeepEqualImport) {
-                const importDeclarations = sourceCode.ast.body.filter((node) => node.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-                const microdiffImport = importDeclarations.find((node) => node.source.value === 'microdiff');
-                if (microdiffImport) {
-                    fixes.push(fixer.insertTextAfter(microdiffImport, `\nimport ${fastDeepEqualImportName} from 'fast-deep-equal';`));
-                    plannedFastDeepEqualImport = true;
-                }
-                else {
-                    const lastImport = importDeclarations[importDeclarations.length - 1];
-                    if (lastImport) {
-                        fixes.push(fixer.insertTextAfter(lastImport, `\nimport ${fastDeepEqualImportName} from 'fast-deep-equal';`));
-                    }
-                    else {
-                        fixes.push(fixer.insertTextBeforeRange([0, 0], `import ${fastDeepEqualImportName} from 'fast-deep-equal';\n`));
-                    }
-                    plannedFastDeepEqualImport = true;
-                }
-            }
-            // If the equality was via an identifier like `changes.length`, and that identifier
-            // is declared as `const changes = diff(...);` and used ONLY for `.length` checks,
-            // remove the redundant variable declaration.
-            const maybeIdentifier = getLengthIdentifierFromNode(node);
-            if (maybeIdentifier && isVariableOnlyUsedForLength(maybeIdentifier)) {
-                const variable = findVariableInScopeChain(maybeIdentifier);
-                const defNode = variable?.defs?.[0]?.node;
-                if (defNode &&
-                    defNode.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
-                    defNode.parent &&
-                    defNode.parent.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
-                    const declaration = defNode.parent;
-                    // Only remove if it's the only declaration in the const/let statement
-                    if (declaration.declarations.length === 1) {
-                        const text = sourceCode.text;
-                        const startOfLine = text.lastIndexOf('\n', declaration.range[0] - 1) + 1;
-                        const nextNewline = text.indexOf('\n', declaration.range[1]);
-                        const endOfLine = nextNewline === -1 ? declaration.range[1] : nextNewline + 1;
-                        fixes.push(fixer.removeRange([startOfLine, endOfLine]));
-                    }
+            const comparisonFixes = createComparisonFixes(fixer, node, diffCall, isEquality);
+            // If the equality was via an identifier like `changes.length`, and that
+            // identifier is declared as `const changes = diff(...);` and used ONLY for
+            // `.length` checks, remove the redundant variable declaration.
+            const declaration = findRedundantDeclaration(node);
+            const declarationFixes = [];
+            if (declaration) {
+                const removalRange = redundantDeclarationRange(declaration);
+                // A comparison nested inside the declaration it would delete — a diff
+                // argument that reads `changes.length` — admits no pair of disjoint
+                // edits. Reporting without a fix beats an overlap, which aborts the
+                // file, and beats a half-applied edit that deletes the surviving code.
+                if (comparisonFixes.some(({ range }) => rangesOverlap(range, removalRange))) {
+                    return null;
                 }
+                declarationFixes.push(fixer.removeRange(removalRange));
             }
-            // Replace the equality expression with isEqual call
-            const isMultilineCall = diffCall.loc &&
-                args[0].loc &&
-                (diffCall.loc.start.line !== args[0].loc.start.line ||
-                    (args[1] && args[0].loc.start.line !== args[1].loc.start.line));
-            let replacement;
-            if (isMultilineCall) {
-                const baseIndent = getLineBaseIndent(node);
-                const innerIndentPlus = baseIndent + '  ';
-                replacement =
-                    `${fastDeepEqualImportName}(` +
-                        `\n${innerIndentPlus}${arg1},` +
-                        `\n${innerIndentPlus}${arg2},` +
-                        `\n${baseIndent})`;
-            }
-            else {
-                replacement = `${fastDeepEqualImportName}(${arg1}, ${arg2})`;
-            }
-            if (!isEquality) {
-                replacement = `!${replacement}`;
-            }
-            fixes.push(fixer.replaceText(node, replacement));
-            return fixes;
+            return [
+                ...planFastDeepEqualImport(fixer),
+                ...declarationFixes,
+                ...comparisonFixes,
+            ];
         }
         function reportEqualityCheck(node, result) {
             const { diffCall, isEquality } = result;