@blumintinc/eslint-plugin-blumint 1.20.30 → 1.20.31

package/lib/index.js

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

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

@@ -10,6 +10,26 @@ const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const DEFAULT_IMPORT_PATH = 'functions/src/util/assertSafe';
+const ASSERT_SAFE_NAME = 'assertSafe';
+/**
+ * A named specifier that binds `assertSafe` under its own name — the only shape
+ * that makes a bare `assertSafe(...)` call resolve to the helper. An alias
+ * (`import { assertSafe as ensureSafe }`) leaves the name free for the injected
+ * import, and a type-only specifier erases at compile time.
+ */
+function isAssertSafeSpecifier(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.name === ASSERT_SAFE_NAME &&
+        specifier.local.name === ASSERT_SAFE_NAME);
+}
+/**
+ * Drops the extension and normalizes separators so two spellings of one module
+ * compare equal.
+ */
+function normalizeModulePath(value) {
+    return value.replace(/\\/g, '/').replace(/\.(tsx?|jsx?|mts|cts)$/i, '');
+}
 exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     name: 'enforce-assert-safe-object-key',
     meta: {
@@ -35,7 +55,14 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
     defaultOptions: [{}],
     create(context, [options]) {
         const importPath = options?.assertSafeImportPath || DEFAULT_IMPORT_PATH;
-        let hasAssertSafeImport = false;
+        // Repo-root-anchored location of the helper, the yardstick every module
+        // specifier written in the file is compared against.
+        const assertSafeTarget = normalizeModulePath(importPath);
+        // Whether an earlier fix in this pass already carries the import. The AST is
+        // not re-parsed between the fixes of a single pass, so the import can only
+        // be claimed once: a second fix repeating it would span the same insertion
+        // point, overlap, and be dropped along with its wrap.
+        let importClaimed = false;
         /**
          * The `import { assertSafe }` statement rides on a single violation's fix,
          * making that violation the file's import carrier. A suppressed carrier
@@ -43,6 +70,21 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * emit `assertSafe(...)`, leaving the call unbound.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        /**
+         * Directory of the file being fixed, relative to the repo root, or null for
+         * virtual/stdin files (RuleTester default 'file.ts', '<input>', '<text>')
+         * whose non-absolute name cannot anchor a relative path.
+         */
+        const fileDirFromRoot = () => {
+            const rawFilename = context.getFilename().replace(/\\/g, '/');
+            if (!path_1.default.isAbsolute(rawFilename)) {
+                return null;
+            }
+            const fileRelToCwd = path_1.default
+                .relative(process.cwd(), rawFilename)
+                .replace(/\\/g, '/');
+            return path_1.default.posix.dirname(fileRelToCwd);
+        };
         /**
          * Computes the module specifier for the injected assertSafe import.
          *
@@ -56,27 +98,69 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          * file being fixed so the emitted import resolves from that file's location.
          */
         const computeImportSpecifier = () => {
-            const rawFilename = context.getFilename().replace(/\\/g, '/');
-            // Virtual/stdin files (RuleTester default 'file.ts', '<input>', '<text>')
-            // are not absolute; we cannot anchor a relative path, so emit the
-            // configured path verbatim (preserves the option's literal value for
-            // non-file lints).
-            if (!path_1.default.isAbsolute(rawFilename)) {
+            const fileDir = fileDirFromRoot();
+            // Emitting the configured path verbatim preserves the option's literal
+            // value for non-file lints.
+            if (fileDir === null) {
                 return importPath;
             }
-            const target = importPath
-                .replace(/\\/g, '/')
-                .replace(/\.(tsx?|jsx?|mts|cts)$/i, '');
-            const fileRelToCwd = path_1.default
-                .relative(process.cwd(), rawFilename)
-                .replace(/\\/g, '/');
-            const fileDir = path_1.default.posix.dirname(fileRelToCwd);
-            let specifier = path_1.default.posix.relative(fileDir, target);
+            let specifier = path_1.default.posix.relative(fileDir, assertSafeTarget);
             if (!specifier.startsWith('.')) {
                 specifier = `./${specifier}`;
             }
             return specifier;
         };
+        /**
+         * Whether a module specifier written in the file denotes the same helper the
+         * fix imports. A relative specifier is resolved against the file's own
+         * directory before the comparison, because the configured path is anchored
+         * at the repo root: `../../assertSafe` inside functions/src/util/a/b and
+         * `functions/src/util/assertSafe` name one module, and treating them as
+         * different would withhold the fix from files that import the helper
+         * perfectly well.
+         */
+        const isAssertSafeModule = (source) => {
+            const normalized = normalizeModulePath(source);
+            if (normalized === assertSafeTarget) {
+                return true;
+            }
+            if (!normalized.startsWith('.')) {
+                return false;
+            }
+            const fileDir = fileDirFromRoot();
+            if (fileDir === null) {
+                return false;
+            }
+            return (path_1.default.posix.normalize(path_1.default.posix.join(fileDir, normalized)) ===
+                assertSafeTarget);
+        };
+        /**
+         * Read the import off the AST instead of a traversal flag: a violation that
+         * precedes the import declaration in source order would otherwise be judged
+         * against a flag the `ImportDeclaration` visitor has not set yet, emitting a
+         * duplicate import.
+         */
+        const importsAssertSafe = (program) => program.body.some((statement) => statement.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+            statement.importKind !== 'type' &&
+            isAssertSafeModule(statement.source.value) &&
+            statement.specifiers.some(isAssertSafeSpecifier));
+        /**
+         * Whether every declaration of a visible `assertSafe` binding is the helper
+         * import itself. A local const/function/class, a parameter, a namespace or
+         * default import, or a named import from another module all mean the emitted
+         * `assertSafe(...)` call would resolve somewhere other than the helper.
+         */
+        const bindsAssertSafe = (variable) => variable.defs.length > 0 &&
+            variable.defs.every((def) => {
+                const specifier = def.node;
+                if (!isAssertSafeSpecifier(specifier)) {
+                    return false;
+                }
+                const declaration = specifier.parent;
+                return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                    declaration.importKind !== 'type' &&
+                    isAssertSafeModule(declaration.source.value));
+            });
         /**
          * Helper function to add assertSafe import if needed
          */
@@ -96,10 +180,9 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
          */
         const createFixes = (fixer, node, argText) => {
             const fixes = [];
-            // Add import if not present
-            if (!hasAssertSafeImport) {
+            if (!importClaimed && !importsAssertSafe(context.sourceCode.ast)) {
                 fixes.push(addAssertSafeImport(fixer));
-                hasAssertSafeImport = true;
+                importClaimed = true;
             }
             // Replace the node with assertSafe(argText)
             fixes.push(fixer.replaceText(node, `assertSafe(${argText})`));
@@ -119,6 +202,17 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
                 if (isReportSuppressed(node)) {
                     return null;
                 }
+                // Resolve `assertSafe` through the scope chain at the fixed node. A
+                // binding that is not the helper import breaks the edit two ways: the
+                // injected import collides with a module-scope declaration (TS2440,
+                // or TS2300 when the binding is itself an import), and a shadowing
+                // parameter or block-scoped binding captures the emitted call with no
+                // compile error at all. Declining leaves the report standing so the
+                // author resolves the clash deliberately.
+                const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), ASSERT_SAFE_NAME);
+                if (existing && !bindsAssertSafe(existing)) {
+                    return null;
+                }
                 return createFixes(fixer, node, expressionText);
             },
         });
