typescript-eslint · ronami · Jan 6, 2025 · Jan 6, 2025 · Jan 7, 2025 · Jan 7, 2025
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-assertion.ts
@@ -2,7 +2,11 @@ import type { Scope } from '@typescript-eslint/scope-manager';
 import type { TSESTree } from '@typescript-eslint/utils';
 import type { ReportFixFunction } from '@typescript-eslint/utils/ts-eslint';
 
-import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  AST_TOKEN_TYPES,
+  ASTUtils,
+} from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
@@ -208,6 +212,63 @@ export default createRule<Options, MessageIds>({
       return false;
     }
 
+    function doesExpressionHaveFreshLiterals(
+      node: TSESTree.Expression,
+    ): boolean {
+      // Actual literals don't seem to have the type of a "fresh literal"
+      if (
+        node.type === AST_NODE_TYPES.TemplateLiteral ||
+        node.type === AST_NODE_TYPES.Literal
+      ) {
+        return true;
+      }
+
+      if (node.type === AST_NODE_TYPES.Identifier) {
+        // It seems "fresh literals" have a slightly different type at their
+        // definition rather than their reference.
+        const scope = context.sourceCode.getScope(node);
+        const superVar = ASTUtils.findVariable(scope, node.name);
+
+        if (superVar == null) {
+          return true;
+        }
+
+        const definition = superVar.defs.at(0);
+
+        if (definition == null) {
+          return true;
+        }
+
+        const typeAtDefinition = services.getTypeAtLocation(definition.node);
+
+        if (tsutils.isUnionType(typeAtDefinition)) {
+          return tsutils
+            .unionTypeParts(typeAtDefinition)
+            .some(part => isFreshLiteralType(part));
+        }
+
+        return isFreshLiteralType(typeAtDefinition);
+      }
+
+      if (node.type === AST_NODE_TYPES.ConditionalExpression) {
+        return (
+          doesExpressionHaveFreshLiterals(node.alternate) ||
+          doesExpressionHaveFreshLiterals(node.consequent)
+        );
+      }
+
+      if (
+        tsutils.isTypeFlagSet(
+          services.getTypeAtLocation(node),
+          ts.TypeFlags.EnumLiteral | ts.TypeFlags.UniqueESSymbol,
+        )
+      ) {
+        return true;
+      }
+
+      return false;
+    }
+
     return {
       'TSAsExpression, TSTypeAssertion'(
         node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
@@ -224,7 +285,11 @@ export default createRule<Options, MessageIds>({
         const uncastType = services.getTypeAtLocation(node.expression);
         const typeIsUnchanged = isTypeUnchanged(uncastType, castType);
 
-        const wouldSameTypeBeInferred = castType.isLiteral()
+        const hasFreshLiterals = doesExpressionHaveFreshLiterals(
+          node.expression,
+        );
+
+        const wouldSameTypeBeInferred = hasFreshLiterals
           ? isImplicitlyNarrowedConstDeclaration(node)
           : !isConstAssertion(node.typeAnnotation);
 
@@ -387,3 +452,8 @@ export default createRule<Options, MessageIds>({
     };
   },
 });
+
+// https://github.com/microsoft/TypeScript/blob/21c1a61b49082915f93e3327dad0d73205cf4273/src/compiler/checker.ts/#L19679-L19681
+function isFreshLiteralType(type: ts.Type) {
+  return tsutils.isFreshableType(type) && type.freshType === type;
+}