@blumintinc/eslint-plugin-blumint 1.20.30 → 1.20.31

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

@@ -3,7 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferFragmentComponent = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
+const REACT_MODULE = 'react';
+const FRAGMENT_NAME = 'Fragment';
+/**
+ * Value `react` import declarations in source order. A type-only declaration
+ * (`import type { FC } from 'react'`) is excluded because a specifier appended
+ * to one erases at compile time, leaving the rewritten <Fragment> unbound at
+ * runtime.
+ */
+function reactValueImports(program) {
+    return program.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+        statement.source.value === REACT_MODULE &&
+        statement.importKind !== 'type');
+}
+/**
+ * A named specifier that binds `Fragment` under its own name — the only shape
+ * that makes a bare <Fragment> element resolve to react's Fragment. An alias
+ * (`import { Fragment as Frag }`) leaves the name free, and a type-only
+ * specifier binds nothing at runtime.
+ */
+function isFragmentSpecifier(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.name === FRAGMENT_NAME &&
+        specifier.local.name === FRAGMENT_NAME);
+}
+/**
+ * Import state is read off `Program.body` at fix time rather than from a
+ * traversal flag: a fragment that precedes the import declaration in source
+ * order is fixed before the `ImportDeclaration` visitor has run, so a flag
+ * would call the import missing and insert a duplicate.
+ */
+function importsFragment(program) {
+    return reactValueImports(program).some((declaration) => declaration.specifiers.some(isFragmentSpecifier));
+}
+/**
+ * Whether every declaration of a visible `Fragment` binding is react's Fragment
+ * import. A const/let/function/class, a parameter, a namespace or default
+ * import, an alias, or a named import from another module all mean the
+ * rewritten <Fragment> renders something other than react's Fragment.
+ */
+function bindsReactFragment(variable) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isFragmentSpecifier(specifier)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                declaration.source.value === REACT_MODULE);
+        }));
+}
 exports.preferFragmentComponent = (0, createRule_1.createRule)({
     name: 'prefer-fragment-component',
     meta: {
@@ -29,11 +83,34 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
         // 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;
+        // One pass rewrites several fragments but must insert the import once. The
+        // AST does not change mid-pass, so the latch records only what an earlier
+        // fix in this same pass already scheduled; existing imports are read from
+        // the AST instead.
+        let importScheduled = false;
         // Track nodes we've already reported to avoid duplicates
         const reportedNodes = new Set();
+        /**
+         * Whether a bare <Fragment> emitted at `node` would resolve to react's
+         * Fragment. Any other visible binding of the name breaks the edit two ways:
+         * the inserted import collides with the existing declaration (TS2440, or
+         * TS2300 when that declaration is itself an import), and a narrower-scope
+         * shadow captures the emitted element with no compile error at all.
+         * Resolving through the scope chain from the reported element covers both,
+         * and keeps `React.Fragment` — a member access on the default import, not a
+         * `Fragment` binding — off the collision path.
+         */
+        function resolvesToReactFragment(node) {
+            const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), FRAGMENT_NAME);
+            return !existing || bindsReactFragment(existing);
+        }
+        /**
+         * True once the file binds react's Fragment, counting an insertion an
+         * earlier fix in this pass already scheduled.
+         */
+        function fragmentImportPresent() {
+            return importScheduled || importsFragment(sourceCode.ast);
+        }
         /**
          * Checks if a node is a React.Fragment element
          */
@@ -74,30 +151,6 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
             }
             return null;
         }
