feat(no-ignored-observable): put back old rule

Too many existing projects manually enable this rule, so removing it is more impactful than the other proposed changes during prerelease.  This rule will be kept as-is and maybe removed in v2.

Author: JasonWeinzierl

README.md

@@ -92,6 +92,7 @@ The package includes the following rules.
 | [no-ignored-default-value](docs/rules/no-ignored-default-value.md)     | Disallow using `firstValueFrom`, `lastValueFrom`, `first`, and `last` without specifying a default value. | 🔒   |    |    | 💭 |    |
 | [no-ignored-error](docs/rules/no-ignored-error.md)                     | Disallow calling `subscribe` without specifying an error handler.                                         | 🔒   |    |    | 💭 |    |
 | [no-ignored-notifier](docs/rules/no-ignored-notifier.md)               | Disallow observables not composed from the `repeatWhen` or `retryWhen` notifier.                          | ✅ 🔒 |    |    | 💭 |    |
+| [no-ignored-observable](docs/rules/no-ignored-observable.md)           | Disallow ignoring observables returned by functions.                                                      |      |    |    | 💭 | ❌  |
 | [no-ignored-replay-buffer](docs/rules/no-ignored-replay-buffer.md)     | Disallow using `ReplaySubject`, `publishReplay` or `shareReplay` without specifying the buffer size.      | ✅ 🔒 |    |    |    |    |
 | [no-ignored-subscribe](docs/rules/no-ignored-subscribe.md)             | Disallow calling `subscribe` without specifying arguments.                                                |      |    |    | 💭 |    |
 | [no-ignored-subscription](docs/rules/no-ignored-subscription.md)       | Disallow ignoring the subscription returned by `subscribe`.                                               |      |    |    | 💭 |    |

docs/rules/no-ignored-observable.md

@@ -0,0 +1,31 @@
+# Disallow ignoring observables returned by functions (`rxjs-x/no-ignored-observable`)
+
+❌ This rule is deprecated. It was replaced by [`rxjs-x/no-floating-observables`](no-floating-observables.md).
+
+💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
+
+<!-- end auto-generated rule header -->
+
+The effects failures if an observable returned by a function is neither assigned to a variable or property or passed to a function.
+
+> [!WARNING]
+> This rule is being replaced by `no-floating-observables`.
+> The new rule has been expanded to handle more expression types.
+>
+> The current rule `no-ignored-observable` will be removed in a future major version.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of } from "rxjs";
+of(42, 54);
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { of } from "rxjs";
+const answers = of(42, 54);
+```

src/index.ts

@@ -20,6 +20,7 @@ import { noFloatingObservablesRule } from './rules/no-floating-observables';
 import { noIgnoredDefaultValueRule } from './rules/no-ignored-default-value';
 import { noIgnoredErrorRule } from './rules/no-ignored-error';
 import { noIgnoredNotifierRule } from './rules/no-ignored-notifier';
+import { noIgnoredObservableRule } from './rules/no-ignored-observable';
 import { noIgnoredReplayBufferRule } from './rules/no-ignored-replay-buffer';
 import { noIgnoredSubscribeRule } from './rules/no-ignored-subscribe';
 import { noIgnoredSubscriptionRule } from './rules/no-ignored-subscription';
@@ -67,6 +68,7 @@ const plugin = {
     'no-ignored-default-value': noIgnoredDefaultValueRule,
     'no-ignored-error': noIgnoredErrorRule,
     'no-ignored-notifier': noIgnoredNotifierRule,
+    'no-ignored-observable': noIgnoredObservableRule,
     'no-ignored-replay-buffer': noIgnoredReplayBufferRule,
     'no-ignored-subscribe': noIgnoredSubscribeRule,
     'no-ignored-subscription': noIgnoredSubscriptionRule,

src/rules/no-ignored-observable.ts

@@ -0,0 +1,35 @@
+import { TSESTree as es } from '@typescript-eslint/utils';
+import { getTypeServices } from '../etc';
+import { ruleCreator } from '../utils';
+
+export const noIgnoredObservableRule = ruleCreator({
+  defaultOptions: [],
+  meta: {
+    deprecated: true,
+    replacedBy: ['no-floating-observables'],
+    docs: {
+      description: 'Disallow ignoring observables returned by functions.',
+      requiresTypeChecking: true,
+    },
+    messages: {
+      forbidden: 'Ignoring a returned Observable is forbidden.',
+    },
+    schema: [],
+    type: 'problem',
+  },
+  name: 'no-ignored-observable',
+  create: (context) => {
+    const { couldBeObservable } = getTypeServices(context);
+
+    return {
+      'ExpressionStatement > CallExpression': (node: es.CallExpression) => {
+        if (couldBeObservable(node)) {
+          context.report({
+            messageId: 'forbidden',
+            node,
+          });
+        }
+      },
+    };
+  },
+});

tests/rules/no-ignored-observable.test.ts

@@ -0,0 +1,61 @@
+import { stripIndent } from 'common-tags';
+import { noIgnoredObservableRule } from '../../src/rules/no-ignored-observable';
+import { fromFixture } from '../etc';
+import { ruleTester } from '../rule-tester';
+
+ruleTester({ types: true }).run('no-ignored-observable', noIgnoredObservableRule, {
+  valid: [
+    stripIndent`
+      // not ignored
+      import { Observable, of } from "rxjs";
+
+      function functionSource() {
+        return of(42);
+      }
+
+      function sink(source: Observable<number>) {
+      }
+
+      const a = functionSource();
+      sink(functionSource());
+    `,
+    stripIndent`
+      // not ignored arrow
+      import { Observable, of } from "rxjs";
+
+      const arrowSource = () => of(42);
+
+      function sink(source: Observable<number>) {
+      }
+
+      const a = arrowSource();
+      sink(arrowSource());
+    `,
+  ],
+  invalid: [
+    fromFixture(
+      stripIndent`
+        // ignored
+        import { Observable, of } from "rxjs";
+
+        function functionSource() {
+          return of(42);
+        }
+
+        functionSource();
+        ~~~~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // ignored arrow
+        import { Observable, of } from "rxjs";
+
+        const arrowSource = () => of(42);
+
+        arrowSource();
+        ~~~~~~~~~~~~~ [forbidden]
+      `,
+    ),
+  ],
+});