@@ -146,13 +240,6 @@ exports.enforceAssertSafeObjectKey = (0, createRule_1.createRule)({
             });
         };
         return {
-            ImportDeclaration(node) {
-                // Check if assertSafe is already imported
-                if (node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                    specifier.imported.name === 'assertSafe')) {
-                    hasAssertSafeImport = true;
-                }
-            },
             // Handle computed property in object destructuring
             Property(node) {
                 if (node.computed && node.key) {

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

@@ -3,9 +3,45 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeAsync = 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 MEMOIZE_MODULE = '@blumintinc/typescript-memoize';
 const ALLOWED_MEMOIZE_MODULES = new Set([MEMOIZE_MODULE, 'typescript-memoize']);
+const MEMOIZE_NAME = 'Memoize';
+/**
+ * A named specifier that binds `Memoize` under its own name — the only shape
+ * that makes a bare `@Memoize()` decorator resolve to the decorator factory. An
+ * alias (`import { Memoize as Cache }`) leaves the name free for the injected
+ * import, and a type-only specifier erases at compile time, so neither backs a
+ * value reference.
+ */
+function isMemoizeSpecifier(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        specifier.imported.name === MEMOIZE_NAME &&
+        specifier.local.name === MEMOIZE_NAME);
+}
+/**
+ * Whether every declaration of a visible `Memoize` binding is a value import of
+ * the decorator itself. A local const/function/class, an enclosing class of the
+ * same name, a parameter, a namespace or default import, or a named import from
+ * any other module all mean the emitted `@Memoize()` would resolve somewhere
+ * other than the decorator factory.
+ */
+function bindsMemoize(variable) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isMemoizeSpecifier(specifier)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                ALLOWED_MEMOIZE_MODULES.has(String(declaration.source.value)));
+        }));
+}
 /**
  * Matches a memoize decorator in supported syntaxes:
  * - @Alias()
@@ -51,9 +87,6 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        let hasMemoizeImport = false;
-        const memoizeAliases = new Map(); // alias -> source module
-        const memoizeNamespaces = new Map(); // namespace -> source module
         let scheduledImportFix = false;
         /**
          * The `import { Memoize }` statement rides on a single violation's fix, so
@@ -62,23 +95,48 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
          * `@Memoize()`, leaving a decorator with no import.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
-        return {
-            ImportDeclaration(node) {
-                if (ALLOWED_MEMOIZE_MODULES.has(String(node.source.value))) {
-                    node.specifiers.forEach((spec) => {
-                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                            spec.imported.name === 'Memoize') {
-                            hasMemoizeImport = true;
-                            memoizeAliases.set(spec.local.name, String(node.source.value));
-                        }
-                        else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-                            hasMemoizeImport = true;
-                            memoizeNamespaces.set(spec.local.name, String(node.source.value));
-                        }
-                    });
+        /**
+         * Memoize bindings the file already imports, keyed by local name: aliases
+         * for `import { Memoize as X }` and namespaces for `import * as X`.
+         *
+         * Read off `Program.body` rather than accumulated by an `ImportDeclaration`
+         * visitor, because a class that precedes the import declaration in source
+         * order is visited — and fixed — before that visitor runs, and would be
+         * judged against state recorded for no import at all. The AST is fixed for
+         * the pass, so a single scan serves every violation.
+         */
+        const readMemoizeImports = () => {
+            const aliases = new Map();
+            const namespaces = new Map();
+            for (const statement of context.sourceCode.ast.body) {
+                if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                    continue;
                 }
-            },
+                const source = String(statement.source.value);
+                if (!ALLOWED_MEMOIZE_MODULES.has(source)) {
+                    continue;
+                }
+                for (const spec of statement.specifiers) {
+                    if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        spec.imported.name === MEMOIZE_NAME) {
+                        aliases.set(spec.local.name, source);
+                    }
+                    else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                        namespaces.set(spec.local.name, source);
+                    }
+                }
+            }
+            return { aliases, namespaces };
+        };
+        let memoizeImportCache = null;
+        const memoizeImports = () => {
+            if (!memoizeImportCache) {
+                memoizeImportCache = readMemoizeImports();
+            }
+            return memoizeImportCache;
+        };
+        return {
             MethodDefinition(node) {
                 // Only process async instance methods (skip static methods)
                 if (node.value.type !== utils_1.AST_NODE_TYPES.FunctionExpression ||
@@ -90,6 +148,8 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (node.value.params.length > 1) {
                     return;
                 }
+                const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
+                const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator
                 const hasDecorator = node.decorators?.some((decorator) => {
                     // If no named imports were found, we assume 'Memoize' is the intended name (for legacy/global support)
@@ -164,6 +224,24 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                             }
                         }
                         const importStatement = `import { Memoize } from '${MEMOIZE_MODULE}';`;
+                        // Resolve `Memoize` through the scope chain at the fixed node
+                        // whenever the edit spells the decorator bare. A binding that is
+                        // not a memoize import breaks the edit two ways: the injected
+                        // import collides with a module-scope declaration (TS2440, or
+                        // TS2300 when the binding is itself an import), and a shadowing
+                        // parameter or block-scoped binding captures the emitted decorator
+                        // with no compile error at all. Declining leaves the report
+                        // standing so the author resolves the clash deliberately.
+                        //
+                        // An alias or namespace decorator (`@Cache()`, `@ns.Memoize()`)
+                        // neither references the bare name nor injects the import, so it is
+                        // unaffected by a `Memoize` binding and must not be declined.
+                        if (decoratorIdent === MEMOIZE_NAME) {
+                            const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMOIZE_NAME);
+                            if (existing && !bindsMemoize(existing)) {
+                                return null;
+                            }
+                        }
                         // Add import if it's not already present; ensure we only add once per file
                         if (!hasMemoizeImport &&
                             memoizeNamespaces.size === 0 &&

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

@@ -3,12 +3,48 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceMemoizeGetters = 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 MEMOIZE_PREFERRED_MODULE = '@blumintinc/typescript-memoize';
 const MEMOIZE_MODULES = new Set([
     MEMOIZE_PREFERRED_MODULE,
     'typescript-memoize',
 ]);
+const MEMOIZE_NAME = 'Memoize';
+/**
+ * A named specifier that binds `Memoize` under its own name — the only shape
+ * that makes a bare `@Memoize()` decorator resolve to the decorator factory. An
+ * alias (`import { Memoize as Cache }`) leaves the name free for the injected
+ * import, and a type-only specifier erases at compile time, so neither backs a
+ * value reference.
+ */
+function isMemoizeSpecifier(specifier) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        specifier.imported.name === MEMOIZE_NAME &&
+        specifier.local.name === MEMOIZE_NAME);
+}
+/**
+ * Whether every declaration of a visible `Memoize` binding is a value import of
+ * the decorator itself. A local const/function/class, an enclosing class of the
+ * same name, a parameter, a namespace or default import, or a named import from
+ * any other module all mean the emitted `@Memoize()` would resolve somewhere
+ * other than the decorator factory.
+ */
+function bindsMemoize(variable) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isMemoizeSpecifier(specifier)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                MEMOIZE_MODULES.has(String(declaration.source.value)));
+        }));
+}
 function isMemoizeDecorator(decorator, alias) {
     const expression = decorator.expression;
     // @Alias()
@@ -54,10 +90,6 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
             return {};
         }
         const sourceCode = context.getSourceCode();