-        /**
-         * Checks for Fragment import from react
-         */
-        function checkFragmentImport(node) {
-            if (node.source.value === 'react') {
-                // Keep track of all React imports
-                if (!reactImportNode) {
-                    reactImportNode = node;
-                }
-                // Keep track of default import for prioritization
-                const hasDefaultImport = node.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
-                if (hasDefaultImport) {
-                    defaultReactImportNode = node;
-                }
-                // Check if Fragment is already imported
-                for (const specifier of node.specifiers) {
-                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        specifier.imported.name === 'Fragment') {
-                        hasFragmentImport = true;
-                        break;
-                    }
-                }
-            }
-        }
         /**
          * Where a brand-new import statement can be spliced in without changing
          * what the file's directives govern. A whole-line insertion directly before
@@ -122,35 +175,42 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
             return anchor;
         }
         /**
-         * Adds Fragment import to an appropriate React import or creates a new one
+         * Adds Fragment to an existing react import or creates a new one. The
+         * emitted shape is a value named specifier, since the rewritten element
+         * references `Fragment` at runtime. Declarations come from `Program.body`
+         * at fix time so the choice does not depend on how far traversal has
+         * progressed.
          */
         function addFragmentImport(fixer) {
-            // Use default import if available, otherwise use first React import
-            const targetImportNode = defaultReactImportNode || reactImportNode;
+            const declarations = reactValueImports(sourceCode.ast);
+            // A declaration carrying the default import keeps `React` and `Fragment`
+            // on one line; otherwise the first declaration that can host a specifier
+            // wins. A bare `import 'react';` hosts none, so it falls through.
+            const targetImportNode = declarations.find((declaration) => declaration.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier)) ??
+                declarations.find((declaration) => declaration.specifiers.length > 0);
             if (targetImportNode) {
-                // Check if it's a namespace import
+                // `import * as React, { Fragment }` is a syntax error, so a namespace
+                // import gets its own declaration beside it.
                 const hasNamespaceImport = targetImportNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
                 if (hasNamespaceImport) {
-                    // Add separate import for Fragment
-                    return fixer.insertTextAfter(targetImportNode, "\nimport { Fragment } from 'react';");
+                    return fixer.insertTextAfter(targetImportNode, `\nimport { ${FRAGMENT_NAME} } from '${REACT_MODULE}';`);
                 }
                 // Add Fragment to existing React import
                 const lastSpecifier = targetImportNode.specifiers[targetImportNode.specifiers.length - 1];
                 const hasNamedImports = targetImportNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
                 if (hasNamedImports) {
-                    return fixer.insertTextAfter(lastSpecifier, ', Fragment');
+                    return fixer.insertTextAfter(lastSpecifier, `, ${FRAGMENT_NAME}`);
                 }
                 else {
-                    return fixer.insertTextAfter(lastSpecifier, ', { Fragment }');
+                    return fixer.insertTextAfter(lastSpecifier, `, { ${FRAGMENT_NAME} }`);
                 }
             }
             // No React import found, create a new one
