Introduce literal freshness for literal enum member types

src/compiler/checker.ts

@@ -5886,9 +5886,9 @@ namespace ts {
                 for (const declaration of symbol.declarations) {
                     if (declaration.kind === SyntaxKind.EnumDeclaration) {
                         for (const member of (<EnumDeclaration>declaration).members) {
-                            const memberType = getLiteralType(getEnumMemberValue(member)!, enumCount, getSymbolOfNode(member)); // TODO: GH#18217
+                            const memberType = getFreshTypeOfLiteralType(getLiteralType(getEnumMemberValue(member)!, enumCount, getSymbolOfNode(member))); // TODO: GH#18217
                             getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType;
-                            memberTypeList.push(memberType);
+                            memberTypeList.push(getRegularTypeOfLiteralType(memberType));
                         }
                     }
                 }
@@ -8221,7 +8221,7 @@ namespace ts {
             const res = tryGetDeclaredTypeOfSymbol(symbol);
             if (res) {
                 return checkNoTypeArguments(node, symbol) ?
-                    res.flags & TypeFlags.TypeParameter ? getConstrainedTypeVariable(<TypeParameter>res, node) : res :
+                    res.flags & TypeFlags.TypeParameter ? getConstrainedTypeVariable(<TypeParameter>res, node) : getRegularTypeOfLiteralType(res) :
                     errorType;
             }
 
@@ -12705,7 +12705,7 @@ namespace ts {
         }
 
         function getWidenedLiteralType(type: Type): Type {
-            return type.flags & TypeFlags.EnumLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
+            return type.flags & TypeFlags.EnumLiteral && type.flags & TypeFlags.FreshLiteral ? getBaseTypeOfEnumLiteralType(<LiteralType>type) :
                 type.flags & TypeFlags.StringLiteral && type.flags & TypeFlags.FreshLiteral ? stringType :
                 type.flags & TypeFlags.NumberLiteral && type.flags & TypeFlags.FreshLiteral ? numberType :
                 type.flags & TypeFlags.BooleanLiteral ? booleanType :
@@ -28090,13 +28090,14 @@ namespace ts {
             return false;
         }
 
-        function literalTypeToNode(type: LiteralType): Expression {
-            return createLiteral(type.value);
+        function literalTypeToNode(type: LiteralType, enclosing: Node): Expression {
+            const enumResult = type.flags & TypeFlags.EnumLiteral && nodeBuilder.symbolToExpression(type.symbol, SymbolFlags.Value, enclosing);
+            return enumResult || createLiteral(type.value);
         }
 
         function createLiteralConstValue(node: VariableDeclaration | PropertyDeclaration | PropertySignature | ParameterDeclaration) {
             const type = getTypeOfSymbol(getSymbolOfNode(node));
-            return literalTypeToNode(<LiteralType>type);
+            return literalTypeToNode(<LiteralType>type, node);
         }
 
         function createResolver(): EmitResolver {
@@ -29430,13 +29431,20 @@ namespace ts {
                 (<PrefixUnaryExpression>expr).operand.kind === SyntaxKind.NumericLiteral;
         }
 
+        function isSimpleLiteralEnumReference(expr: Expression) {
+            if (
+                (isPropertyAccessExpression(expr) || (isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) &&
+                isEntityNameExpression(expr.expression)
+            ) return !!(checkExpressionCached(expr).flags & TypeFlags.EnumLiteral);
+        }
+
         function checkAmbientInitializer(node: VariableDeclaration | PropertyDeclaration | PropertySignature) {
             if (node.initializer) {
-                const isInvalidInitializer = !isStringOrNumberLiteralExpression(node.initializer);
+                const isInvalidInitializer = !(isStringOrNumberLiteralExpression(node.initializer) || isSimpleLiteralEnumReference(node.initializer));
                 const isConstOrReadonly = isDeclarationReadonly(node) || isVariableDeclaration(node) && isVarConst(node);
                 if (isConstOrReadonly && !node.type) {
                     if (isInvalidInitializer) {
-                        return grammarErrorOnNode(node.initializer!, Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal);
+                        return grammarErrorOnNode(node.initializer!, Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference);
                     }
                 }
                 else {

src/compiler/diagnosticMessages.json

@@ -835,7 +835,7 @@
         "category": "Error",
         "code": 1253
     },
-    "A 'const' initializer in an ambient context must be a string or numeric literal.": {
+    "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference.": {
         "category": "Error",
         "code": 1254
     },

tests/baselines/reference/ambientConstLiterals.js

@@ -3,7 +3,7 @@ function f<T>(x: T): T {
     return x;
 }
 
-enum E { A, B, C }
+enum E { A, B, C, "non identifier" }
 
 const c1 = "abc";
 const c2 = 123;
@@ -13,6 +13,7 @@ const c5 = f(123);
 const c6 = f(-123);
 const c7 = true;
 const c8 = E.A;
+const c8b = E["non identifier"];
 const c9 = { x: "abc" };
 const c10 = [123];
 const c11 = "abc" + "def";
@@ -29,6 +30,7 @@ var E;
     E[E["A"] = 0] = "A";
     E[E["B"] = 1] = "B";
     E[E["C"] = 2] = "C";
+    E[E["non identifier"] = 3] = "non identifier";
 })(E || (E = {}));
 var c1 = "abc";
 var c2 = 123;
@@ -38,6 +40,7 @@ var c5 = f(123);
 var c6 = f(-123);
 var c7 = true;
 var c8 = E.A;
+var c8b = E["non identifier"];
 var c9 = { x: "abc" };
 var c10 = [123];
 var c11 = "abc" + "def";
@@ -51,7 +54,8 @@ declare function f<T>(x: T): T;
 declare enum E {
     A = 0,
     B = 1,
-    C = 2
+    C = 2,
+    "non identifier" = 3
 }
 declare const c1 = "abc";
 declare const c2 = 123;
@@ -60,7 +64,8 @@ declare const c4 = 123;
 declare const c5 = 123;
 declare const c6 = -123;
 declare const c7: boolean;
-declare const c8: E;
+declare const c8 = E.A;
+declare const c8b = E["non identifier"];
 declare const c9: {
     x: string;
 };

tests/baselines/reference/ambientConstLiterals.symbols

@@ -10,11 +10,12 @@ function f<T>(x: T): T {
 >x : Symbol(x, Decl(ambientConstLiterals.ts, 0, 14))
 }
 
-enum E { A, B, C }
+enum E { A, B, C, "non identifier" }
 >E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1))
 >A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8))
 >B : Symbol(E.B, Decl(ambientConstLiterals.ts, 4, 11))
 >C : Symbol(E.C, Decl(ambientConstLiterals.ts, 4, 14))
+>"non identifier" : Symbol(E["non identifier"], Decl(ambientConstLiterals.ts, 4, 17))
 
 const c1 = "abc";
 >c1 : Symbol(c1, Decl(ambientConstLiterals.ts, 6, 5))
@@ -47,27 +48,32 @@ const c8 = E.A;
 >E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1))
 >A : Symbol(E.A, Decl(ambientConstLiterals.ts, 4, 8))
 
+const c8b = E["non identifier"];
+>c8b : Symbol(c8b, Decl(ambientConstLiterals.ts, 14, 5))
+>E : Symbol(E, Decl(ambientConstLiterals.ts, 2, 1))
+>"non identifier" : Symbol(E["non identifier"], Decl(ambientConstLiterals.ts, 4, 17))
+
 const c9 = { x: "abc" };
->c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 14, 5))
->x : Symbol(x, Decl(ambientConstLiterals.ts, 14, 12))
+>c9 : Symbol(c9, Decl(ambientConstLiterals.ts, 15, 5))
+>x : Symbol(x, Decl(ambientConstLiterals.ts, 15, 12))
 
 const c10 = [123];
