@blumintinc/eslint-plugin-blumint 1.20.117 → 1.20.119

package/lib/index.js

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

package/lib/rules/enforce-callback-memo.js

@@ -200,6 +200,13 @@ exports.default = (0, createRule_1.createRule)({
             // that happens to build JSX, and JSX rendered from a test body are all
             // outside any render path, so wrapping there would throw
             // "Invalid hook call" while saving no re-render.
+            //
+            // The question the gate asks is RELATIVE — is a render function interposed
+            // between this attribute and whatever encloses it further out — so a
+            // component built by a plain factory (`function makeCard() { return
+            // memo(() => <X onClick={...} />); }`) reports: the arrow handed to `memo`
+            // IS the component, and `useCallback` is legal inside it no matter what
+            // the factory is called.
             if (!ASTHelpers_1.ASTHelpers.isInsideComponentOrHook(node, context)) {
                 return;
             }

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -11,6 +11,7 @@ exports.enforceFirestoreDocRefGeneric = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const ASTHelpers_1 = require("../utils/ASTHelpers");
+const lexicalScope_1 = require("../utils/lexicalScope");
 /** The Firestore reference types that carry a document-shape generic. */
 const REFERENCE_TYPE_NAMES = new Set([
     'DocumentReference',
@@ -38,20 +39,6 @@ const referenceTypeNameOf = (typeName) => {
     }
     return undefined;
 };
-/** Statement containers a type declaration can be a direct child of. */
-function statementsOf(node) {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-}
 /**
  * The type declaration a statement makes, looking through `export`.
  *
@@ -61,10 +48,7 @@ function statementsOf(node) {
  * distinction the document shape knows anything about.
  */
 function typeDeclarationNamed(statement, name) {
-    const declared = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-        statement.declaration
-        ? statement.declaration
-        : statement;
+    const declared = (0, lexicalScope_1.declarationOf)(statement);
     if ((declared.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
         declared.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) &&
         declared.id.name === name) {
@@ -83,20 +67,15 @@ function typeDeclarationNamed(statement, name) {
  * dropped the nested-`any` check rather than reporting anything.
  */
 function declarationOfType(from, name) {
-    let current = from;
-    while (current) {
-        const statements = statementsOf(current);
-        if (statements) {
-            for (const statement of statements) {
-                const declaration = typeDeclarationNamed(statement, name);
-                if (declaration) {
-                    return declaration;
-                }
+    return (0, lexicalScope_1.resolveInEnclosingScopes)(from, (statements) => {
+        for (const statement of statements) {
+            const declaration = typeDeclarationNamed(statement, name);
+            if (declaration) {
+                return declaration;
             }
         }
-        current = current.parent;
-    }
-    return undefined;
+        return undefined;
+    });
 }
 /**
  * @type {import('eslint').Rule.RuleModule}

package/lib/rules/enforce-firestore-set-merge.js

@@ -5,6 +5,7 @@ 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 lexicalScope_1 = require("../utils/lexicalScope");
 const FIRESTORE_MODULES = new Set(['firebase/firestore', 'firebase-admin']);
 const UPDATE_DOC = 'updateDoc';
 const SET_DOC = 'setDoc';
@@ -192,20 +193,6 @@ function isPrimitiveLiteral(node) {
         typeof value === 'boolean' ||
         typeof value === 'bigint');
 }
-/** Statement containers a declaration can be a direct child of. */
-function statementsOf(node) {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-}
 /** Whether a declarator is initialized from a `<x>.firestore()` call. */
 function initializesFirestore(declarator) {
     const { init } = declarator;
@@ -221,14 +208,11 @@ function initializesFirestore(declarator) {
  * deeper, inside an `ExportNamedDeclaration`. Reading the statement without
  * unwrapping makes the `export` keyword alone decide whether the file's
  * Firestore evidence is visible, which is not a distinction a `db` handle knows
- * anything about — `classBodiesByName()` already unwraps it for the same
+ * anything about — `resolveClassBody()` unwraps it for the same
  * "find the in-file declaration that carries the evidence" purpose.
  */
 function declaresFirestoreInstance(statement) {
-    const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-        statement.declaration
-        ? statement.declaration
-        : statement;
+    const declaration = (0, lexicalScope_1.declarationOf)(statement);
     return (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclaration &&
         declaration.declarations.some(initializesFirestore));
 }
@@ -244,15 +228,9 @@ function declaresFirestoreInstance(statement) {
  * falls through to the next one out instead of answering for the whole chain.
  */
 function hasFirestoreInstanceInScope(node) {
-    let current = node;
-    while (current) {
-        const statements = statementsOf(current);
-        if (statements?.some(declaresFirestoreInstance)) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
+    return ((0, lexicalScope_1.resolveInEnclosingScopes)(node, (statements) => statements.some((statement) => declaresFirestoreInstance(statement))
+        ? true
+        : undefined) === true);
 }
 exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     name: 'enforce-firestore-set-merge',
@@ -285,35 +263,59 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
         const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
         let plannedSetDocBinding = false;
         /**
-         * Top-level classes by name, so a field inherited from a superclass declared
-         * in the same file resolves to the declaration that carries its evidence.
+         * Classes declared directly in one statement container, by name — both the
+         * `class X {}` spelling and the `const X = class {}` one, each looked
+         * through its optional `export` wrapper.
+         *
+         * The memo hangs off the container rather than off the file. What a single
+         * container declares is the same answer for every call site that asks, so
+         * caching it is safe, whereas a file-wide name map is not: lexical
+         * resolution is position dependent, and one map computed for whichever site
+         * asked first would hand that site's answer to every other one.
          */
-        let topLevelClasses = null;
-        function classBodiesByName() {
-            if (topLevelClasses) {
-                return topLevelClasses;
+        const classesByContainer = new WeakMap();
+        function containerClasses(container, statements) {
+            const cached = classesByContainer.get(container);
+            if (cached) {
+                return cached;
             }
-            topLevelClasses = new Map();
-            for (const statement of sourceCode.ast.body) {
-                const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
-                    statement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration
-                    ? statement.declaration
-                    : statement;
-                if (declaration?.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
+            const classes = new Map();
+            for (const statement of statements) {
+                const declaration = (0, lexicalScope_1.declarationOf)(statement);
+                if (declaration.type === utils_1.AST_NODE_TYPES.ClassDeclaration &&
                     declaration.id) {
-                    topLevelClasses.set(declaration.id.name, declaration.body);
+                    classes.set(declaration.id.name, declaration.body);
                     continue;
                 }
-                if (declaration?.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                if (declaration.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
                     for (const declarator of declaration.declarations) {
                         if (declarator.id.type === utils_1.AST_NODE_TYPES.Identifier &&
                             declarator.init?.type === utils_1.AST_NODE_TYPES.ClassExpression) {
-                            topLevelClasses.set(declarator.id.name, declarator.init.body);
+                            classes.set(declarator.id.name, declarator.init.body);
                         }
                     }
                 }
             }
-            return topLevelClasses;
+            classesByContainer.set(container, classes);
+            return classes;
+        }
+        /**
+         * The class a superclass reference names, searched from the reference
+         * outward through every enclosing statement container so the declaration
+         * that carries the field's evidence is found wherever it sits.
+         *
+         * Scanning `Program.body` alone made the `export` keyword and the depth of a
+         * declaration decide whether a base class is visible, which is not a
+         * distinction an inherited field knows anything about. This map feeds the
+         * Realtime Database carve-out, so a miss switches the exemption off and
+         * turns a call the rule cannot legally rewrite into a report — the same
+         * hole `hasFirestoreInstanceInScope` closes for the detection direction,
+         * and the two must agree. The innermost container wins, so a nested class
+         * shadowing an outer one of the same name answers for the code that sees
+         * the shadow.
+         */
+        function resolveClassBody(name, reference) {
+            return ((0, lexicalScope_1.resolveInEnclosingScopes)(reference, (statements, container) => containerClasses(container, statements).get(name)) ?? null);
         }
         function enclosingClassBody(node) {
             let current = node.parent;
@@ -342,7 +344,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
             if (superClass?.type !== utils_1.AST_NODE_TYPES.Identifier) {
                 return false;
             }
-            const superBody = classBodiesByName().get(superClass.name);
+            const superBody = resolveClassBody(superClass.name, superClass);
             return superBody ? classBindsRealtime(superBody, name, seen) : false;
         }
         function identifierBindsRealtime(identifier) {

package/lib/rules/no-direct-function-state.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noDirectFunctionState = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const lexicalScope_1 = require("../utils/lexicalScope");
 const DEFAULT_FUNCTION_PATTERNS = [
     'callback',
     'handler',
@@ -10,20 +11,6 @@ const DEFAULT_FUNCTION_PATTERNS = [
     'func',
     'on[A-Z].*',
 ];
-/** Statement containers a type alias can be a direct child of. */
-function statementsOf(node) {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-}
 /**
  * The type alias a statement declares under `name`, looking through `export`.
  *
@@ -33,10 +20,7 @@ function statementsOf(node) {
  * readable, which says nothing about what the state holds.
  */
 function typeAliasNamed(statement, name) {
-    const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-        statement.declaration
-        ? statement.declaration
-        : statement;
+    const declaration = (0, lexicalScope_1.declarationOf)(statement);
     return declaration.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
         declaration.id.name === name
         ? declaration
@@ -56,20 +40,15 @@ function typeAliasNamed(statement, name) {
  * hoisting of type declarations.
  */
 function resolveTypeAlias(from, name) {
-    let current = from;
-    while (current) {
-        const statements = statementsOf(current);
-        if (statements) {
-            for (const statement of statements) {
-                const alias = typeAliasNamed(statement, name);
-                if (alias) {
-                    return alias;
-                }
+    return (0, lexicalScope_1.resolveInEnclosingScopes)(from, (statements) => {
+        for (const statement of statements) {
+            const alias = typeAliasNamed(statement, name);
+            if (alias) {
+                return alias;
             }
         }
-        current = current.parent;
-    }
-    return undefined;
+        return undefined;
+    });
 }
 /**
  * Returns true if the TSTypeAnnotation node (from useState's type parameter)

package/lib/rules/no-explicit-return-type.js

@@ -5,6 +5,7 @@ const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
 const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
+const lexicalScope_1 = require("../utils/lexicalScope");
 const defaultOptions = {
     allowRecursiveFunctions: true,
     allowOverloadedFunctions: true,
@@ -401,24 +402,6 @@ function collectReturnIdentifierNames(fn, visitorKeys) {
     }
     return names;
 }
-/**
- * The statement list a container holds, or undefined for a node that holds
- * none. These are every place a function can be declared as a direct child, so
- * walking them outward reproduces TypeScript's own scope chain.
- */
-function statementsOf(node) {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-}
 /**
  * What a statement list binds each of its names to: the function when the name
  * denotes one, `null` when it denotes anything else.
@@ -437,11 +420,7 @@ function scopeBindings(statements) {
     for (const rawStatement of statements) {
         // `export function f() {}` is the same declaration one AST node deeper, and
         // the `export` keyword alone cannot decide whether a name is resolvable.
-        const statement = (rawStatement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
-            rawStatement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) &&
-            rawStatement.declaration
-            ? rawStatement.declaration
-            : rawStatement;
+        const statement = (0, lexicalScope_1.declarationOf)(rawStatement);
         if (statement.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && statement.id) {
             bind(statement.id.name, statement.body ? statement : null);
             continue;
@@ -510,20 +489,14 @@ function createReturnCycleResolver(visitorKeys) {
         bindings.set(container, computed);
         return computed;
     };
-    const resolveFunctionInScope = (from, name) => {
-        let current = from;
-        while (current) {
-            const statements = statementsOf(current);
-            if (statements) {
-                const scope = bindingsOf(current, statements);
-                if (scope.has(name)) {
-                    return scope.get(name) ?? undefined;
-                }
-            }
-            current = current.parent;
-        }
-        return undefined;
-    };
+    const resolveFunctionInScope = (from, name) => (0, lexicalScope_1.resolveInEnclosingScopes)(from, (statements, container) => {
+        const scope = bindingsOf(container, statements);
+        if (!scope.has(name))
+            return undefined;
+        // A non-function binding still shadows a same-named outer function, so
+        // it ends the search without yielding one.
+        return scope.get(name) ?? lexicalScope_1.BOUND_UNPROVABLE;
+    });
     const edgesOf = (fn) => {
         const cached = edges.get(fn);
         if (cached)

package/lib/rules/no-firestore-object-arrays.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noFirestoreObjectArrays = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const lexicalScope_1 = require("../utils/lexicalScope");
 const PRIMITIVE_TYPES = new Set([
     'string',
     'number',
@@ -14,36 +15,6 @@ const PRIMITIVE_TYPES = new Set([
     'GeoPoint',
 ]);
 const UNKNOWN_FIELD_LABEL = '<unknown field>';
-/** Statements a declaration can be a direct child of, innermost outward. */
-const statementsOf = (node) => {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-};
-/**
- * The declaration a statement carries, looking through `export`.
- *
- * `export type Comment = ...` is the same declaration one AST node deeper,
- * inside an `ExportNamedDeclaration`. Reading the statement without unwrapping
- * would let the `export` keyword alone decide whether an element type is
- * resolvable, which says nothing about the shape it denotes.
- */
-const declarationOf = (statement) => {
-    if ((statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration ||
-        statement.type === utils_1.AST_NODE_TYPES.ExportDefaultDeclaration) &&
-        statement.declaration) {
-        return statement.declaration;
-    }
-    return statement;
-};
 /**
  * Interface beats enum beats alias, matching the order the file-wide tables are
  * consulted in. The orderings can only differ for a name declared twice in one
@@ -55,7 +26,7 @@ const typeDeclarationIn = (statements, name) => {
     let enumMatch;
     let aliasMatch;
     for (const statement of statements) {
-        const declaration = declarationOf(statement);
+        const declaration = (0, lexicalScope_1.declarationOf)(statement);
         switch (declaration.type) {
             case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
                 if (declaration.id.name === name)
@@ -146,13 +117,13 @@ const unwrapExpressionAssertions = (node) => {
 };
 /**
  * A same-named `const` binding shadows any outer one whether or not it holds an
- * array literal, so the lexical search must stop at it rather than reaching past
- * it to a binding the reference cannot denote.
+ * array literal, so the lexical search must stop at it — reported as
+ * `BOUND_UNPROVABLE` — rather than reaching past it to a binding the reference
+ * cannot denote, or falling back to the file-wide table.
  */
-const CONST_ARRAY_SHADOWED = 'shadowed';
 const constArrayIn = (statements, name) => {
     for (const statement of statements) {
-        const declaration = declarationOf(statement);
+        const declaration = (0, lexicalScope_1.declarationOf)(statement);
         if (declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration ||
             declaration.kind !== 'const') {
             continue;
@@ -163,11 +134,11 @@ const constArrayIn = (statements, name) => {
                 continue;
             }
             if (!declarator.init)
-                return CONST_ARRAY_SHADOWED;
+                return lexicalScope_1.BOUND_UNPROVABLE;
             const init = unwrapExpressionAssertions(declarator.init);
             return init.type === utils_1.AST_NODE_TYPES.ArrayExpression
                 ? init
-                : CONST_ARRAY_SHADOWED;
+                : lexicalScope_1.BOUND_UNPROVABLE;
         }
     }
     return undefined;
@@ -395,39 +366,17 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
          * declaration written below its own reference still resolves, matching
          * TypeScript's hoisting of type declarations.
          */
-        const resolveTypeName = (from, name) => {
-            let current = from;
-            while (current) {
-                const statements = statementsOf(current);
-                if (statements) {
-                    const declared = typeDeclarationIn(statements, name);
-                    if (declared)
-                        return declared;
-                }
-                current = current.parent;
-            }
+        const resolveTypeName = (from, name) => (0, lexicalScope_1.resolveInEnclosingScopes)(from, (statements) => typeDeclarationIn(statements, name), () => {
             if (interfaceNames.has(name))
                 return { kind: 'interface' };
             if (enumNames.has(name))
                 return { kind: 'enum' };
             const aliased = aliasNameToType.get(name);
-            return aliased ? { kind: 'alias', typeAnnotation: aliased } : undefined;
-        };
-        const resolveConstArray = (from, name) => {
-            let current = from;
-            while (current) {
-                const statements = statementsOf(current);
-                if (statements) {
-                    const declared = constArrayIn(statements, name);
-                    if (declared === CONST_ARRAY_SHADOWED)
-                        return undefined;
-                    if (declared)
-                        return declared;
-                }
-                current = current.parent;
-            }
-            return constArrayNameToLiteral.get(name);
-        };
+            return aliased
+                ? { kind: 'alias', typeAnnotation: aliased }
+                : undefined;
+        });
+        const resolveConstArray = (from, name) => (0, lexicalScope_1.resolveInEnclosingScopes)(from, (statements) => constArrayIn(statements, name), () => constArrayNameToLiteral.get(name));
         // Keyed by resolved declaration rather than by name: one name can denote
         // different declarations in different scopes, so a name-keyed memo would
         // answer for whichever scope asked first.

package/lib/rules/prefer-batch-operations.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferBatchOperations = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const lexicalScope_1 = require("../utils/lexicalScope");
 const SETTER_METHODS = new Set(['set', 'overwrite']);
 const ARRAY_METHODS = new Set([
     'map',
@@ -261,20 +262,6 @@ function isMapInstance(node) {
     }
     return false;
 }
-/** Statements a declaration can be a direct child of, innermost outward. */
-function statementsOf(node) {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.Program:
-        case utils_1.AST_NODE_TYPES.BlockStatement:
-        case utils_1.AST_NODE_TYPES.TSModuleBlock:
-        case utils_1.AST_NODE_TYPES.StaticBlock:
-            return node.body;
-        case utils_1.AST_NODE_TYPES.SwitchCase:
-            return node.consequent;
-        default:
-            return undefined;
-    }
-}
 /**
  * Lexical lookup of a local declaration, innermost scope outward.
  *
@@ -285,28 +272,20 @@ function statementsOf(node) {
  * searched instead, and the first match wins, which is what shadowing requires.
  */
 function findVariableDeclaration(node, varName) {
-    let current = node;
-    while (current) {
-        const statements = statementsOf(current);
-        if (statements) {
-            for (const statement of statements) {
-                const declaration = statement.type === utils_1.AST_NODE_TYPES.ExportNamedDeclaration &&
-                    statement.declaration
-                    ? statement.declaration
-                    : statement;
-                if (declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration)
-                    continue;
-                for (const decl of declaration.declarations) {
-                    if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        decl.id.name === varName) {
-                        return decl;
-                    }
+    return (0, lexicalScope_1.resolveInEnclosingScopes)(node, (statements) => {
+        for (const statement of statements) {
+            const declaration = (0, lexicalScope_1.declarationOf)(statement);
+            if (declaration.type !== utils_1.AST_NODE_TYPES.VariableDeclaration)
+                continue;
+            for (const decl of declaration.declarations) {
+                if (decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    decl.id.name === varName) {
+                    return decl;
                 }
             }
         }
-        current = current.parent;
-    }
-    return undefined;
+        return undefined;
+    });
 }
 function isSetterMethodCall(node) {
     if (node.type !== utils_1.AST_NODE_TYPES.CallExpression)
@@ -431,19 +410,19 @@ exports.preferBatchOperations = (0, createRule_1.createRule)({
                             });
                         }
                     }
-                    /**
-                     * For array methods, report on the first occurrence — one syntactic
-                     * call inside a `map` callback still runs once per element.
-                     *
-                     * A direct `Promise.all([...])` is not that: its elements are written
-                     * out, so a lone `set()` is a single write and the docs call it
-                     * valid. `findLoopNode` stamps `isArrayMethod: 'map'` onto the
-                     * Promise.all result, which used to route it here and report on the
-                     * first call — and, by adding the node to `reportedLoops`, made the
-                     * deferred second-occurrence branch below unreachable for every
-                     * input. Excluding it hands the decision back to that branch.
-                     */
                     else if (loopInfo.isArrayMethod && !loopInfo.isPromiseAll) {
+                        /**
+                         * For array methods, report on the first occurrence — one syntactic
+                         * call inside a `map` callback still runs once per element.
+                         *
+                         * A direct `Promise.all([...])` is not that: its elements are written
+                         * out, so a lone `set()` is a single write and the docs call it
+                         * valid. `findLoopNode` stamps `isArrayMethod: 'map'` onto the
+                         * Promise.all result, which used to route it here and report on the
+                         * first call — and, by adding the node to `reportedLoops`, made the
+                         * deferred second-occurrence branch below unreachable for every
+                         * input. Excluding it hands the decision back to that branch.
+                         */
                         if (!reportedLoops.has(loopInfo.node)) {
                             reportedLoops.add(loopInfo.node);
                             context.report({