-            const importText = "import { Fragment } from 'react';\n";
+            const importText = `import { ${FRAGMENT_NAME} } from '${REACT_MODULE}';\n`;
             const indentation = sourceCode.text.match(/^[ \t]*/m)?.[0] || '';
             return fixer.insertTextBefore(findImportAnchor(), indentation + importText);
         }
         return {
-            ImportDeclaration: checkFragmentImport,
             // Find JSX Fragment shorthand (<></>)
             JSXFragment(node) {
                 // Skip if already reported
@@ -185,11 +245,18 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             if (isReportSuppressed(node)) {
                                 return null;
                             }
+                            // Both tags are rewritten to the same bare name, so resolving at
+                            // the inner fragment — the deeper of the two scopes — covers the
+                            // outer one too. Every bail precedes the latch so a withheld edit
+                            // cannot make a later fix believe the import is handled.
+                            if (!resolvesToReactFragment(node)) {
+                                return null;
+                            }
                             const fixes = [];
                             // Add Fragment import if needed
-                            if (!hasFragmentImport) {
+                            if (!fragmentImportPresent()) {
                                 fixes.push(addFragmentImport(fixer));
-                                hasFragmentImport = true;
+                                importScheduled = true;
                             }
                             // Fix the outer React.Fragment
                             const outerOpeningElement = reactFragmentParent.openingElement;
@@ -245,11 +312,16 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         if (isReportSuppressed(node)) {
                             return null;
                         }
+                        // Every bail precedes the latch so a withheld edit cannot make a
+                        // later fix believe the import is already handled.
+                        if (!resolvesToReactFragment(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         // Add Fragment import if needed
-                        if (!hasFragmentImport) {
+                        if (!fragmentImportPresent()) {
                             fixes.push(addFragmentImport(fixer));
-                            hasFragmentImport = true;
+                            importScheduled = true;
                         }
                         // Replace fragment tags
                         const openingText = sourceCode.getText(node.openingFragment);
@@ -296,11 +368,16 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                             if (isReportSuppressed(node.name)) {
                                 return null;
                             }
+                            // Every bail precedes the latch so a withheld edit cannot make a
+                            // later fix believe the import is already handled.
+                            if (!resolvesToReactFragment(node)) {
+                                return null;
+                            }
                             const fixes = [];
                             // Add Fragment import if needed
-                            if (!hasFragmentImport) {
+                            if (!fragmentImportPresent()) {
                                 fixes.push(addFragmentImport(fixer));
-                                hasFragmentImport = true;
+                                importScheduled = true;
                             }
                             // Replace opening tag
                             const openingText = sourceCode.getText(node);
@@ -332,11 +409,16 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                         if (isReportSuppressed(node.name)) {
                             return null;
                         }
+                        // Every bail precedes the latch so a withheld edit cannot make a
+                        // later fix believe the import is already handled.
+                        if (!resolvesToReactFragment(node)) {
+                            return null;
+                        }
                         const fixes = [];
                         // Add Fragment import if needed
-                        if (!hasFragmentImport) {
+                        if (!fragmentImportPresent()) {
                             fixes.push(addFragmentImport(fixer));
-                            hasFragmentImport = true;
+                            importScheduled = true;
                         }
                         // Replace opening tag
                         const openingText = sourceCode.getText(node);
@@ -352,34 +434,6 @@ exports.preferFragmentComponent = (0, createRule_1.createRule)({
                     },
                 });
             },
-            'Program:exit'() {
-                // Find appropriate React import for adding Fragment
-                if (!hasFragmentImport) {
-                    // Get all React imports
-                    const reactImports = [];
-                    for (const node of sourceCode.ast.body) {
-                        if (node.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
-                            node.source.value === 'react') {
-                            reactImports.push(node);
-                        }
-                    }
-                    // Prioritize default import for adding Fragment
-                    if (reactImports.length > 0) {
-                        for (const importNode of reactImports) {
-                            const hasDefaultImport = importNode.specifiers.some((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
-                            if (hasDefaultImport) {
-                                defaultReactImportNode = importNode;
-                                reactImportNode = importNode;
-                                break;
-                            }
-                        }
-                        // If no default import found, use the first import
-                        if (!defaultReactImportNode && reactImports.length > 0) {
-                            reactImportNode = reactImports[0];
-                        }
-                    }
-                }
-            },
         };
     },
 });

package/lib/rules/require-memo.js

@@ -55,10 +55,81 @@ const isUnmemoizedExportedFunctionComponent = (parentNode, node) => {
         startsWithUppercase(node.id.name) &&
         !isComponentExplicitlyUnmemoized(node.id.name));
 };
+const MEMO_NAME = 'memo';
 function isMemoImport(importPath) {
     // Match both absolute and relative paths ending with util/memo
     return /(?:^|\/|\\)util\/memo$/.test(importPath);
 }
+/**
+ * Value `util/memo` import declarations in source order. A type-only
+ * declaration (`import type { MemoOptions } from '../util/memo'`) is excluded
+ * because a specifier appended to one erases at compile time, leaving the
+ * emitted `memo(...)` call unbound at runtime.
+ */
+function memoValueImports(program) {
+    return program.body.filter((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+        statement.importKind !== 'type' &&
+        isMemoImport(statement.source.value));
+}
+/**
+ * A named specifier that binds `memo` under its own name — the only shape that
+ * makes the emitted `memo(...)` call reach the helper. An alias in either
+ * direction (`memo as m`, `createMemo as memo`) or a type-only specifier binds
+ * something else, or nothing at all, at runtime.
+ */
+function isMemoSpecifier(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.name === MEMO_NAME &&
+        specifier.local.name === MEMO_NAME);
+}
+/**
+ * Import state is read off `Program.body` at fix time rather than from a
+ * traversal flag: a component that precedes the import declaration in source
+ * order is fixed before an `ImportDeclaration` visitor would have run, so a
+ * flag would call the import missing and insert a duplicate.
+ */
+function importsMemo(program) {
+    return memoValueImports(program).some((declaration) => declaration.specifiers.some(isMemoSpecifier));
+}
+/**
+ * Whether every declaration of a visible `memo` binding is the helper import.
+ * A const/let/function/class, a parameter, a namespace or default import, an
+ * alias, or a named import from another module all mean the emitted `memo(...)`
+ * call would resolve somewhere other than the helper.
+ */
+function bindsMemoHelper(variable) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isMemoSpecifier(specifier)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                isMemoImport(declaration.source.value));
+        }));
+}
+/**
+ * Extends an existing value `util/memo` import with a `memo` specifier instead
+ * of adding a second declaration. A namespace-only or side-effect-only
+ * declaration has nowhere to put a named specifier, so those fall through to a
+ * separate declaration (null).
+ */
+function buildImportExtensionFix(fixer, program) {
+    for (const declaration of memoValueImports(program)) {
+        const named = declaration.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier);
+        if (named.length > 0) {
+            return fixer.insertTextAfter(named[named.length - 1], `, ${MEMO_NAME}`);
+        }
+        const defaultSpecifier = declaration.specifiers.find((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier);
+        if (defaultSpecifier) {
+            return fixer.insertTextAfter(defaultSpecifier, `, { ${MEMO_NAME} }`);
+        }
+    }
+    return null;
+}
 function checkFunction(context, node) {
     const fileName = context.getFilename();
     if (!fileName.endsWith('.tsx')) {
@@ -96,33 +167,37 @@ function checkFunction(context, node) {
                             return null;
                         }
                         const sourceCode = context.sourceCode;
-                        let importFix = null;
-                        // Search for memo import statement
-                        const importDeclarations = sourceCode.ast.body.filter((node) => node.type === 'ImportDeclaration');
-                        const memoImport = importDeclarations.find((importDeclaration) => isMemoImport(importDeclaration.source.value));
-                        if (memoImport) {
-                            // Check if memo is already imported
-                            if (!memoImport.specifiers.some((specifier) => specifier.local.name === 'memo')) {
-                                // Add memo to existing import statement
-                                const lastSpecifier = memoImport.specifiers[memoImport.specifiers.length - 1];
-                                importFix = fixer.insertTextAfter(lastSpecifier, ', memo');
-                            }
+                        const program = sourceCode.ast;
+                        // Resolve `memo` through the scope chain at the fixed node. A
+                        // binding that is not the helper import breaks the edit two
+                        // ways: the inserted import collides with the existing
+                        // declaration (TS2440, or TS2300 when that declaration is
+                        // itself an import), and a binding visible at the fix site
+                        // captures the emitted call with no compile error at all.
+                        // Declining leaves the report standing so the author resolves
+                        // the clash deliberately. `React.memo` is a member access on
+                        // the default import rather than a `memo` binding, so it never
+                        // reaches this path.
+                        const existingMemo = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMO_NAME);
+                        if (existingMemo && !bindsMemoHelper(existingMemo)) {
+                            return null;
                         }
-                        else {
-                            // Calculate relative path based on current file location
-                            const currentFilePath = context.getFilename();
-                            const importPath = calculateImportPath(currentFilePath);
-                            // Find the first import statement to insert after
-                            const firstImport = importDeclarations[0];
-                            // Add new import statement for memo
-                            const importStatement = `import { memo } from '${importPath}';\n`;
-                            if (firstImport) {
-                                // Insert after the first import with a single newline
-                                importFix = fixer.insertTextAfter(firstImport, '\n' + importStatement.trim());
-                            }
-                            else {
-                                // Insert at the start of the file
-                                importFix = fixer.insertTextBeforeRange([sourceCode.ast.range[0], sourceCode.ast.range[0]], importStatement.trim() + '\n');
+                        let importFix = null;
+                        if (!importsMemo(program)) {
+                            importFix = buildImportExtensionFix(fixer, program);
+                            if (!importFix) {
+                                // Calculate relative path based on current file location
+                                const currentFilePath = context.getFilename();
+                                const importPath = calculateImportPath(currentFilePath);
+                                // Find the first import statement to insert after
+                                const firstImport = program.body.find((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration);
+                                // Add new import statement for memo
+                                const importStatement = `import { memo } from '${importPath}';`;
+                                importFix = firstImport
+                                    ? // Insert after the first import with a single newline
+                                        fixer.insertTextAfter(firstImport, '\n' + importStatement)
+                                    : // Insert at the start of the file
+                                        fixer.insertTextBeforeRange([program.range[0], program.range[0]], importStatement + '\n');
                             }
                         }
                         const functionKeywordRange = [

package/lib/rules/use-latest-callback.js

@@ -3,6 +3,47 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLatestCallback = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
+/**
+ * A specifier that binds the hook itself as a value. The module's sole export
+ * is the hook, so a default specifier binds it under any local name. A
+ * namespace specifier binds the module object rather than a callable, and a
+ * type-only specifier erases at compile time, so neither can carry the call.
+ */
+const bindsLatestCallback = (specifier) => {
+    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
+        return true;
+    }
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        specifier.imported.name === LATEST_CALLBACK_HOOK);
+};
+/**
+ * The hook's import read off `Program.body` rather than off a flag set by an
+ * ImportDeclaration visitor, so the answer holds wherever the import sits
+ * relative to the fix site. Reading the AST also exposes the shapes a
+ * name-only flag conflates with a usable binding: a namespace import, a
+ * type-only import, and a reverse alias
+ * (`import { other as useLatestCallback }`) each bind a name without binding
+ * the hook.
+ */
+const findLatestCallbackImport = (program) => {
+    for (const statement of program.body) {
+        if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration ||
+            statement.source.value !== LATEST_CALLBACK_MODULE ||
+            (statement.importKind && statement.importKind !== 'value')) {
+            continue;
+        }
+        const specifier = statement.specifiers.find(bindsLatestCallback);
+        if (specifier) {
+            return { specifier, reference: specifier.local.name };
+        }
+    }
+    return null;
+};
 exports.useLatestCallback = (0, createRule_1.createRule)({
     name: 'use-latest-callback',
     meta: {
@@ -23,9 +64,6 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
         if (filename.includes('/node_modules/')) {
             return {};
         }
-        // Track if the file already has a useLatestCallback import
-        let hasUseLatestCallbackImport = false;
-        let useLatestCallbackImportName = 'useLatestCallback';
         const useCallbackLocalNames = new Set();
         const reactNamespaceNames = new Set();
         const reactDefaultLikeNames = new Set();
@@ -77,31 +115,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
             ImportDeclaration(node) {
                 if (node.importKind && node.importKind !== 'value')
                     return;
-                if (node.source.value === 'use-latest-callback') {
-                    // Check if useLatestCallback is imported
-                    const specifiers = node.specifiers.filter((specifier) => {
-                        if (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-                            return (specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                specifier.imported.name === 'useLatestCallback');
-                        }
-                        return (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
-                            specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
-                    });
-                    if (specifiers.length > 0) {
-                        hasUseLatestCallbackImport = true;
-                        // Get the local name of the import (in case it's renamed)
-                        if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
-                            useLatestCallbackImportName = specifiers[0].local.name;
-                        }
-                        else if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier) {
-                            useLatestCallbackImportName = specifiers[0].local.name;
-                        }
-                        else if (specifiers[0].type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-                            useLatestCallbackImportName = `${specifiers[0].local.name}.useLatestCallback`;
-                        }
-                    }
-                }
-                else if (node.source.value === 'react') {
+                if (node.source.value === 'react') {
                     // Check if useCallback is imported from React
                     const useCallbackSpecifiers = node.specifiers.filter((specifier) => {
                         return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
@@ -171,6 +185,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                             callee: node.callee.type === utils_1.AST_NODE_TYPES.Identifier
                                 ? node.callee
                                 : null,
+                            scope: ASTHelpers_1.ASTHelpers.getScope(context, node),
                         });
                     }
                 }
@@ -226,23 +241,47 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         scope.variables.forEach((variable) => taken.add(variable.name));
                         scope.childScopes.forEach(collectNames);
                     };
-                    collectNames(context.getScope());
-                    let name = 'useLatestCallback';
+                    collectNames(ASTHelpers_1.ASTHelpers.getScope(context, program));
+                    let name = LATEST_CALLBACK_HOOK;
                     let suffix = 2;
                     while (taken.has(name)) {
-                        name = `useLatestCallback${suffix++}`;
+                        name = `${LATEST_CALLBACK_HOOK}${suffix++}`;
                     }
                     return name;
                 };
+                const latestCallbackImport = findLatestCallbackImport(program);
                 const useCallbackLocalName = specifiers[0]?.local.name ?? 'useCallback';
-                const recommendedHook = hasUseLatestCallbackImport
-                    ? useLatestCallbackImportName
+                const recommendedHook = latestCallbackImport
+                    ? latestCallbackImport.reference
                     : hasSurvivingReference
                         ? freeImportName()
                         : useCallbackLocalName === 'useCallback'
-                            ? 'useLatestCallback'
+                            ? LATEST_CALLBACK_HOOK
                             : useCallbackLocalName;
-                const importText = `import ${recommendedHook} from 'use-latest-callback';`;
+                const importText = `import ${recommendedHook} from '${LATEST_CALLBACK_MODULE}';`;
+                // The react specifiers this fix deletes stop binding their names, so a
+                // name that comes only from them is free for the rewritten calls to
+                // claim — that is how an aliased `useCallback as uc` hands `uc` over to
+                // the new import.
+                const releasedSpecifiers = hasSurvivingReference || specifiers.length === 0 ? [] : specifiers;
+                const claimableDefinitions = new Set(releasedSpecifiers);
+                if (latestCallbackImport) {
+                    claimableDefinitions.add(latestCallbackImport.specifier);
+                }
+                // Whether the rewritten call reaches the hook rather than an unrelated
+                // binding of the same name. Resolving through the scope chain at each
+                // rewritten call catches both failure modes: a module-scope binding
+                // that the inserted import would redeclare (TS2440, or TS2300 against
+                // another import), and a narrower shadow that silently captures the
+                // call with no diagnostic at all.
+                const reachesHook = (conversion) => {
+                    const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(conversion.scope, recommendedHook);
+                    if (!existing) {
+                        return true;
+                    }
+                    return (existing.defs.length > 0 &&
+                        existing.defs.every((def) => claimableDefinitions.has(def.node)));
+                };
                 // The react import statement participates in the change set only when
                 // it binds useCallback or anchors a React.useCallback member call.
                 const touchesImport = specifiers.length > 0 || hasReactMemberUseCallback;
@@ -253,7 +292,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     // A surviving reference (or a member-only file) leaves the react
                     // import untouched; only the new import is added when missing.
                     if (hasSurvivingReference || specifiers.length === 0) {
-                        if (hasUseLatestCallbackImport) {
+                        if (latestCallbackImport) {
                             return [];
                         }
                         return [fixer.insertTextBefore(statement, `${importText}\n`)];
@@ -267,7 +306,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         ? 'import type'
                         : 'import';
                     if (remainingNamed.length === 0 && !defaultOrNamespace) {
-                        if (!hasUseLatestCallbackImport) {
+                        if (!latestCallbackImport) {
                             return [fixer.replaceText(statement, importText)];
                         }
                         return [fixer.remove(statement)];
@@ -283,7 +322,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                     }
                     const replacement = `${prefix} ${parts.join(', ')} from 'react';`;
                     const fixes = [];
-                    if (!hasUseLatestCallbackImport) {
+                    if (!latestCallbackImport) {
                         fixes.push(fixer.insertTextBefore(statement, `${importText}\n`));
                     }
                     fixes.push(fixer.replaceText(statement, replacement));
@@ -313,6 +352,14 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                         recommendedHook,
                     },
                     fix(fixer) {
+                        // Withhold the whole edit — nothing before this point mutates
+                        // state, so a withheld pass cannot leave a later one believing the
+                        // import is in place. The violation still stands as a report so
+                        // the author resolves the name clash deliberately. The batch is
+                        // atomic, so one unreachable call site withholds all of it.
+                        if (!batchedConversions.every(reachesHook)) {
+                            return null;
+                        }
                         return [
                             ...batchedConversions.map((conversion) => conversionFix(fixer, conversion)),
                             ...importFixes(fixer),
@@ -332,7 +379,7 @@ exports.useLatestCallback = (0, createRule_1.createRule)({
                 if (!touchesImport) {
                     return;
                 }
-                if (hasSurvivingReference && hasUseLatestCallbackImport) {
+                if (hasSurvivingReference && latestCallbackImport) {
                     return; // The react import stays as is and the new import exists
                 }
                 context.report({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.20.30",
+  "version": "1.20.31",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",