@blumintinc/eslint-plugin-blumint 1.20.136 → 1.20.138

package/lib/rules/no-explicit-return-type.js

@@ -5,6 +5,8 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
+const typeDeclarationRemoval_1 = require("../utils/typeDeclarationRemoval");
+const replacementSegments_1 = require("../utils/replacementSegments");
 const lexicalScope_1 = require("../utils/lexicalScope");
 const defaultOptions = {
     allowRecursiveFunctions: true,
@@ -716,12 +718,17 @@ function containsRange(outer, inner) {
 /**
  * Partitions annotations into the sets whose removals have to travel together.
  *
- * An import read from two annotations is unbound only once both are gone, so
+ * A binding read from two annotations is unbound only once both are gone, so
  * neither annotation may unbind it alone — and a fix may only count on the other
  * removal happening if it performs that removal itself. Annotations that jointly
- * keep an import alive are therefore merged into one batch, and every other
+ * keep a binding alive are therefore merged into one batch, and every other
  * annotation is a batch of one, judged against the file as it stands.
  *
+ * EVERY binding is asked about, not only the imported ones. Partitioning over
+ * imports alone left a local `type` alias named by two annotations owned by no
+ * fix: each annotation looked innocent alone, both were stripped, and the alias
+ * survived with nothing referencing it (#1902).
+ *
  * `candidates` must already exclude suppressed reports: a suppressed report's
  * fix never runs, so its annotation — and the reference it holds — outlives the
  * pass.
@@ -736,13 +743,13 @@ function batchAnnotations(source, candidates) {
         return root;
     };
     const ownerOf = (reference) => candidates.findIndex((candidate) => containsRange(candidate.returnType.range, reference));
-    for (const binding of (0, importRemoval_1.importBindingReferences)(source)) {
+    for (const binding of (0, importRemoval_1.bindingUses)(source)) {
         // A single reference cannot be shared, so the one-annotation judgement
         // already covers it.
-        if (binding.references.length < 2)
+        if (binding.uses.length < 2)
             continue;
         const owners = new Set();
-        const escapes = binding.references.some((reference) => {
+        const escapes = binding.uses.some((reference) => {
             const owner = ownerOf(reference);
             if (owner === -1)
                 return true;
@@ -774,15 +781,110 @@ function batchAnnotations(source, candidates) {
     return [...batches.values()];
 }
 /**
- * The ranges a single fix deletes for `batch`: the annotations themselves plus
- * any import they were the last consumers of. `null` when a binding the removal
+ * A comment whose meaning is tied to where it sits. Re-emitting one somewhere
+ * else retargets it — a disable directive lands on an unrelated line and a
+ * `@ts-expect-error` becomes an error of its own — so a removal that would move
+ * one is withheld instead.
+ */
+function isPositionalDirective(comment) {
+    if ((0, disableDirectives_1.parseDisableDirectives)([comment]).length > 0) {
+        return true;
+    }
+    const value = comment.value.trim();
+    return value.startsWith('@ts-expect-error') || value.startsWith('@ts-ignore');
+}
+/** The indentation of the line `offset` sits on, for a carried line break. */
+function indentAt(source, offset) {
+    const lineStart = source.text.lastIndexOf('\n', offset - 1) + 1;
+    const [indent] = /^[ \t]*/.exec(source.text.slice(lineStart, offset)) ?? [''];
+    return indent;
+}
+/**
+ * Whether the span deletes a whole declaration of the program.
+ *
+ * Such a span owns the comments inside it: they describe the declaration that is
+ * going away, and re-emitting them would leave prose behind with no subject. The
+ * spans that reach across a specifier list are the opposite case — the
+ * declaration survives them, so a comment they cover has to survive too.
+ */
+function removesWholeStatement(source, range) {
+    return source.ast.body.some((statement) => statement.range[0] >= range[0] && statement.range[1] <= range[1]);
+}
+/**
+ * What a removal range is replaced with: nothing, or the comments it covers
+ * re-emitted so the deletion carries them instead of dropping them. `null`
+ * withholds the fix, for a comment whose meaning is its position.
+ *
+ * The separators around the carried run are chosen from the text on either side
+ * rather than added unconditionally, so a range that already sits between
+ * whitespace does not gain any. A trailing line break is mandatory where the
+ * last comment is a line comment or the range consumed its own newline: without
+ * one the surviving code moves onto the comment's line and is commented out.
+ */
+function carriedText(source, range) {
+    const comments = source
+        .getAllComments()
+        .filter((comment) => comment.range[0] >= range[0] && comment.range[1] <= range[1]);
+    if (comments.length === 0)
+        return '';
+    if (comments.some(isPositionalDirective))
+        return null;
+    const indent = indentAt(source, range[0]);
+    const segments = comments.map((comment) => ({
+        text: source.text.slice(comment.range[0], comment.range[1]),
+        breakAfter: (0, replacementSegments_1.requiresLineBreakAfter)(comment),
+    }));
+    const body = (0, replacementSegments_1.joinSegmentBody)(segments, indent);
+    const before = range[0] > 0 ? source.text[range[0] - 1] : '';
+    const after = source.text[range[1]] ?? '';
+    const lead = before === '' || /\s/.test(before) ? '' : ' ';
+    const trail = segments[segments.length - 1].breakAfter ||
+        source.text.slice(range[0], range[1]).endsWith('\n')
+        ? `\n${indent}`
+        : after === '' || /\s/.test(after)
+            ? ''
+            : ' ';
+    return `${lead}${body}${trail}`;
+}
+/**
+ * ESLint applies a fix whole or not at all, and rejects one whose edits
+ * overlap. Two spans planned independently — an annotation and the declaration
+ * that strands it — can only overlap if a premise here is wrong, so an overlap
+ * withdraws the fix rather than throwing at apply time.
+ */
+function isDisjoint(edits) {
+    const sorted = [...edits].sort((left, right) => left.range[0] - right.range[0]);
+    return sorted.every((edit, index) => index === 0 || sorted[index - 1].range[1] <= edit.range[0]);
+}
+/**
+ * The edits a single fix makes for `batch`: the annotations themselves plus the
+ * bindings they were the last consumers of. `null` when a binding the removal
  * orphans cannot be unbound safely — the caller then drops the fix rather than
  * emitting the half of it that leaves a binding behind.
+ *
+ * A cleanup span is REPLACED by the comments it covers rather than deleted
+ * outright. The planner computes spans that reach across separators, so a
+ * comment among the specifiers sits inside one; declining on that comment is no
+ * remedy, since it lets a comment decide whether the annotations are stripped at
+ * all, which is a comment changing the transform just the same (#1877).
  */
-function planRemoval(source, batch) {
+function planRemoval(source, removalSource, batch) {
     const annotations = batch.map((entry) => entry.returnType.range);
-    const imports = (0, importRemoval_1.planOrphanedImportRemoval)(source, annotations);
-    return imports ? [...annotations, ...imports] : null;
+    const cleanups = (0, importRemoval_1.planOrphanedBindingRemoval)(removalSource, annotations, (variables, planned) => (0, typeDeclarationRemoval_1.planTypeDeclarationRemoval)(removalSource, variables, planned));
+    if (!cleanups)
+        return null;
+    const edits = annotations.map((range) => ({ range, text: '' }));
+    for (const range of cleanups) {
+        if (removesWholeStatement(source, range)) {
+            edits.push({ range, text: '' });
+            continue;
+        }
+        const carried = carriedText(source, range);
+        if (carried === null)
+            return null;
+        edits.push({ range, text: carried });
+    }
+    return isDisjoint(edits) ? edits : null;
 }
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',
@@ -822,6 +924,35 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
         const sourceCode = context.getSourceCode();
         const visitorKeys = sourceCode.visitorKeys;
         const pending = [];
+        /**
+         * The source the removal planner reads, with the comments inside a
+         * declaration hidden from it.
+         *
+         * `planImportBindingRemoval` declines outright on any comment inside the
+         * declaration it is asked to edit, because the spans it computes reach
+         * across separators and a comment nested among the specifiers would be
+         * swallowed. That decline is not available here: the annotations that
+         * jointly name an import are stripped by one fix or not at all, so
+         * declining only the import half strands the binding, and declining the
+         * whole fix lets a comment decide whether the rule's own transform fires
+         * (#1877, #1902).
+         *
+         * The planner is therefore asked for the spans as if the declaration
+         * carried no comments, and {@link carriedText} re-emits every comment
+         * those spans cover in place of the text they delete. Only
+         * `getCommentsInside` is blinded: `getCommentsBefore` still answers for
+         * the directive that binds a whole statement, which is the one shape no
+         * re-emission can save.
+         */
+        const removalSource = {
+            text: sourceCode.text,
+            ast: sourceCode.ast,
+            scopeManager: sourceCode.scopeManager,
+            getTokenBefore: sourceCode.getTokenBefore.bind(sourceCode),
+            getTokenAfter: sourceCode.getTokenAfter.bind(sourceCode),
+            getCommentsBefore: sourceCode.getCommentsBefore.bind(sourceCode),
+            getCommentsInside: () => [],
+        };
         /**
          * Whether ESLint will discard a report, resolved the way ESLint resolves
          * it. A fix that deletes several annotations at once is counting on all of
@@ -884,9 +1015,9 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             pending.push({ node, returnType, strippable });
         }
         /**
-         * Emits every held report, each carrying the import cleanup its own
-         * removal makes necessary. An annotation and the import it unbinds are one
-         * fix: applying either half alone leaves the file worse than applying
+         * Emits every held report, each carrying the binding cleanup its own
+         * removal makes necessary. An annotation and the binding it unbinds are
+         * one fix: applying either half alone leaves the file worse than applying
          * neither.
          *
          * Orphanhood is judged against a single fix's own deletions, never against
@@ -899,18 +1030,20 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
          * Waiting for the last such annotation does not work either. Once every
          * annotation is stripped the rule has nothing left to report, so no later
          * fix exists to carry the cleanup and the binding stays orphaned for good
-         * (issue #1654). The annotations that jointly hold an import alive are
+         * (issue #1654). The annotations that jointly hold a binding alive are
          * therefore removed by one fix, which owes two things: it deletes all of
          * them itself rather than assuming sibling reports land, and it counts
          * only annotations whose reports ESLint will not discard.
          */
         function flushReports() {
             const strippable = pending.filter((entry) => entry.strippable);
-            // Every annotation starts with the judgement it would get alone, so a
-            // batch can only ever add a cleanup, never withdraw one.
+            // Each annotation starts with the judgement it would get alone. That
+            // judgement holds only while the annotation is the whole story for every
+            // binding it names; a batch below either extends it to cover the
+            // binding they share, or withdraws it.
             const plans = new Map();
             for (const entry of strippable) {
-                const plan = planRemoval(sourceCode, [entry]);
+                const plan = planRemoval(sourceCode, removalSource, [entry]);
                 if (plan) {
                     plans.set(entry, plan);
                 }
@@ -919,11 +1052,21 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             for (const batch of batches) {
                 if (batch.length < 2)
                     continue;
-                const plan = planRemoval(sourceCode, batch);
-                if (!plan)
+                const plan = planRemoval(sourceCode, removalSource, batch);
+                if (plan) {
+                    for (const entry of batch) {
+                        plans.set(entry, plan);
+                    }
                     continue;
+                }
+                // The batch exists because its members jointly hold a binding alive,
+                // so falling back to the one-at-a-time strip is not the harmless
+                // status quo it looks like: `--fix` applies those strips in the same
+                // run, the last one leaves the binding referenced by nothing, and no
+                // report survives to clean it up (#1902). Every member gives up its
+                // fix and keeps its report.
                 for (const entry of batch) {
-                    plans.set(entry, plan);
+                    plans.delete(entry);
                 }
             }
             for (const entry of pending) {
@@ -936,7 +1079,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                     data: { functionKind: describeFunctionKind(entry.node) },
                     ...(plan
                         ? {
-                            fix: (fixer) => plan.map((range) => fixer.removeRange([range[0], range[1]])),
+                            fix: (fixer) => plan.map((edit) => fixer.replaceTextRange([edit.range[0], edit.range[1]], edit.text)),
                         }
                         : {}),
                 });

package/lib/rules/no-mock-firebase-admin.js

@@ -11,8 +11,10 @@ const createRule_1 = require("../utils/createRule");
 const FIREBASE_ADMIN_MODULE = 'firebaseAdmin';
 const MODULE_EXTENSION = /\.(?:tsx?|jsx?|mjs|cjs)$/;
 /**
- * Backend tier: `jest.setup.node.js` auto-mocks this module repo-wide, so a
- * local `jest.mock()` bypasses the shared stub the rule exists to protect.
+ * Backend tier: `jest.setup.node.js` runs a bare
+ * `jest.mock('./functions/src/config/firebaseAdmin')`, which activates the
+ * manual mock in `functions/src/config/__mocks__/`. A local *factory* replaces
+ * that manual mock and is what the rule exists to catch.
  */
 const BACKEND_FIREBASE_ADMIN = 'functions/src/config/firebaseAdmin';
 /**
@@ -35,19 +37,60 @@ const comparisonPathOf = (mockPath, filename) => {
     }
     return toPosix(path_1.default.resolve(path_1.default.dirname(filename), mockPath));
 };
-const bypassesSharedMock = (comparisonPath) => {
+const tierOf = (comparisonPath) => {
     // Backend is tested first because the backend path *contains* the frontend
     // path as a substring; checking frontend first would exempt every backend
     // mock and silently disable the rule.
     if (comparisonPath.includes(BACKEND_FIREBASE_ADMIN)) {
-        return true;
+        return 'backend';
     }
     if (comparisonPath.includes(FRONTEND_FIREBASE_ADMIN)) {
-        return false;
+        return 'frontend';
     }
     // A specifier attributable to neither tier keeps the rule's protection:
     // prefer reporting over silently allowing an unknown layout to shadow a
     // shared mock.
+    return 'unknown';
+};
+/**
+ * The factory argument, or `undefined` when the call supplies none. An explicit
+ * `undefined` placeholder — `jest.mock(path, undefined, { virtual: true })` — is
+ * the same call as the one-argument form, so it must read as "no factory" too.
+ */
+const factoryOf = (node) => {
+    const factory = node.arguments[1];
+    if (!factory) {
+        return undefined;
+    }
+    if (factory.type === utils_1.AST_NODE_TYPES.Identifier &&
+        factory.name === 'undefined') {
+        return undefined;
+    }
+    return factory;
+};
+/**
+ * Whether the call overrides the shared mock rather than re-activating it.
+ *
+ * A BARE backend `jest.mock()` is byte-for-byte the call `jest.setup.node.js`
+ * already makes: it activates the manual mock at
+ * `functions/src/config/__mocks__/firebaseAdmin.ts`. It replaces nothing and
+ * supplies no divergent state, so the message's rationale simply does not apply
+ * — and suites need the local form to obtain per-call spies (`db.doc`,
+ * `db.runTransaction`) that the shared `FakeFirestore` instance never exposes.
+ * Only a factory substitutes a different module body.
+ *
+ * The exemption stops at the backend tier on purpose. For an unattributable
+ * specifier there is no known `__mocks__` sibling, so a bare call may fall
+ * through to Jest's AUTOMOCK — every export replaced by an empty `jest.fn()` —
+ * which genuinely is divergent state.
+ */
+const overridesSharedMock = (tier, factory) => {
+    if (tier === 'frontend') {
+        return false;
+    }
+    if (tier === 'backend') {
+        return factory !== undefined;
+    }
     return true;
 };
 /**
@@ -126,7 +169,7 @@ exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            noMockFirebaseAdmin: 'Do not mock firebaseAdmin module "{{modulePath}}". The project already ships a stable mock in jest.setup.node.js; overriding it creates divergent Firestore/Auth state and brittle test fixtures. Keep the shared mock and use __test-utils__/mockFirestore to seed data instead of replacing the module.',
+            noMockFirebaseAdmin: 'Do not override the firebaseAdmin module mock for "{{modulePath}}". jest.setup.node.js already activates the shared manual mock; substituting your own module body creates divergent Firestore/Auth state and brittle test fixtures. Use __test-utils__/mockFirestore to seed data, and where a suite only needs the shared mock active, write a bare jest.mock() of functions/src/config/firebaseAdmin with no factory argument.',
         },
     },
     defaultOptions: [],
@@ -165,10 +208,11 @@ exports.noMockFirebaseAdmin = (0, createRule_1.createRule)({
                     if (!targetsFirebaseAdmin(mockPath)) {
                         return;
                     }
-                    if (!bypassesSharedMock(comparisonPathOf(mockPath, filename))) {
+                    const tier = tierOf(comparisonPathOf(mockPath, filename));
+                    const factory = factoryOf(node);
+                    if (!overridesSharedMock(tier, factory)) {
                         return;
                     }
-                    const factory = node.arguments[1];
                     if (factory && exercisesCollectionGroup(factory)) {
                         return;
                     }

package/lib/rules/no-redundant-usecallback-wrapper.d.ts

@@ -1,8 +1,9 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type Options = [
     {
         memoizedHookNames?: string[];
         assumeAllUseAreMemoized?: boolean;
     }
 ];
-export declare const noRedundantUseCallbackWrapper: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"redundantWrapper", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const noRedundantUseCallbackWrapper: TSESLint.RuleModule<"redundantWrapper", Options, TSESLint.RuleListener>;
 export default noRedundantUseCallbackWrapper;

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -4,6 +4,11 @@ exports.noRedundantUseCallbackWrapper = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const disableDirectives_1 = require("../utils/disableDirectives");
+const importRemoval_1 = require("../utils/importRemoval");
+function rangesOverlap(a, b) {
+    return a[0] < b[1] && b[0] < a[1];
+}
 const LATEST_CALLBACK_MODULE = 'use-latest-callback';
 const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 const MEMO_HOOK = 'useMemo';
@@ -290,6 +295,86 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
         // Track identifiers coming from hook-like calls
         const hookReturnObjects = new Set(); // variables assigned to a hook call result (object or function)
         const hookReturnProps = new Set(); // properties destructured from a hook call result
+        /**
+         * Every redundant wrapper the rule finds, in traversal order.
+         *
+         * Reporting is deferred to `Program:exit` because the wrapper's import is
+         * unbound only once no surviving call references it. Judged one call at a
+         * time, a file with two wrappers never sees either as the binding's last
+         * use, and the pass that collapses 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.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        /**
+         * A wrapper collapses to the delegate's bare name, so the delegate is the
+         * only text the rewrite keeps. Everything else inside the call — the
+         * wrapper's callee, the callback's syntax, the dependency array — is
+         * genuinely deleted, and only that may be handed to the orphan planner: a
+         * span covering the delegate would read whatever it names as unreferenced
+         * and delete that import too, an over-removal strictly worse than the
+         * stranded import this exists to prevent.
+         */
+        const planViolation = (violation, delegate) => ({
+            violation,
+            edit: { range: violation.node.range, text: delegate.name },
+            removed: [
+                [violation.node.range[0], delegate.range[0]],
+                [delegate.range[1], violation.node.range[1]],
+            ],
+        });
+        /**
+         * 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 colliding 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. A nested pair collides this way, and the enclosing rewrite wins
+         * because it is visited first; the inner one is fixed on a later pass.
+         */
+        const planViolations = () => {
+            const planned = [];
+            const claimed = [];
+            for (const violation of violations) {
+                if (!violation.delegate)
+                    continue;
+                if (isReportSuppressed(violation.node))
+                    continue;
+                const candidate = planViolation(violation, violation.delegate);
+                if ((0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, candidate.removed) === null) {
+                    continue;
+                }
+                if (claimed.some((taken) => rangesOverlap(candidate.edit.range, taken))) {
+                    continue;
+                }
+                claimed.push(candidate.edit.range);
+                planned.push(candidate);
+            }
+            return planned;
+        };
+        /**
+         * Records a redundant wrapper without reporting it yet.
+         *
+         * A member delegate (`ctx.submit`) is recorded unfixed: rewriting the
+         * wrapper to a bare member reference would detach the callback from its
+         * receiver and change what `this` binds to.
+         */
+        const recordViolation = (node, wrapper, delegate) => {
+            violations.push({
+                node,
+                wrapper,
+                callbackName: sourceCode.getText(delegate),
+                delegate: delegate.type === utils_1.AST_NODE_TYPES.Identifier ? delegate : null,
+            });
+        };
         return {
             ImportDeclaration(node) {
                 // The module's sole export is the hook, so its DEFAULT specifier binds
@@ -364,29 +449,7 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                             (unwrappedArg.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                                 unwrappedArg.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                                 hookReturnObjects.has(unwrappedArg.object.name))) {
-                            if (unwrappedArg.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                const replaceText = unwrappedArg.name;
-                                context.report({
-                                    node,
-                                    messageId: 'redundantWrapper',
-                                    data: {
-                                        wrapper,
-                                        callbackName: sourceCode.getText(unwrappedArg),
-                                    },
-                                    fix: (fixer) => fixer.replaceText(node, replaceText),
-                                });
-                            }
-                            else {
-                                // Member function — report only, no fix to avoid breaking `this`.
-                                context.report({
-                                    node,
-                                    messageId: 'redundantWrapper',
-                                    data: {
-                                        wrapper,
-                                        callbackName: sourceCode.getText(unwrappedArg),
-                                    },
-                                });
-                            }
+                            recordViolation(node, wrapper, unwrappedArg);
                         }
                         return;
                     }
@@ -417,29 +480,7 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                         return;
                                     }
                                     else {
-                                        if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                            const replaceText = callee.name;
-                                            context.report({
-                                                node,
-                                                messageId: 'redundantWrapper',
-                                                data: {
-                                                    wrapper,
-                                                    callbackName: sourceCode.getText(callee),
-                                                },
-                                                fix: (fixer) => fixer.replaceText(node, replaceText),
-                                            });
-                                        }
-                                        else {
-                                            // Member function — report only, no fix to avoid breaking `this`.
-                                            context.report({
-                                                node,
-                                                messageId: 'redundantWrapper',
-                                                data: {
-                                                    wrapper,
-                                                    callbackName: sourceCode.getText(callee),
-                                                },
-                                            });
-                                        }
+                                        recordViolation(node, wrapper, callee);
                                     }
                                 }
                             }
