feat(40793): allow constants/template literals as enum values

Author: a-tarasyuk

src/compiler/checker.ts

@@ -40609,6 +40609,17 @@ m2: ${(this.mapper2 as unknown as DebugTypeMapper).__debugToString().split("\n")
                             }
                         }
                         break;
+                    case SyntaxKind.TemplateExpression:
+                        const expression = expr as TemplateExpression;
+                        const texts = [expression.head.text];
+                        for (const span of expression.templateSpans) {
+                            const exprValue = evaluate(span.expression);
+                            if (exprValue === undefined) return undefined;
+
+                            texts.push(exprValue + "");
+                            texts.push(span.literal.text);
+                        }
+                        return texts.join("");
                 }
                 return undefined;
             }
@@ -40625,9 +40636,36 @@ m2: ${(this.mapper2 as unknown as DebugTypeMapper).__debugToString().split("\n")
                         return 0;
                     }
                     else {
+                        const exprValue = evaluateExpression(expr);
+                        if (exprValue) return exprValue;
                         error(expr, Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol));
                     }
                 }
+                return evaluateExpression(expr);
+            }
+
+            function evaluateExpression(expr: Expression) {
+                if (isIdentifier(expr)) {
+                    const symbol = resolveEntityName(expr, SymbolFlags.Value, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, getSourceFileOfNode(expr));
+                    if (!symbol || !isConstVariable(symbol)) return undefined;
+
+                    const declaration = symbol.valueDeclaration;
+                    if (declaration === undefined) return undefined;
+
+                    if (isBlockScopedNameDeclaredBeforeUse(declaration, member) && hasOnlyExpressionInitializer(declaration)) {
+                        const initializer = getEffectiveInitializer(declaration);
+                        if (initializer === undefined) return undefined;
+
+                        if (isTemplateExpression(initializer)) {
+                            return evaluate(initializer);
+                        }
+
+                        const type = getTypeOfExpression(initializer);
+                        if (type.flags & TypeFlags.StringOrNumberLiteral) {
+                            return (type as NumberLiteralType | StringLiteralType).value;
+                        }
+                    }
+                }
                 return undefined;
             }
         }

tests/baselines/reference/enumWithConst.js

@@ -0,0 +1,28 @@
+//// [enumWithConst.ts]
+const A = 1;
+const B = "B";
+const C: string = "C";
+const D = `D_${A}_${B}_${C}`;
+
+enum T {
+    A = A,
+    B = B,
+    C = C,
+    D = D,
+    E = `E_${A}_${B}_${C}`
+}
+
+
+//// [enumWithConst.js]
+var A = 1;
+var B = "B";
+var C = "C";
+var D = "D_".concat(A, "_").concat(B, "_").concat(C);
+var T;
+(function (T) {
+    T[T["A"] = 1] = "A";
+    T["B"] = "B";
+    T["C"] = "C";
+    T["D"] = "D_1_B_C";
+    T["E"] = "E_1_B_C";
+})(T || (T = {}));

tests/baselines/reference/enumWithConst.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/enumWithConst.ts ===
+const A = 1;
+>A : Symbol(A, Decl(enumWithConst.ts, 0, 5))
+
+const B = "B";
+>B : Symbol(B, Decl(enumWithConst.ts, 1, 5))
+
+const C: string = "C";
+>C : Symbol(C, Decl(enumWithConst.ts, 2, 5))
+
+const D = `D_${A}_${B}_${C}`;
+>D : Symbol(D, Decl(enumWithConst.ts, 3, 5))
+>A : Symbol(A, Decl(enumWithConst.ts, 0, 5))
+>B : Symbol(B, Decl(enumWithConst.ts, 1, 5))
+>C : Symbol(C, Decl(enumWithConst.ts, 2, 5))
+
+enum T {
+>T : Symbol(T, Decl(enumWithConst.ts, 3, 29))
+
+    A = A,
+>A : Symbol(T.A, Decl(enumWithConst.ts, 5, 8))
+>A : Symbol(T.A, Decl(enumWithConst.ts, 5, 8))
+
+    B = B,
+>B : Symbol(T.B, Decl(enumWithConst.ts, 6, 10))
+>B : Symbol(T.B, Decl(enumWithConst.ts, 6, 10))
+
+    C = C,
+>C : Symbol(T.C, Decl(enumWithConst.ts, 7, 10))
+>C : Symbol(T.C, Decl(enumWithConst.ts, 7, 10))
+
+    D = D,
+>D : Symbol(T.D, Decl(enumWithConst.ts, 8, 10))
+>D : Symbol(T.D, Decl(enumWithConst.ts, 8, 10))
+
+    E = `E_${A}_${B}_${C}`
+>E : Symbol(T.E, Decl(enumWithConst.ts, 9, 10))
+>A : Symbol(T.A, Decl(enumWithConst.ts, 5, 8))
+>B : Symbol(T.B, Decl(enumWithConst.ts, 6, 10))
+>C : Symbol(T.C, Decl(enumWithConst.ts, 7, 10))
+}
+

tests/baselines/reference/enumWithConst.types

@@ -0,0 +1,47 @@
+=== tests/cases/compiler/enumWithConst.ts ===
+const A = 1;
+>A : 1
+>1 : 1
+
+const B = "B";
+>B : "B"
+>"B" : "B"
+
+const C: string = "C";
+>C : string
+>"C" : "C"
+
+const D = `D_${A}_${B}_${C}`;
+>D : string
+>`D_${A}_${B}_${C}` : string
+>A : 1
+>B : "B"
+>C : string
+
+enum T {
+>T : T
+
+    A = A,
+>A : T
+>A : T
+
+    B = B,
+>B : T
+>B : T
+
+    C = C,
+>C : T
+>C : T
+
+    D = D,
+>D : T
+>D : T
+
+    E = `E_${A}_${B}_${C}`
+>E : T
+>`E_${A}_${B}_${C}` : string
+>A : T
+>B : T
+>C : T
+}
+

tests/cases/compiler/enumWithConst.ts

@@ -0,0 +1,12 @@
+const A = 1;
+const B = "B";
+const C: string = "C";
+const D = `D_${A}_${B}_${C}`;
+
+enum T {
+    A = A,
+    B = B,
+    C = C,
+    D = D,
+    E = `E_${A}_${B}_${C}`
+}