@blumintinc/eslint-plugin-blumint 1.20.24 → 1.20.26

package/lib/rules/no-entire-object-hook-deps.js

@@ -55,6 +55,21 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
         return false;
     }
 }
+function renderPathSegments(baseName, segments) {
+    let path = baseName;
+    for (const segment of segments) {
+        if (segment.computed) {
+            // why: an optional computed access must render as `?.[` — a bare `?`
+            // before `[` parses as a conditional expression, so `state?[0]` is a
+            // syntax error while `state?.[0]` is the valid optional element access.
+            path += segment.optional ? `?.${segment.text}` : segment.text;
+        }
+        else {
+            path += segment.optional ? `?.${segment.text}` : `.${segment.text}`;
+        }
+    }
+    return path;
+}
 function unwrapExpression(expr) {
     let current = expr;
     while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
@@ -67,6 +82,10 @@ function unwrapExpression(expr) {
 }
 function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Map(); // Track usage and its position
+    // why: derived dependency paths (first-optional intermediate, array base)
+    // must be re-rendered from structured links — string surgery on the
+    // rendered path cannot place `?.` markers correctly.
+    const pathSegments = new Map();
     const visited = new Set();
     let needsEntireObject = false;
     let isUsed = false;
@@ -123,23 +142,33 @@ function getObjectUsagesInHook(hookBody, objectName) {
         'includes',
     ]);
     function buildAccessPath(node) {
-        const parts = [];
+        // why: optionality belongs to individual links, not the whole chain.
+        // Rendering from per-link segments keeps `?.` markers at their real
+        // position (a.b?.[0] stays a.b?.[0], not a?.b[0]) and forms the mandatory
+        // `?.[` for optional computed access (state?.[0], never state?[0]).
+        const segments = [];
         let current = node;
-        let hasOptionalChaining = false;
-        // Collect all parts from leaf to root
+        // Collect all links from leaf to root
         while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             const memberExpr = current;
             // Handle computed properties (like array indices)
             if (memberExpr.computed) {
-                // why: only a *literal* computed key (obj[0], obj['special-key'])
-                // narrows to a single, stable field. EVERY other computed key —
-                // Identifier (obj[i]), CallExpression (obj[assertSafe(i)]),
-                // BinaryExpression (obj[i+1]), MemberExpression (obj[keys[j]]),
-                // TSAsExpression (obj[k as K]), TemplateLiteral (obj[`row-${i}`]), etc.
-                // — is a dynamic access that can read arbitrary elements across an
-                // iteration. There is no single narrowable field, so the whole object
-                // is a legitimate dependency: resolve the base and mark it accordingly.
-                if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Literal) {
+                // why: only a *literal* string/number computed key (obj[0],
+                // obj['special-key']) narrows to a single, stable field. EVERY other
+                // computed key — Identifier (obj[i]), CallExpression
+                // (obj[assertSafe(i)]), BinaryExpression (obj[i+1]), MemberExpression
+                // (obj[keys[j]]), TSAsExpression (obj[k as K]), TemplateLiteral
+                // (obj[`row-${i}`]), etc. — is a dynamic access that can read
+                // arbitrary elements across an iteration. Remaining literal kinds
+                // (boolean/null/regex/bigint keys) have no rendering the fixer can
+                // guarantee round-trips, so they decline narrowing too rather than
+                // emit unreliable text. In every declined case the whole object is a
+                // legitimate dependency: resolve the base and mark it accordingly.
+                const literalValue = memberExpr.property.type === utils_1.AST_NODE_TYPES.Literal
+                    ? memberExpr.property.value
+                    : undefined;
+                if (typeof literalValue !== 'number' &&
+                    typeof literalValue !== 'string') {
                     // Check if this is accessing our target object
                     let currentBase = unwrapExpression(memberExpr.object);
                     while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
@@ -147,24 +176,18 @@ function getObjectUsagesInHook(hookBody, objectName) {
                     }
                     if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
                         currentBase.name === objectName) {
-                        // This is a dynamic computed property access on our target object,
-                        // so we need the entire object (no narrowable field exists).
+                        // No narrowable field exists, so the entire object is required.
                         needsEntireObject = true;
                     }
                     return null;
                 }
-                // For computed properties with literals
-                const literalProp = memberExpr.property;
-                if (typeof literalProp.value === 'number') {
-                    parts.unshift(`[${literalProp.value}]`);
-                }
-                else if (typeof literalProp.value === 'string') {
-                    parts.unshift(`[${JSON.stringify(literalProp.value)}]`);
-                }
-                else {
-                    // For other literal computed properties (e.g. boolean/null), wildcard
-                    parts.unshift('[*]');
-                }
+                segments.unshift({
+                    text: typeof literalValue === 'number'
+                        ? `[${literalValue}]`
+                        : `[${JSON.stringify(literalValue)}]`,
+                    computed: true,
+                    optional: memberExpr.optional,
+                });
             }
             else {
                 // Regular property access
@@ -175,57 +198,37 @@ function getObjectUsagesInHook(hookBody, objectName) {
                 if (memberExpr.property.name &&
                     (ARRAY_METHODS.has(memberExpr.property.name) ||
                         STRING_METHODS.has(memberExpr.property.name))) {
-                    // Check if this is accessing our target object or a property of it
-                    let currentBase = unwrapExpression(memberExpr.object);
-                    const pathParts = [];
-                    let hasOptionalChainingInMethod = false;
-                    // Build the path to the array/string being accessed
-                    while (currentBase.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                        const currentMember = currentBase;
-                        if (currentMember.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            pathParts.unshift(currentMember.property.name);
-                        }
-                        if (currentMember.optional) {
-                            hasOptionalChainingInMethod = true;
-                        }
-                        currentBase = unwrapExpression(currentMember.object);
-                    }
-                    if (currentBase.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        currentBase.name === objectName) {
-                        if (pathParts.length === 0) {
-                            // Direct method call on the object (e.g., userData.map(...))
-                            needsEntireObject = true;
-                        }
-                        else {
-                            // Method call on a property (e.g., userData.items.map(...) or userData?.items?.map(...))
-                            let path = objectName + (hasOptionalChainingInMethod ? '?' : '');
-                            path += '.' + pathParts.join('.');
+                    const methodTarget = unwrapExpression(memberExpr.object);
+                    if (methodTarget.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                        // Method call on a property (e.g., userData.items.map(...) or
+                        // userData?.items?.map(...)): depend on that property's own path,
+                        // rendered with the same per-link optional markers as any other
+                        // access.
+                        const path = buildAccessPath(methodTarget);
+                        if (path) {
                             usages.set(path, memberExpr.range?.[0] || 0);
                         }
                     }
+                    else if (methodTarget.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        methodTarget.name === objectName) {
+                        // Direct method call on the object (e.g., userData.map(...))
+                        needsEntireObject = true;
+                    }
                     return null;
                 }
-                parts.unshift(memberExpr.property.name);
-            }
-            if (memberExpr.optional) {
-                hasOptionalChaining = true;
+                segments.unshift({
+                    text: memberExpr.property.name,
+                    computed: false,
+                    optional: memberExpr.optional,
+                });
             }
             current = unwrapExpression(memberExpr.object);
         }
         // Check if we reached the target identifier
         const base = unwrapExpression(current);
         if (base.type === utils_1.AST_NODE_TYPES.Identifier && base.name === objectName) {
-            // Build the path with optional chaining
-            let path = objectName + (hasOptionalChaining ? '?' : '');
-            // Add each part with proper formatting (dot notation or bracket notation)
-            for (const part of parts) {
-                if (part.startsWith('[')) {
-                    path += part; // Already formatted as bracket notation
-                }
-                else {
-                    path += '.' + part; // Dot notation
-                }
-            }
+            const path = renderPathSegments(objectName, segments);
+            pathSegments.set(path, segments);
             return path;
         }
         return null;
@@ -446,29 +449,24 @@ function getObjectUsagesInHook(hookBody, objectName) {
     paths.forEach((path) => {
         // Always include the main path
         finalPaths.add(path);
-        // For optional chaining, include the FIRST optional chaining point as intermediate
-        if (path.includes('?.')) {
-            // Find the first optional chaining point
-            // For userData?.profile.settings.theme.primary, we want to include userData?.profile
-            const firstOptionalIndex = path.indexOf('?.');
-            if (firstOptionalIndex !== -1) {
-                // Find the end of the first property after the optional chaining
-                const afterOptional = path.substring(firstOptionalIndex + 2);
-                const nextDotIndex = afterOptional.indexOf('.');
-                if (nextDotIndex !== -1) {
-                    // There are more properties after the first optional property
-                    const firstOptionalPath = path.substring(0, firstOptionalIndex + 2 + nextDotIndex);
-                    finalPaths.add(firstOptionalPath);
-                }
-            }
+        const segments = pathSegments.get(path);
+        if (!segments) {
+            return;
         }
-        // For array access, include the array property itself
-        if (path.includes('[') && path.includes(']')) {
-            const bracketIndex = path.indexOf('[');
-            if (bracketIndex > 0) {
-                const arrayPath = path.substring(0, bracketIndex);
-                finalPaths.add(arrayPath);
-            }
+        // Include the FIRST optional link as an intermediate dependency when more
+        // links follow it: for userData?.profile.settings.theme.primary we also
+        // want userData?.profile.
+        const firstOptionalIndex = segments.findIndex((segment) => segment.optional);
+        if (firstOptionalIndex !== -1 && firstOptionalIndex < segments.length - 1) {
+            finalPaths.add(renderPathSegments(objectName, segments.slice(0, firstOptionalIndex + 1)));
+        }
+        // For array access, include the array property itself: for
+        // userData.items[0] we also want userData.items. A bracket directly on
+        // the base (state[0], state?.[0]) adds nothing — its "array" is the
+        // entire object dependency this rule exists to narrow away.
+        const firstComputedIndex = segments.findIndex((segment) => segment.computed);
+        if (firstComputedIndex > 0) {
+            finalPaths.add(renderPathSegments(objectName, segments.slice(0, firstComputedIndex)));
         }
     });
     // Convert to array for sorting
@@ -477,9 +475,11 @@ function getObjectUsagesInHook(hookBody, objectName) {
     // Exception: keep array paths with optional chaining as they represent different dependencies
     const filteredPaths = pathsArray.filter((path) => {
         // Skip array paths if we're accessing specific indices, unless it's optional chaining
+        // why: an optional bracket renders as `?.[`, so the specific-index probe
+        // must accept both `base[0]` and `base?.[0]` shapes.
         const isArrayWithSpecificIndices = pathsArray.some((otherPath) => otherPath !== path &&
             (otherPath.startsWith(path + '[') ||
-                otherPath.match(new RegExp(`^${path.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\[\\d+\\]`))));
+                otherPath.startsWith(path + '?.[')));
         // Keep array paths with optional chaining even if specific indices are accessed
         if (isArrayWithSpecificIndices && path.includes('?.')) {
             return true;

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-map-over-conditional-dispatch.js

@@ -50,6 +50,18 @@ const FUNCTION_TYPES = new Set([
     utils_1.AST_NODE_TYPES.FunctionExpression,
     utils_1.AST_NODE_TYPES.FunctionDeclaration,
 ]);
+/**
+ * Function/constructor/conditional type notation must be parenthesized to
+ * appear as a `|` union member, or the emitted annotation does not parse
+ * ("Function type notation must be parenthesized when used in a union type").
+ * Over-wrapping is harmless — a parenthesized type is valid in any type
+ * position — so this tests the printed text conservatively instead of
+ * re-deriving the printer's precedence rules.
+ */
+function parenthesizeForUnion(text) {
+    const needsParens = text.includes('=>') || /^new\b/.test(text) || /\bextends\b/.test(text);
+    return needsParens ? `(${text})` : text;
+}
 exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
     name: 'prefer-map-over-conditional-dispatch',
     meta: {
@@ -194,7 +206,13 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                     parts.push(text);
                 }
             }
-            return parts.length > 0 ? parts.join(' | ') : null;
+            if (parts.length === 0) {
+                return null;
+            }
+            if (parts.length === 1) {
+                return parts[0];
+            }
+            return parts.map(parenthesizeForUnion).join(' | ');
         }
         function discriminantTypeText(type, discriminant) {
             try {
@@ -209,6 +227,94 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 return null;
             }
         }
+        /**
+         * `checker.typeToString()` prints a symbol's bare name with no regard for
+         * whether that name resolves at the fix site (an unimported helper type
+         * prints the same as an imported one), and exotic printer output can be
+         * invalid in an annotation position. Shipping such an annotation breaks
+         * the build, so the fix is gated on the synthesized text (a) parsing
+         * standalone and (b) referencing only names in scope where the Record is
+         * inserted. Failing the gate downgrades to the report-only path — the
+         * plugin prefers a skipped fix over one that does not compile.
+         */
+        function validateAnnotation(annotationText, fixSite) {
+            const sourceFile = ts.createSourceFile('__annotation__.ts', `type __T = ${annotationText};`, ts.ScriptTarget.Latest, true);
+            // parseDiagnostics is absent from the public SourceFile type but always
+            // populated at runtime; a diagnostic here means the annotation cannot
+            // ship (e.g. printer truncation, or an unparenthesized member shape the
+            // union-wrapping heuristic does not recognize).
+            const parseDiagnostics = sourceFile.parseDiagnostics;
+            if (!parseDiagnostics || parseDiagnostics.length > 0) {
+                return 'unparseable';
+            }
+            const typeReferenceRoots = new Set();
+            const typeQueryRoots = new Set();
+            let hasImportType = false;
+            const rootNameOf = (name) => {
+                let current = name;
+                while (ts.isQualifiedName(current)) {
+                    current = current.left;
+                }
+                return current.text;
+            };
+            const collect = (node) => {
+                if (ts.isTypeReferenceNode(node)) {
+                    typeReferenceRoots.add(rootNameOf(node.typeName));
+                }
+                else if (ts.isTypeQueryNode(node)) {
+                    typeQueryRoots.add(rootNameOf(node.exprName));
+                }
+                else if (ts.isImportTypeNode(node)) {
+                    // `import("...").T` paths printed by the checker are absolute or
+                    // resolver-relative — never portable source text.
+                    hasImportType = true;
+                }
+                ts.forEachChild(node, collect);
+            };
+            collect(sourceFile);
+            if (hasImportType) {
+                return 'unresolvable';
+            }
+            // `Record` is the wrapper this rule itself emits — a TS lib global that
+            // is present in any real project. The isolated single-file program a
+            // RuleTester builds loads no lib files at all, so requiring it in scope
+            // would falsely downgrade every fix under test.
+            typeReferenceRoots.delete('Record');
+            if (typeReferenceRoots.size === 0 && typeQueryRoots.size === 0) {
+                return 'ok';
+            }
+            const tsFixSite = esTreeNodeToTSNodeMap.get(fixSite);
+            if (!tsFixSite) {
+                return 'unresolvable';
+            }
+            try {
+                const namesInScope = (meaning) => new Set(checker
+                    .getSymbolsInScope(tsFixSite, meaning)
+                    .map((symbol) => symbol.name));
+                if (typeReferenceRoots.size > 0) {
+                    const typeNames = namesInScope(ts.SymbolFlags.Type |
+                        ts.SymbolFlags.Namespace |
+                        ts.SymbolFlags.Alias);
+                    for (const root of typeReferenceRoots) {
+                        if (!typeNames.has(root)) {
+                            return 'unresolvable';
+                        }
+                    }
+                }
+                if (typeQueryRoots.size > 0) {
+                    const valueNames = namesInScope(ts.SymbolFlags.Value | ts.SymbolFlags.Alias);
+                    for (const root of typeQueryRoots) {
+                        if (!valueNames.has(root)) {
+                            return 'unresolvable';
+                        }
+                    }
+                }
+            }
+            catch {
+                return 'unresolvable';
+            }
+            return 'ok';
+        }
         // ---- AST helpers --------------------------------------------------------
         /** Whether a discriminant expression is an identifier or a call-free,
          * non-optional member chain (safe to collapse repeated evaluations). */
@@ -500,6 +606,19 @@ exports.preferMapOverConditionalDispatch = (0, createRule_1.createRule)({
                 });
                 return;
             }
+            const verdict = validateAnnotation(`Record<${dText}, ${vText}>`, discriminantOf(node));
+            if (verdict !== 'ok') {
+                context.report({
+                    node,
+                    messageId: 'preferMapManual',
+                    data: {
+                        reason: verdict === 'unparseable'
+                            ? 'the branch value type does not print as a parseable annotation — write the Record with an explicit type manually'
+                            : 'the annotation would name types that are not in scope at the fix site — import them or write the Record manually',
+                    },
+                });
+                return;
+            }
             context.report({
                 node,
                 messageId: 'preferMap',

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) {