fix: support variables and member expression

Author: JasonWeinzierl

src/rules/no-ignored-default-value.ts

@@ -1,5 +1,5 @@
 import { TSESTree as es } from '@typescript-eslint/utils';
-import { getTypeServices, isIdentifier, isImport, isObjectExpression, isProperty } from '../etc';
+import { getTypeServices, isIdentifier, isImport, isMemberExpression, isObjectExpression, isProperty } from '../etc';
 import { ruleCreator } from '../utils';
 
 export const noIgnoredDefaultValueRule = ruleCreator({
@@ -10,16 +10,16 @@ export const noIgnoredDefaultValueRule = ruleCreator({
       requiresTypeChecking: true,
     },
     messages: {
-      forbidden: 'Ignoring the default value is forbidden.',
+      forbidden: 'Not specifying a default value is forbidden.',
     },
     schema: [],
     type: 'problem',
   },
   name: 'no-ignored-default-value',
   create: (context) => {
-    const { couldBeObservable } = getTypeServices(context);
+    const { couldBeObservable, getType } = getTypeServices(context);
 
-    function checkConfig(configArg: es.ObjectExpression) {
+    function checkConfigObj(configArg: es.ObjectExpression) {
       if (!configArg.properties.some(p => isProperty(p) && isIdentifier(p.key) && p.key.name === 'defaultValue')) {
         context.report({
           messageId: 'forbidden',
@@ -28,6 +28,16 @@ export const noIgnoredDefaultValueRule = ruleCreator({
       }
     }
 
+    function checkConfigType(configArg: es.Node) {
+      const configArgType = getType(configArg);
+      if (!configArgType?.getProperties().some(p => p.name === 'defaultValue')) {
+        context.report({
+          messageId: 'forbidden',
+          node: configArg,
+        });
+      }
+    }
+
     function checkFunctionArgs(callExpression: es.CallExpression, reportNode: es.Node) {
       const scope = context.sourceCode.getScope(callExpression);
       if (!isImport(scope, 'firstValueFrom', /^rxjs\/?/)
@@ -49,10 +59,17 @@ export const noIgnoredDefaultValueRule = ruleCreator({
         });
         return;
       }
+      if (isIdentifier(configArg)) {
+        checkConfigType(configArg);
+        return;
+      } else if (isMemberExpression(configArg) && isIdentifier(configArg.property)) {
+        checkConfigType(configArg.property);
+        return;
+      }
       if (!isObjectExpression(configArg)) {
         return;
       }
-      checkConfig(configArg);
+      checkConfigObj(configArg);
     }
 
     function checkOperatorArgs(callExpression: es.CallExpression, reportNode: es.Node) {
@@ -71,10 +88,17 @@ export const noIgnoredDefaultValueRule = ruleCreator({
         return;
       }
       const [arg] = args;
+      if (isIdentifier(arg)) {
+        checkConfigType(arg);
+        return;
+      } else if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        checkConfigType(arg.property);
+        return;
+      }
       if (!isObjectExpression(arg)) {
         return;
       }
-      checkConfig(arg);
+      checkConfigObj(arg);
     }
 
     return {

tests/rules/no-ignored-default-value.test.ts

@@ -12,6 +12,14 @@ ruleTester({ types: true }).run('no-ignored-default-value', noIgnoredDefaultValu
       firstValueFrom(of(42), { defaultValue: 0 });
       firstValueFrom(of(42), { defaultValue: null });
       firstValueFrom(of(42), { defaultValue: undefined });
+      function getValue(obs) {
+        return firstValueFrom(obs, { defaultValue: "hello" });
+      }
+      class Foo {
+        getValue(obs) {
+          return firstValueFrom(obs, { defaultValue: "world" });
+        }
+      }
     `,
     stripIndent`
       // lastValueFrom with default value
@@ -37,12 +45,24 @@ ruleTester({ types: true }).run('no-ignored-default-value', noIgnoredDefaultValu
       of(42).pipe(last(x => x, { defaultValue: null }));
       of(42).pipe(last(x => x, { defaultValue: undefined }));
     `,
+    stripIndent`
+      // other operators
+      import { of, map, filter, refCount } from "rxjs";
+
+      of(42).pipe(map(x => x), filter(x => x > 0), shareReplay({ bufferSize: 1, refCount: true }));
+    `,
     stripIndent`
       // non-RxJS firstValueFrom
       import { of } from "rxjs";
 
       function firstValueFrom(obs) {}
       firstValueFrom(of(42));
+
+      class Foo {
+        firstValueFrom(obs) {}
+      }
+      const myFoo = new Foo();
+      myFoo.firstValueFrom(of(42));
     `,
     stripIndent`
       // non-RxJS lastValueFrom
@@ -76,6 +96,12 @@ ruleTester({ types: true }).run('no-ignored-default-value', noIgnoredDefaultValu
         ~~~~~~~~~~~~~~ [forbidden]
         firstValueFrom(of(42), {});
                                ~~ [forbidden]
+        const config = {};
+        firstValueFrom(of(42), config);
+                               ~~~~~~ [forbidden]
+        const config2 = { config: {} };
+        firstValueFrom(of(42), config2.config);
+                                       ~~~~~~ [forbidden]
       `,
     ),
     fromFixture(
@@ -94,6 +120,14 @@ ruleTester({ types: true }).run('no-ignored-default-value', noIgnoredDefaultValu
 
         of(42).pipe(first());
                     ~~~~~ [forbidden]
+        of(42).pipe(first({}));
+                          ~~ [forbidden]
+        const config = {};
+        of(42).pipe(first(config));
+                          ~~~~~~ [forbidden]
+        const config2 = { config: {} };
+        of(42).pipe(first(config2.config));
+                                  ~~~~~~ [forbidden]
       `,
     ),
     fromFixture(