fix: handle namespace import too

Author: JasonWeinzierl

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

@@ -1,5 +1,5 @@
 import { TSESTree as es, ESLintUtils } from '@typescript-eslint/utils';
-import { getTypeServices, isIdentifier, isImport, isMemberExpression, isObjectExpression, isProperty } from '../etc';
+import { getTypeServices, isIdentifier, isMemberExpression, isObjectExpression, isProperty } from '../etc';
 import { ruleCreator } from '../utils';
 
 export const noIgnoredDefaultValueRule = ruleCreator({
@@ -18,7 +18,7 @@ export const noIgnoredDefaultValueRule = ruleCreator({
   name: 'no-ignored-default-value',
   create: (context) => {
     const { getTypeAtLocation } = ESLintUtils.getParserServices(context);
-    const { couldBeObservable } = getTypeServices(context);
+    const { couldBeObservable, couldBeType } = getTypeServices(context);
 
     function checkConfigObj(configArg: es.ObjectExpression) {
       if (!configArg.properties.some(p => isProperty(p) && isIdentifier(p.key) && p.key.name === 'defaultValue')) {
@@ -39,13 +39,25 @@ export const noIgnoredDefaultValueRule = ruleCreator({
       }
     }
 
-    function checkFunctionArgs(callExpression: es.CallExpression, reportNode: es.Node) {
-      const scope = context.sourceCode.getScope(callExpression);
-      if (!isImport(scope, 'firstValueFrom', /^rxjs\/?/)
-        && !isImport(scope, 'lastValueFrom', /^rxjs\/?/)) {
+    function checkArg(arg: es.Node) {
+      if (isIdentifier(arg)) {
+        checkConfigType(arg);
+        return;
+      } else if (isMemberExpression(arg) && isIdentifier(arg.property)) {
+        checkConfigType(arg.property);
+        return;
+      }
+      if (!isObjectExpression(arg)) {
+        return;
+      }
+      checkConfigObj(arg);
+    }
+
+    function checkFunctionArgs(node: es.Node, args: es.CallExpressionArgument[]) {
+      if (!couldBeType(node, 'firstValueFrom', { name: /[/\\]rxjs[/\\]/ })
+        && !couldBeType(node, 'lastValueFrom', { name: /[/\\]rxjs[/\\]/ })) {
         return;
       }
-      const { arguments: args } = callExpression;
       if (!args || args.length <= 0) {
         return;
       }
@@ -56,62 +68,44 @@ export const noIgnoredDefaultValueRule = ruleCreator({
       if (!configArg) {
         context.report({
           messageId: 'forbidden',
-          node: reportNode,
+          node,
         });
         return;
       }
-      if (isIdentifier(configArg)) {
-        checkConfigType(configArg);
-        return;
-      } else if (isMemberExpression(configArg) && isIdentifier(configArg.property)) {
-        checkConfigType(configArg.property);
-        return;
-      }
-      if (!isObjectExpression(configArg)) {
-        return;
-      }
-      checkConfigObj(configArg);
+      checkArg(configArg);
     }
 
-    function checkOperatorArgs(callExpression: es.CallExpression, reportNode: es.Node) {
-      const scope = context.sourceCode.getScope(callExpression);
-      if (!isImport(scope, 'first', /^rxjs\/?/)
-        && !isImport(scope, 'last', /^rxjs\/?/)) {
+    function checkOperatorArgs(node: es.Node, args: es.CallExpressionArgument[]) {
+      if (!couldBeType(node, 'first', { name: /[/\\]rxjs[/\\]/ })
+        && !couldBeType(node, 'last', { name: /[/\\]rxjs[/\\]/ })) {
         return;
       }
-      const { arguments: args } = callExpression;
 
       if (!args || args.length <= 0) {
         context.report({
           messageId: 'forbidden',
-          node: reportNode,
+          node,
         });
         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;
-      }
-      checkConfigObj(arg);
+      checkArg(arg);
     }
 
     return {
-      'CallExpression[callee.name=/^(firstValueFrom|lastValueFrom)$/]': (
-        node: es.CallExpression,
-      ) => {
-        checkFunctionArgs(node, node.callee);
+      'CallExpression[callee.name=/^(firstValueFrom|lastValueFrom)$/]': (node: es.CallExpression) => {
+        checkFunctionArgs(node.callee, node.arguments);
+      },
+      'CallExpression[callee.property.name=/^(firstValueFrom|lastValueFrom)$/]': (node: es.CallExpression) => {
+        const memberExpression = node.callee as es.MemberExpression;
+        checkFunctionArgs(memberExpression.property, node.arguments);
+      },
+      'CallExpression[callee.property.name=\'pipe\'] > CallExpression[callee.name=/^(first|last)$/]': (node: es.CallExpression) => {
+        checkOperatorArgs(node.callee, node.arguments);
       },
-      'CallExpression[callee.property.name=\'pipe\'] > CallExpression[callee.name=/^(first|last)$/]': (
-        node: es.CallExpression,
-      ) => {
-        checkOperatorArgs(node, node.callee);
+      'CallExpression[callee.property.name=\'pipe\'] > CallExpression[callee.property.name=/^(first|last)$/]': (node: es.CallExpression) => {
+        const memberExpression = node.callee as es.MemberExpression;
+        checkOperatorArgs(memberExpression.property, node.arguments);
       },
     };
   },

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

@@ -139,5 +139,28 @@ ruleTester({ types: true }).run('no-ignored-default-value', noIgnoredDefaultValu
                     ~~~~ [forbidden]
       `,
     ),
+    fromFixture(
+      stripIndent`
+        // namespace import
+        import * as Rx from "rxjs";
+
+        Rx.firstValueFrom(Rx.of(42));
+           ~~~~~~~~~~~~~~ [forbidden]
+        Rx.of(42).pipe(Rx.first());
+                          ~~~~~ [forbidden]
+      `,
+    ),
+    fromFixture(
+      stripIndent`
+        // operators import (deprecated)
+        import { of } from "rxjs";
+        import { first, last } from "rxjs/operators";
+
+        of(42).pipe(first());
+                    ~~~~~ [forbidden]
+        of(42).pipe(last());
+                    ~~~~ [forbidden]
+      `,
+    ),
   ],
 });