@blumintinc/eslint-plugin-blumint 1.20.25 → 1.20.26

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

@@ -699,34 +699,20 @@ function getNextStart(body, index, parent, sourceCode) {
     const closingBraceOffset = parent.type === utils_1.AST_NODE_TYPES.BlockStatement ? 1 : 0;
     return parent.range[1] - closingBraceOffset;
 }
-function buildMoveFix(body, fromIndex, toIndex, parent, sourceCode, fixer) {
-    const text = sourceCode.getText();
-    if (toIndex < fromIndex) {
-        const segmentStart = getStartWithComments(body[toIndex], sourceCode);
-        const movingStart = getStartWithComments(body[fromIndex], sourceCode);
-        const segmentEnd = getNextStart(body, fromIndex, parent, sourceCode);
-        const before = text.slice(segmentStart, movingStart);
-        const moving = text.slice(movingStart, segmentEnd).replace(/[ \t]+$/u, '');
-        const newText = moving + before;
-        return fixer.replaceTextRange([segmentStart, segmentEnd], newText);
-    }
-    const segmentStart = getStartWithComments(body[fromIndex], sourceCode);
-    const movingEnd = getNextStart(body, fromIndex, parent, sourceCode);
-    const segmentEnd = getStartWithComments(body[toIndex], sourceCode);
-    const moving = text.slice(segmentStart, movingEnd).replace(/[ \t]+$/u, '');
-    const between = text.slice(movingEnd, segmentEnd);
-    const newText = between + moving;
-    return fixer.replaceTextRange([segmentStart, segmentEnd], newText);
-}
 function truncateWithEllipsis(text, max = 60) {
     return text.length <= max ? text : `${text.slice(0, max)}…`;
 }