->c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 15, 5))
+>c10 : Symbol(c10, Decl(ambientConstLiterals.ts, 16, 5))
 
 const c11 = "abc" + "def";
->c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 16, 5))
+>c11 : Symbol(c11, Decl(ambientConstLiterals.ts, 17, 5))
 
 const c12 = 123 + 456;
->c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 17, 5))
+>c12 : Symbol(c12, Decl(ambientConstLiterals.ts, 18, 5))
 
 const c13 = Math.random() > 0.5 ? "abc" : "def";
->c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 18, 5))
+>c13 : Symbol(c13, Decl(ambientConstLiterals.ts, 19, 5))
 >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
 >Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
 
 const c14 = Math.random() > 0.5 ? 123 : 456;
->c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 19, 5))
+>c14 : Symbol(c14, Decl(ambientConstLiterals.ts, 20, 5))
 >Math.random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))
 >Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >random : Symbol(Math.random, Decl(lib.es5.d.ts, --, --))

tests/baselines/reference/ambientConstLiterals.types

@@ -7,11 +7,12 @@ function f<T>(x: T): T {
 >x : T
 }
 
-enum E { A, B, C }
+enum E { A, B, C, "non identifier" }
 >E : E
 >A : E.A
 >B : E.B
 >C : E.C
+>"non identifier" : E.non identifier
 
 const c1 = "abc";
 >c1 : "abc"
@@ -52,6 +53,12 @@ const c8 = E.A;
 >E : typeof E
 >A : E.A
 
