feat(no-misused-observables): new rule (#58)

New rule based on `@typescript-eslint/no-misused-promises`. Ensures you
don't return an Observable where void is expected, or try to spread an
Observable. This rule is added to the `strict` configuration.

Resolves #43 .

Note: `checksVoidReturn` is noticeably slow, specifically stemming from
the `arguments`, `properties`, and `variables` sub-options. It's still
faster than `@typescript-eslint/no-deprecated` and some `import-x`
rules, but it's in the top 10 with `TIMING=1` enabled. But since the
implementation is similar to `@typescript-eslint/no-misused-promises`
which has similar performance, we'll allow it.

Author: JasonWeinzierl

README.md

@@ -100,6 +100,7 @@ The package includes the following rules.
 | [no-implicit-any-catch](docs/rules/no-implicit-any-catch.md)           | Disallow implicit `any` error parameters in `catchError` operators.                                       | ✅ 🔒 | 🔧 | 💡 | 💭 |    |
 | [no-index](docs/rules/no-index.md)                                     | Disallow importing index modules.                                                                         | ✅ 🔒 |    |    |    |    |
 | [no-internal](docs/rules/no-internal.md)                               | Disallow importing internal modules.                                                                      | ✅ 🔒 | 🔧 | 💡 |    |    |
+| [no-misused-observables](docs/rules/no-misused-observables.md)         | Disallow Observables in places not designed to handle them.                                               | 🔒   |    |    | 💭 |    |
 | [no-nested-subscribe](docs/rules/no-nested-subscribe.md)               | Disallow calling `subscribe` within a `subscribe` callback.                                               | ✅ 🔒 |    |    | 💭 |    |
 | [no-redundant-notify](docs/rules/no-redundant-notify.md)               | Disallow sending redundant notifications from completed or errored observables.                           | ✅ 🔒 |    |    | 💭 |    |
 | [no-sharereplay](docs/rules/no-sharereplay.md)                         | Disallow unsafe `shareReplay` usage.                                                                      | ✅ 🔒 |    |    |    |    |

docs/rules/no-floating-observables.md

@@ -19,6 +19,7 @@ This rule will report observable-valued statements that are not treated in one o
 
 > [!TIP]
 > `no-floating-observables` only detects apparently unhandled observable _statements_.
+> See [`no-misused-observables`](./no-misused-observables.md) for detecting code that provides observables to _logical_ locations
 
 ## Rule details
 

docs/rules/no-misused-observables.md

@@ -0,0 +1,85 @@
+# Disallow Observables in places not designed to handle them (`rxjs-x/no-misused-observables`)
+
+💼 This rule is enabled in the 🔒 `strict` config.
+
+💭 This rule requires [type information](https://typescript-eslint.io/linting/typed-linting).
+
+<!-- end auto-generated rule header -->
+
+This rule forbids providing observables to logical locations where the TypeScript compiler allows them but they are not handled properly.
+These situations can often arise due to a misunderstanding of the way observables are handled.
+
+> [!TIP]
+> `no-misused-observables` only detects code that provides observables to incorrect _logical_ locations.
+> See [`no-floating-observables`](./no-floating-observables.md) for detecting unhandled observable _statements_.
+
+This rule is like [no-misused-promises](https://typescript-eslint.io/rules/no-misused-promises) but for Observables.
+
+> [!NOTE]
+> Unlike `@typescript-eslint/no-misused-promises`, this rule does not check conditionals like `if` statements.
+> Use `@typescript-eslint/no-unnecessary-condition` for linting those situations.
+
+## Rule details
+
+Examples of **incorrect** code for this rule:
+
+```ts
+import { of } from "rxjs";
+
+[1, 2, 3].forEach(i => of(i));
+
+interface MySyncInterface {
+    foo(): void;
+}
+class MyRxClass implements MySyncInterface {
+    foo(): Observable<number> {
+        return of(42);
+    }
+}
+
+const a = of(42);
+const b = { ...b };
+```
+
+Examples of **correct** code for this rule:
+
+```ts
+import { of } from "rxjs";
+
+[1, 2, 3].map(i => of(i));
+
+interface MyRxInterface {
+    foo(): Observable<number>;
+}
+class MyRxClass implements MyRxInterface {
+    foo(): Observable<number> {
+        return of(42);
+    }
+}
+```
+
+## Options
+
+<!-- WARNING: not auto-generated! -->
+
+| Name               | Description                                                                 | Type    | Default |
+| :----------------- | :-------------------------------------------------------------------------- | :------ | :------ |
+| `checksSpreads`    | Disallow `...` spreading an Observable.                                     | Boolean | `true`  |
+| `checksVoidReturn` | Disallow returning an Observable from a function typed as returning `void`. | Object  | `true`  |
+
+### `checksVoidReturn`
+
+You can disable selective parts of the `checksVoidReturn` option. The following sub-options are supported:
+
+| Name               | Description                                                                                                                              | Type    | Default |
+| :----------------- | :--------------------------------------------------------------------------------------------------------------------------------------- | :------ | :------ |
+| `arguments`        | Disallow passing an Observable-returning function as an argument where the parameter type expects a function that returns `void`.        | Boolean | `true`  |
+| `attributes`       | Disallow passing an Observable-returning function as a JSX attribute expected to be a function that returns `void`.                      | Boolean | `true`  |
+| `inheritedMethods` | Disallow providing an Observable-returning function where a function that returns `void` is expected by an extended or implemented type. | Boolean | `true`  |
+| `properties`       | Disallow providing an Observable-returning function where a function that returns `void` is expected by a property.                      | Boolean | `true`  |
+| `returns`          | Disallow returning an Observable-returning function where a function that returns `void` is expected.                                    | Boolean | `true`  |
+| `variables`        | Disallow assigning or declaring an Observable-returning function where a function that returns `void` is expected.                       | Boolean | `true`  |
+
+## Further reading
+
+- [TypeScript void function assignability](https://github.com/Microsoft/TypeScript/wiki/FAQ#why-are-functions-returning-non-void-assignable-to-function-returning-void)

src/configs/strict.ts

@@ -22,6 +22,7 @@ export const createStrictConfig = (
     }],
     'rxjs-x/no-index': 'error',
     'rxjs-x/no-internal': 'error',
+    'rxjs-x/no-misused-observables': 'error',
     'rxjs-x/no-nested-subscribe': 'error',
     'rxjs-x/no-redundant-notify': 'error',
     'rxjs-x/no-sharereplay': 'error',

src/etc/get-type-services.ts

@@ -38,12 +38,16 @@ export function getTypeServices<
       || ts.isMethodDeclaration(tsNode)
       || ts.isFunctionExpression(tsNode)
     ) {
-      tsTypeNode = tsNode.type ?? tsNode.body;
+      tsTypeNode = tsNode.type ?? tsNode.body; // TODO(#57): this doesn't work for Block bodies.
     } else if (
       ts.isCallSignatureDeclaration(tsNode)
       || ts.isMethodSignature(tsNode)
     ) {
       tsTypeNode = tsNode.type;
+    } else if (
+      ts.isPropertySignature(tsNode)
+    ) {
+      // TODO(#66): this doesn't work for functions assigned to class properties, variables, params.
     }
     return Boolean(
       tsTypeNode

src/etc/is.ts

@@ -78,6 +78,10 @@ export function isImportSpecifier(node: TSESTree.Node): node is TSESTree.ImportS
   return node.type === AST_NODE_TYPES.ImportSpecifier;
 }
 
+export function isJSXExpressionContainer(node: TSESTree.Node): node is TSESTree.JSXExpressionContainer {
+  return node.type === AST_NODE_TYPES.JSXExpressionContainer;
+}
+
 export function isLiteral(node: TSESTree.Node): node is TSESTree.Literal {
   return node.type === AST_NODE_TYPES.Literal;
 }
@@ -86,6 +90,10 @@ export function isMemberExpression(node: TSESTree.Node): node is TSESTree.Member
   return node.type === AST_NODE_TYPES.MemberExpression;
 }
 
+export function isMethodDefinition(node: TSESTree.Node): node is TSESTree.MethodDefinition {
+  return node.type === AST_NODE_TYPES.MethodDefinition;
+}
+
 export function isNewExpression(node: TSESTree.Node): node is TSESTree.NewExpression {
   return node.type === AST_NODE_TYPES.NewExpression;
 }
@@ -106,6 +114,10 @@ export function isProperty(node: TSESTree.Node): node is TSESTree.Property {
   return node.type === AST_NODE_TYPES.Property;
 }
 
+export function isPropertyDefinition(node: TSESTree.Node): node is TSESTree.PropertyDefinition {
+  return node.type === AST_NODE_TYPES.PropertyDefinition;
+}
+
 export function isPrivateIdentifier(
   node: TSESTree.Node,
 ): node is TSESTree.PrivateIdentifier {

src/index.ts

@@ -27,6 +27,7 @@ import { noIgnoredTakewhileValueRule } from './rules/no-ignored-takewhile-value'
 import { noImplicitAnyCatchRule } from './rules/no-implicit-any-catch';
 import { noIndexRule } from './rules/no-index';
 import { noInternalRule } from './rules/no-internal';
+import { noMisusedObservablesRule } from './rules/no-misused-observables';
 import { noNestedSubscribeRule } from './rules/no-nested-subscribe';
 import { noRedundantNotifyRule } from './rules/no-redundant-notify';
 import { noSharereplayRule } from './rules/no-sharereplay';
@@ -74,6 +75,7 @@ const plugin = {
     'no-implicit-any-catch': noImplicitAnyCatchRule,
     'no-index': noIndexRule,
     'no-internal': noInternalRule,
+    'no-misused-observables': noMisusedObservablesRule,
     'no-nested-subscribe': noNestedSubscribeRule,
     'no-redundant-notify': noRedundantNotifyRule,
     'no-sharereplay': noSharereplayRule,