feat(no-misused-observables): properties

Author: JasonWeinzierl

src/rules/no-misused-observables.ts

@@ -54,7 +54,7 @@ export const noMisusedObservablesRule = ruleCreator({
       ClassDeclaration: checkClassLikeOrInterfaceNode,
       ClassExpression: checkClassLikeOrInterfaceNode,
       TSInterfaceDeclaration: checkClassLikeOrInterfaceNode,
-      // Property: checkProperty,
+      Property: checkProperty,
       // ReturnStatement: checkReturnStatement,
       // AssignmentExpression: checkAssignment,
       // VariableDeclarator: checkVariableDeclarator,
@@ -150,6 +150,27 @@ export const noMisusedObservablesRule = ruleCreator({
       }
     }
 
+    function checkProperty(node: es.Property): void {
+      const tsNode = esTreeNodeToTSNodeMap.get(node);
+
+      const contextualType = getPropertyContextualType(checker, tsNode);
+      if (contextualType === undefined) {
+        return;
+      }
+
+      if (!isVoidReturningFunctionType(contextualType)) {
+        return;
+      }
+      if (!couldReturnObservable(node.value)) {
+        return;
+      }
+
+      context.report({
+        messageId: 'forbiddenVoidReturnProperty',
+        node: node.value,
+      });
+    }
+
     return {
       ...(checksVoidReturn ? voidReturnChecks : {}),
       ...(checksSpreads ? spreadChecks : {}),
@@ -224,3 +245,36 @@ function isStaticMember(node: es.Node): boolean {
   return (isMethodDefinition(node) || isPropertyDefinition(node))
     && node.static;
 }
+
+function getPropertyContextualType(
+  checker: ts.TypeChecker,
+  tsNode: ts.Node,
+): ts.Type | undefined {
+  if (ts.isPropertyAssignment(tsNode)) {
+    // { a: 1 }
+    return checker.getContextualType(tsNode.initializer);
+  } else if (ts.isShorthandPropertyAssignment(tsNode)) {
+    // { a }
+    return checker.getContextualType(tsNode.name);
+  } else if (ts.isMethodDeclaration(tsNode)) {
+    // { a() {} }
+    if (ts.isComputedPropertyName(tsNode.name)) {
+      return;
+    }
+    const obj = tsNode.parent;
+    if (!ts.isObjectLiteralExpression(obj)) {
+      return;
+    }
+    const objType = checker.getContextualType(obj);
+    if (objType === undefined) {
+      return;
+    }
+    const propertySymbol = checker.getPropertyOfType(objType, tsNode.name.text);
+    if (propertySymbol === undefined) {
+      return;
+    }
+    return checker.getTypeOfSymbolAtLocation(propertySymbol, tsNode.name);
+  } else {
+    return undefined;
+  }
+}

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

@@ -122,6 +122,55 @@ ruleTester({ types: true }).run('no-misused-observables', noMisusedObservablesRu
       }
     `,
     // #endregion valid; void return inherited method
+    // #region valid; void return property
+    {
+      code: stripIndent`
+        // void return property; explicitly allowed
+        import { Observable, of } from "rxjs";
+
+        type Foo = { a: () => void, b: () => void, c: () => void };
+        const b: () => Observable<number> = () => of(42);
+        const foo: Foo = {
+          a: (): Observable<number> => of(42),
+          b,
+          c(): Observable<number> { return of(42); },
+        };
+      `,
+      options: [{ checksVoidReturn: false }],
+    },
+    stripIndent`
+      // void return property; not void
+      import { Observable, of } from "rxjs";
+
+      type Foo = { a: () => Observable<number>, b: () => Observable<number>, c: () => Observable<number> };
+      const b: () => Observable<number> = () => of(42);
+      const foo: Foo = {
+        a: () => of(42),
+        b,
+        c(): Observable<number> { return of(42); },
+      };
+    `,
+    stripIndent`
+      // void return property; unrelated
+      type Foo = { a: () => void, b: () => void, c: () => void };
+      const b: () => number = () => 42;
+      const foo: Foo = {
+        a: () => 42,
+        b,
+        c(): number { return 42; },
+      };
+    `,
+    stripIndent`
+      // couldReturnType is bugged for variables (#66)
+      import { Observable, of } from "rxjs";
+
+      type Foo = { bar: () => void };
+      const bar: () => Observable<number> = () => of(42);
+      const foo: Foo = {
+        bar,
+      };
+    `,
+    // #endregion valid; void return property
     // #region valid; spread
     {
       code: stripIndent`
@@ -584,6 +633,32 @@ ruleTester({ types: true }).run('no-misused-observables', noMisusedObservablesRu
       `,
     ),
     // #endregion invalid; void return inherited method
+    // #region invalid; void return property
+    fromFixture(
+      stripIndent`
+        // void return property; arrow function
+        import { of } from "rxjs";
+
+        type Foo = { bar: () => void };
+        const foo: Foo = {
+          bar: () => of(42),
+               ~~~~~~~~~~~~ [forbiddenVoidReturnProperty]
+        };
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // void return property; function
+        import { Observable, of } from "rxjs";
+
+        type Foo = { bar: () => void };
+        const foo: Foo = {
+          bar(): Observable<number> { return of(42); },
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ [forbiddenVoidReturnProperty]
+        };
+      `,
+    ),
+    // #endregion invalid; void return property
     // #region invalid; spread
     fromFixture(
       stripIndent`