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

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;
@@ -48,22 +56,92 @@ export default createTestingLibraryRule<Options, MessageIds>({
       );
     }
 
+    function isRenderInVariableDeclaration(node: TSESTree.Node) {
+      return (
+        isVariableDeclaration(node) &&
+        node.declarations.some((declaration) =>
+          helpers.isRenderVariableDeclarator(declaration)
+        )
+      );
+    }
+
+    function isRenderInAssignment(node: TSESTree.Node) {
+      if (
+        !isExpressionStatement(node) ||
+        !isAssignmentExpression(node.expression)
+      ) {
+        return false;
+      }
+
+      const expressionIdentifier = getPropertyIdentifierNode(
+        node.expression.right
+      );
+
+      if (!expressionIdentifier) {
+        return false;
+      }
+
+      return helpers.isRenderUtil(expressionIdentifier);
+    }
+
+    function isRenderInImplicitReturnAssignment(node: TSESTree.Node) {
+      if (!isAssignmentExpression(node)) {
+        return false;
+      }
+
+      const expressionIdentifier = getPropertyIdentifierNode(node.right);
+
+      if (!expressionIdentifier) {
+        return false;
+      }
+
+      return helpers.isRenderUtil(expressionIdentifier);
+    }
+
+    function isExpressionRenderUtil(expression: TSESTree.Expression) {
+      if (!isAssignmentExpression(expression)) {
+        return false;
+      }
+
+      const expressionIdentifier = getPropertyIdentifierNode(expression.right);
+
+      if (!expressionIdentifier) {
+        return false;
+      }
+
+      return helpers.isRenderUtil(expressionIdentifier);
+    }
+
+    function isRenderInSequenceAssignment(node: TSESTree.Node) {
+      if (!isSequenceExpression(node)) {
+        return false;
+      }
+
+      return node.expressions.some(isExpressionRenderUtil);
+    }
+
     function getSideEffectNodes(
       body: TSESTree.Node[]
     ): TSESTree.ExpressionStatement[] {
       return body.filter((node) => {
-        if (!isExpressionStatement(node)) {
+        if (!isExpressionStatement(node) && !isVariableDeclaration(node)) {
           return false;
         }
 
+        if (isRenderInVariableDeclaration(node) || isRenderInAssignment(node)) {
+          return true;
+        }
+
         const expressionIdentifier = getPropertyIdentifierNode(node);
+
         if (!expressionIdentifier) {
           return false;
         }
 
         return (
           helpers.isFireEventUtil(expressionIdentifier) ||
-          helpers.isUserEventUtil(expressionIdentifier)
+          helpers.isUserEventUtil(expressionIdentifier) ||
+          helpers.isRenderUtil(expressionIdentifier)
         );
       }) as TSESTree.ExpressionStatement[];
     }
@@ -86,19 +164,33 @@ 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) {
+      const expressionIdentifier = isCallExpression(node)
+        ? getPropertyIdentifierNode(node.callee)
+        : null;
+
+      if (
+        !expressionIdentifier &&
+        !isRenderInImplicitReturnAssignment(node) &&
+        !isRenderInSequenceAssignment(node)
+      ) {
         return;
       }
 
       if (
+        expressionIdentifier &&
         !helpers.isFireEventUtil(expressionIdentifier) &&
-        !helpers.isUserEventUtil(expressionIdentifier)
+        !helpers.isUserEventUtil(expressionIdentifier) &&
+        !helpers.isRenderUtil(expressionIdentifier)
       ) {
         return;
       }
@@ -112,6 +204,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,
     };
   },