@blumintinc/eslint-plugin-blumint 1.20.136 → 1.20.138

package/lib/rules/enforce-microdiff.js

@@ -417,10 +417,12 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                 DIFF_FUNCTION_NAMES.has(specifier.local.name));
         }
         /**
-         * Whether retiring `declaration` leaves every name it binds accounted for.
+         * How many references retiring `declaration` hands to the call fixes, or
+         * null when retiring it would strand one.
+         *
          * The fix removes the whole declaration, so each reference it serves has to
          * be one the call fixes rewrite to `diff` in the same pass — an import swap
-         * that strands a reference behind is the defect this guards.
+         * that strands a reference behind is the defect the null answer guards.
          *
          * Two things have to hold at every reference. `diff` must reach microdiff
          * there: the import rewrite lands at module scope while the references it
@@ -428,28 +430,71 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
          * would resolve to the shadow. And the reference has to sit where a rewrite
          * exists at all, which is the callee position of a convertible call.
          *
-         * A specifier nothing references is vacuously safe: retiring it removes an
-         * import no code reads.
+         * The count answers the mirror-image question. A specifier nothing
+         * references strands nothing, but it hands the import that replaces it no
+         * call either, so a declaration serving zero rewrites is exactly the case
+         * where writing `import diff from '@blumintinc/microdiff'` over it binds a
+         * name no code reads.
          */