@@ -490,30 +531,7 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             }
                                             else {
                                                 // No args and trivial wrapper
-                                                if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                                    const replaceText = callee
-                                                        .name;
-                                                    context.report({
-                                                        node,
-                                                        messageId: 'redundantWrapper',
-                                                        data: {
-                                                            wrapper,
-                                                            callbackName: sourceCode.getText(callee),
-                                                        },
-                                                        fix: (fixer) => fixer.replaceText(node, replaceText),
-                                                    });
-                                                }
-                                                else {
-                                                    // Member function — report only, no fix to avoid breaking `this`.
-                                                    context.report({
-                                                        node,
-                                                        messageId: 'redundantWrapper',
-                                                        data: {
-                                                            wrapper,
-                                                            callbackName: sourceCode.getText(callee),
-                                                        },
-                                                    });
-                                                }
+                                                recordViolation(node, wrapper, callee);
                                             }
                                         }
                                     }
@@ -523,6 +541,44 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                     }
                 }
             },
+            'Program:exit'() {
+                if (violations.length === 0)
+                    return;
+                const planned = planViolations();
+                // One plan over every surviving rewrite: the wrapper's binding is left
+                // unreferenced by their union even when no single collapse 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 collapse can land without the
+                // others the import's orphanhood was judged against, and no unbinding
+                // can land without the collapse 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 collapse stays behind: reports
+                // without a fixer are the lesser damage.
+                const removalRanges = importRemoval ?? [];
+                const carrier = importRemoval ? planned[0] : undefined;
+                for (const violation of violations) {
+                    context.report({
+                        node: violation.node,
+                        messageId: 'redundantWrapper',
+                        data: {
+                            wrapper: violation.wrapper,
+                            callbackName: violation.callbackName,
+                        },
+                        fix: violation === carrier?.violation
+                            ? (fixer) => [
+                                ...removalRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...planned.map((entry) => fixer.replaceTextRange(entry.edit.range, entry.edit.text)),
+                            ]
+                            : undefined,
+                    });
+                }
+            },
         };
     },
 });