chore: refactor tree-walking to respect function scope boundaries

Author: JMiltier

src/rules/no-unsettled-absence-query.ts

@@ -8,6 +8,7 @@ import {
 	isArrowFunctionExpression,
 	isBlockStatement,
 	isCallExpression,
+	isFunctionDeclaration,
 	isFunctionExpression,
 	isMemberExpression,
 } from '../node-utils';
@@ -18,10 +19,54 @@ const RULE_NAME = 'no-unsettled-absence-query';
 export type MessageIds = 'noUnsettledAbsenceQuery';
 export type Options = [];
 
-// Matchers that indicate absence when negated, beyond those already
-// covered by helpers.isAbsenceAssert() (which handles PRESENCE_MATCHERS).
 const NEGATED_ABSENCE_MATCHERS = ['toBeVisible'];
 
+function isNestedFunction(node: TSESTree.Node): boolean {
+	return (
+		isArrowFunctionExpression(node) ||
+		isFunctionExpression(node) ||
+		isFunctionDeclaration(node)
+	);
+}
+
+function containsNode(
+	node: TSESTree.Node,
+	predicate: (n: TSESTree.Node) => boolean
+): boolean {
+	if (predicate(node)) {
+		return true;
+	}
+
+	if (isNestedFunction(node)) {
+		return false;
+	}
+
+	for (const key of Object.keys(node)) {
+		if (key === 'parent') continue;
+		const child = (node as unknown as Record<string, unknown>)[key];
+		if (child && typeof child === 'object') {
+			if (Array.isArray(child)) {
+				for (const item of child) {
+					if (
+						item &&
+						typeof item === 'object' &&
+						'type' in item &&
+						containsNode(item as TSESTree.Node, predicate)
+					) {
+						return true;
+					}
+				}
+			} else if (
+				'type' in child &&
+				containsNode(child as TSESTree.Node, predicate)
+			) {
+				return true;
+			}
+		}
+	}
+	return false;
+}
+
 export default createTestingLibraryRule<Options, MessageIds>({
 	name: RULE_NAME,
 	meta: {
@@ -62,12 +107,6 @@ export default createTestingLibraryRule<Options, MessageIds>({
 			);
 		}
 
-		/**
-		 * Determines whether a node is inside a callback passed to an async
-		 * Testing Library utility (e.g. waitFor). Absence assertions inside
-		 * these callbacks are always flagged because they can pass on the first
-		 * invocation before the component has settled.
-		 */
 		function isInsideAsyncUtilCallback(node: TSESTree.Node): boolean {
 			let current: TSESTree.Node | undefined = node.parent;
 
@@ -121,82 +160,23 @@ export default createTestingLibraryRule<Options, MessageIds>({
 			return null;
 		}
 
-		function containsAwaitExpression(node: TSESTree.Node): boolean {
-			if (ASTUtils.isAwaitExpression(node)) {
-				return true;
-			}
-
-			for (const key of Object.keys(node)) {
-				if (key === 'parent') continue;
-				const child = (node as unknown as Record<string, unknown>)[key];
-				if (child && typeof child === 'object') {
-					if (Array.isArray(child)) {
-						for (const item of child) {
-							if (
-								item &&
-								typeof item === 'object' &&
-								'type' in item &&
-								containsAwaitExpression(item as TSESTree.Node)
-							) {
-								return true;
-							}
-						}
-					} else if (
-						'type' in child &&
-						containsAwaitExpression(child as TSESTree.Node)
-					) {
-						return true;
-					}
-				}
-			}
-			return false;
-		}
-
-		function containsGetQueryCall(node: TSESTree.Node): boolean {
-			if (ASTUtils.isIdentifier(node) && helpers.isGetQueryVariant(node)) {
-				return true;
-			}
-
-			for (const key of Object.keys(node)) {
-				if (key === 'parent') continue;
-				const child = (node as unknown as Record<string, unknown>)[key];
-				if (child && typeof child === 'object') {
-					if (Array.isArray(child)) {
-						for (const item of child) {
-							if (
-								item &&
-								typeof item === 'object' &&
-								'type' in item &&
-								containsGetQueryCall(item as TSESTree.Node)
-							) {
-								return true;
-							}
-						}
-					} else if (
-						'type' in child &&
-						containsGetQueryCall(child as TSESTree.Node)
-					) {
-						return true;
-					}
-				}
-			}
-			return false;
-		}
-
 		function hasSettlingExpression(statement: TSESTree.Statement): boolean {
-			return (
-				containsAwaitExpression(statement) || containsGetQueryCall(statement)
+			const hasAwait = containsNode(statement, (n) =>
+				ASTUtils.isAwaitExpression(n)
+			);
+			const hasGetQuery = containsNode(
+				statement,
+				(n) => ASTUtils.isIdentifier(n) && helpers.isGetQueryVariant(n)
 			);
+			return hasAwait || hasGetQuery;
 		}
 
 		return {
 			'CallExpression Identifier'(node: TSESTree.Identifier) {
-				// Only interested in queryBy* / queryAllBy* variants
 				if (!helpers.isQueryQueryVariant(node)) {
 					return;
 				}
 
-				// Must be inside an expect() call
 				const expectCallNode = findClosestCallNode(node, 'expect');
 				if (
 					!expectCallNode?.parent ||
@@ -205,14 +185,10 @@ export default createTestingLibraryRule<Options, MessageIds>({
 					return;
 				}
 
-				// Must be an absence assertion
 				if (!isAbsenceAssertion(expectCallNode.parent)) {
 					return;
 				}
 
-				// Absence assertions inside async util callbacks (e.g. waitFor) are
-				// always flagged - they pass on the first invocation before the
-				// component has settled.
 				if (isInsideAsyncUtilCallback(node)) {
 					context.report({
 						node,
@@ -222,8 +198,6 @@ export default createTestingLibraryRule<Options, MessageIds>({
 					return;
 				}
 
-				// Find the enclosing function body and determine whether a settling
-				// expression appears on any preceding statement.
 				const functionBody = findEnclosingFunctionBody(node);
 				if (!functionBody) {
 					return;