@pobammer-ts/eslint-cease-nonsense-rules 0.10.1 → 0.11.0

package/dist/rules/use-exhaustive-dependencies.js

@@ -11,9 +11,6 @@ const UNSTABLE_VALUES = new Set([
     TSESTree.AST_NODE_TYPES.ObjectExpression,
     TSESTree.AST_NODE_TYPES.ArrayExpression,
 ]);
-/**
- * Internal metrics used for testing to ensure specific branches execute.
- */
 const testingMetrics = {
     moduleLevelStableConst: 0,
     outerScopeSkip: 0,
@@ -22,9 +19,6 @@ function resetTestingMetrics() {
     testingMetrics.moduleLevelStableConst = 0;
     testingMetrics.outerScopeSkip = 0;
 }
-/**
- * Default hooks to check for exhaustive dependencies.
- */
 const DEFAULT_HOOKS = new Map([
     ["useEffect", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useLayoutEffect", { closureIndex: 0, dependenciesIndex: 1 }],
@@ -32,38 +26,23 @@ const DEFAULT_HOOKS = new Map([
     ["useCallback", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useMemo", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useImperativeHandle", { closureIndex: 1, dependenciesIndex: 2 }],
-    // React Spring hooks (function factory pattern)
-    // Note: These hooks support both function and object patterns.
-    // Only the function pattern is analyzed for dependencies.
     ["useSpring", { closureIndex: 0, dependenciesIndex: 1 }],
     ["useSprings", { closureIndex: 1, dependenciesIndex: 2 }],
     ["useTrail", { closureIndex: 1, dependenciesIndex: 2 }],
 ]);
-/**
- * Hooks with stable results that don't need to be in dependencies.
- */
 const STABLE_HOOKS = new Map([
-    ["useState", new Set([1])], // setter at index 1
-    ["useReducer", new Set([1])], // dispatch at index 1
-    ["useTransition", new Set([1])], // startTransition at index 1
-    ["useRef", true], // entire result is stable
-    ["useBinding", true], // React Lua: both binding and setter are stable
+    ["useState", new Set([1])],
+    ["useReducer", new Set([1])],
+    ["useTransition", new Set([1])],
+    ["useRef", true],
+    ["useBinding", true],
 ]);
-/**
- * Values that don't need to be in dependencies (imported, constants, etc.).
- */
 const STABLE_VALUE_TYPES = new Set(["ImportBinding", "FunctionDeclaration", "ClassDeclaration", "FunctionName"]);
-/**
- * Global built-in identifiers that are always stable and should never be dependencies.
- * Includes JavaScript/TypeScript globals, constructors, and type-only names.
- */
 const GLOBAL_BUILTINS = new Set([
-    // Primitive values
     "undefined",
     "null",
     "Infinity",
     "NaN",
-    // Constructors
     "Array",
     "Object",
     "String",
@@ -72,20 +51,16 @@ const GLOBAL_BUILTINS = new Set([
     "Symbol",
     "BigInt",
     "Function",
-    // Collections
     "Map",
     "Set",
     "WeakMap",
     "WeakSet",
-    // Promises and async
     "Promise",
-    // Utility
     "Date",
     "RegExp",
     "Error",
     "Math",
     "JSON",
-    // Global functions
     "parseInt",
     "parseFloat",
     "isNaN",
@@ -94,7 +69,6 @@ const GLOBAL_BUILTINS = new Set([
     "encodeURIComponent",
     "decodeURI",
     "decodeURIComponent",
-    // TypeScript utility types (appear in type annotations but shouldn't be dependencies)
     "ReadonlyArray",
     "ReadonlyMap",
     "ReadonlySet",
@@ -110,109 +84,65 @@ const GLOBAL_BUILTINS = new Set([
     "ReturnType",
     "InstanceType",
     "Parameters",
-    // Web/Node globals commonly seen
     "console",
     "setTimeout",
     "setInterval",
     "clearTimeout",
     "clearInterval",
-    // Common DOM/Web types
     "Element",
     "Node",
     "Document",
     "Window",
     "Event",
 ]);
-/**
- * Gets the hook name from a call expression.
- *
- * @param node - The call expression node.
- * @returns The hook name or undefined.
- */
 function getHookName(node) {
     const { callee } = node;
-    // Direct call: useEffect(...)
     if (callee.type === "Identifier") {
         return callee.name;
     }
-    // Member expression: React.useEffect(...)
     if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
         return callee.property.name;
     }
     return undefined;
 }
-/**
- * Gets the member expression depth (number of property accesses).
- *
- * @param node - The node to analyze.
- * @returns The depth count.
- */
 function getMemberExpressionDepth(node) {
     let depth = 0;
     let current = node;
-    while (current.type === "MemberExpression") {
+    while (current.type === TSESTree.AST_NODE_TYPES.MemberExpression) {
         depth += 1;
         current = current.object;
     }
     return depth;
 }
-/**
- * Gets the root identifier from a member expression.
- *
- * @param node - The node to analyze.
- * @returns The root identifier or undefined.
- */
 function getRootIdentifier(node) {
     let current = node;
-    while (current.type === "MemberExpression")
+    while (current.type === TSESTree.AST_NODE_TYPES.MemberExpression)
         current = current.object;
-    return current.type === "Identifier" ? current : undefined;
+    return current.type === TSESTree.AST_NODE_TYPES.Identifier ? current : undefined;
 }
-/**
- * Converts a node to a dependency string representation.
- *
- * @param node - The node to convert.
- * @param sourceCode - The source code instance.
- * @returns The dependency string.
- */
 function nodeToDependencyString(node, sourceCode) {
     return sourceCode.getText(node);
 }
-/**
- * Checks if a stable array index is being accessed.
- *
- * @param stableResult - The stable result set.
- * @param node - The variable declarator node.
- * @param identifierName - The identifier name being accessed.
- * @returns True if accessing a stable array index.
- */
 function isStableArrayIndex(stableResult, node, identifierName) {
     if (!stableResult)
         return false;
-    if (!(stableResult instanceof Set) || node.type !== "VariableDeclarator" || node.id.type !== "ArrayPattern")
+    if (!(stableResult instanceof Set) ||
+        node.type !== TSESTree.AST_NODE_TYPES.VariableDeclarator ||
+        node.id.type !== TSESTree.AST_NODE_TYPES.ArrayPattern)
         return false;
     const elements = node.id.elements;
     for (let index = 0; index < elements.length; index += 1) {
         const element = elements[index];
-        if (element?.type === "Identifier" && element.name === identifierName)
+        if (element?.type === TSESTree.AST_NODE_TYPES.Identifier && element.name === identifierName)
             return stableResult.has(index);
     }
     return false;
 }
-/**
- * Checks if a value is from a stable hook.
- *
- * @param init - The initializer expression.
- * @param node - The variable declarator node.
- * @param identifierName - The identifier name being accessed.
- * @param stableHooks - Map of stable hooks.
- * @returns True if the value is from a stable hook.
- */
 function isStableHookValue(init, node, identifierName, stableHooks) {
-    const initNode = init;
-    if (initNode.type !== "CallExpression")
+    const castInit = init;
+    if (castInit.type !== TSESTree.AST_NODE_TYPES.CallExpression)
         return false;
-    const hookName = getHookName(initNode);
+    const hookName = getHookName(castInit);
     if (!hookName)
         return false;
     const stableResult = stableHooks.get(hookName);
@@ -220,67 +150,52 @@ function isStableHookValue(init, node, identifierName, stableHooks) {
         return true;
     return isStableArrayIndex(stableResult, node, identifierName);
 }
-/**
- * Checks if a value is stable (doesn't need to be in dependencies).
- *
- * @param variable - The variable to check.
- * @param identifierName - The identifier name being accessed.
- * @param stableHooks - Map of stable hooks.
- * @returns True if the value is stable.
- */
 /* eslint-disable jsdoc/require-param, jsdoc/require-returns */
 function isStableValue(variable, identifierName, stableHooks) {
     if (!variable)
         return false;
-    const { defs } = variable;
-    if (defs.length === 0)
+    const definitions = variable.defs;
+    if (definitions.length === 0)
         return false;
-    for (const def of defs) {
-        const { node, type } = def;
-        // Imports, functions, classes are stable
+    for (const definition of definitions) {
+        const { node, type } = definition;
         if (STABLE_VALUE_TYPES.has(type))
             return true;
-        // Check for const declarations with constant initializers
         if (type === "Variable" && node.type === "VariableDeclarator") {
             const parent = node.parent;
-            if (!parent || parent.type !== "VariableDeclaration" || parent.kind !== "const")
+            if (!parent || parent.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration || parent.kind !== "const")
                 continue;
             const { init } = node;
-            // Check if it's from a stable hook first
             // @ts-expect-error - Type mismatch between ESLint and TypeScript AST types
             if (init && isStableHookValue(init, node, identifierName, stableHooks))
                 return true;
-            // Check for React Lua bindings - bindings are always stable
-            if (init?.type === "CallExpression") {
+            if (init?.type === TSESTree.AST_NODE_TYPES.CallExpression) {
                 const { callee } = init;
-                // React.joinBindings() returns a stable binding
-                if (callee.type === "MemberExpression" &&
-                    callee.object.type === "Identifier" &&
+                if (callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+                    callee.object.type === TSESTree.AST_NODE_TYPES.Identifier &&
                     callee.object.name === "React" &&
-                    callee.property.type === "Identifier" &&
+                    callee.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
                     callee.property.name === "joinBindings")
                     return true;
-                // .map() on bindings returns a stable binding
-                // This covers: binding.map(...), React.joinBindings(...).map(...), etc.
-                if (callee.type === "MemberExpression" &&
-                    callee.property.type === "Identifier" &&
+                if (callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+                    callee.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
                     callee.property.name === "map")
                     return true;
             }
-            // Check for literal values FIRST (stable regardless of scope)
             if (init) {
-                if (init.type === "Literal" || init.type === "TemplateLiteral")
+                if (init.type === TSESTree.AST_NODE_TYPES.Literal ||
+                    init.type === TSESTree.AST_NODE_TYPES.TemplateLiteral)
                     return true;
-                if (init.type === "UnaryExpression" && init.argument.type === "Literal")
+                if (init.type === TSESTree.AST_NODE_TYPES.UnaryExpression &&
+                    init.argument.type === TSESTree.AST_NODE_TYPES.Literal)
                     return true;
             }
-            // For non-literal constants, only module-level is stable
-            // Component-scoped non-literal constants are recreated on every render
-            const varDef = variable.defs.find((d) => d.node === node);
-            if (varDef && varDef.node.type === "VariableDeclarator") {
-                const declParent = varDef.node.parent?.parent;
-                // Module-level (Program or ExportNamedDeclaration)
-                if (declParent && (declParent.type === "Program" || declParent.type === "ExportNamedDeclaration")) {
+            const variableDefinition = variable.defs.find((definition) => definition.node === node);
+            if (variableDefinition && variableDefinition.node.type === TSESTree.AST_NODE_TYPES.VariableDeclarator) {
+                const declarationParent = variableDefinition.node.parent?.parent;
+                if (declarationParent &&
+                    (declarationParent.type === TSESTree.AST_NODE_TYPES.Program ||
+                        declarationParent.type === TSESTree.AST_NODE_TYPES.ExportNamedDeclaration)) {
                     testingMetrics.moduleLevelStableConst += 1;
                     return true;
                 }
@@ -297,9 +212,9 @@ function isStableValue(variable, identifierName, stableHooks) {
  */
 function findTopmostMemberExpression(node) {
     let current = node;
-    let parent = node.parent;
+    let { parent } = node;
     // Walk up the tree while we're the object of a member expression
-    while (parent?.type === "MemberExpression" && parent.object === current) {
+    while (parent?.type === TSESTree.AST_NODE_TYPES.MemberExpression && parent.object === current) {
         current = parent;
         parent = parent.parent;
     }
@@ -350,18 +265,18 @@ function isDeclaredInComponentBody(variable, closureNode) {
             // Capture parent in a const so TypeScript understands it's stable in closures
             const functionParent = parent;
             // Check if variable is a parameter of this function (props)
-            const isParameter = variable.defs.some((def) => {
-                if (def.type !== "Parameter")
+            const isParameter = variable.defs.some((definition) => {
+                if (definition.type !== "Parameter")
                     return false;
                 // For parameters, the def.node is the function itself
                 // Just check if the definition's node is the current function parent
-                return def.node === functionParent;
+                return definition.node === functionParent;
             });
             if (isParameter)
                 return true; // Props are reactive
             // Check if variable is defined inside this function
-            return variable.defs.some((def) => {
-                let node = def.node.parent;
+            return variable.defs.some((definition) => {
+                let node = definition.node.parent;
                 while (node && node !== functionParent)
                     node = node.parent;
                 return node === functionParent;
@@ -391,48 +306,28 @@ function resolveFunctionReference(identifier, scope) {
     if (!variable || variable.defs.length === 0)
         return undefined;
     // Check all definitions for a function
-    for (const def of variable.defs) {
-        const { node } = def;
+    for (const definition of variable.defs) {
+        const { node } = definition;
         // Direct function declaration
-        if (node.type === "FunctionDeclaration")
+        if (node.type === TSESTree.AST_NODE_TYPES.FunctionDeclaration)
             return node;
         // Variable declarator with function initializer
-        if (node.type === "VariableDeclarator" &&
+        if (node.type === TSESTree.AST_NODE_TYPES.VariableDeclarator &&
             node.init &&
-            (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression"))
+            (node.init.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.init.type === TSESTree.AST_NODE_TYPES.FunctionExpression))
             return node.init;
     }
     return undefined;
 }
-/**
- * Collects all captured identifiers from a closure.
- *
- * @param node - The closure node (function/arrow function).
- * @param scope - The scope of the closure.
- * @param sourceCode - The source code instance.
- * @returns Array of captured identifiers.
- */
 function collectCaptures(node, scope, sourceCode) {
     const captures = new Array();
     const captureSet = new Set();
-    /**
-     * Recursively visits nodes to find identifier references.
-     *
-     * @param current - The current node.
-     */
     function visit(current) {
-        if (current.type === "Identifier") {
+        if (current.type === TSESTree.AST_NODE_TYPES.Identifier) {
             const { name } = current;
-            // Skip if already captured
-            if (captureSet.has(name))
-                return;
-            // Skip global built-ins (always stable, never need to be in dependencies)
-            if (GLOBAL_BUILTINS.has(name))
+            if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
                 return;
-            // Skip TypeScript type-only positions (type parameters, annotations, etc.)
-            if (isInTypePosition(current))
-                return;
-            // Look up the variable in the scope chain
             let variable;
             let currentScope = scope;
             while (currentScope) {
@@ -441,24 +336,20 @@ function collectCaptures(node, scope, sourceCode) {
                     break;
                 currentScope = currentScope.upper;
             }
-            // Only capture if variable is defined outside the closure
             if (variable) {
-                const isDefinedInClosure = variable.defs.some((def) => {
-                    let defNode = def.node;
-                    while (defNode) {
-                        if (defNode === node)
+                const isDefinedInClosure = variable.defs.some((definition) => {
+                    let definitionNode = definition.node;
+                    while (definitionNode) {
+                        if (definitionNode === node)
                             return true;
-                        defNode = defNode.parent;
+                        definitionNode = definitionNode.parent;
                     }
                     return false;
                 });
                 if (!isDefinedInClosure) {
-                    // Only capture variables declared in the component body
-                    // Per React rules, only "variables declared directly inside the component body" are reactive
-                    // Variables from outer scopes (module-level, parent functions) are non-reactive and stable
                     if (!isDeclaredInComponentBody(variable, node)) {
                         testingMetrics.outerScopeSkip += 1;
-                        return; // From outer scope - skip
+                        return;
                     }
                     captureSet.add(name);
                     const depthNode = findTopmostMemberExpression(current);
@@ -473,23 +364,20 @@ function collectCaptures(node, scope, sourceCode) {
                 }
             }
         }
-        // Unwrap TypeScript type expressions to visit the actual expression
-        if (current.type === "TSSatisfiesExpression" ||
-            current.type === "TSAsExpression" ||
-            current.type === "TSTypeAssertion" ||
-            current.type === "TSNonNullExpression") {
+        if (current.type === TSESTree.AST_NODE_TYPES.TSSatisfiesExpression ||
+            current.type === TSESTree.AST_NODE_TYPES.TSAsExpression ||
+            current.type === TSESTree.AST_NODE_TYPES.TSTypeAssertion ||
+            current.type === TSESTree.AST_NODE_TYPES.TSNonNullExpression) {
             visit(current.expression);
             return;
         }
-        // Traverse member expressions
-        if (current.type === "MemberExpression") {
+        if (current.type === TSESTree.AST_NODE_TYPES.MemberExpression) {
             visit(current.object);
             if (current.computed)
                 visit(current.property);
             return;
         }
-        // Visit children
-        const keys = sourceCode.visitorKeys?.[current.type] || [];
+        const keys = sourceCode.visitorKeys?.[current.type] ?? [];
         for (const key of keys) {
             const value = current[key];
             if (Array.isArray(value)) {
@@ -504,17 +392,10 @@ function collectCaptures(node, scope, sourceCode) {
     visit(node);
     return captures;
 }
-/**
- * Parses dependencies from a dependency array expression.
- *
- * @param node - The dependency array node.
- * @param sourceCode - The source code instance.
- * @returns Array of dependency information.
- */
 function parseDependencies(node, sourceCode) {
     const dependencies = new Array();
     for (const element of node.elements) {
-        if (!element || element.type === "SpreadElement")
+        if (!element || element.type === TSESTree.AST_NODE_TYPES.SpreadElement)
             continue;
         const name = nodeToDependencyString(element, sourceCode);
         const depth = getMemberExpressionDepth(element);
@@ -526,23 +407,11 @@ function parseDependencies(node, sourceCode) {
     }
     return dependencies;
 }
-/**
- * Checks if a dependency or capture is an inline function or object (unstable).
- *
- * @param node - The node to check.
- * @returns True if the node is an unstable value.
- */
 function isUnstableValue(node) {
     return node ? UNSTABLE_VALUES.has(node.type) : false;
 }
 const isNumberArray = Compile(Type.Array(Type.Number(), { minItems: 1, readOnly: true }));
 const isStringArray = Compile(Type.Array(Type.String(), { minItems: 1, readOnly: true }));
-/**
- * Converts stableResult configuration to internal format.
- *
- * @param stableResult - The stable result configuration.
- * @returns The internal stable result format.
- */
 function convertStableResult(stableResult) {
     if (typeof stableResult === "boolean")
         return stableResult;
@@ -565,12 +434,12 @@ const useExhaustiveDependencies = {
         // Build hook configuration map
         const hookConfigs = new Map(DEFAULT_HOOKS);
         for (const customHook of options.hooks) {
-            if (customHook.closureIndex !== undefined && customHook.dependenciesIndex !== undefined) {
-                hookConfigs.set(customHook.name, {
-                    closureIndex: customHook.closureIndex,
-                    dependenciesIndex: customHook.dependenciesIndex,
-                });
-            }
+            if (customHook.closureIndex === undefined || customHook.dependenciesIndex === undefined)
+                continue;
+            hookConfigs.set(customHook.name, {
+                closureIndex: customHook.closureIndex,
+                dependenciesIndex: customHook.dependenciesIndex,
+            });
         }
         // Build stable hooks map
         const stableHooks = new Map(STABLE_HOOKS);
@@ -600,33 +469,33 @@ const useExhaustiveDependencies = {
                 const callNode = node;
                 // Early exit: get hook name
                 const hookName = getHookName(callNode);
-                if (!hookName)
+                if (hookName === undefined || hookName === "")
                     return;
                 // Early exit: check if this hook needs dependency checking
                 const hookConfig = hookConfigs.get(hookName);
                 if (!hookConfig)
                     return;
                 const { closureIndex, dependenciesIndex } = hookConfig;
-                const { arguments: args } = callNode;
+                const parameters = callNode.arguments;
                 // Early exit: check if closure argument exists
-                const closureArg = args[closureIndex];
-                if (!closureArg)
+                const closureArgument = parameters[closureIndex];
+                if (closureArgument === undefined)
                     return;
                 // Resolve the actual closure function (handles both inline and reference cases)
                 let closureFunction;
-                if (closureArg.type === "ArrowFunctionExpression" || closureArg.type === "FunctionExpression") {
-                    closureFunction = closureArg;
-                }
-                else if (closureArg.type === "Identifier") {
+                if (closureArgument.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    closureArgument.type === TSESTree.AST_NODE_TYPES.FunctionExpression)
+                    closureFunction = closureArgument;
+                else if (closureArgument.type === TSESTree.AST_NODE_TYPES.Identifier) {
                     // Function reference - try to resolve it
                     const scope = getScope(callNode);
-                    closureFunction = resolveFunctionReference(closureArg, scope);
+                    closureFunction = resolveFunctionReference(closureArgument, scope);
                 }
                 // Early exit: check if we have a valid closure function
                 if (!closureFunction)
                     return;
                 // Get dependencies argument
-                const dependenciesArgument = args[dependenciesIndex];
+                const dependenciesArgument = parameters[dependenciesIndex];
                 // Report missing dependencies array if configured
                 if (!dependenciesArgument && options.reportMissingDependenciesArray) {
                     // Collect captures to see if any are needed
@@ -649,8 +518,8 @@ const useExhaustiveDependencies = {
                                     desc: `Add dependencies array: ${depsArrayString}`,
                                     fix(fixer) {
                                         // Insert the dependencies array after the closure argument
-                                        const closureArgNode = args[closureIndex];
-                                        return fixer.insertTextAfter(closureArgNode, `, ${depsArrayString}`);
+                                        const closureArgumentNode = parameters[closureIndex];
+                                        return fixer.insertTextAfter(closureArgumentNode, `, ${depsArrayString}`);
                                     },
                                 },
                             ],
@@ -662,14 +531,14 @@ const useExhaustiveDependencies = {
                 if (!dependenciesArgument)
                     return;
                 // Dependencies must be an array
-                if (dependenciesArgument.type !== "ArrayExpression")
+                if (dependenciesArgument.type !== TSESTree.AST_NODE_TYPES.ArrayExpression)
                     return;
-                const depsArray = dependenciesArgument;
+                const dependenciesArray = dependenciesArgument;
                 // Collect captures from closure
                 const scope = getScope(closureFunction);
                 const captures = collectCaptures(closureFunction, scope, context.sourceCode);
                 // Parse dependencies array
-                const dependencies = parseDependencies(depsArray, context.sourceCode);
+                const dependencies = parseDependencies(dependenciesArray, context.sourceCode);
                 // Check for unnecessary dependencies first (for consistent error ordering)
                 for (const dependency of dependencies) {
                     const dependencyRootIdentifier = getRootIdentifier(dependency.node);
@@ -682,8 +551,10 @@ const useExhaustiveDependencies = {
                     if (matchingCaptures.length === 0) {
                         if (options.reportUnnecessaryDependencies) {
                             // Generate fix suggestion
-                            const newDeps = dependencies.filter((d) => d.name !== dependency.name).map((d) => d.name);
-                            const newDepsString = `[${newDeps.join(", ")}]`;
+                            const newDependencies = dependencies
+                                .filter((value) => value.name !== dependency.name)
+                                .map(({ name }) => name);
+                            const dependenciesString = `[${newDependencies.join(", ")}]`;
                             context.report({
                                 data: { name: dependency.name },
                                 messageId: "unnecessaryDependency",
@@ -692,7 +563,7 @@ const useExhaustiveDependencies = {
                                     {
                                         desc: `Remove '${dependency.name}' from dependencies array`,
                                         fix(fixer) {
-                                            return fixer.replaceText(depsArray, newDepsString);
+                                            return fixer.replaceText(dependenciesArray, dependenciesString);
                                         },
                                     },
                                 ],
@@ -702,11 +573,13 @@ const useExhaustiveDependencies = {
                     }
                     // Check if dependency is more specific than any usage
                     // dep.depth > all capture depths means the dep is too specific
-                    const maxCaptureDepth = Math.max(...matchingCaptures.map((c) => c.depth));
+                    const maxCaptureDepth = Math.max(...matchingCaptures.map(({ depth }) => depth));
                     if (dependency.depth > maxCaptureDepth && options.reportUnnecessaryDependencies) {
                         // Generate fix suggestion
-                        const newDeps = dependencies.filter((d) => d.name !== dependency.name).map((d) => d.name);
-                        const newDepsString = `[${newDeps.join(", ")}]`;
+                        const newDependencies = dependencies
+                            .filter(({ name }) => name !== dependency.name)
+                            .map(({ name }) => name);
+                        const newDependenciesString = `[${newDependencies.join(", ")}]`;
                         context.report({
                             data: { name: dependency.name },
                             messageId: "unnecessaryDependency",
@@ -715,7 +588,7 @@ const useExhaustiveDependencies = {
                                 {
                                     desc: `Remove '${dependency.name}' from dependencies array`,
                                     fix(fixer) {
-                                        return fixer.replaceText(depsArray, newDepsString);
+                                        return fixer.replaceText(dependenciesArray, newDependenciesString);
                                     },
                                 },
                             ],
@@ -759,12 +632,12 @@ const useExhaustiveDependencies = {
                         context.report({
                             data: { name: firstMissing.usagePath },
                             messageId: "missingDependency",
-                            node: lastDependency?.node || depsArray,
+                            node: lastDependency?.node || dependenciesArray,
                             suggest: [
                                 {
                                     desc: `Add '${firstMissing.usagePath}' to dependencies array`,
                                     fix(fixer) {
-                                        return fixer.replaceText(depsArray, newDependenciesString);
+                                        return fixer.replaceText(dependenciesArray, newDependenciesString);
                                     },
                                 },
                             ],
@@ -776,12 +649,12 @@ const useExhaustiveDependencies = {
                         context.report({
                             data: { names: missingNames },
                             messageId: "missingDependencies",
-                            node: lastDependency?.node || depsArray,
+                            node: lastDependency?.node || dependenciesArray,
                             suggest: [
                                 {
                                     desc: "Add missing dependencies to array",
                                     fix(fixer) {
-                                        return fixer.replaceText(depsArray, newDependenciesString);
+                                        return fixer.replaceText(dependenciesArray, newDependenciesString);
                                     },
                                 },
                             ],