fix(eslint-plugin): [no-unnecessary-type-assertion] fix false negative for const variable declarations

packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts

@@ -59,37 +59,6 @@ export default createRule<Options, MessageIds>({
     const checker = services.program.getTypeChecker();
     const compilerOptions = services.program.getCompilerOptions();
 
-    /**
-     * Sometimes tuple types don't have ObjectFlags.Tuple set, like when they're being matched against an inferred type.
-     * So, in addition, check if there are integer properties 0..n and no other numeric keys
-     */
-    function couldBeTupleType(type: ts.ObjectType): boolean {
-      const properties = type.getProperties();
-
-      if (properties.length === 0) {
-        return false;
-      }
-      let i = 0;
-
-      for (; i < properties.length; ++i) {
-        const name = properties[i].name;
-
-        if (String(i) !== name) {
-          if (i === 0) {
-            // if there are no integer properties, this is not a tuple
-            return false;
-          }
-          break;
-        }
-      }
-      for (; i < properties.length; ++i) {
-        if (String(+properties[i].name) === properties[i].name) {
-          return false; // if there are any other numeric properties, this is not a tuple
-        }
-      }
-      return true;
-    }
-
     /**
      * Returns true if there's a chance the variable has been used before a value has been assigned to it
      */
@@ -137,6 +106,13 @@ export default createRule<Options, MessageIds>({
       );
     }
 
+    function isConstVariableDeclaration(node: TSESTree.Node): boolean {
+      return (
+        node.type === AST_NODE_TYPES.VariableDeclaration &&
+        node.kind === 'const'
+      );
+    }
+
     return {
       TSNonNullExpression(node): void {
         if (
@@ -234,28 +210,20 @@ export default createRule<Options, MessageIds>({
         if (
           options.typesToIgnore?.includes(
             context.sourceCode.getText(node.typeAnnotation),
-          ) ||
-          isConstAssertion(node.typeAnnotation)
+          )
         ) {
           return;
         }
 
         const castType = services.getTypeAtLocation(node);
-
-        if (
-          isTypeFlagSet(castType, ts.TypeFlags.Literal) ||
-          (tsutils.isObjectType(castType) &&
-            (tsutils.isObjectFlagSet(castType, ts.ObjectFlags.Tuple) ||
-              couldBeTupleType(castType)))
-        ) {
-          // It's not always safe to remove a cast to a literal type or tuple
-          // type, as those types are sometimes widened without the cast.
-          return;
-        }
-
         const uncastType = services.getTypeAtLocation(node.expression);
+        const typeIsUnchanged = uncastType === castType;
+
+        const wouldSameTypeBeInferred = castType.isLiteral()
+          ? isConstVariableDeclaration(node.parent.parent!)
+          : !isConstAssertion(node.typeAnnotation);
 
-        if (uncastType === castType) {
+        if (typeIsUnchanged && wouldSameTypeBeInferred) {
           context.report({
             node,
             messageId: 'unnecessaryAssertion',

packages/eslint-plugin/tests/rules/no-array-constructor.test.ts

@@ -7,7 +7,7 @@ const ruleTester = new RuleTester({
   parser: '@typescript-eslint/parser',
 });
 
-const messageId = 'useLiteral' as const;
+const messageId = 'useLiteral';
 
 ruleTester.run('no-array-constructor', rule, {
   valid: [

packages/eslint-plugin/tests/rules/no-unnecessary-type-assertion.test.ts

@@ -25,10 +25,28 @@ if (
   const name = member.id as TSESTree.StringLiteral;
 }
     `,
+    `
+      const cx = 1;
+      let z0 = cx as number;
+      let z1 = cx as const;
+      let z2 = cx as 1;
+    `,
+    `
+      type Bar = 'bar';
+      const data = {
+        x: 'foo' as 'foo',
+        y: 'bar' as Bar,
+      };
+    `,
+    "[1, 2, 3, 4, 5].map(x => [x, 'A' + x] as [number, string]);",
+    `
+      let x: Array<[number, string]> = [1, 2, 3, 4, 5].map(
+        x => [x, 'A' + x] as [number, string],
+      );
+    `,
+    'let y = 1 as 1;',
     'const foo = 3 as number;',
     'const foo = <number>3;',
-    'const foo = <3>3;',
-    'const foo = 3 as 3;',
     `
 type Tuple = [3, 'hi', 'bye'];
 const foo = [3, 'hi', 'bye'] as Tuple;
@@ -174,9 +192,6 @@ const c = [...a, ...b] as const;
     {
       code: 'const a = [1, 2] as const;',
     },
-    {
-      code: "const a = 'a' as const;",
-    },
     {
       code: "const a = { foo: 'foo' } as const;",
     },
@@ -190,9 +205,6 @@ const c = <const>[...a, ...b];
     {
       code: 'const a = <const>[1, 2];',
     },
-    {
-      code: "const a = <const>'a';",
-    },
     {
       code: "const a = <const>{ foo: 'foo' };",
     },
@@ -245,6 +257,48 @@ const item = <object>arr[0];
   ],
 
   invalid: [
+    {
+      code: "const a = 'a' as const;",
+      output: "const a = 'a';",
+      errors: [{ messageId: 'unnecessaryAssertion', line: 1 }],
+    },
+    {
+      code: "const a = <const>'a';",
+      output: "const a = 'a';",
+      errors: [{ messageId: 'unnecessaryAssertion', line: 1 }],
+    },
+    {
+      code: 'const foo = <3>3;',
+      output: 'const foo = 3;',
+      errors: [{ messageId: 'unnecessaryAssertion', line: 1, column: 13 }],
+    },
+    {
+      code: 'const foo = 3 as 3;',
+      output: 'const foo = 3;',
+      errors: [{ messageId: 'unnecessaryAssertion', line: 1, column: 13 }],
+    },
+    {
+      code: `
+        type Foo = 3;
+        const foo = <Foo>3;
+      `,
+      output: `
+        type Foo = 3;
+        const foo = 3;
+      `,
+      errors: [{ messageId: 'unnecessaryAssertion', line: 3, column: 21 }],
+    },
+    {
+      code: `
+        type Foo = 3;
+        const foo = 3 as Foo;
+      `,
+      output: `
+        type Foo = 3;
+        const foo = 3;
+      `,
+      errors: [{ messageId: 'unnecessaryAssertion', line: 3, column: 21 }],
+    },
     {
       code: `
 const foo = 3;