danvk
diff --git a/‎packages/eslint-plugin/src/rules/no-useless-template-literals.ts
Copy file name to clipboardExpand all lines: packages/eslint-plugin/src/rules/no-useless-template-literals.ts
+24-4Lines changed: 24 additions & 4 deletions b/‎packages/eslint-plugin/src/rules/no-useless-template-literals.ts
Copy file name to clipboardExpand all lines: packages/eslint-plugin/src/rules/no-useless-template-literals.ts
+24-4Lines changed: 24 additions & 4 deletions
diff --git a/‎packages/eslint-plugin/tests/rules/no-useless-template-literals.test.ts
Copy file name to clipboardExpand all lines: packages/eslint-plugin/tests/rules/no-useless-template-literals.test.ts
+26Lines changed: 26 additions & 0 deletions b/‎packages/eslint-plugin/tests/rules/no-useless-template-literals.test.ts
Copy file name to clipboardExpand all lines: packages/eslint-plugin/tests/rules/no-useless-template-literals.test.ts
+26Lines changed: 26 additions & 0 deletions
@@ -53,6 +53,24 @@ export default createRule<[], MessageId>({
       return isString(type);
     }
 
+    function isLiteral(expression: TSESTree.Expression): boolean {
+      return expression.type === AST_NODE_TYPES.Literal;
+    }
+
+    function isInfinityIdentifier(expression: TSESTree.Expression): boolean {
+      return (
+        expression.type === AST_NODE_TYPES.Identifier &&
+        expression.name === 'Infinity'
+      );
+    }
+
+    function isNaNIdentifier(expression: TSESTree.Expression): boolean {
+      return (
+        expression.type === AST_NODE_TYPES.Identifier &&
+        expression.name === 'NaN'
+      );
+    }
+
     return {
       TemplateLiteral(node: TSESTree.TemplateLiteral): void {
         if (node.parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
@@ -91,13 +109,15 @@ export default createRule<[], MessageId>({
           return;
         }
 
-        const literalsOrUndefinedExpressions = node.expressions.filter(
+        const fixableExpressions = node.expressions.filter(
           (expression): expression is TSESTree.Literal | TSESTree.Identifier =>
-            expression.type === AST_NODE_TYPES.Literal ||
-            isUndefinedIdentifier(expression),
+            isLiteral(expression) ||
+            isUndefinedIdentifier(expression) ||
+            isInfinityIdentifier(expression) ||
+            isNaNIdentifier(expression),
         );
 
-        literalsOrUndefinedExpressions.forEach(expression => {
+        fixableExpressions.forEach(expression => {
           context.report({
             node: expression,
             messageId: 'noUselessTemplateLiteral',
 
@@ -280,6 +280,32 @@ ruleTester.run('no-useless-template-literals', rule, {
       ],
     },
 
+    {
+      code: '`${Infinity}`;',
+      output: '`Infinity`;',
+      errors: [
+        {
+          messageId: 'noUselessTemplateLiteral',
+          line: 1,
+          column: 4,
+          endColumn: 12,
+        },
+      ],
+    },
+
+    {
+      code: '`${NaN}`;',
+      output: '`NaN`;',
+      errors: [
+        {
+          messageId: 'noUselessTemplateLiteral',
+          line: 1,
+          column: 4,
+          endColumn: 7,
+        },
+      ],
+    },
+
     {
       code: "`${'a'} ${'b'}`;",
       output: '`a b`;',