fix(no-unnecessary-assertion): don't report for any and unknown types (#1918)

* fix(no-unnecessary-assertion): don't report for `any` and `unknown `types

* test(no-unnecessary-assertion): add a case with `never`

Author: G-Rath

src/rules/__tests__/no-unnecessary-assertion.test.ts

@@ -88,6 +88,18 @@ const generateValidCases = (
 
       expect(add(1, 1)).not.${matcher}();
     `,
+    dedent`
+      declare function mx(): any;
+
+      expect(mx()).${matcher}();
+      expect(mx()).not.${matcher}();
+    `,
+    dedent`
+      declare function mx(): unknown;
+
+      expect(mx()).${matcher}();
+      expect(mx()).not.${matcher}();
+    `,
     dedent`
       declare function mx(): string | ${thing};
 
@@ -259,6 +271,21 @@ const generateInvalidCases = (
       ],
     },
 
+    {
+      code: dedent`
+        declare function mx(): never;
+
+        expect(mx()).not.${matcher}();
+      `,
+      errors: [
+        {
+          messageId: 'unnecessaryAssertion',
+          data: { thing },
+          line: 3,
+        },
+      ],
+    },
+
     {
       code: dedent`
         const result = "hello world".match("sunshine") ?? [];

src/rules/no-unnecessary-assertion.ts

@@ -81,29 +81,32 @@ export default createRule<Options, MessageIds>({
 
         const [argument] = jestFnCall.head.node.parent.arguments;
 
-        const isTypePossible = canBe(
-          services.getTypeAtLocation(argument),
+        let desiredType = TypeFlags.Any | TypeFlags.Unknown;
+
+        // add in the appropriate type flag based on the matcher being used
+        desiredType |=
           matcherName === 'toBeNaN'
             ? TypeFlags.NumberLike
             : matcherName === 'toBeNull'
               ? TypeFlags.Null
-              : TypeFlags.Undefined,
-        );
-
-        if (!isTypePossible) {
-          context.report({
-            messageId: 'unnecessaryAssertion',
-            data: {
-              thing:
-                matcherName === 'toBeNaN'
-                  ? 'a number'
-                  : matcherName === 'toBeNull'
-                    ? 'null'
-                    : 'undefined',
-            },
-            node,
-          });
+              : TypeFlags.Undefined;
+
+        if (canBe(services.getTypeAtLocation(argument), desiredType)) {
+          return;
         }
+
+        context.report({
+          messageId: 'unnecessaryAssertion',
+          data: {
+            thing:
+              matcherName === 'toBeNaN'
+                ? 'a number'
+                : matcherName === 'toBeNull'
+                  ? 'null'
+                  : 'undefined',
+          },
+          node,
+        });
       },
     };
   },