Fix noUnnecessaryTypeAssertion edge case [publish]

Author: ArnaudBarre

CHANGELOG.md

@@ -1,5 +1,5 @@
 # Changelog
 
-## 1.0.16
+## 1.0.17
 
 Beta release

README.md

@@ -210,7 +210,7 @@ const b = 2;
 
 Writing custom rules is part of the core value of tsl.
 
-Rules run on the TS AST, which is less known than ESTree but allows to query type information for a given node with `context.checker.getTypeAtLocation(node)`. Use [ast-explorer.dev](https://ast-explorer.dev/#eNo9zEEKwjAQheGrxLdSKG5ctV5AcO9qNiEdQmSYCUlVpPTuTSl0+72fN0Mw4O2/voaS8oQOucH0z3xAaBBMqwlfxeKZ8GARcz8rMp4Ilztpy6xlM6lzBPEaPz7yi0tNpoTB9X23b/vtM+m48Y10wbIChCAraw==) to explore the AST.
+Rules run on the TS AST, which is less known than ESTree but allows to query type information for a given node with `context.checker.getTypeAtLocation(node)`. Use [ast-explorer.dev](https://ast-explorer.dev/#eNo9zEEKwjAQheGrxLdSKG5ctV5AcO9qNiEdQmSYCUlVpPTuTSl0+72fN0Mw4O2/voaS8oQOucH0z3xAaBBMqwlfxeKZ8GARcz8rMp4Ilztpy6xlM6lzBPEaPz7yi0tNpoTB9X23b/vtM+m48Y10wbIChCAraw==) to explore the AST. To explore type information, use [ts-ast-viewer](https://ts-ast-viewer.com/).
 
 By default, the TS AST is, funny enough, poorly typed. That's why tsl ships with rewritten AST types that allows for type narrowing and exhaustive switches.
 

package.json

@@ -1,7 +1,7 @@
 {
   "name": "tsl",
   "description": "An extension of tsc for type-aware linting",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "license": "MIT",
   "author": "Arnaud Barré (https://github.com/ArnaudBarre)",
   "private": true,

src/ruleTester.ts

@@ -5,7 +5,7 @@ import type { AST, Checker, Context, ReportDescriptor, Rule } from "./types.ts";
 import { visitorEntries } from "./visitorEntries.ts";
 
 export function print(...args: any[]) {
-  console.log(...args.map(transform));
+  console.log(...args.map((value) => transform(value, new Set())));
 }
 
 const allFlags = Object.entries(NodeFlags).filter(
@@ -17,9 +17,14 @@ for (const [key, value] of Object.entries(SyntaxKind)) {
     syntaxKinds[value] = key;
   }
 }
-const transform = (value: unknown): unknown => {
+const transform = (
+  value: unknown,
+  alreadyTransformed: Set<unknown>,
+): unknown => {
+  if (alreadyTransformed.has(value)) return value;
+  alreadyTransformed.add(value);
   if (Array.isArray(value)) {
-    return value.map(transform);
+    return value.map((value) => transform(value, alreadyTransformed));
   }
   if (typeof value === "object" && value) {
     if (isNode(value)) {
@@ -43,7 +48,10 @@ const transform = (value: unknown): unknown => {
       return node;
     } else {
       return Object.fromEntries(
-        Object.entries(value).map(([key, value]) => [key, transform(value)]),
+        Object.entries(value).map(([key, value]) => [
+          key,
+          transform(value, alreadyTransformed),
+        ]),
       );
     }
   }

src/rules/noUnnecessaryTypeAssertion/noUnnecessaryTypeAssertion.test.ts

@@ -357,6 +357,11 @@ x!;
       // https://www.typescriptlang.org/play/?#code/MYewdgzgLgBAZiEMC8MBECRpgQwjUSKAbgCgYKYB6KmAPQH5TDoYAjHAJxXQ87TKVqtRs3CtMAeTYArAKbBYqAN7xEMAL6DKNekxaw+0+Yp6q+m8jpEMgA
       "const a = 'a' as const;",
       "const a = <const>'a';",
+      `
+      function castNonNull<T extends { input: any }>(arg: T["input"] | null) {
+        return arg!;
+      }
+      `,
     ],
     invalid: [
       {

src/rules/noUnnecessaryTypeAssertion/noUnnecessaryTypeAssertion.ts

@@ -58,25 +58,31 @@ export const noUnnecessaryTypeAssertion = defineRule(
           return;
         }
 
-        const type = context.utils.getConstrainedTypeAtLocation(
+        const type = context.checker.getTypeAtLocation(node.expression);
+        const constraintType = context.utils.getConstrainedTypeAtLocation(
           node.expression,
         );
+        const nullableFlags =
+          TypeFlags.Null
+          | TypeFlags.Undefined
+          | TypeFlags.Void
+          | TypeFlags.Unknown;
 
-        if (
-          !context.utils.typeOrUnionHasFlag(
-            type,
-            TypeFlags.Null
-              | TypeFlags.Undefined
-              | TypeFlags.Void
-              | TypeFlags.Unknown,
-          )
-        ) {
+        if (!context.utils.typeOrUnionHasFlag(constraintType, nullableFlags)) {
           if (
             node.expression.kind === SyntaxKind.Identifier
             && isPossiblyUsedBeforeAssigned(context, node.expression)
           ) {
             return;
           }
+          if (
+            context.utils.typeHasFlag(constraintType, TypeFlags.Any)
+            && context.utils.typeOrUnionHasFlag(type, nullableFlags)
+          ) {
+            // If the generic contains any, T | null will be any,
+            // so we need to check the non constrained type
+            return;
+          }
 
           context.report({
             node,
@@ -90,7 +96,10 @@ export const noUnnecessaryTypeAssertion = defineRule(
           const contextualType = getContextualType(context, node);
           if (contextualType) {
             if (
-              context.utils.typeOrUnionHasFlag(type, TypeFlags.Unknown)
+              context.utils.typeOrUnionHasFlag(
+                constraintType,
+                TypeFlags.Unknown,
+              )
               && !context.utils.typeOrUnionHasFlag(
                 contextualType,
                 TypeFlags.Unknown,
@@ -102,15 +111,15 @@ export const noUnnecessaryTypeAssertion = defineRule(
             // in strict mode you can't assign null to undefined, so we have to make sure that
             // the two types share a nullable type
             const typeIncludesUndefined = context.utils.typeOrUnionHasFlag(
-              type,
+              constraintType,
               TypeFlags.Undefined,
             );
             const typeIncludesNull = context.utils.typeOrUnionHasFlag(
-              type,
+              constraintType,
               TypeFlags.Null,
             );
             const typeIncludesVoid = context.utils.typeOrUnionHasFlag(
-              type,
+              constraintType,
               TypeFlags.Void,
             );