align behavior of constant expressions in initializers of ambient enum members with spec

Author: vladima

src/compiler/checker.ts

@@ -12940,26 +12940,41 @@ namespace ts {
  if (!(nodeLinks.flags & NodeCheckFlags.EnumValuesComputed)) {
  let enumSymbol = getSymbolOfNode(node);
  let enumType = getDeclaredTypeOfSymbol(enumSymbol);
- let autoValue = 0;
+ let autoValue = 0; // set to undefined when enum member is non-constant
  let ambient = isInAmbientContext(node);
  let enumIsConst = isConst(node);
 
- forEach(node.members, member => {
- if (member.name.kind !== SyntaxKind.ComputedPropertyName && isNumericLiteralName((<Identifier>member.name).text)) {
+ for (const member of node.members) {
+ if (member.name.kind === SyntaxKind.ComputedPropertyName) {
+ error(member.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
+ }
+ else if (isNumericLiteralName((<Identifier>member.name).text)) {
  error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
  }
+
+ const previousEnumMemberIsNonConstant = autoValue === undefined;
+ 
  let initializer = member.initializer;
  if (initializer) {
  autoValue = computeConstantValueForEnumMemberInitializer(initializer, enumType, enumIsConst, ambient);
  }
  else if (ambient && !enumIsConst) {
+ // In ambient enum declarations that specify no const modifier, enum member declarations 
+ // that omit a value are considered computed members (as opposed to having auto-incremented values assigned).
  autoValue = undefined;
  }
+ else if (previousEnumMemberIsNonConstant) {
+ // If the member declaration specifies no value, the member is considered a constant enum member. 
+ // If the member is the first member in the enum declaration, it is assigned the value zero. 
+ // Otherwise, it is assigned the value of the immediately preceding member plus one,
+ // and an error occurs if the immediately preceding member is not a constant enum member
+ error(member.name, Diagnostics.Enum_member_must_have_initializer);
+ }
 
  if (autoValue !== undefined) {
  getNodeLinks(member).enumMemberValue = autoValue++;
  }
- });
+ }
 
  nodeLinks.flags |= NodeCheckFlags.EnumValuesComputed;
  }
@@ -12975,11 +12990,11 @@ namespace ts {
  if (enumIsConst) {
  error(initializer, Diagnostics.In_const_enum_declarations_member_initializer_must_be_constant_expression);
  }
- else if (!ambient) {
+ else if (ambient) {
+ error(initializer, Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression);
+ } 
+ else {
  // Only here do we need to check that the initializer is assignable to the enum type.
- // If it is a constant value (not undefined), it is syntactically constrained to be a number.
- // Also, we do not need to check this for ambients because there is already
- // a syntax error if it is not a constant.
  checkTypeAssignableTo(checkExpression(initializer), enumType, initializer, /*headMessage*/ undefined);
  }
  }
@@ -13119,7 +13134,7 @@ namespace ts {
  }
 
  // Grammar checking
- checkGrammarDecorators(node) || checkGrammarModifiers(node) || checkGrammarEnumDeclaration(node);
+ checkGrammarDecorators(node) || checkGrammarModifiers(node);
 
  checkTypeNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0);
  checkCollisionWithCapturedThisVariable(node, node.name);
@@ -15619,40 +15634,6 @@ namespace ts {
  return false;
  }
 
- function checkGrammarEnumDeclaration(enumDecl: EnumDeclaration): boolean {
- let enumIsConst = (enumDecl.flags & NodeFlags.Const) !== 0;
-
- let hasError = false;
-
- // skip checks below for const enums - they allow arbitrary initializers as long as they can be evaluated to constant expressions.
- // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members.
- if (!enumIsConst) {
- let inConstantEnumMemberSection = true;
- let inAmbientContext = isInAmbientContext(enumDecl);
- for (let node of enumDecl.members) {
- // Do not use hasDynamicName here, because that returns false for well known symbols.
- // We want to perform checkComputedPropertyName for all computed properties, including
- // well known symbols.
- if (node.name.kind === SyntaxKind.ComputedPropertyName) {
- hasError = grammarErrorOnNode(node.name, Diagnostics.Computed_property_names_are_not_allowed_in_enums);
- }
- else if (inAmbientContext) {
- if (node.initializer && !isIntegerLiteral(node.initializer)) {
- hasError = grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers) || hasError;
- }
- }
- else if (node.initializer) {
- inConstantEnumMemberSection = isIntegerLiteral(node.initializer);
- }
- else if (!inConstantEnumMemberSection) {
- hasError = grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer) || hasError;
- }
- }
- }
-
- return hasError;
- }
-
  function hasParseDiagnostics(sourceFile: SourceFile): boolean {
  return sourceFile.parseDiagnostics.length > 0;
  }

src/compiler/diagnosticMessages.json

@@ -195,7 +195,7 @@
  "category": "Error",
  "code": 1063
  },
