Add support for template literals in enums

src/compiler/checker.ts

@@ -6326,7 +6326,7 @@ namespace ts {
         }
 
         function isStringConcatExpression(expr: Node): boolean {
-            if (expr.kind === SyntaxKind.StringLiteral) {
+            if (isStringLiteralLike(expr)) {
                 return true;
             }
             else if (expr.kind === SyntaxKind.BinaryExpression) {
@@ -6343,6 +6343,7 @@ namespace ts {
             switch (expr.kind) {
                 case SyntaxKind.StringLiteral:
                 case SyntaxKind.NumericLiteral:
+                case SyntaxKind.NoSubstitutionTemplateLiteral:
                     return true;
                 case SyntaxKind.PrefixUnaryExpression:
                     return (<PrefixUnaryExpression>expr).operator === SyntaxKind.MinusToken &&
@@ -6365,7 +6366,7 @@ namespace ts {
             for (const declaration of symbol.declarations) {
                 if (declaration.kind === SyntaxKind.EnumDeclaration) {
                     for (const member of (<EnumDeclaration>declaration).members) {
-                        if (member.initializer && member.initializer.kind === SyntaxKind.StringLiteral) {
+                        if (member.initializer && isStringLiteralLike(member.initializer)) {
                             return links.enumKind = EnumKind.Literal;
                         }
                         if (!isLiteralEnumMember(member)) {
@@ -28006,6 +28007,8 @@ namespace ts {
                         break;
                     case SyntaxKind.StringLiteral:
                         return (<StringLiteral>expr).text;
+                    case SyntaxKind.NoSubstitutionTemplateLiteral:
+                        return (<NoSubstitutionTemplateLiteral>expr).text;
                     case SyntaxKind.NumericLiteral:
                         checkGrammarNumericLiteral(<NumericLiteral>expr);
                         return +(<NumericLiteral>expr).text;

tests/baselines/reference/enumConstantMemberWithTemplateLiterals.errors.txt

@@ -0,0 +1,59 @@
+tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts(28,9): error TS2553: Computed values are not permitted in an enum with string valued members.
+tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts(29,9): error TS2553: Computed values are not permitted in an enum with string valued members.
+tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts(30,9): error TS2553: Computed values are not permitted in an enum with string valued members.
+tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts(31,9): error TS2553: Computed values are not permitted in an enum with string valued members.
+
+
+==== tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts (4 errors) ====
+    enum T1 {
+        a = `1`
+    }
+
+    enum T2 {
+        a = `1`,
+        b = "2",
+        c = 3
+    }
+
+    enum T3 {
+        a = `1` + `1`
+    }
+
+    enum T4 {
+        a = `1`,
+        b = `1` + `1`,
+        c = `1` + "2",
+        d = "2" + `1`,
+        e = "2" + `1` + `1`
+    }
+
+    enum T5 {
+        a = `1`,
+        b = `1` + `2`,
+        c = `1` + `2` + `3`,
+        d = 1,
+        e = `1` - `1`,
+            ~~~~~~~~~
+!!! error TS2553: Computed values are not permitted in an enum with string valued members.
+        f = `1` + 1,
+            ~~~~~~~
+!!! error TS2553: Computed values are not permitted in an enum with string valued members.
+        g = `1${"2"}3`,
+            ~~~~~~~~~~
+!!! error TS2553: Computed values are not permitted in an enum with string valued members.
+        h = `1`.length
+            ~~~~~~~~~~
+!!! error TS2553: Computed values are not permitted in an enum with string valued members.
+    }
+
+    enum T6 {
+        a = 1,
+        b = `12`.length
+    }
+
+    declare enum T7 {
+        a = `1`,
+        b = `1` + `1`,
+        c = "2" + `1`
+    }
+

tests/baselines/reference/enumConstantMemberWithTemplateLiterals.js

@@ -0,0 +1,85 @@
+//// [enumConstantMemberWithTemplateLiterals.ts]
+enum T1 {
+    a = `1`
+}
+
+enum T2 {
+    a = `1`,
+    b = "2",
+    c = 3
+}
+
+enum T3 {
+    a = `1` + `1`
+}
+
+enum T4 {
+    a = `1`,
+    b = `1` + `1`,
+    c = `1` + "2",
+    d = "2" + `1`,
+    e = "2" + `1` + `1`
+}
+
+enum T5 {
+    a = `1`,
+    b = `1` + `2`,
+    c = `1` + `2` + `3`,
+    d = 1,
+    e = `1` - `1`,
+    f = `1` + 1,
+    g = `1${"2"}3`,
+    h = `1`.length
+}
+
+enum T6 {
+    a = 1,
+    b = `12`.length
+}
+
+declare enum T7 {
+    a = `1`,
+    b = `1` + `1`,
+    c = "2" + `1`
+}
+
+
+//// [enumConstantMemberWithTemplateLiterals.js]
+var T1;
+(function (T1) {
+    T1["a"] = "1";
+})(T1 || (T1 = {}));
+var T2;
+(function (T2) {
+    T2["a"] = "1";
+    T2["b"] = "2";
+    T2[T2["c"] = 3] = "c";
+})(T2 || (T2 = {}));
+var T3;
+(function (T3) {
+    T3["a"] = "11";
+})(T3 || (T3 = {}));
+var T4;
+(function (T4) {
+    T4["a"] = "1";
+    T4["b"] = "11";
+    T4["c"] = "12";
+    T4["d"] = "21";
+    T4["e"] = "211";
+})(T4 || (T4 = {}));
+var T5;
+(function (T5) {
+    T5["a"] = "1";
+    T5["b"] = "12";
+    T5["c"] = "123";
+    T5[T5["d"] = 1] = "d";
+    T5[T5["e"] = 0] = "e";
+    T5[T5["f"] = 0] = "f";
+    T5[T5["g"] = 0] = "g";
+    T5[T5["h"] = 0] = "h";
+})(T5 || (T5 = {}));
+var T6;
+(function (T6) {
+    T6[T6["a"] = 1] = "a";
+    T6[T6["b"] = "12".length] = "b";
+})(T6 || (T6 = {}));

tests/baselines/reference/enumConstantMemberWithTemplateLiterals.symbols

@@ -0,0 +1,102 @@
+=== tests/cases/conformance/enums/enumConstantMemberWithTemplateLiterals.ts ===
+enum T1 {
+>T1 : Symbol(T1, Decl(enumConstantMemberWithTemplateLiterals.ts, 0, 0))
+
+    a = `1`
+>a : Symbol(T1.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 0, 9))
+}
+
+enum T2 {
+>T2 : Symbol(T2, Decl(enumConstantMemberWithTemplateLiterals.ts, 2, 1))
+
+    a = `1`,
+>a : Symbol(T2.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 4, 9))
+
+    b = "2",
+>b : Symbol(T2.b, Decl(enumConstantMemberWithTemplateLiterals.ts, 5, 12))
+
+    c = 3
+>c : Symbol(T2.c, Decl(enumConstantMemberWithTemplateLiterals.ts, 6, 12))
+}
+
+enum T3 {
+>T3 : Symbol(T3, Decl(enumConstantMemberWithTemplateLiterals.ts, 8, 1))
+
+    a = `1` + `1`
+>a : Symbol(T3.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 10, 9))
+}
+
+enum T4 {
+>T4 : Symbol(T4, Decl(enumConstantMemberWithTemplateLiterals.ts, 12, 1))
+
+    a = `1`,
+>a : Symbol(T4.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 14, 9))
+
+    b = `1` + `1`,
+>b : Symbol(T4.b, Decl(enumConstantMemberWithTemplateLiterals.ts, 15, 12))
+
+    c = `1` + "2",
+>c : Symbol(T4.c, Decl(enumConstantMemberWithTemplateLiterals.ts, 16, 18))
+
+    d = "2" + `1`,
+>d : Symbol(T4.d, Decl(enumConstantMemberWithTemplateLiterals.ts, 17, 18))
+
+    e = "2" + `1` + `1`
+>e : Symbol(T4.e, Decl(enumConstantMemberWithTemplateLiterals.ts, 18, 18))
+}
+
+enum T5 {
+>T5 : Symbol(T5, Decl(enumConstantMemberWithTemplateLiterals.ts, 20, 1))
+
+    a = `1`,
+>a : Symbol(T5.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 22, 9))
+
+    b = `1` + `2`,
+>b : Symbol(T5.b, Decl(enumConstantMemberWithTemplateLiterals.ts, 23, 12))
+
+    c = `1` + `2` + `3`,
+>c : Symbol(T5.c, Decl(enumConstantMemberWithTemplateLiterals.ts, 24, 18))
+
+    d = 1,
+>d : Symbol(T5.d, Decl(enumConstantMemberWithTemplateLiterals.ts, 25, 24))
+
+    e = `1` - `1`,
+>e : Symbol(T5.e, Decl(enumConstantMemberWithTemplateLiterals.ts, 26, 10))
+
+    f = `1` + 1,
+>f : Symbol(T5.f, Decl(enumConstantMemberWithTemplateLiterals.ts, 27, 18))
+
+    g = `1${"2"}3`,
+>g : Symbol(T5.g, Decl(enumConstantMemberWithTemplateLiterals.ts, 28, 16))
+
+    h = `1`.length
+>h : Symbol(T5.h, Decl(enumConstantMemberWithTemplateLiterals.ts, 29, 19))
+>`1`.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+enum T6 {
+>T6 : Symbol(T6, Decl(enumConstantMemberWithTemplateLiterals.ts, 31, 1))
+
+    a = 1,
+>a : Symbol(T6.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 33, 9))
+
+    b = `12`.length
+>b : Symbol(T6.b, Decl(enumConstantMemberWithTemplateLiterals.ts, 34, 10))
+>`12`.length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+>length : Symbol(String.length, Decl(lib.es5.d.ts, --, --))
+}
+
+declare enum T7 {
+>T7 : Symbol(T7, Decl(enumConstantMemberWithTemplateLiterals.ts, 36, 1))
+
+    a = `1`,
+>a : Symbol(T7.a, Decl(enumConstantMemberWithTemplateLiterals.ts, 38, 17))
+
+    b = `1` + `1`,
+>b : Symbol(T7.b, Decl(enumConstantMemberWithTemplateLiterals.ts, 39, 12))
+
+    c = "2" + `1`
+>c : Symbol(T7.c, Decl(enumConstantMemberWithTemplateLiterals.ts, 40, 18))
+}
+