@blumintinc/eslint-plugin-blumint 1.20.136 → 1.20.138

package/lib/rules/key-only-outermost-element.js

@@ -2,6 +2,109 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.keyOnlyOutermostElement = void 0;
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
+const importRemoval_1 = require("../utils/importRemoval");
+/**
+ * The span a removed `key` gives up: the attribute together with the whitespace
+ * separating it from whatever precedes it.
+ *
+ * Taking the whitespace BEFORE the attribute rather than after is what makes
+ * every position in an attribute list come out right. Consuming the trailing
+ * space instead leaves `<div >` whenever the key ends the list — no other
+ * attribute follows to donate a space — and consuming both would fuse the
+ * survivors on either side into `id="x"className="y"`.
+ *
+ * Only whitespace is swallowed, so a block comment sitting between the previous
+ * token and the key stays where its author put it.
+ */
+function removalRangeOf(source, attribute) {
+    let start = attribute.range[0];
+    while (start > 0 && /\s/.test(source.text[start - 1])) {
+        start--;
+    }
+    return [start, attribute.range[1]];
+}
+/**
+ * Partitions violations into the sets whose removals have to travel together.
+ *
+ * A binding read from two key expressions is unbound only once both are gone, so
+ * neither removal may unbind it alone — and a fix may only count on the other
+ * removal happening if it performs that removal itself. Keys that jointly hold a
+ * binding alive are therefore merged into one batch, and every other key is a
+ * batch of one, judged against the file as it stands.
+ *
+ * EVERY binding is asked about, not the imported ones alone: a local helper named
+ * by two keys would otherwise be owned by no fix at all, each key looking
+ * innocent by itself while `--fix` strips both in the same run (#1902).
+ *
+ * `violations` must already exclude suppressed reports, whose fixes never run.
+ */
+function batchViolations(source, violations) {
+    const parents = violations.map((_violation, index) => index);
+    const find = (index) => {
+        let current = index;
+        while (parents[current] !== current) {
+            parents[current] = parents[parents[current]];
+            current = parents[current];
+        }
+        return current;
+    };
+    const union = (left, right) => {
+        const rootLeft = find(left);
+        const rootRight = find(right);
+        if (rootLeft !== rootRight) {
+            parents[rootRight] = rootLeft;
+        }
+    };
+    const ownerOf = (use) => violations.findIndex(({ removal }) => use[0] >= removal[0] && use[1] <= removal[1]);
+    for (const { uses } of (0, importRemoval_1.bindingUses)(source)) {
+        // A single use cannot be shared, so the one-key judgement already covers it.
+        if (uses.length < 2)
+            continue;
+        const owners = new Set();
+        const escapes = uses.some((use) => {
+            const owner = ownerOf(use);
+            if (owner === -1)
+                return true;
+            owners.add(owner);
+            return false;
+        });
+        // A use outside every removal keeps the binding alive whatever these fixes
+        // do, so its readers owe each other nothing.
+        if (escapes || owners.size < 2)
+            continue;
+        const [first, ...rest] = [...owners];
+        for (const other of rest) {
+            union(first, other);
+        }
+    }
+    const groups = new Map();
+    violations.forEach((violation, index) => {
+        const root = find(index);
+        const group = groups.get(root);
+        if (group) {
+            group.push(violation);
+        }
+        else {
+            groups.set(root, [violation]);
+        }
+    });
+    return [...groups.values()];
+}
+/**
+ * The ranges one fix deletes for `batch`: the keys themselves plus any import
+ * they were the last consumers of. `null` when a binding the removal orphans
+ * cannot be unbound safely — a `map` callback parameter read by nothing else, a
+ * local helper, an import behind a directive comment. The caller then drops the
+ * fix and keeps the report, because emitting the half that strips the last use
+ * while leaving the binding behind turns a clean file into one that fails
+ * `no-unused-vars`.
+ */
+function planBatch(source, batch) {
+    const removals = batch.map((violation) => violation.removal);
+    const cleanups = (0, importRemoval_1.planOrphanedImportRemoval)(source, removals);
+    return cleanups ? [...removals, ...cleanups] : null;
+}
 const getJSXElementName = (name) => {
     if (name.type === 'JSXIdentifier') {
         return name.name;
@@ -34,12 +137,26 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.sourceCode;
         // Track JSXElements that are direct children of a map callback
         const mapCallbackElements = new Set();
         // Track JSXFragments that are direct children of a map callback
         const mapCallbackFragments = new Set();
         // Track JSX attributes that have already been reported to avoid duplicate reports
         const reportedAttributes = new Set();
+        /**
+         * Nested keys held until `Program:exit`. Whether removing one strands a
+         * binding is a whole-file question, and the answer can only be given once
+         * every key that reads that binding is known.
+         */
+        const violations = [];
+        /**
+         * Whether ESLint will discard a report, resolved the way ESLint resolves it.
+         * A batched fix counts on every removal in its batch happening; a suppressed
+         * report never fixes, so its key — and the reference it holds — outlives the
+         * pass and must not be counted on.
+         */
+        const isSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         // Helper function to process map calls
         const processMapCall = (node) => {
             // Get the callback function
@@ -119,27 +236,10 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
                         if (isNestedInMapCallback) {
                             // Mark this attribute as reported to avoid duplicate reports
                             reportedAttributes.add(attr);
-                            const sourceCode = context.sourceCode;
-                            context.report({
-                                node: attr,
-                                messageId: 'keyOnlyOutermostElement',
-                                data: {
-                                    elementName: getJSXElementName(openingElement.name),
-                                },
-                                fix(fixer) {
-                                    // Find the exact range of the attribute in the source code
-                                    const startPos = attr.range[0];
-                                    const endPos = attr.range[1];
-                                    // Get the text before and after the attribute to check for whitespace
-                                    const fullText = sourceCode.getText();
-                                    // Check if there's a space after the attribute
-                                    let rangeEnd = endPos;
-                                    if (rangeEnd < fullText.length &&
-                                        fullText[rangeEnd] === ' ') {
-                                        rangeEnd++;
-                                    }
-                                    return fixer.replaceTextRange([startPos, rangeEnd], '');
-                                },
+                            violations.push({
+                                attribute: attr,
+                                elementName: getJSXElementName(openingElement.name),
+                                removal: removalRangeOf(sourceCode, attr),
                             });
                         }
                     }
@@ -170,6 +270,44 @@ exports.keyOnlyOutermostElement = (0, createRule_1.createRule)({
                     processMapCall(node.right);
                 }
             },
+            /**
+             * Emits every held report, each carrying the cleanup its own removal makes
+             * necessary.
+             *
+             * Orphanhood is judged against a single fix's own deletions, never against
+             * what sibling reports might also delete: ESLint may discard a sibling
+             * (a disable directive, a fix that collided with another rule's), and the
+             * key it was going to remove then keeps the binding alive. Keys that
+             * jointly hold a binding alive are therefore removed by one fix, which
+             * deletes all of them itself rather than assuming its siblings land.
+             */
+            'Program:exit'() {
+                if (violations.length === 0)
+                    return;
+                const fixable = violations.filter((violation) => !isSuppressed(violation.attribute));
+                const plans = new Map();
+                for (const batch of batchViolations(sourceCode, fixable)) {
+                    const plan = planBatch(sourceCode, batch);
+                    if (!plan)
+                        continue;
+                    for (const violation of batch) {
+                        plans.set(violation, plan);
+                    }
+                }
+                for (const violation of violations) {
+                    const plan = plans.get(violation);
+                    context.report({
+                        node: violation.attribute,
+                        messageId: 'keyOnlyOutermostElement',
+                        data: { elementName: violation.elementName },
+                        ...(plan
+                            ? {
+                                fix: (fixer) => plan.map((range) => fixer.removeRange([range[0], range[1]])),
+                            }
+                            : {}),
+                    });
+                }
+            },
         };
     },
 });