-function reportOnce({ context, reportedStatements }, statement, messageId, data, fix) {
-    if (reportedStatements.has(statement)) {
+/**
+ * At most one violation per statement: a statement can qualify under several
+ * handlers with contradictory targets, so the first handler to claim it wins and
+ * the handler call order in `detectViolations` is the tie-break.
+ */
+function record(sink, statement, messageId, data, fromIndex, toIndex) {
+    if (sink.flagged.has(statement)) {
         return;
     }
-    reportedStatements.add(statement);
-    context.report({ node: statement, messageId, data, fix });
+    sink.flagged.add(statement);
+    sink.violations.push({ statement, messageId, data, fromIndex, toIndex });
 }
 function isGuardIfStatement(statement) {
     if (statement.type !== utils_1.AST_NODE_TYPES.IfStatement || statement.alternate) {
@@ -749,8 +735,8 @@ function isGuardIfStatement(statement) {
     }
     return false;
 }
-function handleGuardHoists(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleGuardHoists(sink, body) {
+    const { sourceCode } = sink;
     body.forEach((statement, index) => {
         if (!isGuardIfStatement(statement)) {
             return;
@@ -770,10 +756,10 @@ function handleGuardHoists(ruleContext, body, parent) {
         if (targetIndex === index) {
             return;
         }
-        reportOnce(ruleContext, statement, 'moveGuardUp', { guard: truncateWithEllipsis(sourceCode.getText(statement.test)) }, (fixer) => buildMoveFix(body, index, targetIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveGuardUp', { guard: truncateWithEllipsis(sourceCode.getText(statement.test)) }, index, targetIndex);
     });
 }
-function handleDerivedGrouping(ruleContext, body, parent) {
+function handleDerivedGrouping(sink, body) {
     const declaredIndices = new Map();
     /**
      * Each binding name → the declarator that introduced it. Sibling bindings of
@@ -782,10 +768,9 @@ function handleDerivedGrouping(ruleContext, body, parent) {
      * from `b` even though `a` separates `b` from its declaration.
      */
     const sourceDeclarators = new Map();
-    const { sourceCode } = ruleContext;
     body.forEach((statement, index) => {
         if (isVariableDeclaration(statement)) {
-            processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode);
+            processVariableDeclaration(sink, statement, index, body, declaredIndices, sourceDeclarators);
         }
         trackDeclaredNames(statement, index, declaredIndices);
         trackSourceDeclarators(statement, sourceDeclarators);
@@ -794,11 +779,10 @@ function handleDerivedGrouping(ruleContext, body, parent) {
 function isVariableDeclaration(statement) {
     return statement.type === utils_1.AST_NODE_TYPES.VariableDeclaration;
 }
-function processVariableDeclaration(ruleContext, statement, index, body, declaredIndices, sourceDeclarators, parent, sourceCode) {
+function processVariableDeclaration(sink, statement, index, body, declaredIndices, sourceDeclarators) {
     const dependencies = collectDependencies(statement);
     const priorDependencies = findPriorDependencies(dependencies, declaredIndices);
-    if (priorDependencies.length === 0 ||
-        ruleContext.reportedStatements.has(statement)) {
+    if (priorDependencies.length === 0 || sink.flagged.has(statement)) {
         return;
     }
     const lastDependencyIndex = findLastDependencyIndex(priorDependencies, declaredIndices);
@@ -813,7 +797,7 @@ function processVariableDeclaration(ruleContext, statement, index, body, declare
     if (hasBlockers(body, lastDependencyIndex, index, priorDependencySet, declaredNames)) {
         return;
     }
-    reportDerivedGroupingViolation(ruleContext, statement, priorDependencies, declaredNames, body, index, lastDependencyIndex, parent, sourceCode);
+    reportDerivedGroupingViolation(sink, statement, priorDependencies, declaredNames, index, lastDependencyIndex);
 }
 function collectDependencies(statement) {
     const dependencies = new Set();
@@ -843,13 +827,13 @@ function hasBlockers(body, lastDependencyIndex, currentIndex, priorDependencySet
         statementDeclaresAny(between, declaredNames) ||
         statementReferencesAny(between, declaredNames));
 }
-function reportDerivedGroupingViolation(ruleContext, statement, priorDependencies, declaredNames, body, currentIndex, lastDependencyIndex, parent, sourceCode) {
+function reportDerivedGroupingViolation(sink, statement, priorDependencies, declaredNames, currentIndex, lastDependencyIndex) {
     const dependency = priorDependencies[0];
     const name = declaredNames.values().next().value ?? 'value';
-    reportOnce(ruleContext, statement, 'groupDerived', {
+    record(sink, statement, 'groupDerived', {
         dependency,
         name,
-    }, (fixer) => buildMoveFix(body, currentIndex, lastDependencyIndex + 1, parent, sourceCode, fixer));
+    }, currentIndex, lastDependencyIndex + 1);
 }
 function trackDeclaredNames(statement, index, declaredIndices) {
     const declared = getDeclaredNames(statement);
@@ -971,8 +955,7 @@ function isMutatedInLoop(body, usageIndex, nameSet) {
     }
     return statementMutatesAny(firstUsage, nameSet);
 }
-function handleLateDeclarations(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleLateDeclarations(sink, body) {
     body.forEach((statement, index) => {
         if (!isLateDeclarationCandidate(statement)) {
             return;
@@ -1026,7 +1009,7 @@ function handleLateDeclarations(ruleContext, body, parent) {
         if (crossesImpureOrTracked) {
             return;
         }
-        reportOnce(ruleContext, statement, 'moveDeclarationCloser', { name }, (fixer) => buildMoveFix(body, index, usageIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveDeclarationCloser', { name }, index, usageIndex);
     });
 }
 function extractCallExpression(expression) {
@@ -1327,8 +1310,8 @@ function isSideEffectExpression(statement) {
     }
     return Boolean(extractCallExpression(statement.expression));
 }
-function handleSideEffects(ruleContext, body, parent) {
-    const { sourceCode } = ruleContext;
+function handleSideEffects(sink, body) {
+    const { sourceCode } = sink;
     body.forEach((statement, index) => {
         if (!isSideEffectExpression(statement)) {
             return;
@@ -1357,15 +1340,211 @@ function handleSideEffects(ruleContext, body, parent) {
             return;
         }
         const effectText = truncateWithEllipsis(sourceCode.getText(statement).trim());
-        reportOnce(ruleContext, statement, 'moveSideEffect', { effect: effectText }, (fixer) => buildMoveFix(body, index, targetIndex, parent, sourceCode, fixer));
+        record(sink, statement, 'moveSideEffect', { effect: effectText }, index, targetIndex);
     });
 }
+/**
+ * Detection is pure over the statement order, so it scores a hypothetical
+ * reordering exactly as it scores the real one. Handler order is the tie-break for
+ * a statement several handlers claim — do not reorder these calls.
+ */
+function detectViolations(sourceCode, body) {
+    const sink = {
+        sourceCode,
+        flagged: new Set(),
+        violations: [],
+    };
+    handleGuardHoists(sink, body);
+    handleDerivedGrouping(sink, body);
+    handleLateDeclarations(sink, body);
+    handleSideEffects(sink, body);
+    return sink.violations;
+}
+/**
+ * Mirrors the rotation `moveSegment` performs on text, at statement granularity, so a
+ * candidate ordering can be scored without rewriting and reparsing the source. The
+ * two must stay in step: the search verifies the order that the fix emits.
+ */
+function applyMove(body, fromIndex, toIndex) {
+    const next = [...body];
+    const [moved] = next.splice(fromIndex, 1);
+    next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved);
+    return next;
+}
+/**
+ * Upper bound on candidate moves expanded per search node. Each candidate costs one
+ * full detection pass, so a node offering more violations than this has its tail
+ * ignored: the frontier stays bounded and the budget buys depth rather than width.
+ */
+const MAX_FIX_CANDIDATES = 12;
+/**
+ * Real code routinely needs a run of moves before every constraint holds: hoisting
+ * one `jest.mock` exposes the next, and interleaved `before`/`after` fixtures pass
+ * through orders with *more* violations than they started with before settling at
+ * zero. Satisfying every adjacency constraint at once therefore requires looking well
+ * past the first move.
+ *
+ * The block's violation count is the search's initial branching factor, so a lone
+ * violation starts a near-chain that can be followed far while a wide block cannot.
+ * Bodies too large for repeated detection are skipped outright, and `SEARCH_BUDGET`
+ * caps total detections whatever the shape — a block whose ordering cannot be settled
+ * inside the budget is reported without a fix.
+ */
+const SEARCH_DEPTH_CHAIN = 16;
+const SEARCH_DEPTH_BRANCHING = 6;
+const SEARCH_MAX_VIOLATIONS = 12;
+const SEARCH_MAX_STATEMENTS = 120;
+const SEARCH_BUDGET = 400;
+function searchDepthFor(violationCount, statementCount) {
+    if (statementCount > SEARCH_MAX_STATEMENTS) {
+        return 0;
+    }
+    if (violationCount === 1) {
+        return SEARCH_DEPTH_CHAIN;
+    }
+    if (violationCount <= SEARCH_MAX_VIOLATIONS) {
+        return SEARCH_DEPTH_BRANCHING;
+    }
+    return 0;
+}
+/**
+ * Statement identity is stable across reorderings, so the original indices of an
+ * order identify it uniquely and cheaply — which is what lets the search skip orders
+ * reachable by more than one sequence of moves.
+ */
+function orderKey(order, indices) {
+    return order.map((statement) => indices.get(statement)).join(',');
+}
+/**
+ * Shortest sequence of moves reaching an order with **zero** violations, or null when
+ * the search bounds contain no such order.
+ *
+ * Breadth-first for two reasons: the emitted fix is then the smallest reordering that
+ * satisfies every constraint, and a block whose single named move already suffices
+ * yields exactly that move.
+ *
+ * Violation count is not used to prune: an order that trades one violation for two
+ * can still be the only route to a clean order, so the frontier is bounded by move
+ * count and detection budget rather than by any notion of progress. Only the
+ * zero-violation goal test decides whether a fix is emitted at all.
+ */
+function findResolvingMoves(sourceCode, body, violations, maxMoves) {
+    if (maxMoves === 0) {
+        return null;
+    }
+    const indices = new Map(body.map((statement, index) => [statement, index]));
+    const seen = new Set([orderKey(body, indices)]);
+    const queue = [{ order: body, violations, moves: [] }];
+    let budget = SEARCH_BUDGET;
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (node.moves.length >= maxMoves) {
+            continue;
+        }
+        const candidates = Math.min(node.violations.length, MAX_FIX_CANDIDATES);
+        for (let candidate = 0; candidate < candidates; candidate += 1) {
+            if (budget <= 0) {
+                return null;
+            }
+            const { fromIndex, toIndex } = node.violations[candidate];
+            const order = applyMove(node.order, fromIndex, toIndex);
+            const key = orderKey(order, indices);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            budget -= 1;
+            const next = detectViolations(sourceCode, order);
+            const moves = [...node.moves, { fromIndex, toIndex }];
+            if (next.length === 0) {
+                return moves;
+            }
+            queue.push({ order, violations: next, moves });
+        }
+    }
+    return null;
+}
+/**
+ * Statement `i` owns the text from its own leading comments and indentation up to
+ * where statement `i + 1`'s begins, so the segments tile the block's statement region
+ * exactly and any reordering is a permutation of them.
+ */
+function collectSegments(body, parent, sourceCode) {
+    const text = sourceCode.getText();
+    const bounds = body.map((statement) => getStartWithComments(statement, sourceCode));
+    bounds.push(getNextStart(body, body.length - 1, parent, sourceCode));
+    return {
+        bounds,
+        segments: body.map((_, index) => text.slice(bounds[index], bounds[index + 1])),
+    };
+}
+/**
+ * Trailing spaces and tabs are dropped as a segment moves: that whitespace is the
+ * indentation of whatever used to follow the segment, not part of the segment itself.
+ * Keeping it would double the indentation at the segment's destination.
+ */
+function moveSegment(segments, fromIndex, toIndex) {
+    const next = [...segments];
+    const [moved] = next.splice(fromIndex, 1);
+    next.splice(toIndex < fromIndex ? toIndex : toIndex - 1, 0, moved.replace(/[ \t]+$/u, ''));
+    return next;
+}
+/**
+ * Emits an entire reordering as one fix by permuting the block's text segments.
+ *
+ * Only the span that actually changes is replaced. That keeps the fix disjoint from
+ * fixes in nested and sibling blocks — ESLint discards overlapping fixes — and makes
+ * a one-move reordering byte-identical to relocating that one statement.
+ */
+function buildReorderFix(body, moves, parent, sourceCode, fixer) {
+    const { bounds, segments } = collectSegments(body, parent, sourceCode);
+    const reordered = moves.reduce((current, move) => moveSegment(current, move.fromIndex, move.toIndex), segments);
+    let first = 0;
+    while (first < segments.length && reordered[first] === segments[first]) {
+        first += 1;
+    }
+    let last = segments.length - 1;
+    while (last > first && reordered[last] === segments[last]) {
+        last -= 1;
+    }
+    if (first > last) {
+        return null;
+    }
+    return fixer.replaceTextRange([bounds[first], bounds[last + 1]], reordered.slice(first, last + 1).join(''));
+}
+/**
+ * A fix is emitted only for a reordering the detector scores at zero violations, and
+ * the whole reordering ships as a single fix. Relocating one statement per report
+ * satisfies its own adjacency constraint while breaking another's, which under
+ * `--fix` oscillates or exhausts the pass budget (#1405).
+ *
+ * Convergence is structural rather than argued: the emitted order is verified clean
+ * by the same detector that produced the reports, and detection depends only on
+ * statement order, so a single pass settles the block. Blocks with no clean order in
+ * range are reported without a fix — a report the developer resolves beats a fix that
+ * leaves a different violation behind.
+ *
+ * The fix rides on the first report because the reordering resolves every violation
+ * in the block at once; a second fix would be redundant and would overlap this one.
+ */
 function handleBlock(ruleContext, node) {
-    const statements = node.body;
-    handleGuardHoists(ruleContext, statements, node);
-    handleDerivedGrouping(ruleContext, statements, node);
-    handleLateDeclarations(ruleContext, statements, node);
-    handleSideEffects(ruleContext, statements, node);
+    const { context, sourceCode } = ruleContext;
+    const body = node.body;
+    const violations = detectViolations(sourceCode, body);
+    if (violations.length === 0) {
+        return;
+    }
+    const moves = findResolvingMoves(sourceCode, body, violations, searchDepthFor(violations.length, body.length));
+    violations.forEach((violation, index) => {
+        context.report({
+            node: violation.statement,
+            messageId: violation.messageId,
+            data: violation.data,
+            fix: moves && index === 0
+                ? (fixer) => buildReorderFix(body, moves, node, sourceCode, fixer)
+                : null,
+        });
+    });
 }
 exports.logicalTopToBottomGrouping = (0, createRule_1.createRule)({
     name: 'logical-top-to-bottom-grouping',
@@ -1392,7 +1571,6 @@ exports.logicalTopToBottomGrouping = (0, createRule_1.createRule)({
         const ruleContext = {
             context,
             sourceCode,
-            reportedStatements: new WeakSet(),
         };
         const visitBlock = (node) => handleBlock(ruleContext, node);
         return {

package/lib/rules/no-array-length-in-deps.js

@@ -4,6 +4,7 @@ exports.noArrayLengthInDeps = 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");
 // React hooks to check
 const HOOK_NAMES = new Set(['useEffect', 'useCallback', 'useMemo']);
 const DEFAULT_HASH_IMPORT = {
@@ -370,6 +371,15 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
         let importsPlanned = false;
         const perBlockDeclaredBases = new WeakMap();
         const perBlockBaseToVar = new WeakMap();
+        /**
+         * `useMemo` and the hash helper are imported by a single violation's fix,
+         * making that violation the file's import carrier. ESLint builds fixes
+         * before it applies inline disable directives, so a suppressed carrier
+         * takes both imports down with it while the surviving violations still
+         * emit `useMemo(() => stableHash(...))` — two unbound identifiers that no
+         * number of `--fix` passes can repair.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         return {
             CallExpression(node) {
                 if (!isHookCall(node))
@@ -404,7 +414,10 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                 const dependencies = lengthDeps
                     .map(({ element }) => sourceCode.getText(element))
                     .join(', ');
-                // Report once on the dependency array
+                // Report once on the dependency array. The report is emitted even when
+                // suppressed: ESLint discards it, and reporting keeps the user's
+                // disable directive "used" so `--report-unused-disable-directives`
+                // does not flag it.
                 context.report({
                     node: depsArg,
                     messageId: 'noArrayLengthInDeps',
@@ -412,6 +425,15 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         dependencies,
                     },
                     fix(fixer) {
+                        // A suppressed report is dropped together with its fix. Declining
+                        // to fix — and leaving the imports and the per-block declarations
+                        // unclaimed — passes the carrier slot to the first violation that
+                        // actually survives. Checked against the reported node so the
+                        // resolution matches ESLint's own, and before every other bail so
+                        // no shared state is touched.
+                        if (isReportSuppressed(depsArg)) {
+                            return null;
+                        }
                         // All bail checks precede any shared-state mutation so a skipped
                         // fix cannot make a later fix believe imports or declarations are
                         // already handled.

package/lib/rules/prefer-fragment-component.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferFragmentComponent = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 exports.preferFragmentComponent = (0, createRule_1.createRule)({
     name: 'prefer-fragment-component',
     meta: {
@@ -21,6 +22,13 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const sourceCode = context.sourceCode;
+        // The `import { Fragment } from 'react'` edit rides on one violation's fix,
+        // making that violation the file's import carrier. ESLint builds fixes
+        // eagerly and drops inline-disabled reports afterwards, so a suppressed
+        // carrier would take the import down with it while the surviving
+        // violations still emit <Fragment>. Resolving suppression before the latch
+        // is read hands the carrier slot to the first violation that survives.
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         let hasFragmentImport = false;
         let reactImportNode = null;
         let defaultReactImportNode = null;
@@ -90,6 +98,29 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                 }
             }
         }
+        /**
+         * Where a brand-new import statement can be spliced in without changing
+         * what the file's directives govern. A whole-line insertion directly before
+         * the first statement slides in between an `eslint-disable-next-line`
+         * comment and the line it applies to, silently retargeting that directive
+         * at the import. Anchoring above such comments keeps every directive
+         * pointed at the code its author aimed it at.
+         */
+        function findImportAnchor() {
+            const firstStatement = sourceCode.ast.body[0];
+            let anchor = firstStatement;
+            const leadingComments = sourceCode.getCommentsBefore(firstStatement);
+            for (let index = leadingComments.length - 1; index >= 0; index--) {
+                const comment = leadingComments[index];
+                const [directive] = (0, disableDirectives_1.parseDisableDirectives)([comment]);
+                if (directive?.kind !== 'disable-next-line' ||
+                    comment.loc.end.line + 1 !== anchor.loc.start.line) {
+                    break;
+                }
+                anchor = comment;
+            }
+            return anchor;
+        }
         /**
          * Adds Fragment import to an appropriate React import or creates a new one
          */
@@ -116,7 +147,7 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
             // No React import found, create a new one
             const importText = "import { Fragment } from 'react';\n";
             const indentation = sourceCode.text.match(/^[ \t]*/m)?.[0] || '';
-            return fixer.insertTextBefore(sourceCode.ast.body[0], indentation + importText);
+            return fixer.insertTextBefore(findImportAnchor(), indentation + importText);
         }
         return {
             ImportDeclaration: checkFragmentImport,
@@ -149,6 +180,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         messageId: 'preferFragment',
                         data: { type: 'shorthand fragment (<>)' },
                         fix(fixer) {
+                            // A suppressed report is discarded together with its fix, so it
+                            // must not claim the import carrier slot.
+                            if (isReportSuppressed(node)) {
+                                return null;
+                            }
                             const fixes = [];
                             // Add Fragment import if needed
                             if (!hasFragmentImport) {
@@ -204,6 +240,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     messageId: 'preferFragment',
                     data: { type: 'shorthand fragment (<>)' },
                     fix(fixer) {
+                        // A suppressed report is discarded together with its fix, so it
+                        // must not claim the import carrier slot.
+                        if (isReportSuppressed(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         // Add Fragment import if needed
                         if (!hasFragmentImport) {
@@ -250,6 +291,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         messageId: 'preferFragment',
                         data: { type: 'React.Fragment' },
                         fix(fixer) {
+                            // A suppressed report is discarded together with its fix, so it
+                            // must not claim the import carrier slot.
+                            if (isReportSuppressed(node.name)) {
+                                return null;
+                            }
                             const fixes = [];
                             // Add Fragment import if needed
                             if (!hasFragmentImport) {
@@ -281,6 +327,11 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     messageId: 'preferFragment',
                     data: { type: 'React.Fragment' },
                     fix(fixer) {
+                        // A suppressed report is discarded together with its fix, so it
+                        // must not claim the import carrier slot.
+                        if (isReportSuppressed(node.name)) {
+                            return null;
+                        }
                         const fixes = [];
                         // Add Fragment import if needed
                         if (!hasFragmentImport) {

package/lib/rules/prefer-type-over-interface.js

@@ -30,19 +30,46 @@ exports.preferTypeOverInterface = (0, createRule_1.createRule)({
                     },
                     fix(fixer) {
                         const sourceCode = context.sourceCode;
-                        const openingBrace = sourceCode.getTokenAfter(node.id, {
-                            filter: (token) => token.value === '{',
-                        });
-                        const fixes = [
-                            fixer.replaceTextRange([node.range[0], node.id.range[1]], `type ${node.id.name} =`),
+                        // The `=` must land after the entire declaration header (the
+                        // name plus any type-parameter list); anchoring on the
+                        // identifier alone emits unparseable `type Name =<T> {`.
+                        const header = node.typeParameters ?? node.id;
+                        const keywordSpan = [
+                            node.range[0],
+                            node.id.range[0],
                         ];
-                        if (node.extends && node.extends.length > 0 && openingBrace) {
-                            const extendsKeyword = sourceCode.getFirstTokenBetween(node.id, openingBrace, { filter: (token) => token.value === 'extends' });
-                            fixes.push(
-                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                            fixer.remove(extendsKeyword), fixer.insertTextBefore(openingBrace, '& '));
+                        // Everything between the header and the opening brace is
+                        // rewritten wholesale rather than patched token by token: the
+                        // heritage list needs `,` turned into `&` and the `extends`
+                        // keyword dropped, and surgical edits leave the separators and
+                        // the keyword's surrounding whitespace behind. The body starts at
+                        // the opening brace, so this span cannot swallow a `{` belonging
+                        // to a heritage type argument or a type-parameter constraint.
+                        const headerSpan = [
+                            header.range[1],
+                            node.body.range[0],
+                        ];
+                        // Both rewritten spans are replaced in full, so a comment sitting
+                        // inside either one would be silently destroyed (and a line
+                        // comment would even swallow the `=` that follows it). Reporting
+                        // without a fix preserves the author's prose; the conversion is
+                        // then made by hand.
+                        const clobbersComment = sourceCode
+                            .getAllComments()
+                            .some((comment) => [keywordSpan, headerSpan].some(([start, end]) => comment.range[0] < end && comment.range[1] > start));
+                        if (clobbersComment) {
+                            return null;
                         }
-                        return fixes;
+                        const heritage = node.extends ?? [];
+                        // `getText` round-trips type arguments and qualified names, so
+                        // `extends ns.B<T>, C` becomes `ns.B<T> & C`.
+                        const intersection = heritage
+                            .map((clause) => sourceCode.getText(clause))
+                            .join(' & ');
+                        return [
+                            fixer.replaceTextRange(keywordSpan, 'type '),
+                            fixer.replaceTextRange(headerSpan, heritage.length > 0 ? ` = ${intersection} & ` : ' = '),
+                        ];
                     },
                 });
             },

package/lib/rules/prefer-usecallback-over-usememo-for-functions.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferUseCallbackOverUseMemoForFunctions = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)({
     name: 'prefer-usecallback-over-usememo-for-functions',
     meta: {
@@ -119,6 +120,14 @@ exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)(
         // knowing every conversion in the file: useMemo may only be dropped from the
         // import when no reference to it survives the fixes.
         const candidates = [];
+        /**
+         * A suppressed report is discarded together with its fix, yet its
+         * `useMemo(...)` call stays in the file. Both halves of the import rewrite
+         * therefore hinge on suppression: the rename must not ride on a violation
+         * that disappears, and it must not retire a specifier a suppressed call
+         * still resolves to.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         return {
             CallExpression(node) {
                 // Check if the call is to useMemo
@@ -149,7 +158,7 @@ exports.preferUseCallbackOverUseMemoForFunctions = (0, createRule_1.createRule)(
                 if (candidates.length === 0) {
                     return;
                 }
-                const plan = planConversion(context, candidates);
+                const plan = planConversion(context, candidates, isReportSuppressed);
                 for (const candidate of candidates) {
                     reportAndFix(candidate.node, context, plan);
                 }
@@ -261,7 +270,7 @@ function removeImportSpecifierFixes(sourceCode, fixer, binding) {
  * Works out which conversions can be autofixed and how the import list must
  * change so the emitted useCallback resolves and useMemo is not left dangling.
  */
-function planConversion(context, candidates) {
+function planConversion(context, candidates, isReportSuppressed) {
     const sourceCode = context.getSourceCode();
     const program = sourceCode.ast;
     const existingUseCallback = findImportedSpecifier(program, 'useCallback');
@@ -270,7 +279,13 @@ function planConversion(context, candidates) {
         : 'useCallback';
     // A local binding of the target name would capture the emitted call, so those
     // conversions are reported without a fix rather than silently miscompiled.
+    // A suppressed violation is skipped for the same reason it is skipped for the
+    // import: ESLint drops its fix, so treating it as unfixable keeps the plan
+    // honest about which useMemo calls actually go away.
     const fixableCandidates = candidates.filter((candidate) => {
+        if (isReportSuppressed(candidate.node)) {
+            return false;
+        }
         const bound = resolveVariable(candidate.scope, calleeName);
         if (!existingUseCallback) {
             return bound === null;
@@ -298,6 +313,10 @@ function planConversion(context, candidates) {
     const convertedReferences = new Set(fixableCandidates
         .filter((candidate) => toImportBinding(resolveVariable(candidate.scope, candidate.node.callee.name))?.variable === useMemoBinding.variable)
         .map((candidate) => candidate.node.callee));
+    // Every reference the fixes do not rewrite still needs the specifier: a plain
+    // value memo, a bare `useMemo` mention, a conversion blocked by shadowing, or
+    // the call behind a disable directive. Any one of them turns the rename into
+    // a plain insertion of useCallback beside useMemo.
     const useMemoSurvives = useMemoBinding.variable.references.some((reference) => !convertedReferences.has(reference.identifier));
     const shouldAdd = existingUseCallback === null;
     const shouldRemove = !useMemoSurvives;
@@ -307,6 +326,8 @@ function planConversion(context, candidates) {
     return {
         calleeName,
         fixable,
+        // The carrier is the first violation whose fix actually survives, so a
+        // suppressed leading violation cannot take the import edit down with it.
         importOwner: fixableCandidates[0].node,
         importFixes: (fixer) => {
             if (shouldAdd && shouldRemove) {