Treat NoSubstitutionTemplateLiteral same as a StringLiteral

Author: Andy Hanson

src/compiler/checker.ts

@@ -17738,15 +17738,14 @@ namespace ts {
             return getBestChoiceType(type1, type2);
         }
 
-        function checkLiteralExpression(node: Expression): Type {
-            if (node.kind === SyntaxKind.NumericLiteral) {
-                checkGrammarNumericLiteral(<NumericLiteral>node);
-            }
+        function checkLiteralExpression(node: LiteralExpression | Token<SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword>): Type {
             switch (node.kind) {
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
                 case SyntaxKind.StringLiteral:
-                    return getFreshTypeOfLiteralType(getLiteralType((<LiteralExpression>node).text));
+                    return getFreshTypeOfLiteralType(getLiteralType(node.text));
                 case SyntaxKind.NumericLiteral:
-                    return getFreshTypeOfLiteralType(getLiteralType(+(<LiteralExpression>node).text));
+                    checkGrammarNumericLiteral(<NumericLiteral>node);
+                    return getFreshTypeOfLiteralType(getLiteralType(+node.text));
                 case SyntaxKind.TrueKeyword:
                     return trueType;
                 case SyntaxKind.FalseKeyword:
@@ -17964,15 +17963,14 @@ namespace ts {
                     return checkSuperExpression(node);
                 case SyntaxKind.NullKeyword:
                     return nullWideningType;
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
                 case SyntaxKind.StringLiteral:
                 case SyntaxKind.NumericLiteral:
                 case SyntaxKind.TrueKeyword:
                 case SyntaxKind.FalseKeyword:
-                    return checkLiteralExpression(node);
+                    return checkLiteralExpression(node as LiteralExpression);
                 case SyntaxKind.TemplateExpression:
                     return checkTemplateExpression(<TemplateExpression>node);
-                case SyntaxKind.NoSubstitutionTemplateLiteral:
-                    return stringType;
                 case SyntaxKind.RegularExpressionLiteral:
                     return globalRegExpType;
                 case SyntaxKind.ArrayLiteralExpression:

tests/baselines/reference/stringLiteralNoSubstitutionTemplate.js

@@ -0,0 +1,6 @@
+//// [stringLiteralNoSubstitutionTemplate.ts]
+const x: "foo" = `foo`;
+
+
+//// [stringLiteralNoSubstitutionTemplate.js]
+var x = "foo";

tests/baselines/reference/stringLiteralNoSubstitutionTemplate.symbols

@@ -0,0 +1,4 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralNoSubstitutionTemplate.ts ===
+const x: "foo" = `foo`;
+>x : Symbol(x, Decl(stringLiteralNoSubstitutionTemplate.ts, 0, 5))
+

tests/baselines/reference/stringLiteralNoSubstitutionTemplate.types

@@ -0,0 +1,5 @@
+=== tests/cases/conformance/types/stringLiteral/stringLiteralNoSubstitutionTemplate.ts ===
+const x: "foo" = `foo`;
+>x : "foo"
+>`foo` : "foo"
+

tests/cases/conformance/types/stringLiteral/stringLiteralNoSubstitutionTemplate.ts

@@ -0,0 +1 @@
+const x: "foo" = `foo`;