feat(no-wait-for-side-effects): report render in waitFor

lib/create-testing-library-rule/detect-testing-library-utils.ts

@@ -75,7 +75,7 @@ type IsAsyncUtilFn = (
 ) => boolean;
 type IsFireEventMethodFn = (node: TSESTree.Identifier) => boolean;
 type IsUserEventMethodFn = (node: TSESTree.Identifier) => boolean;
-type IsRenderUtilFn = (node: TSESTree.Identifier) => boolean;
+type IsRenderUtilFn = (node: TSESTree.Identifier | null) => boolean;
 type IsRenderVariableDeclaratorFn = (
   node: TSESTree.VariableDeclarator
 ) => boolean;
@@ -105,8 +105,8 @@ export interface DetectionHelpers {
   isCustomQuery: IsCustomQueryFn;
   isBuiltInQuery: IsBuiltInQueryFn;
   isAsyncUtil: IsAsyncUtilFn;
-  isFireEventUtil: (node: TSESTree.Identifier) => boolean;
-  isUserEventUtil: (node: TSESTree.Identifier) => boolean;
+  isFireEventUtil: (node: TSESTree.Identifier | null) => boolean;
+  isUserEventUtil: (node: TSESTree.Identifier | null) => boolean;
   isFireEventMethod: IsFireEventMethodFn;
   isUserEventMethod: IsUserEventMethodFn;
   isRenderUtil: IsRenderUtilFn;
@@ -429,7 +429,9 @@ export function detectTestingLibraryUtils<
      *
      * Not to be confused with {@link isFireEventMethod}
      */
-    const isFireEventUtil = (node: TSESTree.Identifier): boolean => {
+    const isFireEventUtil = (node: TSESTree.Identifier | null): boolean => {
+      if (!node) return false;
+
       return isTestingLibraryUtil(
         node,
         (identifierNodeName, originalNodeName) => {
@@ -443,7 +445,9 @@ export function detectTestingLibraryUtils<
      *
      * Not to be confused with {@link isUserEventMethod}
      */
-    const isUserEventUtil = (node: TSESTree.Identifier): boolean => {
+    const isUserEventUtil = (node: TSESTree.Identifier | null): boolean => {
+      if (!node) return false;
+
       const userEvent = findImportedUserEventSpecifier();
       let userEventName: string | undefined;
 
@@ -569,18 +573,25 @@ export function detectTestingLibraryUtils<
      * Testing Library. Otherwise, it means `custom-module` has been set up, so
      * only those nodes coming from Testing Library will be considered as valid.
      */
-    const isRenderUtil: IsRenderUtilFn = (node) =>
-      isTestingLibraryUtil(node, (identifierNodeName, originalNodeName) => {
-        if (isAggressiveRenderReportingEnabled()) {
-          return identifierNodeName.toLowerCase().includes(RENDER_NAME);
-        }
+    const isRenderUtil: IsRenderUtilFn = (node) => {
+      if (!node) return false;
 
-        return [RENDER_NAME, ...getCustomRenders()].some(
-          (validRenderName) =>
-            validRenderName === identifierNodeName ||
-            (Boolean(originalNodeName) && validRenderName === originalNodeName)
-        );
-      });
+      return isTestingLibraryUtil(
+        node,
+        (identifierNodeName, originalNodeName) => {
+          if (isAggressiveRenderReportingEnabled()) {
+            return identifierNodeName.toLowerCase().includes(RENDER_NAME);
+          }
+
+          return [RENDER_NAME, ...getCustomRenders()].some(
+            (validRenderName) =>
+              validRenderName === identifierNodeName ||
+              (Boolean(originalNodeName) &&
+                validRenderName === originalNodeName)
+          );
+        }
+      );
+    };
 
     const isRenderVariableDeclarator: IsRenderVariableDeclaratorFn = (node) => {
       if (!node.init) {

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

@@ -16,6 +16,15 @@ export const isCallExpression = isNodeOfType(AST_NODE_TYPES.CallExpression);
 export const isExpressionStatement = isNodeOfType(
   AST_NODE_TYPES.ExpressionStatement
 );
+export const isVariableDeclaration = isNodeOfType(
+  AST_NODE_TYPES.VariableDeclaration
+);
+export const isAssignmentExpression = isNodeOfType(
+  AST_NODE_TYPES.AssignmentExpression
+);
+export const isSequenceExpression = isNodeOfType(
+  AST_NODE_TYPES.SequenceExpression
+);
 export const isImportDeclaration = isNodeOfType(
   AST_NODE_TYPES.ImportDeclaration
 );

lib/rules/no-wait-for-side-effects.ts

@@ -2,6 +2,10 @@ import { TSESTree } from '@typescript-eslint/experimental-utils';
 import {
   getPropertyIdentifierNode,
   isExpressionStatement,
+  isVariableDeclaration,
+  isAssignmentExpression,
+  isCallExpression,
+  isSequenceExpression,
 } from '../node-utils';
 import { createTestingLibraryRule } from '../create-testing-library-rule';
 
@@ -32,7 +36,11 @@ export default createTestingLibraryRule<Options, MessageIds>({
   defaultOptions: [],
   create: function (context, _, helpers) {
     function isCallerWaitFor(
-      node: TSESTree.BlockStatement | TSESTree.CallExpression
+      node:
+        | TSESTree.BlockStatement
+        | TSESTree.CallExpression
+        | TSESTree.AssignmentExpression
+        | TSESTree.SequenceExpression
     ): boolean {
       if (!node.parent) {
         return false;
@@ -52,18 +60,31 @@ export default createTestingLibraryRule<Options, MessageIds>({
       body: TSESTree.Node[]
     ): TSESTree.ExpressionStatement[] {
       return body.filter((node) => {
-        if (!isExpressionStatement(node)) {
+        if (!isExpressionStatement(node) && !isVariableDeclaration(node)) {
           return false;
         }
 
         const expressionIdentifier = getPropertyIdentifierNode(node);
-        if (!expressionIdentifier) {
-          return false;
-        }
+
+        const isRenderInVariableDeclaration =
+          isVariableDeclaration(node) &&
+          node.declarations.some((declaration) =>
+            helpers.isRenderVariableDeclarator(declaration)
+          );
+
+        const isRenderInAssignment =
+          isExpressionStatement(node) &&
+          isAssignmentExpression(node.expression) &&
+          helpers.isRenderUtil(
+            getPropertyIdentifierNode(node.expression.right)
+          );
 
         return (
           helpers.isFireEventUtil(expressionIdentifier) ||
-          helpers.isUserEventUtil(expressionIdentifier)
+          helpers.isUserEventUtil(expressionIdentifier) ||
+          helpers.isRenderUtil(expressionIdentifier) ||
+          isRenderInVariableDeclaration ||
+          isRenderInAssignment
         );
       }) as TSESTree.ExpressionStatement[];
     }
@@ -86,19 +107,35 @@ export default createTestingLibraryRule<Options, MessageIds>({
       }
     }
 
-    function reportImplicitReturnSideEffect(node: TSESTree.CallExpression) {
+    function reportImplicitReturnSideEffect(
+      node:
+        | TSESTree.CallExpression
+        | TSESTree.AssignmentExpression
+        | TSESTree.SequenceExpression
+    ) {
       if (!isCallerWaitFor(node)) {
         return;
       }
 
-      const expressionIdentifier = getPropertyIdentifierNode(node.callee);
-      if (!expressionIdentifier) {
-        return;
-      }
+      const expressionIdentifier =
+        isCallExpression(node) && getPropertyIdentifierNode(node.callee);
+      const isRenderInAssignment =
+        isAssignmentExpression(node) &&
+        helpers.isRenderUtil(getPropertyIdentifierNode(node.right));
+      const isRenderInSequenceAssignment =
+        isSequenceExpression(node) &&
+        node.expressions.some(
+          (expression) =>
+            isAssignmentExpression(expression) &&
+            helpers.isRenderUtil(getPropertyIdentifierNode(expression.right))
+        );
 
       if (
-        !helpers.isFireEventUtil(expressionIdentifier) &&
-        !helpers.isUserEventUtil(expressionIdentifier)
+        !helpers.isFireEventUtil(expressionIdentifier || null) &&
+        !helpers.isUserEventUtil(expressionIdentifier || null) &&
+        !helpers.isRenderUtil(expressionIdentifier || null) &&
+        !isRenderInAssignment &&
+        !isRenderInSequenceAssignment
       ) {
         return;
       }
@@ -112,6 +149,8 @@ export default createTestingLibraryRule<Options, MessageIds>({
     return {
       'CallExpression > ArrowFunctionExpression > BlockStatement': reportSideEffects,
       'CallExpression > ArrowFunctionExpression > CallExpression': reportImplicitReturnSideEffect,
+      'CallExpression > ArrowFunctionExpression > AssignmentExpression': reportImplicitReturnSideEffect,
+      'CallExpression > ArrowFunctionExpression > SequenceExpression': reportImplicitReturnSideEffect,
       'CallExpression > FunctionExpression > BlockStatement': reportSideEffects,
     };
   },