package/lib/rules/logical-top-to-bottom-grouping.js

@@ -828,12 +828,31 @@ function truncateWithEllipsis(text, max = 60) {
  * handlers with contradictory targets, so the first handler to claim it wins and
  * the handler call order in `detectViolations` is the tie-break.
  */
-function record(sink, statement, messageId, data, fromIndex, toIndex) {
+function record(sink, statement, messageId, data, fromIndex, toIndex, relocatable = true) {
     if (sink.flagged.has(statement)) {
         return;
     }
     sink.flagged.add(statement);
-    sink.violations.push({ statement, messageId, data, fromIndex, toIndex });
+    sink.violations.push({
+        statement,
+        messageId,
+        data,
+        fromIndex,
+        toIndex,
+        relocatable,
+    });
+}
+/**
+ * The violations the reordering search is allowed to expand into moves, and the
+ * only ones its zero-violation goal test answers about.
+ *
+ * Screening here rather than at detection is what keeps the fix path identical to
+ * one that never saw an unrelocatable violation: the search's candidate moves, its
+ * budget and the order it certifies clean are all computed as if the report were
+ * absent, so adding a report can never redirect, weaken or block a fix.
+ */
+function relocatableViolations(violations) {
+    return violations.filter((violation) => violation.relocatable);
 }
 function isGuardIfStatement(statement) {
     if (statement.type !== utils_1.AST_NODE_TYPES.IfStatement || statement.alternate) {
@@ -1058,23 +1077,58 @@ function unwrappedInitOf(declarator) {
  *
  * The classification runs on the unwrapped initializer: an assertion is erased
  * before the code runs, so `1 as const` is exactly the movable literal `1` is.
+ *
+ * Every declarator must qualify, because the statement is diagnosed — and moved —
+ * as a whole. A sibling binding does not disqualify the statement: how many
+ * bindings a declaration introduces decides whether the fix may relocate it, not
+ * whether the declaration is far from the first use of what it declares (#1889).
  */
-function lateDeclarationCandidateOf(statement) {
+function lateDeclarationDeclaratorsOf(statement) {
     const declaration = variableDeclarationOf(statement);
-    if (!declaration || declaration.declarations.length !== 1) {
+    if (!declaration || declaration.declarations.length === 0) {
         return null;
     }
-    const [declarator] = declaration.declarations;
-    if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return null;
+    const declarators = [];
+    for (const declarator of declaration.declarations) {
+        if (declarator.id.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            return null;
+        }
+        const init = unwrappedInitOf(declarator);
+        if (init &&
+            init.type !== utils_1.AST_NODE_TYPES.Identifier &&
+            init.type !== utils_1.AST_NODE_TYPES.Literal) {
+            return null;
+        }
+        declarators.push(declarator);
     }
-    const init = unwrappedInitOf(declarator);
-    if (init &&
-        init.type !== utils_1.AST_NODE_TYPES.Identifier &&
-        init.type !== utils_1.AST_NODE_TYPES.Literal) {
-        return null;
+    return declarators;
+}
+/**
+ * Whether the reordering fix may relocate this statement to satisfy a
+ * late-declaration report.
+ *
+ * The fix moves whole statements, so relocating `const x = 1, y = 2;` carries `y`
+ * along — past its own first use in the general case, and always further than the
+ * report asked for. Splitting the declaration is the developer's call, so a
+ * declaration with sibling bindings is reported and left where it stands.
+ */
+function isRelocatableLateDeclaration(statement) {
+    return lateDeclarationDeclaratorsOf(statement)?.length === 1;
+}
+/**
+ * The binding the report names: the one whose own first use is the group's.
+ *
+ * A statement's bindings share its position, so the declaration is late relative to
+ * whichever of them is read first; naming a sibling read later would point the
+ * reader at the wrong line.
+ */
+function earliestUsedDeclarator(declarators, body, afterIndex, usageIndex) {
+    if (declarators.length === 1) {
+        return declarators[0];
     }
-    return declarator;
+    const earliest = declarators.find((declarator) => findFirstUsageIndex(body, new Set([declarator.id.name]), afterIndex) ===
+        usageIndex);
+    return earliest ?? declarators[0];
 }
 const LOOP_TYPES = new Set([
     utils_1.AST_NODE_TYPES.ForStatement,
@@ -1110,17 +1164,18 @@ function isMutatedInLoop(body, usageIndex, nameSet) {
 }
 function handleLateDeclarations(sink, body) {
     body.forEach((statement, index) => {
-        const declarator = lateDeclarationCandidateOf(statement);
-        if (!declarator) {
+        const declarators = lateDeclarationDeclaratorsOf(statement);
+        if (!declarators) {
             return;
         }
-        const name = declarator.id.name;
         const dependencies = new Set();
-        const init = unwrappedInitOf(declarator);
-        if (init && init.type === utils_1.AST_NODE_TYPES.Identifier) {
-            dependencies.add(init.name);
-        }
-        const nameSet = new Set([name]);
+        declarators.forEach((declarator) => {
+            const init = unwrappedInitOf(declarator);
+            if (init && init.type === utils_1.AST_NODE_TYPES.Identifier) {
+                dependencies.add(init.name);
+            }
+        });
+        const nameSet = new Set(declarators.map((declarator) => declarator.id.name));
         const usageIndex = findFirstUsageIndex(body, nameSet, index + 1);
         if (usageIndex === -1 || usageIndex <= index + 1) {
             return;
@@ -1140,7 +1195,9 @@ function handleLateDeclarations(sink, body) {
             // Do not hop over another declaration that is used at the same index or earlier
             // if it is also a candidate for being moved.
             // This prevents circular swapping of related declarations (like resolve/reject pairs).
-            if (lateDeclarationCandidateOf(stmt)) {
+            // The test asks about *relocation*, so a declaration the fix will never move
+            // is not one of the two ends of such a swap and does not block the hop.
+            if (isRelocatableLateDeclaration(stmt)) {
                 const declaredNames = getDeclaredNames(stmt);
                 const firstUsageOfIntervening = findFirstUsageIndex(body, declaredNames, index + 1 + i + 1);
                 if (firstUsageOfIntervening !== -1 &&
@@ -1163,7 +1220,11 @@ function handleLateDeclarations(sink, body) {
         if (crossesImpureOrTracked) {
             return;
         }
-        record(sink, statement, 'moveDeclarationCloser', { name }, index, usageIndex);
+        const subject = earliestUsedDeclarator(declarators, body, index + 1, usageIndex);
+        // The same test `isRelocatableLateDeclaration` applies to an intervening
+        // statement, read off the declarators already in hand.
+        const relocatable = declarators.length === 1;
+        record(sink, statement, 'moveDeclarationCloser', { name: subject.id.name }, index, usageIndex, relocatable);
     });
 }
 /**
@@ -1655,8 +1716,12 @@ function orderKey(order, indices) {
     return order.map((statement) => indices.get(statement)).join(',');
 }
 /**
- * Shortest sequence of moves reaching an order with **zero** violations, or null when
- * the search bounds contain no such order.
+ * Shortest sequence of moves reaching an order with **zero** relocatable violations,
+ * or null when the search bounds contain no such order.
+ *
+ * `violations` is pre-screened by `relocatableViolations`, and so is every detection
+ * the search performs: a violation whose statement the fix may not move is neither a
+ * candidate move nor a reason to reject an order, since no reordering can answer it.
  *
  * Breadth-first for two reasons: the emitted fix is then the smallest reordering that
  * satisfies every constraint, and a block whose single named move already suffices
@@ -1706,7 +1771,7 @@ function findResolvingMoves(sourceCode, body, violations, maxMoves) {
             }
             seen.add(key);
             budget -= 1;
-            const next = detectViolations(sourceCode, order);
+            const next = relocatableViolations(detectViolations(sourceCode, order));
             const moves = [...node.moves, { fromIndex, toIndex }];
             if (next.length === 0) {
                 return moves;
@@ -1765,10 +1830,15 @@ function buildReorderFix(body, moves, parent, sourceCode, fixer) {
     return fixer.replaceTextRange([bounds[first], bounds[last + 1]], reordered.slice(first, last + 1).join(''));
 }
 /**
- * A fix is emitted only for a reordering the detector scores at zero violations, and
- * the whole reordering ships as a single fix. Relocating one statement per report
- * satisfies its own adjacency constraint while breaking another's, which under
- * `--fix` oscillates or exhausts the pass budget (#1405).
+ * A fix is emitted only for a reordering the detector scores at zero relocatable
+ * violations, and the whole reordering ships as a single fix. Relocating one
+ * statement per report satisfies its own adjacency constraint while breaking
+ * another's, which under `--fix` oscillates or exhausts the pass budget (#1405).
+ *
+ * A violation no reordering may answer — a declaration whose sibling bindings the
+ * fix would drag along — is reported and otherwise invisible here: it does not
+ * carry the fix, does not veto one, and cannot keep the block from settling, since
+ * the fixed text scores it exactly as the input did.
  *
  * Convergence is structural rather than argued: the emitted order is verified clean
  * by the same detector that produced the reports, and detection depends only on
@@ -1786,13 +1856,14 @@ function handleBlock(ruleContext, node) {
     if (violations.length === 0) {
         return;
     }
-    const moves = findResolvingMoves(sourceCode, body, violations, searchDepthFor(violations.length, body.length));
-    violations.forEach((violation, index) => {
+    const relocatable = relocatableViolations(violations);
+    const moves = findResolvingMoves(sourceCode, body, relocatable, searchDepthFor(relocatable.length, body.length));
+    violations.forEach((violation) => {
         context.report({
             node: violation.statement,
             messageId: violation.messageId,
             data: violation.data,
-            fix: moves && index === 0
+            fix: moves && violation === relocatable[0]
                 ? (fixer) => buildReorderFix(body, moves, node, sourceCode, fixer)
                 : null,
         });

package/lib/rules/no-empty-dependency-use-callbacks.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const minimatch_1 = require("minimatch");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
 const DEFAULT_TEST_PATTERNS = ['**/__tests__/**', '**/*.test.*', '**/*.spec.*'];
 const PREFER_UTILITY_FUNCTION_MESSAGE = [
@@ -464,35 +465,10 @@ function dedentedCallbackText(sourceCode, callback, hoistTarget) {
     })
         .join('\n');
 }
-/**
- * The imports the hoist leaves bound to nothing, or `null` when none can be
- * unbound safely.
- *
- * The hoist is not a deletion: the declared identifier and the callback text
- * are re-emitted at module scope, so every reference inside them outlives the
- * fix. Only the wrapper disappears — the `const` keyword, the ` = hook(`
- * between the identifier and the callback, and the trailing `, []);`. Orphan-
- * hood is judged against those three slices alone, which keeps a hook call
- * nested in the callback body counted as a live reference (unwrapping the
- * outer call carries the inner one along verbatim).
- *
- * A member callee (`React.useCallback`) is left alone. Its object is usually
- * the JSX pragma, and under the classic runtime JSX consumes that binding
- * through a transform no scope analysis records — a use this cannot see, so it
- * must not delete it.
- */
-function planHoistImportRemoval(sourceCode, callExpression, declarator, callback, idRangeEnd, removal) {
-    if (callExpression.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
-        return null;
-    }
-    const deleted = [
-        [removal[0], declarator.id.range[0]],
-        [idRangeEnd, callback.range[0]],
-        [callback.range[1], removal[1]],
-    ];
-    return (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, deleted);
+function rangesOverlap(a, b) {
+    return a[0] < b[1] && b[0] < a[1];
 }
-function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCache) {
+function buildHoistPlan(context, callExpression, callback, hoistedIdentifierCache) {
     if (!callExpression.parent ||
         callExpression.parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
         return null;
@@ -565,17 +541,18 @@ function buildHoistFixes(context, callExpression, callback, hoistedIdentifierCac
     if (hasOnlyIndentBefore && hasOnlyWhitespaceAfter && lineEnd !== -1) {
         removeEnd = lineEnd + 1;
     }
-    // The hook import the call was the last consumer of goes with the hoist, in
-    // the same fix: applying the hoist alone trades this rule's report for an
-    // unused-import one, and nothing re-reports that debt once the hoist has
-    // resolved the original violation. An unremovable binding costs only the
-    // unused import — the hoist is the fix's value and is kept regardless.
-    const importRanges = planHoistImportRemoval(sourceCode, callExpression, declarator, callback, idRangeEnd, [removeStart, removeEnd]) ?? [];
-    return (fixer) => [
-        fixer.insertTextBefore(hoistTarget, hoisted),
-        fixer.removeRange([removeStart, removeEnd]),
-        ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
-    ];
+    return {
+        edits: [
+            { range: [hoistTarget.range[0], hoistTarget.range[0]], text: hoisted },
+            { range: [removeStart, removeEnd], text: '' },
+        ],
+        removed: [
+            [removeStart, declarator.id.range[0]],
+            [idRangeEnd, callback.range[0]],
+            [callback.range[1], removeEnd],
+        ],
+        span: [hoistTarget.range[0], removeEnd],
+    };
 }
 exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
     name: 'no-empty-dependency-use-callbacks',
@@ -613,8 +590,68 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
         const testPatterns = options?.testFilePatterns ?? DEFAULT_TEST_PATTERNS;
         const ignoreUseLatestCallback = options?.ignoreUseLatestCallback === true;
         const hoistedIdentifierCache = new WeakMap();
+        const sourceCode = context.getSourceCode();
         const filename = context.getFilename();
         const isTest = ignoreTestFiles && filenameMatchesPatterns(filename, testPatterns);
+        /**
+         * Every hoistable callback the rule finds, in traversal order.
+         *
+         * Reporting is deferred to `Program:exit` because the binding the call
+         * reads — the `useCallback` specifier, or the `React` default import behind
+         * `React.useCallback` — is unbound only once no surviving call references
+         * it. Judged one call at a time, a file with two hoistable callbacks never
+         * sees either as the binding's last use, and the pass that hoists both
+         * resolves every report — so nothing ever revisits the stranded import.
+         */
+        const violations = [];
+        /**
+         * A suppressed report is dropped together with its fix, so its hoist never
+         * happens: counting it toward the batch would unbind an import the
+         * surviving call still reads.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        /**
+         * The hoists that actually ship.
+         *
+         * Each is screened alone before it joins the batch: a hoist whose own
+         * deletion orphans something that cannot be unbound safely — a local
+         * variable, an import behind a directive comment — would otherwise poison
+         * every other hoist in the file.
+         *
+         * Candidates are then ordered and screened for collisions exactly as ESLint
+         * orders and screens competing reports, so batching cannot change which of
+         * two colliding hoists lands. A nested pair collides: both insert at the
+         * same module-scope offset, but the inner declaration's span ends first, so
+         * the inner hoist wins and the outer one waits for a later pass — hoisting
+         * the outer instead would relocate the inner hook call to module scope.
+         * Sibling hoists in one component share only that zero-width insertion
+         * point, so both ship together.
+         */
+        function planViolations() {
+            const candidates = [];
+            for (const violation of violations) {
+                if (isReportSuppressed(violation.node))
+                    continue;
+                const plan = buildHoistPlan(context, violation.node, violation.callback, hoistedIdentifierCache);
+                if (!plan)
+                    continue;
+                if ((0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, plan.removed) === null) {
+                    continue;
+                }
+                candidates.push({ violation, ...plan });
+            }
+            candidates.sort((left, right) => left.span[0] - right.span[0] || left.span[1] - right.span[1]);
+            const planned = [];
+            const claimed = [];
+            for (const candidate of candidates) {
+                if (claimed.some((taken) => candidate.edits.some((edit) => rangesOverlap(edit.range, taken)))) {
+                    continue;
+                }
+                claimed.push(...candidate.edits.map((edit) => edit.range));
+                planned.push(candidate);
+            }
+            return planned;
+        }
         function reportIfStaticCallback(callExpression, messageId) {
             const callee = callExpression.callee;
             if (callee.type !== utils_1.AST_NODE_TYPES.Identifier &&
@@ -648,12 +685,11 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
                 callExpression.parent.id.type === utils_1.AST_NODE_TYPES.Identifier
                 ? callExpression.parent.id.name
                 : 'this callback';
-            const fix = buildHoistFixes(context, callExpression, callback, hoistedIdentifierCache);
-            context.report({
+            violations.push({
                 node: callExpression,
+                callback,
                 messageId,
-                data: { name: callbackName },
-                fix,
+                name: callbackName,
             });
         }
         return {
@@ -678,6 +714,43 @@ exports.noEmptyDependencyUseCallbacks = (0, createRule_1.createRule)({
                     reportIfStaticCallback(node, 'preferUtilityLatest');
                 }
             },
+            'Program:exit'() {
+                if (violations.length === 0)
+                    return;
+                const planned = planViolations();
+                // One plan over every surviving hoist: the binding behind the callee is
+                // left unreferenced by their union even when no single hoist strips 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;
+                // The whole batch ships as one fix, so no hoist can land without the
+                // others the import's orphanhood was judged against, and no unbinding
+                // can land without the hoist 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 hoist stays behind: reports
+                // without a fixer are the lesser damage. Hoisting anyway would trade
+                // this rule's report for an unused-import one, and nothing re-reports
+                // that debt once the hoist has resolved the original violation.
+                const removalRanges = importRemoval ?? [];
+                const carrier = importRemoval ? planned[0] : undefined;
+                for (const violation of violations) {
+                    context.report({
+                        node: violation.node,
+                        messageId: violation.messageId,
+                        data: { name: violation.name },
+                        fix: violation === carrier?.violation
+                            ? (fixer) => [
+                                ...removalRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...planned.flatMap((entry) => entry.edits.map((edit) => fixer.replaceTextRange([edit.range[0], edit.range[1]], edit.text))),
+                            ]
+                            : undefined,
+                    });
+                }
+            },
         };
     },
 });