@blumintinc/eslint-plugin-blumint 1.20.144 → 1.20.146

package/lib/index.js

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

package/lib/rules/enforce-memoize-async.js

@@ -196,6 +196,246 @@ function declaresFunctionParameter(params) {
     }
     return parameterAnnotation(params[0])?.type === utils_1.AST_NODE_TYPES.TSFunctionType;
 }
+/**
+ * A database transaction handle is valid only for the attempt that created it,
+ * and a transaction body is re-run whenever the driver retries — Firestore
+ * retries an attempt whose reads a concurrent write invalidated. A memoized
+ * body hands the retry the first attempt's cached promise, so the retry queues
+ * no writes on its own handle, commits empty, and the caller reads the first
+ * attempt's return value and reports success. Memoizing the method that OWNS
+ * the transaction is the same defect one level up: the whole transaction, writes
+ * included, then runs once per instance.
+ */
+const TRANSACTION_TYPE_NAME = 'Transaction';
+const RUN_TRANSACTION_NAME = 'runTransaction';
+/**
+ * Keys that hold source positions or the tree's only back-edge rather than
+ * child nodes; `parent` would make a subtree walk non-terminating.
+ */
+const NON_TRAVERSABLE_KEYS = new Set(['parent', 'range', 'loc', 'type']);
+/** Every node of `root`'s subtree, `root` included. */
+function* subtreeOf(root) {
+    yield root;
+    for (const [key, value] of Object.entries(root)) {
+        if (NON_TRAVERSABLE_KEYS.has(key)) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            for (const element of value) {
+                if (ASTHelpers_1.ASTHelpers.isNode(element)) {
+                    yield* subtreeOf(element);
+                }
+            }
+        }
+        else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+            yield* subtreeOf(value);
+        }
+    }
+}
+/** The name a call invokes, for `f()` and for `o.f()` alike. */
+function calleeName(node) {
+    const callee = withoutChain(node.callee);
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name;
+    }
+    return undefined;
+}
+/**
+ * Whether the node is a `runTransaction(…)` call, under any receiver:
+ * `db.runTransaction`, `firestore.runTransaction` and a bare imported
+ * `runTransaction` all open a retryable transaction.
+ */
+function isRunTransactionCall(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        calleeName(node) === RUN_TRANSACTION_NAME);
+}
+/** Whether the method opens a transaction anywhere in its own body. */
+function ownsTransaction(fn) {
+    for (const node of subtreeOf(fn)) {
+        if (isRunTransactionCall(node)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether a type name denotes the transaction handle. The rightmost segment is
+ * the type's own name, so the qualified spellings — `FirebaseFirestore.
+ * Transaction`, `admin.firestore.Transaction` — answer alongside the bare one;
+ * a locally aliased import (`import { Transaction as Txn }`) answers through
+ * the alias set the file's imports define.
+ */
+function namesTransaction(typeName, aliases) {
+    if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return (typeName.name === TRANSACTION_TYPE_NAME || aliases.has(typeName.name));
+    }
+    if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+        return typeName.right.name === TRANSACTION_TYPE_NAME;
+    }
+    return false;
+}
+/**
+ * Whether a declared type hands the method a transaction handle: written
+ * directly, as one arm of a union or intersection, or as a property of an
+ * object type — the shape a destructured `{ transaction }: { transaction:
+ * Transaction }` parameter carries.
+ *
+ * Type ARGUMENTS are deliberately not entered: `Map<string, Transaction>` or
+ * `Promise<Transaction>` describes a collection of handles or a handle yet to
+ * exist, neither of which is the attempt-scoped handle this carve-out is about.
+ */
+function declaresTransactionType(annotation, aliases) {
+    if (!annotation) {
+        return false;
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return namesTransaction(annotation.typeName, aliases);
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+        annotation.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+        return annotation.types.some((member) => declaresTransactionType(member, aliases));
+    }
+    if (annotation.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+        return annotation.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+            declaresTransactionType(member.typeAnnotation?.typeAnnotation, aliases));
+    }
+    return false;
+}
+/**
+ * The type annotation a parameter declares, including the destructuring shapes
+ * `parameterAnnotation` does not reach: an object or array pattern carries its
+ * annotation on the pattern itself.
+ */
+function bindingAnnotation(param) {
+    if (param.type === utils_1.AST_NODE_TYPES.ObjectPattern ||
+        param.type === utils_1.AST_NODE_TYPES.ArrayPattern) {
+        return param.typeAnnotation?.typeAnnotation;
+    }
+    return parameterAnnotation(param);
+}
+/**
+ * Whether the method declares a parameter typed as a transaction handle.
+ *
+ * The test reads the ANNOTATION, not the parameter's name: a parameter merely
+ * named `transaction` is as likely to hold a payment or a ledger entry, and the
+ * rule's other carve-outs (void result, callback parameter) are annotation-driven
+ * for the same reason. A bare `async apply(transaction)` therefore keeps
+ * reporting — it declares nothing to honour, and under the `noImplicitAny` its
+ * consumers compile with it does not type-check anyway. Where the handle arrives
+ * through an unresolvable alias (`args: MembershipArgs`), the call-site test
+ * below is what recognises it.
+ */
+function declaresTransactionParameter(params, aliases) {
+    return params.some((param) => declaresTransactionType(bindingAnnotation(param), aliases));
+}
+/**
+ * The expression itself, with any `ChainExpression` wrapper removed. ESTree
+ * wraps a whole optional chain in that node, so `this?.body` and
+ * `this.body.bind?.(this)` reach a bare member/call test as something else
+ * entirely. Nullish spellings carry the transaction handle exactly as the plain
+ * ones do, and reading through the wrapper is what keeps the carve-out from
+ * lapsing on them — a lapse that would restore the empty-commit autofix.
+ */
+function withoutChain(node) {
+    return node.type === utils_1.AST_NODE_TYPES.ChainExpression
+        ? withoutChain(node.expression)
+        : node;
+}
+/** The own-method name a `this.foo` reference reads, if it reads one. */
+function thisMemberName(node) {
+    const expression = withoutChain(node);
+    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.computed &&
+        withoutChain(expression.object).type === utils_1.AST_NODE_TYPES.ThisExpression &&
+        expression.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return expression.property.name;
+    }
+    // `this.body.bind(this)` passes the same method, one wrapper out.
+    if (expression.type === utils_1.AST_NODE_TYPES.CallExpression &&
+        expression.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !expression.callee.computed &&
+        expression.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        expression.callee.property.name === 'bind') {
+        return thisMemberName(expression.callee.object);
+    }
+    return undefined;
+}
+/** Whether the subtree mentions the binding, under any nesting. */
+function mentionsBinding(node, name) {
+    for (const descendant of subtreeOf(node)) {
+        if (descendant.type === utils_1.AST_NODE_TYPES.Identifier &&
+            descendant.name === name) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Own methods a `runTransaction` argument hands the attempt to: the method
+ * passed as the callback itself, and every `this.method(…)` the callback body
+ * invokes with the attempt's handle among its arguments.
+ *
+ * Passing the handle on is what makes a method part of the attempt, so a
+ * helper the callback calls WITHOUT it — a config read, a lookup that takes no
+ * transaction — is untouched and keeps reporting.
+ */
+function collectTransactionParticipants(argument, participants) {
+    const passed = thisMemberName(argument);
+    if (passed) {
+        participants.add(passed);
+        return;
+    }
+    if (argument.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        argument.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return;
+    }
+    const handle = argument.params[0];
+    if (handle?.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return;
+    }
+    for (const node of subtreeOf(argument.body)) {
+        if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
+            continue;
+        }
+        const method = thisMemberName(node.callee);
+        if (method &&
+            node.arguments.some((arg) => mentionsBinding(arg, handle.name))) {
+            participants.add(method);
+        }
+    }
+}
+/** Every own method the class hands a transaction handle to. */
+function transactionParticipantsOf(body) {
+    const participants = new Set();
+    for (const node of subtreeOf(body)) {
+        if (!isRunTransactionCall(node)) {
+            continue;
+        }
+        for (const argument of node.arguments) {
+            collectTransactionParticipants(argument, participants);
+        }
+    }
+    return participants;
+}
+/** The statically known name of a method, for matching call sites against it. */
+function methodName(node) {
+    if (node.computed) {
+        return undefined;
+    }
+    const { key } = node;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return undefined;
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -290,6 +530,66 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
             }
             return memoizeImportCache;
         };
+        /**
+         * Local names bound to an imported `Transaction` type, so that an aliased
+         * import (`import { Transaction as Txn } from 'firebase-admin/firestore'`)
+         * is read as the handle it is. The module is not constrained: a handle is
+         * re-exported through as many paths as a codebase has layers, and the
+         * imported NAME already carries the signal.
+         */
+        let transactionAliasCache = null;
+        const transactionAliases = () => {
+            if (!transactionAliasCache) {
+                transactionAliasCache = new Set();
+                for (const statement of context.sourceCode.ast.body) {
+                    if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                        continue;
+                    }
+                    for (const spec of statement.specifiers) {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            spec.imported.name === TRANSACTION_TYPE_NAME) {
+                            transactionAliasCache.add(spec.local.name);
+                        }
+                    }
+                }
+            }
+            return transactionAliasCache;
+        };
+        /**
+         * The class-level scan is shared by every method of the class, so it runs
+         * once per class body rather than once per candidate method.
+         */
+        const participantCache = new WeakMap();
+        const transactionParticipants = (body) => {
+            let participants = participantCache.get(body);
+            if (!participants) {
+                participants = transactionParticipantsOf(body);
+                participantCache.set(body, participants);
+            }
+            return participants;
+        };
+        /**
+         * Whether the method takes part in a database transaction attempt, either
+         * by opening one or by being handed the attempt's handle. Caching such a
+         * method is never an optimisation: a retried attempt would replay the first
+         * attempt's promise, writing nothing on its own handle while the caller
+         * reads a success it did not get.
+         */
+        const participatesInTransaction = (node, fn) => {
+            if (declaresTransactionParameter(fn.params, transactionAliases())) {
+                return true;
+            }
+            if (ownsTransaction(fn)) {
+                return true;
+            }
+            const body = node.parent;
+            if (body?.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+                return false;
+            }
+            const name = methodName(node);
+            return name !== undefined && transactionParticipants(body).has(name);
+        };
         return {
             MethodDefinition(node) {
                 // Only process async instance methods (skip static methods)
@@ -341,6 +641,17 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (declaresVoidResult(node.value.returnType)) {
                     return;
                 }
+                // A transaction handle is valid only for the attempt that created it,
+                // so a result derived from one must not outlive that attempt. Caching
+                // the body of a `runTransaction` callback — or the method that owns the
+                // call — turns the retry a concurrent write provokes into a silent
+                // no-op: the retry replays the first attempt's promise, queues nothing
+                // on its own handle, commits empty, and reports the first attempt's
+                // value as success. The fixer would apply that unattended under
+                // `--fix`, so both report and fix are withheld.
+                if (participatesInTransaction(node, node.value)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator

package/lib/rules/no-always-true-false-conditions.js

@@ -3,6 +3,81 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noAlwaysTrueFalseConditions = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const BREAKABLE = new Set([
+    utils_1.AST_NODE_TYPES.WhileStatement,
+    utils_1.AST_NODE_TYPES.DoWhileStatement,
+    utils_1.AST_NODE_TYPES.ForStatement,
+    utils_1.AST_NODE_TYPES.ForInStatement,
+    utils_1.AST_NODE_TYPES.ForOfStatement,
+    utils_1.AST_NODE_TYPES.SwitchStatement,
+]);
+/**
+ * Whether `body` can leave the loop that owns it.
+ *
+ * An unlabeled `break` binds to the nearest enclosing loop or switch, so a
+ * nested breakable is still walked but its own unlabeled breaks do not count; a
+ * labeled one counts when it names this loop. `return` and `throw` leave the
+ * loop as well, unless they sit inside a nested function, which has its own.
+ */
+function canExitLoop(body, label) {
+    let escapes = false;
+    const visit = (node, insideNestedBreakable) => {
+        if (escapes)
+            return;
+        switch (node.type) {
+            case utils_1.AST_NODE_TYPES.FunctionDeclaration:
+            case utils_1.AST_NODE_TYPES.FunctionExpression:
+            case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                return;
+            case utils_1.AST_NODE_TYPES.BreakStatement:
+                if (node.label ? node.label.name === label : !insideNestedBreakable) {
+                    escapes = true;
+                }
+                return;
+            case utils_1.AST_NODE_TYPES.ReturnStatement:
+            case utils_1.AST_NODE_TYPES.ThrowStatement:
+                escapes = true;
+                return;
+            default:
+                break;
+        }
+        const nested = insideNestedBreakable || BREAKABLE.has(node.type);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'parent')
+                continue;
+            if (Array.isArray(value)) {
+                for (const child of value) {
+                    if (ASTHelpers_1.ASTHelpers.isNode(child))
+                        visit(child, nested);
+                }
+            }
+            else if (ASTHelpers_1.ASTHelpers.isNode(value)) {
+                visit(value, nested);
+            }
+        }
+    };
+    visit(body, false);
+    return escapes;
+}
+/**
+ * `while (true)` and `do … while (true)` around a `break` are how a loop whose
+ * exit is only known mid-body is written — cursor pagination being the usual
+ * case. The condition is the point, and unlike an `if` it cannot be removed:
+ * the only way to satisfy the report is to rewrite the loop as `for (;;)`,
+ * which this rule already accepts because it has no test node to check. A
+ * literal `true` over a body with no way out is still reported, since that loop
+ * really does run forever (#1973).
+ */
+function isDeliberateInfiniteLoop(loop) {
+    if (loop.test?.type !== utils_1.AST_NODE_TYPES.Literal || loop.test.value !== true) {
+        return false;
+    }
+    const label = loop.parent?.type === utils_1.AST_NODE_TYPES.LabeledStatement
+        ? loop.parent.label.name
+        : null;
+    return canExitLoop(loop.body, label);
+}
 exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
     name: 'no-always-true-false-conditions',
     meta: {
@@ -1498,15 +1573,19 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             },
             // Check while loops
             WhileStatement(node) {
+                if (isDeliberateInfiniteLoop(node))
+                    return;
                 checkCondition(node.test);
             },
             // Check do-while loops
             DoWhileStatement(node) {
+                if (isDeliberateInfiniteLoop(node))
+                    return;
                 checkCondition(node.test);
             },
             // Check for loop conditions
             ForStatement(node) {
-                if (node.test) {
+                if (node.test && !isDeliberateInfiniteLoop(node)) {
                     checkCondition(node.test);
                 }
             },

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

@@ -8,6 +8,7 @@ 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 arrowAnnotationGap_1 = require("../utils/arrowAnnotationGap");
 const defaultOptions = {
     allowRecursiveFunctions: true,
     allowOverloadedFunctions: true,
@@ -780,25 +781,6 @@ function batchAnnotations(source, candidates) {
     });
     return [...batches.values()];
 }
-/**
- * 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.
  *
@@ -827,9 +809,9 @@ function carriedText(source, range) {
         .filter((comment) => comment.range[0] >= range[0] && comment.range[1] <= range[1]);
     if (comments.length === 0)
         return '';
-    if (comments.some(isPositionalDirective))
+    if (comments.some(arrowAnnotationGap_1.isPositionalDirective))
         return null;
-    const indent = indentAt(source, range[0]);
+    const indent = (0, arrowAnnotationGap_1.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),
@@ -846,70 +828,20 @@ function carriedText(source, range) {
             : ' ';
     return `${lead}${body}${trail}`;
 }
-/** Every character the syntactic grammar counts as a LineTerminator. */
-const LINE_TERMINATOR = /[\n\r\u2028\u2029]/;
-const textOf = (source, range) => source.text.slice(range[0], range[1]);
-/**
- * The span an arrow's return annotation occupies between the parameter list and
- * the `=>`, together with that arrow token.
- *
- * The span holds the annotation, whitespace and comments and nothing else,
- * which is what makes it safe to rewrite wholesale: no binding reference can
- * hide in it beyond the ones the annotation itself names.
- */
-function arrowAnnotationGap(source, returnType) {
-    const parametersEnd = source.getTokenBefore(returnType);
-    const arrow = source.getTokenAfter(returnType, {
-        filter: (token) => token.value === '=>',
-    });
-    if (!parametersEnd || !arrow)
-        return null;
-    const gap = [parametersEnd.range[1], arrow.range[0]];
-    return containsRange(gap, returnType.range) ? { gap, arrow } : null;
-}
-/**
- * Re-emits `comments` on the far side of the arrow, where a line terminator is
- * inert, consuming the horizontal whitespace the arrow already had after it so
- * the body keeps a single separator.
- */
-function hoistPastArrow(source, arrow, comments) {
-    const indent = indentAt(source, arrow.range[0]);
-    const trailingText = source.text.slice(arrow.range[1]);
-    const [spacing] = /^[ \t]*/.exec(trailingText) ?? [''];
-    const body = (0, replacementSegments_1.joinSegmentBody)(comments.map((comment) => ({
-        text: textOf(source, comment.range),
-        breakAfter: true,
-    })), indent);
-    const rest = trailingText.slice(spacing.length);
-    const separator = LINE_TERMINATOR.test(rest.charAt(0))
-        ? ''
-        : (0, replacementSegments_1.requiresLineBreakAfter)(comments[comments.length - 1])
-            ? `\n${indent}`
-            : ' ';
-    return {
-        range: [arrow.range[1], arrow.range[1] + spacing.length],
-        text: ` ${body}${separator}`,
-    };
-}
 /**
  * The edits that strip one annotation, carrying every comment the strip
  * strands rather than deleting it (#1877). `null` withholds the fix, for a
  * comment whose meaning is its position and which cannot stay where it is.
  *
  * An arrow is the one subject whose annotation sits inside a restricted
- * production: `ArrowParameters [no LineTerminator here] =>` forbids a line
- * terminator between the parameter list and the arrow, and a block comment
- * carrying a line terminator IS one to the grammar. A comment left there — or
- * carried there from inside the annotation — therefore turns the output into a
- * hard SyntaxError that only V8 reports, since `@typescript-eslint/parser`
- * accepts it (#1964). Such a comment is re-emitted past the `=>` instead, the
- * nearest position outside the restricted gap that cannot itself begin one;
- * hoisting it above the enclosing line would anchor an insertion at a column
- * zero that may sit inside a template literal or JSX text, where the comment
- * would become content rather than code.
+ * production, so its edits come from the shared planner that answers for that
+ * grammar (#1964). The removal span handed to it is the annotation's own
+ * range: unlike the planner's other caller, nothing here reaches back over the
+ * whitespace ahead of the `:`.
  *
  * Every other subject ends its parameter list at a body or a semicolon, so its
- * stranded comments stay where they were written.
+ * stranded comments stay where they were written and a deletion that carries
+ * them in place is correct.
  */
 function planAnnotationEdits(source, entry) {
     const range = entry.returnType.range;
@@ -917,53 +849,7 @@ function planAnnotationEdits(source, entry) {
         const carried = carriedText(source, range);
         return carried === null ? null : [{ range, text: carried }];
     }
-    const gapInfo = arrowAnnotationGap(source, entry.returnType);
-    if (!gapInfo)
-        return null;
-    const { gap, arrow } = gapInfo;
-    const comments = source
-        .getAllComments()
-        .filter((comment) => containsRange(gap, comment.range));
-    const stranded = comments.filter((comment) => containsRange(range, comment.range));
-    // What the plain deletion would leave between the parameters and the arrow.
-    // A comment left there contributes its own text, so a line comment or a
-    // multi-line block comment shows up here as the line terminator it is.
-    const residue = `${textOf(source, [gap[0], range[0]])}${textOf(source, [
-        range[1],
-        gap[1],
-    ])}`;
-    // The plain deletion is kept wherever it already lands a legal gap and
-    // strands nothing, so no output that survives today moves by a byte.
-    if (stranded.length === 0 && !LINE_TERMINATOR.test(residue)) {
-        return [{ range, text: '' }];
-    }
-    // Rewriting the gap collapses the lines it spanned, which moves the line a
-    // directive inside it points at, so the whole fix is withheld rather than
-    // retargeting one. The gap a directive can share with nothing else is left
-    // untouched by the branch above.
-    if (comments.some(isPositionalDirective))
-        return null;
-    const hoisted = comments.filter(replacementSegments_1.requiresOwnLine);
-    const inline = comments
-        .filter((comment) => !(0, replacementSegments_1.requiresOwnLine)(comment))
-        .map((comment) => textOf(source, comment.range));
-    const edits = [
-        { range: gap, text: inline.length === 0 ? ' ' : ` ${inline.join(' ')} ` },
-    ];
-    if (hoisted.length > 0) {
-        edits.push(hoistPastArrow(source, arrow, hoisted));
-    }
-    return edits;
-}
-/**
- * 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]);
+    return (0, arrowAnnotationGap_1.planArrowAnnotationEdits)(source, entry.returnType, range);
 }
 /**
  * The edits a single fix makes for `batch`: the annotations themselves plus the
@@ -1002,7 +888,7 @@ function planRemoval(source, removalSource, batch) {
             return null;
         edits.push({ range, text: carried });
     }
-    return isDisjoint(edits) ? edits : null;
+    return (0, arrowAnnotationGap_1.isDisjoint)(edits) ? edits : null;
 }
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',