fix(no-unnecessary-act): handle optional chaining calls

lib/node-utils/index.ts

@@ -6,6 +6,7 @@ import {
 	isArrayExpression,
 	isArrowFunctionExpression,
 	isAssignmentExpression,
+	isChainExpression,
 	isBlockStatement,
 	isCallExpression,
 	isExpressionStatement,
@@ -379,7 +380,7 @@ export function getPropertyIdentifierNode(
 		return getPropertyIdentifierNode(node.callee);
 	}
 
-	if (isExpressionStatement(node)) {
+	if (isExpressionStatement(node) || isChainExpression(node)) {
 		return getPropertyIdentifierNode(node.expression);
 	}
 
@@ -407,6 +408,10 @@ export function getDeepestIdentifierNode(
 		return node;
 	}
 
+	if (isChainExpression(node)) {
+		return getDeepestIdentifierNode(node.expression);
+	}
+
 	if (isMemberExpression(node) && ASTUtils.isIdentifier(node.property)) {
 		return node.property;
 	}
@@ -615,48 +620,45 @@ export function hasImportMatch(
 	return importNode.local.name === identifierName;
 }
 
-export function getStatementCallExpression(
-	statement: TSESTree.Statement
-): TSESTree.CallExpression | undefined {
-	if (isExpressionStatement(statement)) {
-		const { expression } = statement;
-		if (isCallExpression(expression)) {
-			return expression;
-		}
+function getCallExpressionFromNode(
+	node: TSESTree.Node | null
+): TSESTree.CallExpression | null {
+	if (isCallExpression(node)) {
+		return node;
+	}
 
-		if (
-			ASTUtils.isAwaitExpression(expression) &&
-			isCallExpression(expression.argument)
-		) {
-			return expression.argument;
-		}
+	if (isChainExpression(node)) {
+		return getCallExpressionFromNode(node.expression);
+	}
 
-		if (isAssignmentExpression(expression)) {
-			if (isCallExpression(expression.right)) {
-				return expression.right;
-			}
+	if (ASTUtils.isAwaitExpression(node)) {
+		return getCallExpressionFromNode(node.argument);
+	}
 
-			if (
-				ASTUtils.isAwaitExpression(expression.right) &&
-				isCallExpression(expression.right.argument)
-			) {
-				return expression.right.argument;
-			}
-		}
+	if (isAssignmentExpression(node)) {
+		return getCallExpressionFromNode(node.right);
 	}
 
-	if (isReturnStatement(statement) && isCallExpression(statement.argument)) {
-		return statement.argument;
+	return null;
+}
+
+export function getStatementCallExpression(
+	statement: TSESTree.Statement
+): TSESTree.CallExpression | null {
+	if (isExpressionStatement(statement)) {
+		return getCallExpressionFromNode(statement.expression);
+	}
+
+	if (isReturnStatement(statement)) {
+		return getCallExpressionFromNode(statement.argument);
 	}
 
 	if (isVariableDeclaration(statement)) {
 		for (const declaration of statement.declarations) {
-			if (isCallExpression(declaration.init)) {
-				return declaration.init;
-			}
+			return getCallExpressionFromNode(declaration.init);
 		}
 	}
-	return undefined;
+	return null;
 }
 
 /**

lib/node-utils/is-node-of-type.ts

@@ -21,6 +21,9 @@ export const isVariableDeclaration = ASTUtils.isNodeOfType(
 export const isAssignmentExpression = ASTUtils.isNodeOfType(
 	AST_NODE_TYPES.AssignmentExpression
 );
+export const isChainExpression = ASTUtils.isNodeOfType(
+	AST_NODE_TYPES.ChainExpression
+);
 export const isSequenceExpression = ASTUtils.isNodeOfType(
 	AST_NODE_TYPES.SequenceExpression
 );

tests/lib/rules/no-unnecessary-act.test.ts

@@ -78,6 +78,18 @@ const validNonStrictTestCases: RuleValidTestCase[] = [
       })
       `,
 	},
+	{
+		code: `// case: RTL act wrapping optional chaining call without RTL usage
+      import { act, render } from '@testing-library/react'
+
+      test('valid case', async () => {
+        act(() => {
+          render(element);
+          callback?.();
+        });
+      });
+      `,
+	},
 ];
 
 const validTestCases: RuleValidTestCase[] = [
@@ -140,6 +152,19 @@ const validTestCases: RuleValidTestCase[] = [
       act(() => stuffThatDoesNotUseRTL()).then(() => {})
       act(stuffThatDoesNotUseRTL().then(() => {}))
     });
+    `,
+	})),
+	...SUPPORTED_TESTING_FRAMEWORKS.map(([testingFramework, shortName]) => ({
+		code: `// case: ${shortName} act wrapping non-${shortName} calls
+    import { act } from '${testingFramework}'
+
+		let callback: undefined | (() => void);
+
+    test('valid case', async () => {
+      act(() => {
+        callback?.();
+      });
+    });
     `,
 	})),
 	{