Introduce literal freshness for literal enum member types (microsoft#26556)

* Introduce literal freshness for literal enum members, allow enum references in ambient const initializers * Merge statements * Add enum literal readonly property test case * Accept better baselines post-merge

Author: weswigham

src/compiler/checker.ts

@@ -5907,9 +5907,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));
  }
  }
  }
@@ -8242,7 +8242,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;
  }
 
@@ -12736,7 +12736,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 :
@@ -28274,13 +28274,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 {
@@ -29643,13 +29644,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
 }