@pobammer-ts/eslint-cease-nonsense-rules 0.10.1 → 1.0.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") {
+    if (callee.type === TSESTree.AST_NODE_TYPES.Identifier)
         return callee.name;
-    }
-    // Member expression: React.useEffect(...)
-    if (callee.type === "MemberExpression" && callee.property.type === "Identifier") {
+    if (callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
+        callee.property.type === TSESTree.AST_NODE_TYPES.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)
+    let index = 0;
+    for (const element of elements) {
+        if (element.type === TSESTree.AST_NODE_TYPES.Identifier && element.name === identifierName)
             return stableResult.has(index);
+        index += 1;
     }
     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,50 @@ 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") {
+        if (type === "Variable" && node.type === TSESTree.AST_NODE_TYPES.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
+            const init = node.init;
             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;
                 }
@@ -289,17 +202,10 @@ function isStableValue(variable, identifierName, stableHooks) {
     }
     return false;
 }
-/**
- * Finds the topmost member expression in a chain when an identifier is the object.
- *
- * @param node - The identifier node.
- * @returns The topmost member expression or the node itself.
- */
 function findTopmostMemberExpression(node) {
     let current = node;
-    let parent = node.parent;
-    // Walk up the tree while we're the object of a member expression
-    while (parent?.type === "MemberExpression" && parent.object === current) {
+    let { parent } = node;
+    while (parent?.type === TSESTree.AST_NODE_TYPES.MemberExpression && parent.object === current) {
         current = parent;
         parent = parent.parent;
     }
@@ -311,57 +217,32 @@ const IS_CEASE_BOUNDARY = new Set([
     TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
     TSESTree.AST_NODE_TYPES.VariableDeclarator,
 ]);
-/**
- * Checks if an identifier is in a TypeScript type-only position.
- * Type parameters and type annotations are compile-time only and should not be dependencies.
- *
- * @param identifier - The identifier node to check.
- * @returns True if the identifier is in a type-only position.
- */
 function isInTypePosition(identifier) {
     let parent = identifier.parent;
     while (parent) {
-        // Any TypeScript-specific node indicates a type-only position
         if (parent.type.startsWith("TS"))
             return true;
-        // Stop searching at certain boundaries
         if (IS_CEASE_BOUNDARY.has(parent.type))
             return false;
         parent = parent.parent;
     }
     return false;
 }
-/**
- * Checks if a variable is declared directly in the component/hook body OR is a prop (parameter).
- * Per React rules, only variables "declared directly inside the component body" are reactive.
- * This includes props (function parameters).
- * Variables from outer scopes (module-level, parent functions) are non-reactive.
- *
- * @param variable - The variable to check.
- * @param closureNode - The closure node (useEffect callback, etc.).
- * @returns True if the variable is declared in the component body or is a prop.
- */
 function isDeclaredInComponentBody(variable, closureNode) {
-    // Find the parent component/hook function
     let parent = closureNode.parent;
     while (parent) {
         const isFunction = FUNCTION_DECLARATIONS.has(parent.type);
         if (isFunction) {
-            // 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 true;
+            return variable.defs.some((definition) => {
+                let node = definition.node.parent;
                 while (node && node !== functionParent)
                     node = node.parent;
                 return node === functionParent;
@@ -371,15 +252,7 @@ function isDeclaredInComponentBody(variable, closureNode) {
     }
     return false;
 }
-/**
- * Resolves an identifier to its function definition if it references a function.
- *
- * @param identifier - The identifier node.
- * @param scope - The scope to search in.
- * @returns The function node if found, undefined otherwise.
- */
 function resolveFunctionReference(identifier, scope) {
-    // Look up the variable in the scope chain
     let variable;
     let currentScope = scope;
     while (currentScope) {
@@ -390,49 +263,26 @@ 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;
-        // Direct function declaration
-        if (node.type === "FunctionDeclaration")
+    for (const definition of variable.defs) {
+        const { node } = definition;
+        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))
+            if (captureSet.has(name) || GLOBAL_BUILTINS.has(name) || isInTypePosition(current))
                 return;
-            // Skip global built-ins (always stable, never need to be in dependencies)
-            if (GLOBAL_BUILTINS.has(name))
-                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 +291,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 +319,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 +347,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 +362,14 @@ 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 returnName({ name }) {
+    return name;
+}
 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;
@@ -562,31 +389,22 @@ const useExhaustiveDependencies = {
             reportUnnecessaryDependencies: true,
             ...context.options[0],
         };
-        // 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);
         for (const customHook of options.hooks) {
             if (customHook.stableResult === undefined)
                 continue;
             stableHooks.set(customHook.name, convertStableResult(customHook.stableResult));
         }
-        // Performance: cache scope lookups
         const scopeCache = new WeakMap();
-        /**
-         * Gets the scope for a node with caching.
-         *
-         * @param node - The node to get scope for.
-         * @returns The scope.
-         */
         function getScope(node) {
             const cached = scopeCache.get(node);
             if (cached)
@@ -598,59 +416,49 @@ const useExhaustiveDependencies = {
         return {
             CallExpression(node) {
                 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;
-                // Early exit: check if closure argument exists
-                const closureArg = args[closureIndex];
-                if (!closureArg)
+                const parameters = callNode.arguments;
+                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") {
-                    // Function reference - try to resolve it
+                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) {
                     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];
-                // Report missing dependencies array if configured
+                const dependenciesArgument = parameters[dependenciesIndex];
                 if (!dependenciesArgument && options.reportMissingDependenciesArray) {
-                    // Collect captures to see if any are needed
                     const scope = getScope(closureFunction);
                     const captures = collectCaptures(closureFunction, scope, context.sourceCode);
-                    // Filter out stable values
                     const requiredCaptures = captures.filter((capture) => !isStableValue(capture.variable, capture.name, stableHooks));
                     if (requiredCaptures.length > 0) {
-                        const missingNames = Array.from(new Set(requiredCaptures.map(({ name }) => name))).join(", ");
-                        // Generate fix suggestion - add dependencies array
+                        // oxlint-disable-next-line no-array-callback-reference
+                        const missingNames = Array.from(new Set(requiredCaptures.map(returnName))).join(", ");
                         const usagePaths = requiredCaptures.map(({ usagePath }) => usagePath);
-                        const uniqueDeps = Array.from(new Set(usagePaths)).toSorted();
-                        const depsArrayString = `[${uniqueDeps.join(", ")}]`;
+                        const uniqueDependencies = Array.from(new Set(usagePaths)).toSorted();
+                        const dependenciesString = `[${uniqueDependencies.join(", ")}]`;
                         context.report({
                             data: { deps: missingNames },
                             messageId: "missingDependenciesArray",
                             node: callNode,
                             suggest: [
                                 {
-                                    desc: `Add dependencies array: ${depsArrayString}`,
+                                    desc: `Add dependencies array: ${dependenciesString}`,
                                     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, `, ${dependenciesString}`);
                                     },
                                 },
                             ],
@@ -658,32 +466,27 @@ const useExhaustiveDependencies = {
                     }
                     return;
                 }
-                // Early exit: no dependencies array
                 if (!dependenciesArgument)
                     return;
-                // Dependencies must be an array
-                if (dependenciesArgument.type !== "ArrayExpression")
+                if (dependenciesArgument.type !== TSESTree.AST_NODE_TYPES.ArrayExpression)
                     return;
-                const depsArray = dependenciesArgument;
-                // Collect captures from closure
+                const dependenciesArray = dependenciesArgument;
                 const scope = getScope(closureFunction);
                 const captures = collectCaptures(closureFunction, scope, context.sourceCode);
-                // Parse dependencies array
-                const dependencies = parseDependencies(depsArray, context.sourceCode);
-                // Check for unnecessary dependencies first (for consistent error ordering)
+                const dependencies = parseDependencies(dependenciesArray, context.sourceCode);
                 for (const dependency of dependencies) {
                     const dependencyRootIdentifier = getRootIdentifier(dependency.node);
                     if (!dependencyRootIdentifier)
                         continue;
                     const dependencyName = dependencyRootIdentifier.name;
-                    // Find all captures with the same root identifier
                     const matchingCaptures = captures.filter(({ node }) => getRootIdentifier(node)?.name === dependencyName);
-                    // If no captures use this identifier at all, it's unnecessary
                     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)
+                                // oxlint-disable-next-line no-array-callback-reference
+                                .map(returnName);
+                            const dependenciesString = `[${newDependencies.join(", ")}]`;
                             context.report({
                                 data: { name: dependency.name },
                                 messageId: "unnecessaryDependency",
@@ -692,7 +495,7 @@ const useExhaustiveDependencies = {
                                     {
                                         desc: `Remove '${dependency.name}' from dependencies array`,
                                         fix(fixer) {
-                                            return fixer.replaceText(depsArray, newDepsString);
+                                            return fixer.replaceText(dependenciesArray, dependenciesString);
                                         },
                                     },
                                 ],
@@ -700,13 +503,13 @@ const useExhaustiveDependencies = {
                         }
                         continue;
                     }
-                    // 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)
+                            // oxlint-disable-next-line no-array-callback-reference
+                            .map(returnName);
+                        const dependencyString = `[${newDependencies.join(", ")}]`;
                         context.report({
                             data: { name: dependency.name },
                             messageId: "unnecessaryDependency",
@@ -715,29 +518,24 @@ const useExhaustiveDependencies = {
                                 {
                                     desc: `Remove '${dependency.name}' from dependencies array`,
                                     fix(fixer) {
-                                        return fixer.replaceText(depsArray, newDepsString);
+                                        return fixer.replaceText(dependenciesArray, dependencyString);
                                     },
                                 },
                             ],
                         });
                     }
                 }
-                // Check for missing dependencies
                 const missingCaptures = new Array();
                 for (const capture of captures) {
-                    // Skip stable values
                     if (isStableValue(capture.variable, capture.name, stableHooks))
                         continue;
-                    // Check if the capture is in the dependencies
                     const rootIdentifier = getRootIdentifier(capture.node);
                     if (!rootIdentifier)
                         continue;
                     const captureName = rootIdentifier.name;
                     let isInDependencies = false;
-                    // Check if capture is covered by dependencies
                     for (const dependency of dependencies) {
                         const dependencyRootIdentifier = getRootIdentifier(dependency.node);
-                        // Check name match and depth: dependency should not be more specific than capture
                         if (dependencyRootIdentifier?.name === captureName && dependency.depth <= capture.depth) {
                             isInDependencies = true;
                             break;
@@ -746,7 +544,6 @@ const useExhaustiveDependencies = {
                     if (!isInDependencies)
                         missingCaptures.push(capture);
                 }
-                // Report all missing dependencies at once
                 if (missingCaptures.length > 0) {
                     const dependencyNames = dependencies.map(({ name }) => name);
                     const missingPaths = missingCaptures.map(({ usagePath }) => usagePath);
@@ -754,51 +551,45 @@ const useExhaustiveDependencies = {
                     const newDependenciesString = `[${newDependencies.join(", ")}]`;
                     const lastDependency = dependencies.at(-1);
                     const firstMissing = missingCaptures.at(0);
-                    // For single missing dependency, use singular message for backward compat
                     if (missingCaptures.length === 1 && firstMissing) {
                         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);
                                     },
                                 },
                             ],
                         });
                     }
                     else {
-                        // For multiple missing dependencies, use plural message
                         const missingNames = missingPaths.join(", ");
                         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);
                                     },
                                 },
                             ],
                         });
                     }
                 }
-                // Check for unstable dependencies in the array
                 for (const capture of captures) {
-                    // Skip stable values
                     if (isStableValue(capture.variable, capture.name, stableHooks))
                         continue;
-                    // Check if this capture has a corresponding dependency
                     const rootIdentifier = getRootIdentifier(capture.node);
                     if (!rootIdentifier)
                         continue;
                     const captureName = rootIdentifier.name;
-                    // Find if there's a matching dependency
                     for (const dependency of dependencies) {
                         const dependencyRootIdentifier = getRootIdentifier(dependency.node);
                         const isMatch = dependencyRootIdentifier?.name === captureName && dependency.depth === capture.depth;