@blumintinc/eslint-plugin-blumint 1.20.170 → 1.20.171

package/lib/index.js

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

package/lib/rules/enforce-assert-safe-object-key.js

@@ -640,6 +640,47 @@ function foldKeyDomains(domains) {
     }
     return values;
 }
+/**
+ * The span of the access a written key belongs to: `obj[key]` including the
+ * object and both brackets, `[key]` for a computed property (whose value is an
+ * expression of its own), and the whole comparison for `key in obj`. Null where
+ * the key sits in none of those, which leaves the wrap to span the key alone.
+ *
+ * This is the unit a fix that rewrites a key has to claim. The key's own range
+ * stops short of the `]` that closes the access, and a fixer that reformats the
+ * access spreads its edits across the whole of it — so a span ending between
+ * the key and its bracket splits that set in half. Claiming the access instead
+ * leaves a competing rewrite of it either wholly discarded (and re-made against
+ * the fixed text on a later pass) or wholly applied, both of which parse.
+ */
+function accessSpan(sourceCode, written) {
+    const { parent } = written;
+    if (!parent) {
+        return null;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        parent.computed &&
+        parent.property === written) {
+        return [parent.range[0], parent.range[1]];
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.Property &&
+        parent.computed &&
+        parent.key === written) {
+        // A computed property's range runs past its key to the end of its value,
+        // which the wrap has no business claiming; the bracket that closes the key
+        // is where this access ends.
+        const closing = sourceCode.getTokenAfter(written);
+        return closing?.value === ']'
+            ? [parent.range[0], closing.range[1]]
+            : [written.range[0], written.range[1]];
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+        parent.operator === 'in' &&
+        parent.left === written) {
+        return [parent.range[0], parent.range[1]];
+    }
+    return null;
+}
 /**
  * An enum is a compiler-checked finite set. Members with literal initializers
  * enumerate their runtime key strings (which is what lets the forbidden-name
@@ -836,17 +877,51 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             const importStatement = `import { assertSafe } from '${computeImportSpecifier()}';\n`;
             return (0, importInsertion_1.insertAtImportAnchor)(context.sourceCode, fixer, (0, importInsertion_1.importInsertionAnchor)(context.sourceCode), importStatement);
         };
+        /**
+         * The wrap of the key, emitted over the whole access the key belongs to
+         * rather than over the key alone.
+         *
+         * ESLint merges the fixes of one report into a single edit spanning
+         * [first start, last end], splicing the original text back in between. The
+         * import anchor sits at the top of the file, so bundling it with the wrap
+         * turns a three-character edit into one that claims everything from the
+         * file's first statement to the end of the key — which is a point in the
+         * middle of the access, before the `]` that closes it. That span sorts
+         * ahead of every competing fix and wins the race against all of them, but
+         * only up to its end. A fixer whose edits are coherent only as a set (a
+         * formatter re-wrapping one access across several lines is the common
+         * case) then has the edits inside the span discarded and the edits past
+         * its end applied, and the two halves do not fit together: the emitted
+         * file does not parse.
+         *
+         * Ending the span where the access ends puts every edit of such a
+         * competing rewrite on one side of the boundary — either wholly inside the
+         * span (discarded whole, and re-made against the fixed text on the next
+         * pass) or wholly outside it. Both parse. The re-emitted head and tail are
+         * copied verbatim from the source, so the text this fix produces is
+         * character-for-character what replacing the key alone produced.
+         */
+        const wrapKey = (fixer, node, argText) => {
+            const replacement = `assertSafe(${argText})`;
+            const span = accessSpan(context.sourceCode, node);
+            if (!span) {
+                return fixer.replaceText(node, replacement);
+            }
+            const [start, end] = span;
+            const { text } = context.sourceCode;
+            return fixer.replaceTextRange([start, end], `${text.slice(start, node.range[0])}${replacement}${text.slice(node.range[1], end)}`);
+        };
         /**
          * Helper function to create fixes for a node
          */
         const createFixes = (fixer, node, argText) => {
             const fixes = [];
-            if (!importClaimed && !importsAssertSafe(context.sourceCode.ast)) {
+            const carriesImport = !importClaimed && !importsAssertSafe(context.sourceCode.ast);
+            if (carriesImport) {
                 fixes.push(addAssertSafeImport(fixer));
                 importClaimed = true;
             }
-            // Replace the node with assertSafe(argText)
-            fixes.push(fixer.replaceText(node, `assertSafe(${argText})`));
+            fixes.push(wrapKey(fixer, node, argText));
             return fixes;
         };
         // The report is emitted even when suppressed: ESLint discards it, and

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

@@ -6,6 +6,7 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importInsertion_1 = require("../utils/importInsertion");
+const resourceHandleType_1 = require("../utils/resourceHandleType");
 const MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
 const ALLOWED_MEMOIZE_MODULES = new Set([MEMOIZE_MODULE, 'typescript-memoize']);
 const MEMOIZE_NAME = 'Memoize';
@@ -641,6 +642,17 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (declaresVoidResult(node.value.returnType)) {
                     return;
                 }
+                // A method that hands back a resource handle — an object carrying the
+                // closure that releases what the call allocated — must run per caller.
+                // Cached, N concurrent callers share one lease and one release closure:
+                // the first `release()` frees it while the remaining N-1 keep running
+                // against budget nobody accounts for, and a caller's `finally` block
+                // disposes another caller's resource. The failure is silent and
+                // load-dependent, so the fixer would apply it unattended under `--fix`
+                // and a passing concurrency suite would keep passing.
+                if ((0, resourceHandleType_1.declaresResourceHandleResult)(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

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

@@ -7,6 +7,7 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importInsertion_1 = require("../utils/importInsertion");
+const resourceHandleType_1 = require("../utils/resourceHandleType");
 const MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
 const MEMOIZE_MODULES = new Set([
     MEMOIZE_PREFERRED_MODULE,
@@ -436,6 +437,25 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // declaration despite having no name.
                 if (classBody?.parent?.type === utils_1.AST_NODE_TYPES.ClassExpression)
                     return;
+                // A getter that hands back a resource handle — an object carrying the
+                // closure that releases what the read allocated — allocates that handle
+                // for the reader taking it. Memoized, every later read receives the
+                // FIRST reader's live lease and the release closure bound to it: the
+                // first `release()` frees it while the remaining readers keep running
+                // against budget nobody accounts for, and one reader's `finally` block
+                // disposes another reader's resource. The failure is silent and
+                // load-dependent, so the fixer would apply it unattended under `--fix`
+                // past a green concurrency suite.
+                //
+                // The predicate is SHARED with `enforce-memoize-async` and with
+                // `no-explicit-return-type`, which preserves exactly this annotation
+                // rather than stripping it as a restatement of the result. Split
+                // predicates would not merely drift, they would cancel: a shape this
+                // rule exempts and the reader strips loses the carve-out inside a
+                // single unattended `eslint --fix` run.
+                if ((0, resourceHandleType_1.declaresResourceHandleResult)(node.value.returnType)) {
+                    return;
+                }
                 // A getter whose value is a fresh read of live external state is not a
                 // lazy factory: memoizing it pins the first observation forever, so the
                 // report is dropped along with its unattended `--fix` edit.

package/lib/rules/enforce-stable-hash-spread-props.js

@@ -171,6 +171,275 @@ function getIndentBeforeNode(sourceCode, node) {
     const match = lineText.match(/^[ \t]*/);
     return match ? match[0] : '';
 }
+const EXHAUSTIVE_DEPS_DISABLE = '// eslint-disable-next-line react-hooks/exhaustive-deps';
+/**
+ * One level of indentation, spelled because the fixer prints an argument list
+ * rather than nudging the existing one. Two spaces is prettier's `tabWidth`
+ * default and this repo's and its consumers' setting; a tab-indented region is
+ * declined below instead of being indented with a mixture of the two.
+ */
+const INDENT_STEP = '  ';
+/**
+ * Wrappers that sit between a call and its statement without changing where
+ * prettier indents the call's arguments.
+ */
+const TRANSPARENT_PARENTS = new Set([
+    utils_1.AST_NODE_TYPES.AwaitExpression,
+    utils_1.AST_NODE_TYPES.ChainExpression,
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+/**
+ * Where an expanded argument list is measured from, or null where that cannot
+ * be resolved.
+ *
+ * Giving an argument a leading own-line comment forces prettier to print one
+ * argument per line — the decision is the comment's, not the line width's —
+ * indented one step past the enclosing statement, with the closing paren back
+ * at the statement's indentation. That holds while the call is the whole of a
+ * statement. A call nested inside another expression sits in a group prettier
+ * may break as well, and its arguments then indent against that break rather
+ * than against the line the call starts on, so those positions are declined
+ * rather than guessed at.
+ *
+ * A concise arrow body is the one nested position with a settled answer, and it
+ * has to be handled rather than declined because it is the same call spelled
+ * another way: `() => useCallback(…)` and `() => { return useCallback(…); }`
+ * are one function, and a fixer that remedies only one of them reports a
+ * violation it will not fix. Measured at the repo's prettier settings, the
+ * break lands after the final `=>` with the call one step past the statement,
+ * whatever the length of the arrow chain ahead of it.
+ */
+function expandedArgumentAnchor(node) {
+    const skipTransparent = (from) => {
+        let current = from;
+        while (current.parent && TRANSPARENT_PARENTS.has(current.parent.type)) {
+            current = current.parent;
+        }
+        return current;
+    };
+    let current = skipTransparent(node);
+    let followsArrow = false;
+    while (current.parent?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        current.parent.body === current) {
+        followsArrow = true;
+        current = skipTransparent(current.parent);
+    }
+    const parent = current.parent;
+    if (!parent) {
+        return null;
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.ExpressionStatement ||
+        parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
+        return { statement: parent, followsArrow };
+    }
+    // A second declarator is a break of its own, which moves the indentation the
+    // argument list is measured from off the declaration's line.
+    if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+        parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
+        parent.parent.declarations.length === 1) {
+        return { statement: parent.parent, followsArrow };
+    }
+    if (parent.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+        parent.parent?.type === utils_1.AST_NODE_TYPES.ExpressionStatement) {
+        return { statement: parent.parent, followsArrow };
+    }
+    return null;
+}
+/**
+ * Source lines whose leading whitespace belongs to a string's value rather than
+ * to the file's indentation. Re-indenting one of them would change what the
+ * program prints, and prettier leaves them alone for the same reason.
+ */
+function stringContinuationLines(sourceCode, node) {
+    const lines = new Set();
+    for (const token of sourceCode.getTokens(node)) {
+        if (token.type !== utils_1.AST_TOKEN_TYPES.String &&
+            token.type !== utils_1.AST_TOKEN_TYPES.Template) {
+            continue;
+        }
+        for (let line = token.loc.start.line + 1; line <= token.loc.end.line; line += 1) {
+            lines.add(line);
+        }
+    }
+    return lines;
+}
+/**
+ * Moves a span of source text by `shift` columns, leaving its first line alone
+ * because that line's indentation is written by the caller.
+ *
+ * Returns null when a line carries a tab, since a shift expressed in spaces
+ * cannot preserve a tab-indented line's column.
+ */
+function shiftIndentation(text, shift, firstLine, protectedLines) {
+    if (shift === 0) {
+        return text;
+    }
+    const shifted = [];
+    const lines = text.split('\n');
+    for (const [index, line] of lines.entries()) {
+        // A blank line gets no indentation: padding one is exactly the trailing
+        // whitespace this fixer exists to stop emitting.
+        if (index === 0 || protectedLines.has(firstLine + index) || !line.trim()) {
+            shifted.push(line);
+            continue;
+        }
+        if (line.startsWith('\t')) {
+            return null;
+        }
+        shifted.push(shift > 0
+            ? `${' '.repeat(shift)}${line}`
+            : line.slice(Math.min(-shift, line.length - line.trimStart().length)));
+    }
+    return shifted.join('\n');
+}
+/**
+ * Whether an argument that spans several lines keeps the layout prettier gave
+ * it once the expansion moves it to `argumentIndent`.
+ *
+ * Prettier breaks an argument for one of two reasons: the construct forces it,
+ * or it did not fit the room it had. Only the first survives the move, because
+ * the expansion hands every argument a different amount of room — an argument
+ * broken purely for width may fit on one line where it lands, and prettier would
+ * join it back up over text this fixer had copied verbatim.
+ *
+ * Two cases qualify. An argument already sitting alone at the target indent has
+ * lost no room at all. And a function with a non-empty block body is the shape
+ * prettier never prints on one line, whatever room it is given, provided
+ * everything ahead of the body already fits on one line.
+ */
+function keepsItsLayoutWhenMoved(sourceCode, argument, argumentIndent, currentIndent) {
+    if (argument.loc.start.line === argument.loc.end.line) {
+        return true;
+    }
+    if (currentIndent === argumentIndent &&
+        argument.loc.start.column === currentIndent.length) {
+        return true;
+    }
+    if (argument.type !== utils_1.AST_NODE_TYPES.ArrowFunctionExpression &&
+        argument.type !== utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return false;
+    }
+    const { body } = argument;
+    return (body.type === utils_1.AST_NODE_TYPES.BlockStatement &&
+        body.loc.start.line === argument.loc.start.line &&
+        (body.body.length > 0 || sourceCode.getCommentsInside(body).length > 0));
+}
+/**
+ * The text of `node` with the rewrites that fall inside it already applied, so
+ * that a caller re-emitting the surrounding span carries them along instead of
+ * overlapping them with a second edit.
+ */
+function applyRewrites(sourceCode, node, rewrites) {
+    const inside = rewrites
+        .filter(({ range }) => range[0] >= node.range[0] && range[1] <= node.range[1])
+        .sort((left, right) => left.range[0] - right.range[0]);
+    let cursor = node.range[0];
+    let text = '';
+    for (const rewrite of inside) {
+        text += sourceCode.text.slice(cursor, rewrite.range[0]) + rewrite.text;
+        cursor = rewrite.range[1];
+    }
+    return text + sourceCode.text.slice(cursor, node.range[1]);
+}
+/**
+ * Re-emits a call's argument list in the one-argument-per-line shape prettier
+ * prints once an argument carries an own-line comment, with `comment` placed
+ * above `commentTarget` and `rewrites` folded into the arguments they fall in.
+ *
+ * Inserting the comment in place instead leaves two marks of the pre-image on
+ * the file: the separator whitespace the inserted line break strands at the end
+ * of the preceding line, and the arguments' pre-expansion indentation. Owning
+ * the whole span between the parentheses settles both, at the cost of having to
+ * reproduce every argument — so a span this cannot reproduce faithfully returns
+ * null and the caller declines the fix outright.
+ */
+function expandArgumentList(sourceCode, node, commentTarget, comment, rewrites) {
+    const anchor = expandedArgumentAnchor(node);
+    if (!anchor) {
+        return null;
+    }
+    const { statement, followsArrow } = anchor;
+    const lineStart = sourceCode.getIndexFromLoc({
+        line: statement.loc.start.line,
+        column: 0,
+    });
+    const statementIndent = sourceCode.text.slice(lineStart, statement.range[0]);
+    if (!/^ *$/.test(statementIndent)) {
+        return null;
+    }
+    const edits = [];
+    let callIndent = statementIndent;
+    if (followsArrow) {
+        // The arrow chain ahead of the body stays on the statement's line, so the
+        // break the expansion forces is the one after the final `=>` — and the
+        // whitespace across that break is the fixer's to write, for the same reason
+        // the separator between two arguments is.
+        const arrowToken = sourceCode.getTokenBefore(node);
+        if (!arrowToken ||
+            arrowToken.value !== '=>' ||
+            arrowToken.loc.end.line !== statement.loc.start.line ||
+            !/^\s*$/.test(sourceCode.text.slice(arrowToken.range[1], node.range[0]))) {
+            return null;
+        }
+        callIndent = `${statementIndent}${INDENT_STEP}`;
+        edits.push({
+            range: [arrowToken.range[1], node.range[0]],
+            text: `\n${callIndent}`,
+        });
+    }
+    else if (statement.loc.start.line !== node.loc.start.line) {
+        return null;
+    }
+    const openParen = sourceCode.getTokenAfter(node.typeParameters ?? node.callee, {
+        filter: utils_1.ASTUtils.isOpeningParenToken,
+    });
+    const closeParen = sourceCode.getLastToken(node);
+    if (!openParen || !closeParen || !utils_1.ASTUtils.isClosingParenToken(closeParen)) {
+        return null;
+    }
+    // A comment written between the arguments belongs to no argument, so the
+    // re-emitted list has nowhere to carry it and would delete it. Declining is
+    // the deliberate choice here: a formatting correction does not justify
+    // dropping a comment (#1877).
+    const strandsAComment = sourceCode
+        .getCommentsInside(node)
+        .some((existing) => existing.range[0] >= openParen.range[1] &&
+        existing.range[1] <= closeParen.range[0] &&
+        !node.arguments.some((argument) => existing.range[0] >= argument.range[0] &&
+            existing.range[1] <= argument.range[1]));
+    if (strandsAComment) {
+        return null;
+    }
+    const argumentIndent = `${callIndent}${INDENT_STEP}`;
+    const protectedLines = stringContinuationLines(sourceCode, node);
+    const parts = [];
+    for (const argument of node.arguments) {
+        const base = getIndentBeforeNode(sourceCode, argument);
+        if (!/^ *$/.test(base)) {
+            return null;
+        }
+        if (!keepsItsLayoutWhenMoved(sourceCode, argument, argumentIndent, base)) {
+            return null;
+        }
+        // Wrapping an element in a call adds no line terminator, so each line of
+        // the rewritten text still stands for the source line at the same offset
+        // and the protected-line numbering survives the rewrite.
+        const shifted = shiftIndentation(applyRewrites(sourceCode, argument, rewrites), argumentIndent.length - base.length, argument.loc.start.line, protectedLines);
+        if (shifted === null) {
+            return null;
+        }
+        if (argument === commentTarget) {
+            parts.push(`${argumentIndent}${comment}\n`);
+        }
+        parts.push(`${argumentIndent}${shifted},\n`);
+    }
+    edits.push({
+        range: [openParen.range[1], closeParen.range[0]],
+        text: `\n${parts.join('')}${callIndent}`,
+    });
+    return edits;
+}
 function hasExhaustiveDepsDisable(sourceCode, callNode, depsNode) {
     const [start, end] = [callNode.range[0], depsNode.range[1]];
     const callStartLine = callNode.loc.start.line;
@@ -355,15 +624,40 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                             !bindsHashImport(existingBinding, hashImport)) {
                             return null;
                         }
-                        const fixes = [];
                         const seen = new Set();
+                        const rewrites = [];
                         for (const { node: targetNode } of offendingElements) {
                             if (seen.has(targetNode.range[0]))
                                 continue;
                             seen.add(targetNode.range[0]);
                             const original = sourceCode.getText(targetNode);
-                            fixes.push(fixer.replaceText(targetNode, `${hashIdentifier}(${original})`));
+                            rewrites.push({
+                                range: targetNode.range,
+                                text: `${hashIdentifier}(${original})`,
+                            });
                         }
+                        // The disable comment and the `stableHash(...)` wraps are one edit
+                        // whenever the comment lands: an own-line comment forces prettier
+                        // to expand the argument list, and the expansion re-emits the very
+                        // span the wraps live in, which ESLint rejects as two overlapping
+                        // fixes. Where the comment is already there, the wraps stand alone
+                        // and the call's layout is left as the author wrote it.
+                        const needsDisable = !hasExhaustiveDepsDisable(sourceCode, node, depsArg);
+                        const expansion = needsDisable
+                            ? expandArgumentList(sourceCode, node, depsArg, EXHAUSTIVE_DEPS_DISABLE, rewrites)
+                            : null;
+                        // A call whose argument list cannot be reproduced still needs the
+                        // disable, since the wrapped dependency is what makes
+                        // `react-hooks/exhaustive-deps` fire. Emitting the wraps without it
+                        // would trade this rule's report for that one, so the whole fix is
+                        // declined and the report stands for the author. The decision is
+                        // taken before any fix is scheduled: `importPlanned` claims the
+                        // file's import for this violation, and a later `return null` would
+                        // strand the surviving violations with no import at all.
+                        if (needsDisable && !expansion) {
+                            return null;
+                        }
+                        const fixes = (expansion ?? rewrites).map(({ range, text }) => fixer.replaceTextRange(range, text));
                         if (!isStableHashImported(sourceCode, hashImport) &&
                             !importPlanned) {
                             const importText = `import { ${hashImport.importName} } from '${hashImport.source}';\n`;
@@ -387,17 +681,6 @@ exports.enforceStableHashSpreadProps = (0, createRule_1.createRule)({
                             }
                             importPlanned = true;
                         }
-                        if (!hasExhaustiveDepsDisable(sourceCode, node, depsArg)) {
-                            const indent = getIndentBeforeNode(sourceCode, depsArg);
-                            const tokenBefore = sourceCode.getTokenBefore(depsArg, {
-                                includeComments: true,
-                            });
-                            const needsLeadingNewline = tokenBefore?.loc.end.line === depsArg.loc.start.line;
-                            const commentText = needsLeadingNewline
-                                ? `\n${indent}// eslint-disable-next-line react-hooks/exhaustive-deps\n${indent}`
-                                : `// eslint-disable-next-line react-hooks/exhaustive-deps\n${indent}`;
-                            fixes.push(fixer.insertTextBefore(depsArg, commentText));
-                        }
                         return fixes;
                     },
                 });

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

@@ -532,12 +532,40 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
          * declares, so any other name would be written as an import that resolves
          * nowhere.
          */
+        function importDeclarationsOf() {
+            return sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+        }
+        /**
+         * Where {@link planFastDeepEqualImport} lands its statement, told to the
+         * removal planner so the blank line under a deleted microdiff import is
+         * judged against a file that opens on the replacement rather than on the
+         * module body (issue #2078).
+         *
+         * The anchor positions are a superset of the one the fixer picks, since which
+         * declarations the plan deletes is not known until it exists. Naming a
+         * position the fix does not use only leaves a blank line standing, which is
+         * the layout the file already had.
+         */
+        function fastDeepEqualImportSites() {
+            if (hasFastDeepEqualImport)
+                return [];
+            const importDeclarations = importDeclarationsOf();
+            const microdiffImports = importDeclarations.filter((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
+            if (microdiffImports.length > 0) {
+                return [
+                    ...microdiffImports.map((declaration) => declaration.range[0]),
+                    microdiffImports[0].range[1],
+                ];
+            }
+            const last = importDeclarations[importDeclarations.length - 1];
+            return [last ? last.range[1] : 0];
+        }
         function planFastDeepEqualImport(fixer, removalRanges) {
             if (hasFastDeepEqualImport) {
                 return [];
             }
             const importStatement = (0, fastDeepEqualModules_1.fastDeepEqualImport)(fastDeepEqualImportName);
-            const importDeclarations = sourceCode.ast.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+            const importDeclarations = importDeclarationsOf();
             const removalStartOf = (declaration) => removalRanges.find((range) => range[0] <= declaration.range[0] &&
                 range[1] >= declaration.range[1])?.[0];
             const microdiffImports = importDeclarations.filter((declaration) => microdiffModules_1.MICRODIFF_MODULES.has(String(declaration.source.value)));
@@ -741,7 +769,7 @@ exports.fastDeepEqualOverMicrodiff = (0, createRule_1.createRule)({
                 // 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))
+                    ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, planned.flatMap((entry) => entry.removed), { insertions: fastDeepEqualImportSites() })
                     : null;
                 const removalRanges = importRemoval ?? [];
                 // The whole batch ships as one fix, so no rewrite can land without the

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 resourceHandleType_1 = require("../utils/resourceHandleType");
 const arrowAnnotationGap_1 = require("../utils/arrowAnnotationGap");
 const defaultOptions = {
     allowRecursiveFunctions: true,
@@ -845,6 +846,36 @@ function declaresVoidResult(returnType) {
     return (typeArguments?.length === 1 &&
         typeArguments[0].type === utils_1.AST_NODE_TYPES.TSVoidKeyword);
 }
+/**
+ * Returns true when the annotation declares that the function hands back a
+ * RESOURCE HANDLE: an object result carrying a function-valued member, which is
+ * the closure that releases whatever the call allocated.
+ *
+ * `declaresVoidResult` above answers the same objection for the opposite shape,
+ * and the reasoning transfers verbatim. This annotation is not a restatement of
+ * a result either — it is the evidence a sibling rule's correctness decision
+ * rests on. `enforce-memoize-async` reads exactly this shape and declines to
+ * demand `@Memoize()` on the method, because a memoized handle factory serves
+ * every caller after the first the FIRST caller's live lease and the release
+ * closure bound to it: N concurrent callers hold one lease between them while
+ * the pool accounts for N, and whichever caller finishes first disposes a
+ * resource the others still believe they own.
+ *
+ * Stripping the annotation therefore destroys information rather than removing
+ * redundancy, and it destroys it unattended: `eslint --fix` re-lints until the
+ * output settles, so the strip and the memoization it re-arms land in the same
+ * run. Nothing downstream catches what that re-arms, because the failure is
+ * silent and load-dependent — it needs concurrent callers to show itself, so a
+ * green suite stays green and the corruption surfaces under load.
+ *
+ * The predicate is SHARED with the owner (`../utils/resourceHandleType`) rather
+ * than restated here. A shape one rule exempts while the other strips is the
+ * whole defect; a shape one rule strips while the other exempts is the same
+ * defect pointing the other way, so the two cannot be allowed to drift apart.
+ */
+function isResourceHandleReturnType(returnType) {
+    return (0, resourceHandleType_1.declaresResourceHandleResult)(returnType);
+}
 // TypeScript's built-in decorator signatures. A factory annotated with one of
 // these is the one shape where the annotation is WIDER than what inference
 // produces rather than a restatement of it: `MethodDecorator` accepts three
@@ -1364,6 +1395,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isResourceHandleReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
                     isOverloadImplementation(node) ||
                     (mergedOptions.allowRecursiveFunctions &&
@@ -1383,6 +1415,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isResourceHandleReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
                     (mergedOptions.allowRecursiveFunctions &&
                         isRecursiveFunction(node)) ||
@@ -1398,6 +1431,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isResourceHandleReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
                     isReturnTypeRequiredByRecursion(node)) {
                     return;
@@ -1424,6 +1458,7 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
                 if (isTypeGuardFunction(node.value) ||
                     isReadonlyWideningReturnType(returnType) ||
                     isAllowedVoidReturnType(returnType) ||
+                    isResourceHandleReturnType(returnType) ||
                     isDecoratorFactory(node, returnType) ||
                     isOverloadImplementationMethod(node) ||
                     (mergedOptions.allowOverloadedFunctions &&