fix(no-floating-observables): handle array expressions

Author: JasonWeinzierl

src/rules/no-floating-observables.ts

@@ -1,5 +1,5 @@
 import { TSESTree as es } from '@typescript-eslint/utils';
-import { getTypeServices, isCallExpression, isChainExpression } from '../etc';
+import { getTypeServices, isCallExpression, isChainExpression, isUnaryExpression } from '../etc';
 import { ruleCreator } from '../utils';
 
 const defaultOptions: readonly {
@@ -50,21 +50,25 @@ export const noFloatingObservablesRule = ruleCreator({
       }
     }
 
+    function checkVoid(node: es.UnaryExpression) {
+      if (ignoreVoid) return;
+      if (node.operator !== 'void') return;
+
+      let expression = node.argument;
+      if (isChainExpression(expression)) {
+        expression = expression.expression;
+      }
+
+      if (!isCallExpression(expression)) return;
+      checkNode(expression);
+    }
+
     return {
       'ExpressionStatement > CallExpression': (node: es.CallExpression) => {
         checkNode(node);
       },
       'ExpressionStatement > UnaryExpression': (node: es.UnaryExpression) => {
-        if (ignoreVoid) return;
-        if (node.operator !== 'void') return;
-
-        let expression = node.argument;
-        if (isChainExpression(expression)) {
-          expression = expression.expression;
-        }
-
-        if (!isCallExpression(expression)) return;
-        checkNode(expression);
+        checkVoid(node);
       },
       'ExpressionStatement > ChainExpression': (node: es.ChainExpression) => {
         if (!isCallExpression(node.expression)) return;
@@ -78,6 +82,16 @@ export const noFloatingObservablesRule = ruleCreator({
           }
         });
       },
+      'ExpressionStatement > ArrayExpression': (node: es.ArrayExpression) => {
+        node.elements.forEach(expression => {
+          if (!expression) return;
+          if (isCallExpression(expression)) {
+            checkNode(expression);
+          } else if (isUnaryExpression(expression)) {
+            checkVoid(expression);
+          }
+        });
+      },
     };
   },
 });

tests/rules/no-floating-observables.test.ts

@@ -18,6 +18,8 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
 
       functionSource().subscribe();
       const a = functionSource();
+      const b = [functionSource()];
+      [void functionSource()];
       sink(functionSource());
       void functionSource();
     `,
@@ -32,9 +34,21 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
 
       functionSource().subscribe();
       const a = arrowSource();
+      const b = [arrowSource()];
+      [void arrowSource()];
       sink(arrowSource());
       void functionSource();
     `,
+    stripIndent`
+      // unrelated
+      function foo() {}
+
+      [1, 2, 3, 'foo'];
+      const a = [1];
+      foo();
+      [foo()];
+      void foo();
+    `,
   ],
   invalid: [
     fromFixture(
@@ -72,6 +86,15 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
         ~~~~~~~~~~~~~~~ [forbidden]
       `,
     ),
+    fromFixture(
+      stripIndent`
+        // array
+        import { of } from "rxjs";
+
+        [of(42)];
+         ~~~~~~ [forbidden]
+      `,
+    ),
     fromFixture(
       stripIndent`
         // ignoreVoid false
@@ -85,6 +108,10 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
              ~~~~~~~~~~~~~~~~ [forbiddenNoVoid]
         void functionSource?.();
              ~~~~~~~~~~~~~~~~~~ [forbiddenNoVoid]
+        [void functionSource()];
+              ~~~~~~~~~~~~~~~~ [forbiddenNoVoid]
+        [void functionSource?.()];
+              ~~~~~~~~~~~~~~~~~~ [forbiddenNoVoid]
       `,
       {
         options: [{ ignoreVoid: false }],