- "Ambient enum elements can only have integer literal initializers.": {
+ "In ambient enum declarations member initializer must be constant expression.": {
  "category": "Error",
  "code": 1066
  },

tests/baselines/reference/ambientEnum1.errors.txt

@@ -1,17 +1,14 @@
-tests/cases/compiler/ambientEnum1.ts(2,9): error TS1066: Ambient enum elements can only have integer literal initializers.
-tests/cases/compiler/ambientEnum1.ts(7,9): error TS1066: Ambient enum elements can only have integer literal initializers.
+tests/cases/compiler/ambientEnum1.ts(7,13): error TS1066: In ambient enum declarations member initializer must be constant expression.
 
 
-==== tests/cases/compiler/ambientEnum1.ts (2 errors) ====
+==== tests/cases/compiler/ambientEnum1.ts (1 errors) ====
  declare enum E1 {
  y = 4.23
- ~
-!!! error TS1066: Ambient enum elements can only have integer literal initializers.
  }
 
  // Ambient enum with computer member
  declare enum E2 {
  x = 'foo'.length
- ~
-!!! error TS1066: Ambient enum elements can only have integer literal initializers.
+  ~~~~~~~~~~~~
+!!! error TS1066: In ambient enum declarations member initializer must be constant expression.
  }

tests/baselines/reference/ambientEnumDeclaration1.errors.txt

@@ -0,0 +1,23 @@
+=== tests/cases/conformance/ambient/ambientEnumDeclaration1.ts ===
+// In ambient enum declarations, all values specified in enum member declarations must be classified as constant enum expressions.
+
+declare enum E {
+>E : Symbol(E, Decl(ambientEnumDeclaration1.ts, 0, 0))
+
+ a = 10,
+>a : Symbol(E.a, Decl(ambientEnumDeclaration1.ts, 2, 16))
+
+ b = 10 + 1,
+>b : Symbol(E.b, Decl(ambientEnumDeclaration1.ts, 3, 11))
+
+ c = b,
+>c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
+>b : Symbol(E.b, Decl(ambientEnumDeclaration1.ts, 3, 11))
+
+ d = (c) + 1,
+>d : Symbol(E.d, Decl(ambientEnumDeclaration1.ts, 5, 10))
+>c : Symbol(E.c, Decl(ambientEnumDeclaration1.ts, 4, 15))
+
+ e = 10 << 2 * 8,
+>e : Symbol(E.e, Decl(ambientEnumDeclaration1.ts, 6, 16))
+}

tests/baselines/reference/ambientEnumDeclaration1.symbols

@@ -0,0 +1,35 @@
+=== tests/cases/conformance/ambient/ambientEnumDeclaration1.ts ===
+// In ambient enum declarations, all values specified in enum member declarations must be classified as constant enum expressions.
+
+declare enum E {
+>E : E
+
+ a = 10,
+>a : E
+>10 : number
+
+ b = 10 + 1,
+>b : E
+>10 + 1 : number
+>10 : number
+>1 : number
+
+ c = b,
+>c : E
+>b : E
+
+ d = (c) + 1,
+>d : E
+>(c) + 1 : number
+>(c) : E
+>c : E
+>1 : number
+
+ e = 10 << 2 * 8,
+>e : E
+>10 << 2 * 8 : number
+>10 : number
+>2 * 8 : number
+>2 : number
+>8 : number
+}

tests/baselines/reference/ambientEnumDeclaration1.types

@@ -0,0 +1,7 @@
+=== tests/cases/compiler/ambientEnumElementInitializer3.ts ===
+declare enum E {
+>E : Symbol(E, Decl(ambientEnumElementInitializer3.ts, 0, 0))
+
+ e = 3.3 // Decimal
+>e : Symbol(E.e, Decl(ambientEnumElementInitializer3.ts, 0, 16))
+}

tests/baselines/reference/ambientEnumElementInitializer3.errors.txt

@@ -0,0 +1,8 @@
+=== tests/cases/compiler/ambientEnumElementInitializer3.ts ===
+declare enum E {
+>E : E
+
+ e = 3.3 // Decimal
+>e : E
+>3.3 : number
+}

tests/baselines/reference/ambientEnumElementInitializer3.symbols

@@ -2,8 +2,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(2,15): error TS1039: Initialize
 tests/cases/conformance/ambient/ambientErrors.ts(6,18): error TS2382: Specialized overload signature is not assignable to any non-specialized signature.
 tests/cases/conformance/ambient/ambientErrors.ts(17,22): error TS2371: A parameter initializer is only allowed in a function or constructor implementation.
 tests/cases/conformance/ambient/ambientErrors.ts(20,24): error TS1183: An implementation cannot be declared in ambient contexts.
-tests/cases/conformance/ambient/ambientErrors.ts(24,5): error TS1066: Ambient enum elements can only have integer literal initializers.
-tests/cases/conformance/ambient/ambientErrors.ts(29,5): error TS1066: Ambient enum elements can only have integer literal initializers.
+tests/cases/conformance/ambient/ambientErrors.ts(29,9): error TS1066: In ambient enum declarations member initializer must be constant expression.
 tests/cases/conformance/ambient/ambientErrors.ts(34,11): error TS1039: Initializers are not allowed in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(35,19): error TS1183: An implementation cannot be declared in ambient contexts.
 tests/cases/conformance/ambient/ambientErrors.ts(37,20): error TS1039: Initializers are not allowed in ambient contexts.
@@ -16,7 +15,7 @@ tests/cases/conformance/ambient/ambientErrors.ts(51,16): error TS2436: Ambient m
 tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export assignment cannot be used in a module with other exported elements.
 
 
-==== tests/cases/conformance/ambient/ambientErrors.ts (16 errors) ====
+==== tests/cases/conformance/ambient/ambientErrors.ts (15 errors) ====
  // Ambient variable with an initializer 
  declare var x = 4;
  ~
@@ -49,15 +48,13 @@ tests/cases/conformance/ambient/ambientErrors.ts(57,5): error TS2309: An export
  // Ambient enum with non - integer literal constant member
  declare enum E1 {
  y = 4.23
- ~
-!!! error TS1066: Ambient enum elements can only have integer literal initializers.
  }
 
  // Ambient enum with computer member
  declare enum E2 {
  x = 'foo'.length
- ~
-!!! error TS1066: Ambient enum elements can only have integer literal initializers.
+  ~~~~~~~~~~~~
+!!! error TS1066: In ambient enum declarations member initializer must be constant expression.
  }
 
  // Ambient module with initializers for values, bodies for functions / classes