feat(no-floating-observables): add option to ignore void expression

Author: JasonWeinzierl

docs/rules/no-floating-observables.md

@@ -35,3 +35,13 @@ Examples of **correct** code for this rule:
 import { of } from "rxjs";
 const answers = of(42, 54);
 ```
+
+## Options
+
+<!-- begin auto-generated rule options list -->
+
+| Name         | Description                           | Type    | Default |
+| :----------- | :------------------------------------ | :------ | :------ |
+| `ignoreVoid` | Whether to ignore `void` expressions. | Boolean | `true`  |
+
+<!-- end auto-generated rule options list -->

src/etc/is.ts

@@ -124,6 +124,10 @@ export function isTSTypeReference(node: TSESTree.Node): node is TSESTree.TSTypeR
   return node.type === AST_NODE_TYPES.TSTypeReference;
 }
 
+export function isUnaryExpression(node: TSESTree.Node): node is TSESTree.UnaryExpression {
+  return node.type === AST_NODE_TYPES.UnaryExpression;
+}
+
 export function isVariableDeclarator(
   node: TSESTree.Node,
 ): node is TSESTree.VariableDeclarator {

src/rules/no-floating-observables.ts

@@ -1,34 +1,66 @@
 import { TSESTree as es } from '@typescript-eslint/utils';
-import { getTypeServices } from '../etc';
+import { getTypeServices, isUnaryExpression } from '../etc';
 import { ruleCreator } from '../utils';
 
+const defaultOptions: readonly {
+  ignoreVoid?: boolean;
+}[] = [];
+
+const messageBase
+  = 'Observables must be subscribed to, returned, converted to a promise and awaited, '
+  + 'or be explicitly marked as ignored with the `void` operator.';
+
+const messageBaseNoVoid
+    = 'Observables must be subscribed to, returned, or converted to a promise and awaited.';
+
 export const noFloatingObservablesRule = ruleCreator({
-  defaultOptions: [],
+  defaultOptions,
   meta: {
     docs: {
       description: 'Require Observables to be handled appropriately.',
       recommended: 'strict',
       requiresTypeChecking: true,
     },
     messages: {
-      forbidden:
-        'Observables must be subscribed to, returned, converted to a promise and awaited, '
-        + 'or be explicitly marked as ignored with the `void` operator.',
+      forbidden: messageBase,
+      forbiddenNoVoid: messageBaseNoVoid,
     },
-    schema: [],
+    schema: [
+      {
+        properties: {
+          ignoreVoid: { type: 'boolean', default: true, description: 'Whether to ignore `void` expressions.' },
+        },
+        type: 'object',
+      },
+    ],
     type: 'problem',
   },
   name: 'no-floating-observables',
   create: (context) => {
     const { couldBeObservable } = getTypeServices(context);
+    const [config = {}] = context.options;
+    const { ignoreVoid = true } = config;
 
     return {
-      'ExpressionStatement > CallExpression': (node: es.CallExpression) => {
-        if (couldBeObservable(node)) {
+      ExpressionStatement: (node: es.ExpressionStatement) => {
+        const { expression } = node;
+        if (couldBeObservable(expression)) {
           context.report({
-            messageId: 'forbidden',
+            messageId: ignoreVoid ? 'forbidden' : 'forbiddenNoVoid',
             node,
           });
+          return;
+        }
+
+        if (!ignoreVoid && isUnaryExpression(expression)) {
+          const { operator, argument } = expression;
+          if (operator === 'void' && couldBeObservable(argument)) {
+            context.report({
+              messageId: 'forbiddenNoVoid',
+              node: argument,
+            });
+            return;
+          }
         }
       },
     };

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

@@ -16,8 +16,10 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
       function sink(source: Observable<number>) {
       }
 
+      functionSource().subscribe();
       const a = functionSource();
       sink(functionSource());
+      void functionSource();
     `,
     stripIndent`
       // not ignored arrow
@@ -28,17 +30,9 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
       function sink(source: Observable<number>) {
       }
 
+      functionSource().subscribe();
       const a = arrowSource();
       sink(arrowSource());
-    `,
-    stripIndent`
-      // void operator
-      import { of } from "rxjs";
-
-      function functionSource() {
-        return of(42);
-      }
-
       void functionSource();
     `,
   ],
@@ -53,7 +47,7 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
         }
 
         functionSource();
-        ~~~~~~~~~~~~~~~~ [forbidden]
+        ~~~~~~~~~~~~~~~~~ [forbidden]
       `,
     ),
     fromFixture(
@@ -64,8 +58,24 @@ ruleTester({ types: true }).run('no-floating-observables', noFloatingObservables
         const arrowSource = () => of(42);
 
         arrowSource();
-        ~~~~~~~~~~~~~ [forbidden]
+        ~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // ignoreVoid false
+        import { Observable, of } from "rxjs";
+
+        function functionSource() {
+          return of(42);
+        }
+
+        void functionSource();
+             ~~~~~~~~~~~~~~~~ [forbiddenNoVoid]
       `,
+      {
+        options: [{ ignoreVoid: false }],
+      },
     ),
   ],
 });