+const c8b = E["non identifier"];
+>c8b : E.non identifier
+>E["non identifier"] : E.non identifier
+>E : typeof E
+>"non identifier" : "non identifier"
+
 const c9 = { x: "abc" };
 >c9 : { x: string; }
 >{ x: "abc" } : { x: string; }

tests/baselines/reference/ambientEnum1.types

@@ -3,7 +3,7 @@
 >E1 : E1
 
         y = 4.23
->y : E1
+>y : E1.y
 >4.23 : 4.23
     }
 

tests/baselines/reference/ambientEnumElementInitializer1.types

@@ -3,6 +3,6 @@ declare enum E {
 >E : E
 
  e = 3
->e : E
+>e : E.e
 >3 : 3
 }

tests/baselines/reference/ambientEnumElementInitializer2.types

@@ -3,7 +3,7 @@ declare enum E {
 >E : E
 
  e = -3 // Negative
->e : E
+>e : E.e
 >-3 : -3
 >3 : 3
 }

tests/baselines/reference/ambientEnumElementInitializer3.types

@@ -3,6 +3,6 @@ declare enum E {
 >E : E
 
  e = 3.3 // Decimal
->e : E
+>e : E.e
 >3.3 : 3.3
 }

tests/baselines/reference/ambientEnumElementInitializer4.types

@@ -3,6 +3,6 @@ declare enum E {
 >E : E
 
  e = 0xA
->e : E
+>e : E.e
 >0xA : 10
 }

tests/baselines/reference/ambientEnumElementInitializer5.types

@@ -3,7 +3,7 @@ declare enum E {
 >E : E
 
  e = -0xA
->e : E
+>e : E.e
 >-0xA : -10
 >0xA : 10
 }

tests/baselines/reference/ambientEnumElementInitializer6.types

@@ -6,7 +6,7 @@ declare module M {
 >E : E
 
         e = 3
->e : E
+>e : E.e
 >3 : 3
     }
 }

tests/baselines/reference/ambientErrors.types

@@ -46,7 +46,7 @@ declare enum E1 {
 >E1 : E1
 
     y = 4.23
->y : E1
+>y : E1.y
 >4.23 : 4.23
 }
 

tests/baselines/reference/anyAssignabilityInInheritance.types

@@ -199,7 +199,7 @@ var r3 = foo3(a); // any
 
 enum E { A }
 >E : E
->A : E
+>A : E.A
 
 declare function foo14(x: E): E;
 >foo14 : { (x: E): E; (x: any): any; }

tests/baselines/reference/anyAssignableToEveryType.types

@@ -20,7 +20,7 @@ var ai: I;
 
 enum E { A }
 >E : E
->A : E
+>A : E.A
 
 var ae: E;
 >ae : E

tests/baselines/reference/anyAssignableToEveryType2.types

@@ -129,7 +129,7 @@ interface I13 {
 
 enum E { A }
 >E : E
->A : E
+>A : E.A
 
 interface I14 {
     [x: string]: E;

tests/baselines/reference/assignAnyToEveryType.types

@@ -42,7 +42,7 @@ enum E {
 >E : E
 
     A
->A : E
+>A : E.A
 }
 
 var g: E = x;

tests/baselines/reference/assignEveryTypeToAny.types

@@ -76,7 +76,7 @@ enum E {
 >E : E
 
     A
->A : E
+>A : E.A
 }
 
 x = E.A;

tests/baselines/reference/assignmentToParenthesizedIdentifiers.types

@@ -294,7 +294,7 @@ enum E {
 >E : E
 
     A
->A : E
+>A : E.A
 }
 E = undefined; // Error
 >E = undefined : undefined

tests/baselines/reference/assignments.types

@@ -24,7 +24,7 @@ C = null; // Error
 
 enum E { A }
 >E : E
->A : E
+>A : E.A
 
 E = null; // Error
 >E = null : null

tests/baselines/reference/asyncEnum_es5.types

@@ -3,5 +3,5 @@ async enum E {
 >E : E
 
   Value
->Value : E
+>Value : E.Value
 }

tests/baselines/reference/asyncEnum_es6.types

@@ -3,5 +3,5 @@ async enum E {
 >E : E
 
   Value
->Value : E
+>Value : E.Value
 }

tests/baselines/reference/augmentedTypesClass.types

@@ -15,5 +15,5 @@ class c4 { public foo() { } }
 
 enum c4 { One } // error
 >c4 : c4
->One : c4
+>One : c4.One
 

tests/baselines/reference/augmentedTypesClass2.types

@@ -32,7 +32,7 @@ class c33 {
 }
 enum c33 { One };
 >c33 : c33
->One : c33
+>One : c33.One
 
 // class then import
 class c44 {