-        let hasMemoizeImport = false;
-        let memoizeAlias = 'Memoize';
-        let memoizeNamespace = null;
-        let hasNamedImport = false;
         let scheduledImportFix = false;
         /**
          * The `import { Memoize }` statement rides on a single violation's fix, so
@@ -66,25 +98,59 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
          * `@Memoize()`, leaving a decorator with no import.
          */
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
-        return {
-            ImportDeclaration(node) {
-                if (MEMOIZE_MODULES.has(String(node.source.value))) {
-                    for (const spec of node.specifiers) {
-                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                            spec.imported.name === 'Memoize') {
-                            hasMemoizeImport = true;
-                            hasNamedImport = true;
-                            memoizeAlias = spec.local.name;
-                        }
-                        else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-                            hasMemoizeImport = true;
-                            if (!hasNamedImport) {
-                                memoizeNamespace = spec.local.name;
-                            }
+        /**
+         * The memoize import the file already carries: the local name of a named
+         * `Memoize` specifier, or the local name of a namespace import.
+         *
+         * Read off `Program.body` rather than accumulated by an `ImportDeclaration`
+         * visitor, because a class that precedes the import declaration in source
+         * order is visited — and fixed — before that visitor runs, and would be
+         * judged against state recorded for no import at all. The AST is fixed for
+         * the pass, so a single scan serves every violation.
+         */
+        const readMemoizeImports = () => {
+            let hasMemoizeImport = false;
+            let memoizeAlias = MEMOIZE_NAME;
+            let memoizeNamespace = null;
+            let hasNamedImport = false;
+            for (const statement of sourceCode.ast.body) {
+                if (statement.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+                    continue;
+                }
+                if (!MEMOIZE_MODULES.has(String(statement.source.value))) {
+                    continue;
+                }
+                for (const spec of statement.specifiers) {
+                    if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        spec.imported.name === MEMOIZE_NAME) {
+                        hasMemoizeImport = true;
+                        hasNamedImport = true;
+                        memoizeAlias = spec.local.name;
+                    }
+                    else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                        hasMemoizeImport = true;
+                        if (!hasNamedImport) {
+                            memoizeNamespace = spec.local.name;
                         }
                     }
                 }
-            },
+            }
+            return {
+                hasMemoizeImport,
+                memoizeAlias,
+                memoizeNamespace,
+                hasNamedImport,
+            };
+        };
+        let memoizeImportCache = null;
+        const memoizeImports = () => {
+            if (!memoizeImportCache) {
+                memoizeImportCache = readMemoizeImports();
+            }
+            return memoizeImportCache;
+        };
+        return {
             MethodDefinition(node) {
                 // Target: instance private getters
                 if (node.kind !== 'get')
@@ -95,7 +161,10 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // enforce only "private" accessibility (undefined => public)
                 if (node.accessibility !== 'private')
                     return;
-                const decoratorAliases = memoizeAlias === 'Memoize' ? ['Memoize'] : ['Memoize', memoizeAlias];
+                const { hasMemoizeImport, memoizeAlias, memoizeNamespace, hasNamedImport, } = memoizeImports();
+                const decoratorAliases = memoizeAlias === MEMOIZE_NAME
+                    ? [MEMOIZE_NAME]
+                    : [MEMOIZE_NAME, memoizeAlias];
                 const hasDecorator = node.decorators?.some((decorator) => decoratorAliases.some((alias) => isMemoizeDecorator(decorator, alias)));
                 if (hasDecorator)
                     return;
@@ -127,6 +196,24 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                             return memoizeAlias;
                         };
                         const decoratorIdent = getDecoratorIdent();
+                        // Resolve `Memoize` through the scope chain at the fixed node
+                        // whenever the edit spells the decorator bare. A binding that is
+                        // not a memoize import breaks the edit two ways: the injected
+                        // import collides with a module-scope declaration (TS2440, or
+                        // TS2300 when the binding is itself an import), and a shadowing
+                        // parameter or block-scoped binding captures the emitted decorator
+                        // with no compile error at all. Declining leaves the report
+                        // standing so the author resolves the clash deliberately.
+                        //
+                        // An alias or namespace decorator (`@Cache()`, `@ns.Memoize()`)
+                        // neither references the bare name nor injects the import, so it is
+                        // unaffected by a `Memoize` binding and must not be declined.
+                        if (decoratorIdent === MEMOIZE_NAME) {
+                            const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(ASTHelpers_1.ASTHelpers.getScope(context, node), MEMOIZE_NAME);
+                            if (existing && !bindsMemoize(existing)) {
+                                return null;
+                            }
+                        }
                         // Insert import if needed, at the top alongside other imports
                         if (!hasMemoizeImport && !scheduledImportFix) {
                             const programBody = sourceCode.ast.body;

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

@@ -7,6 +7,8 @@ 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 REACT_MODULE = 'react';
+const MEMO_HOOK_NAME = 'useMemo';
 const DEFAULT_HASH_IMPORT = {
     source: 'functions/src/util/hash/stableHash',
     importName: 'stableHash',
@@ -232,20 +234,49 @@ function getValueImports(sourceCode, source) {
  * specifier (`useMemo as um`) or a type-only specifier does not count — the
  * value binding under the exact local name must exist.
  */
+function isNamedValueSpecifier(specifier, name) {
+    return (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type' &&
+        specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+        specifier.imported.name === name &&
+        specifier.local.name === name);
+}
+/**
+ * Import presence is read off the AST at fix time rather than from a traversal
+ * flag: a hook call that precedes the import declaration in source order would
+ * otherwise be judged against a flag the `ImportDeclaration` visitor has not
+ * set yet, duplicating the import.
+ */
 function hasNamedValueImport(sourceCode, source, name) {
     for (const declaration of getValueImports(sourceCode, source)) {
         for (const spec of declaration.specifiers) {
-            if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                spec.importKind !== 'type' &&
-                spec.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                spec.imported.name === name &&
-                spec.local.name === name) {
+            if (isNamedValueSpecifier(spec, name)) {
                 return true;
             }
         }
     }
     return false;
 }
+/**
+ * Whether every declaration of a visible binding is the value import this fix
+ * intends to add. A local const/function/class, a parameter, a namespace or
+ * default import, an alias, or a named import from any other module all mean
+ * the emitted `useMemo(() => stableHash(...))` would resolve somewhere other
+ * than the helper — so the binding cannot be reused.
+ */
+function bindsIntendedImport(variable, name, source) {
+    return (variable.defs.length > 0 &&
+        variable.defs.every((def) => {
+            const specifier = def.node;
+            if (!isNamedValueSpecifier(specifier, name)) {
+                return false;
+            }
+            const declaration = specifier.parent;
+            return (declaration?.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
+                declaration.importKind !== 'type' &&
+                declaration.source.value === source);
+        }));
+}
 /**
  * Extends an existing import from `source` with `name` instead of prepending
  * a duplicate declaration. Namespace-only imports cannot host a named
@@ -437,6 +468,30 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         // All bail checks precede any shared-state mutation so a skipped
                         // fix cannot make a later fix believe imports or declarations are
                         // already handled.
+                        // The generated declaration spells both helper names bare and
+                        // imports both, so a binding of either name breaks the edit two
+                        // ways: the inserted import collides with a declaration of that
+                        // name (TS2440, or TS2300 when the binding is itself an import),
+                        // and a shadowing parameter or block-scoped binding captures the
+                        // emitted call with no compile error at all. Resolving through the
+                        // scope chain at the hook call catches both, since the insertion
+                        // point shares that scope. Because the emitted code needs BOTH
+                        // names, a clash on either withholds the whole edit — a partial
+                        // one would still be broken. The report stands so the author
+                        // resolves the clash deliberately.
+                        const scope = ASTHelpers_1.ASTHelpers.getScope(context, node);
+                        const collides = [
+                            { name: MEMO_HOOK_NAME, source: REACT_MODULE },
+                            {
+                                name: hashImportConfig.importName,
+                                source: hashImportConfig.source,
+                            },
+                        ].some(({ name, source }) => {
+                            const existing = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, name);
+                            return !!existing && !bindsIntendedImport(existing, name, source);
+                        });
+                        if (collides)
+                            return null;
                         const insertion = findInsertionPoint(node);
                         if (!insertion)
                             return null;
@@ -483,12 +538,13 @@ exports.noArrayLengthInDeps = (0, createRule_1.createRule)({
                         }
                         if (!importsPlanned) {
                             const newImportLines = [];
-                            if (!hasNamedValueImport(sourceCode, 'react', 'useMemo')) {
-                                const extension = buildImportExtensionFix(fixer, sourceCode, 'react', 'useMemo');
+                            if (!hasNamedValueImport(sourceCode, REACT_MODULE, MEMO_HOOK_NAME)) {
+                                const extension = buildImportExtensionFix(fixer, sourceCode, REACT_MODULE, MEMO_HOOK_NAME);
                                 if (extension)
                                     fixes.push(extension);
-                                else
-                                    newImportLines.push(`import { useMemo } from 'react';`);
+                                else {
+                                    newImportLines.push(`import { ${MEMO_HOOK_NAME} } from '${REACT_MODULE}';`);
+                                }
                             }
                             if (!hasNamedValueImport(sourceCode, hashImportConfig.source, hashImportConfig.importName)) {
                                 const extension = buildImportExtensionFix(fixer, sourceCode, hashImportConfig.source, hashImportConfig.importName);