-        function canRetireImport(declaration) {
+        function rewrittenReferenceCount(declaration) {
             const claimable = collectClaimableSpecifiers(sourceCode.ast);
             const declarationScope = ASTHelpers_1.ASTHelpers.getScope(context, declaration);
-            return declaration.specifiers.every((specifier) => {
+            let rewrites = 0;
+            for (const specifier of declaration.specifiers) {
                 const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(declarationScope, specifier.local.name);
                 if (!variable) {
-                    return true;
+                    continue;
                 }
                 const rewritten = isRewrittenSpecifier(specifier);
-                return variable.references.every((reference) => canEmitDiff(reference.from, claimable) &&
-                    rewritten &&
-                    isRewrittenCallee(reference.identifier));
-            });
+                for (const reference of variable.references) {
+                    if (!rewritten ||
+                        !canEmitDiff(reference.from, claimable) ||
+                        !isRewrittenCallee(reference.identifier)) {
+                        return null;
+                    }
+                    rewrites += 1;
+                }
+            }
+            return rewrites;
         }
         /**
-         * Whether the import fix retires `declaration` in this same pass.
+         * Whether the import fix retires `declaration` in this same pass. The
+         * branches mirror the fix's own: a declaration serving no call rewrite is
+         * dropped when the file already imports microdiff, and left alone when
+         * dropping it would mean writing an unread `diff` in its place.
          */
         function willRetireImport(declaration) {
-            return canEmitDiffAt(declaration) && canRetireImport(declaration);
+            if (!canEmitDiffAt(declaration)) {
+                return false;
+            }
+            const rewrites = rewrittenReferenceCount(declaration);
+            if (rewrites === null) {
+                return false;
+            }
+            return rewrites > 0 || !!findMicrodiffImport(sourceCode.ast);
+        }
+        /**
+         * Whether a callee's binding keeps a reference this pass leaves alone.
+         *
+         * Renaming a call to `diff` stops it referencing whatever bound the callee.
+         * When the import binding it is retired in the same pass, the binding goes
+         * with the declaration and nothing is left behind. A declaration that
+         * survives — because a sibling specifier has no rewrite of its own — keeps a
+         * name that nothing reads unless some other reference outlives the pass, and
+         * an import bound to nothing is what the consumer's `no-unused-vars` and
+         * `noUnusedLocals` both fail the build on.
+         *
+         * A reference the call fixes cannot rewrite is what keeps the binding alive:
+         * one in a position that has no rewrite, or one standing where the emitted
+         * `diff` would resolve to something else.
+         */
+        function keepsUnrewrittenReference(variable) {
+            if (!variable) {
+                return false;
+            }
+            const claimable = collectClaimableSpecifiers(sourceCode.ast);
+            return variable.references.some((reference) => !isRewrittenCallee(reference.identifier) ||
+                !canEmitDiff(reference.from, claimable));
         }
         /**
          * Whether the call at `node`, whose callee `declaration` binds, may be
@@ -461,15 +506,22 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
          * file already has, or the one that replaces `declaration` in this same
          * pass. Renaming a callee whose import survives strands the rewritten call
          * exactly as retiring an import whose callee survives strands that one.
+         *
+         * It also needs the binding it stops referencing to be accounted for. An
+         * existing microdiff import binds the emitted `diff` whatever happens to
+         * `declaration`, which is what lets a rename land beside an import too
+         * entangled to retire — and that is precisely when the renamed call can have
+         * been the last thing reading the name the surviving import binds.
          */
-        function canRewriteCall(node, declaration) {
+        function canRewriteCall(node, declaration, calleeVariable) {
             if (!canEmitDiffAt(node) || !hasRewritableArity(node)) {
                 return false;
             }
-            if (findMicrodiffImport(sourceCode.ast)) {
-                return true;
+            const retires = !!declaration && willRetireImport(declaration);
+            if (!retires && !keepsUnrewrittenReference(calleeVariable)) {
+                return false;
             }
-            return !!declaration && willRetireImport(declaration);
+            return retires || !!findMicrodiffImport(sourceCode.ast);
         }
         /**
          * The fix element that puts microdiff's import at the top of the file, or
@@ -628,13 +680,28 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                             // already binds to something else, and rather than retire an
                             // import whose references no call fix rewrites. The report stands
                             // either way, so the author resolves it deliberately.
-                            if (!canEmitDiffAt(node) || !canRetireImport(node)) {
+                            if (!canEmitDiffAt(node)) {
+                                return null;
+                            }
+                            const rewrites = rewrittenReferenceCount(node);
+                            if (rewrites === null) {
                                 return null;
                             }
                             // If we already have a microdiff import, just remove this import
                             if (findMicrodiffImport(sourceCode.ast)) {
                                 return fixer.remove(node);
                             }
+                            // A declaration whose names no call fix rewrites has nothing to
+                            // hand the import that would replace it, so writing microdiff's
+                            // import over it trades one unread name for another: the file
+                            // comes out of the fix with `diff` bound to nothing, which the
+                            // consumer's `no-unused-vars` and `noUnusedLocals` both fail on.
+                            // A local shadowing the import is exactly that shape — the calls
+                            // belong to the shadow, so the import's own reference list is
+                            // empty — and so is an import nothing uses at all.
+                            if (rewrites === 0) {
+                                return null;
+                            }
                             // Otherwise, replace with microdiff import
                             return fixer.replaceText(node, MICRODIFF_IMPORT);
                         },
@@ -691,7 +758,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
-                                    if (!canRewriteCall(node, competingImport)) {
+                                    if (!canRewriteCall(node, competingImport, calleeVariable)) {
                                         return null;
                                     }
                                     return fixer.replaceText(callee, DIFF_NAME);
@@ -718,7 +785,7 @@ exports.enforceMicrodiff = (0, createRule_1.createRule)({
                                 node,
                                 messageId: 'enforceMicrodiff',
                                 fix(fixer) {
-                                    if (!canRewriteCall(node, competingImport)) {
+                                    if (!canRewriteCall(node, competingImport, calleeVariable)) {
                                         return null;
                                     }
                                     // When handling fast-diff and similar libraries, need to ensure the function name is replaced

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

@@ -6,6 +6,7 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const microdiffModules_1 = require("../utils/microdiffModules");
+const importRemoval_1 = require("../utils/importRemoval");
 const fastDeepEqualModules_1 = require("../utils/fastDeepEqualModules");
 const DIFF_EXPORT_NAME = 'diff';
 /**
@@ -86,6 +87,14 @@ function unwrapChain(node) {
 function rangesOverlap(a, b) {
     return a[0] < b[1] && b[0] < a[1];
 }
+/**
+ * Whether the diff call sits inside the comparison being rewritten.
+ * `diff(a, b).length === 0` rewrites the call where it stands, while
+ * `changes.length === 0` compares a call declared elsewhere that the fix moves.
+ */
+function isCallInPlace(node, diffCall) {
+    return (diffCall.range[0] >= node.range[0] && diffCall.range[1] <= node.range[1]);
+}
 exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
     name: 'fast-deep-equal-over-microdiff',
     meta: {
@@ -110,12 +119,22 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         let microdiffImportName = 'diff';
         let fastDeepEqualImportName = 'isEqual';
         const reportedNodes = new Set();
-        let plannedFastDeepEqualImport = false;
         /**
-         * The `import ... from '@blumintinc/fast-deep-equal'` statement rides on a
-         * single violation's fix, so that violation is the file's import carrier. A
-         * suppressed carrier would take the import down with it while the surviving
-         * violations still emit `isEqual(...)` calls, leaving them unbound.
+         * Every comparison the rule reports, in traversal order.
+         *
+         * Reporting is deferred to `Program:exit` because the microdiff import is
+         * unbound only once no rewrite leaves a reference to it standing. Judged one
+         * comparison at a time, a file with two of them never sees either as the
+         * binding's last use, and the pass that rewrites both resolves every report
+         * — so nothing ever revisits the stranded import.
+         */
+        const violations = [];
+        /**
+         * A suppressed report is dropped together with its fix, so its rewrite never
+         * happens: counting it toward the batch would unbind an import the surviving
+         * text still calls, and would hand the `import ... from
+         * '@blumintinc/fast-deep-equal'` statement — which rides on one violation's
+         * fix — to a violation ESLint is about to discard.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         function isMicrodiffCallee(callee) {
@@ -434,66 +453,121 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
         /**
          * 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) {
+        function createComparisonEdits(node, diffCall, isEquality) {
+            if (!isCallInPlace(node, diffCall)) {
                 // `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}`)];
+                return [{ range: node.range, text: isEquality ? call : `!${call}` }];
             }
-            const fixes = [];
+            // Comparing a call in place — `diff(a, b).length === 0` — is rewritten by
+            // splicing the 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 edits = [];
             const headRange = [node.range[0], diffCall.range[0]];
             if (!isEquality) {
-                fixes.push(fixer.replaceTextRange(headRange, '!'));
+                edits.push({ range: headRange, text: '!' });
             }
             else if (headRange[0] !== headRange[1]) {
-                fixes.push(fixer.removeRange(headRange));
+                edits.push({ range: headRange, text: '' });
+            }
+            edits.push({
+                range: diffCall.callee.range,
+                text: fastDeepEqualImportName,
+            });
+            edits.push({ range: [diffCall.range[1], node.range[1]], text: '' });
+            return edits;
+        }
+        /**
+         * The positions a rewrite genuinely erases, which is all the orphan
+         * analysis may be told about.
+         *
+         * Only deleted text counts, and the argument list is never deleted: it is
+         * spliced around where it stands, or moved verbatim to the comparison's
+         * position. Handing over the enclosing span instead would read every binding
+         * the arguments mention as unreferenced and delete its import — an
+         * over-removal strictly worse than the stranded import this exists to
+         * prevent. So each shape gives up the span around the call, plus the callee
+         * the rewrite renames.
+         *
+         * The one case that lists the comparison itself is a hoisted
+         * `const changes = diff(...)` this rule will not delete, since then the
+         * rewrite really does strip `changes` of its last read. Where the
+         * declaration goes too, `changes` goes with it, and listing the comparison
+         * would only make the planner refuse a rewrite that orphans nothing.
+         */
+        function removedReferenceRanges(node, diffCall, declarationRemoval) {
+            if (isCallInPlace(node, diffCall)) {
+                return [
+                    [node.range[0], diffCall.range[0]],
+                    diffCall.callee.range,
+                    [diffCall.range[1], node.range[1]],
+                ];
+            }
+            if (!declarationRemoval) {
+                return [node.range];
             }
-            fixes.push(fixer.replaceText(diffCall.callee, fastDeepEqualImportName));
-            fixes.push(fixer.removeRange([diffCall.range[1], node.range[1]]));
-            return fixes;
+            return [
+                [declarationRemoval[0], diffCall.range[0]],
+                diffCall.callee.range,
+                [diffCall.range[1], declarationRemoval[1]],
+            ];
         }
         /**
-         * The `import ... from '@blumintinc/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.
+         * The `import ... from '@blumintinc/fast-deep-equal'` edit, emitted once as
+         * part of the file's single fix.
+         *
+         * The anchor is the microdiff declaration, which the same fix may be
+         * deleting. Inserting *after* a declaration that is going away puts the
+         * insertion point inside the deleted span, and ESLint rejects that pair as
+         * overlapping and discards every message for the file — so a displaced
+         * anchor is taken over rather than followed: the new import lands on the
+         * exact position the old one occupied.
          *
          * The specifier is the scoped fork: it is the dependency this codebase
          * declares, so any other name would be written as an import that resolves
          * nowhere.
          */
-        function planFastDeepEqualImport(fixer) {
-            if (hasFastDeepEqualImport || plannedFastDeepEqualImport) {
+        function planFastDeepEqualImport(fixer, removalRanges) {
+            if (hasFastDeepEqualImport) {
                 return [];
             }
-            plannedFastDeepEqualImport = true;
             const importStatement = (0, fastDeepEqualModules_1.fastDeepEqualImport)(fastDeepEqualImportName);
             const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
-            const microdiffImport = importDeclarations.find((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
-            const anchor = microdiffImport ?? importDeclarations[importDeclarations.length - 1];
+            const removalStartOf = (declaration) => removalRanges.find((range) => range[0] <= declaration.range[0] &&
+                range[1] >= declaration.range[1])?.[0];
+            const microdiffImports = importDeclarations.filter((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
+            for (const declaration of microdiffImports) {
+                const start = removalStartOf(declaration);
+                if (start !== undefined) {
+                    return [
+                        fixer.insertTextBeforeRange([start, start], `${importStatement}\n`),
+                    ];
+                }
+            }
+            const surviving = importDeclarations.filter((declaration) => removalStartOf(declaration) === undefined);
+            const anchor = microdiffImports[0] ?? surviving[surviving.length - 1];
             if (anchor) {
                 return [fixer.insertTextAfter(anchor, `\n${importStatement}`)];
             }
             return [fixer.insertTextBeforeRange([0, 0], `${importStatement}\n`)];
         }
         /**
-         * Create a fix for replacing microdiff equality check with fast-deep-equal
+         * The edits one violation contributes, or `null` when its rewrite is not
+         * provably safe.
+         *
+         * `removedDeclarations` carries the hoisted declarations earlier violations
+         * already claimed, so two comparisons measuring the same
+         * `const changes = diff(...)` delete it once and both get rewritten —
+         * deleting it twice is an overlap, and deleting it while leaving the second
+         * comparison reading `changes` unbinds that read.
          */
-        function createFix(fixer, node, diffCall, isEquality) {
-            // A suppressed report is dropped together with its fix. Producing no fix
-            // — and leaving the import unscheduled — passes the carrier slot to the
-            // first violation that survives.
+        function planViolation(violation, removedDeclarations) {
+            const { node, diffCall, isEquality, scope } = violation;
             if (isReportSuppressed(node)) {
                 return null;
             }
@@ -501,57 +575,93 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
             // makes both halves of the edit wrong: an inserted import collides with a
             // same-scope declaration (TS2440/TS2300), and a narrower-scope shadow
             // rebinds the emitted call to the local value with no diagnostic at all.
-            // Resolving from the fixed node's scope chain catches both. Declining
-            // before the import is scheduled leaves the carrier slot to a violation
-            // whose scope is safe, and drops the whole edit — including the removal
-            // of a redundant `const changes = diff(...)` — rather than half of it.
-            const existingBinding = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), fastDeepEqualImportName);
+            // Resolving from the fixed node's scope chain catches both. Dropping this
+            // violation from the batch leaves the carrier slot to one whose scope is
+            // safe, and drops its whole edit — including the removal of a redundant
+            // `const changes = diff(...)` — rather than half of it.
+            const existingBinding = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, fastDeepEqualImportName);
             if (existingBinding && !bindsFastDeepEqual(existingBinding)) {
                 return null;
             }
             if (diffCall.arguments.length !== 2) {
                 return null; // Can't fix if not exactly 2 arguments
             }
-            const comparisonFixes = createComparisonFixes(fixer, node, diffCall, isEquality);
+            const comparisonEdits = createComparisonEdits(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;
+            if (!declaration) {
+                return {
+                    violation,
+                    edits: comparisonEdits,
+                    removed: removedReferenceRanges(node, diffCall),
+                };
+            }
+            const claimed = removedDeclarations.get(declaration);
+            const removalRange = claimed ?? 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 (comparisonEdits.some(({ range }) => rangesOverlap(range, removalRange))) {
+                return null;
+            }
+            return {
+                violation,
+                declaration,
+                declarationRemoval: removalRange,
+                edits: claimed
+                    ? comparisonEdits
+                    : [...comparisonEdits, { range: removalRange, text: '' }],
+                removed: removedReferenceRanges(node, diffCall, removalRange),
+            };
+        }
+        /**
+         * The rewrites that actually ship, in traversal order.
+         *
+         * Each is screened alone before it joins the batch: a rewrite whose own
+         * deletion orphans something that cannot be unbound safely — a local
+         * variable, an import behind a directive comment — would otherwise poison
+         * every other rewrite in the file. Edits that collide with an already
+         * accepted one are dropped for the same reason a single report's
+         * overlapping fixes are: ESLint asserts on the overlap and discards every
+         * message for the file.
+         */
+        function planViolations() {
+            const planned = [];
+            const claimedRanges = [];
+            const removedDeclarations = new Map();
+            for (const violation of violations) {
+                const candidate = planViolation(violation, removedDeclarations);
+                if (!candidate)
+                    continue;
+                if ((0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, candidate.removed) === null) {
+                    continue;
                 }
-                declarationFixes.push(fixer.removeRange(removalRange));
+                if (candidate.edits.some(({ range }) => claimedRanges.some((taken) => rangesOverlap(range, taken)))) {
+                    continue;
+                }
+                claimedRanges.push(...candidate.edits.map(({ range }) => range));
+                if (candidate.declaration && candidate.declarationRemoval) {
+                    removedDeclarations.set(candidate.declaration, candidate.declarationRemoval);
+                }
+                planned.push(candidate);
             }
-            return [
-                ...planFastDeepEqualImport(fixer),
-                ...declarationFixes,
-                ...comparisonFixes,
-            ];
+            return planned;
         }
-        function reportEqualityCheck(node, result) {
+        function collectEqualityCheck(node, result) {
             const { diffCall, isEquality } = result;
             if (!diffCall)
                 return;
             if (reportedNodes.has(node))
                 return;
             reportedNodes.add(node);
-            context.report({
+            violations.push({
                 node,
-                messageId: 'useFastDeepEqual',
-                data: {
-                    diffName: microdiffImportName,
-                    fastEqualName: fastDeepEqualImportName,
-                },
-                fix(fixer) {
-                    return createFix(fixer, node, diffCall, isEquality);
-                },
+                diffCall,
+                isEquality,
+                scope: ASTHelpers_1.ASTHelpers.getScope(context, node),
             });
         }
         return {
@@ -599,7 +709,7 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node)) {
                     return;
                 }
-                reportEqualityCheck(node, isMicrodiffEqualityCheck(node));
+                collectEqualityCheck(node, isMicrodiffEqualityCheck(node));
             },
             // Check if statements for microdiff equality patterns
             IfStatement(node) {
@@ -609,7 +719,7 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                 if (reportedNodes.has(node.test)) {
                     return;
                 }
-                reportEqualityCheck(node.test, isMicrodiffEqualityCheck(node.test));
+                collectEqualityCheck(node.test, isMicrodiffEqualityCheck(node.test));
             },
             // Check return statements for microdiff equality patterns
             ReturnStatement(node) {
@@ -620,7 +730,46 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                 if (!argument || reportedNodes.has(argument)) {
                     return;
                 }
-                reportEqualityCheck(argument, isMicrodiffEqualityCheck(argument));
+                collectEqualityCheck(argument, isMicrodiffEqualityCheck(argument));
+            },
+            'Program:exit'() {
+                if (violations.length === 0)
+                    return;
+                const planned = planViolations();
+                // One plan over every surviving rewrite: the microdiff binding is left
+                // unreferenced by their union even when no single rewrite would strip
+                // its last use, and the pass that applies them all resolves every
+                // report — so this is the only moment the stranded import is visible.
+                const importRemoval = planned.length > 0
+                    ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, planned.flatMap((entry) => entry.removed))
+                    : null;
+                const removalRanges = importRemoval ?? [];
+                // The whole batch ships as one fix, so no rewrite can land without the
+                // others the import's orphanhood was judged against, and no unbinding
+                // can land without the rewrite it was claimed on. The other violations
+                // report without a fixer; the carrier's pass already resolves them.
+                //
+                // No plan at all means some binding would be left unreferenced yet
+                // cannot be unbound safely, so every rewrite stays: reports without a
+                // fixer are the lesser damage.
+                const carrier = importRemoval ? planned[0] : undefined;
+                for (const violation of violations) {
+                    context.report({
+                        node: violation.node,
+                        messageId: 'useFastDeepEqual',
+                        data: {
+                            diffName: microdiffImportName,
+                            fastEqualName: fastDeepEqualImportName,
+                        },
+                        fix: violation === carrier?.violation
+                            ? (fixer) => [
+                                ...planFastDeepEqualImport(fixer, removalRanges),
+                                ...removalRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...planned.flatMap((entry) => entry.edits.map(({ range, text }) => fixer.replaceTextRange(range, text))),
+                            ]
+                            : undefined,
+                    });
+                }
             },
         };
     },