Error for more than one enum omitting an initial initializer

Author: JsonFreeman

src/compiler/checker.ts

@@ -5212,7 +5212,8 @@ module ts {
         function checkEnumDeclaration(node: EnumDeclaration) {
             checkDeclarationModifiers(node);
             checkNameIsReserved(node.name, Diagnostics.Enum_name_cannot_be_0);
-            var enumType = getDeclaredTypeOfSymbol(getSymbolOfNode(node));
+            var enumSymbol = getSymbolOfNode(node);
+            var enumType = getDeclaredTypeOfSymbol(enumSymbol);
             var autoValue = 0;
             var ambient = isInAmbientContext(node);
             forEach(node.members, member => {
@@ -5235,7 +5236,38 @@ module ts {
                     getNodeLinks(member).enumMemberValue = autoValue++;
                 }
             });
-            // TODO: Only one enum declaration can omit the initial value
+
+            // Spec 2014 - Section 9.3:
+            // It isn't possible for one enum declaration to continue the automatic numbering sequence of another,
+            // and when an enum type has multiple declarations, only one declaration is permitted to omit a value
+            // for the first member.
+            //
+            // Only perform this check once per symbol
+            var firstDeclaration = getDeclarationOfKind(enumSymbol, node.kind);
+            if (node === firstDeclaration) {
+                var seenEnumMissingInitialInitializer = false;
+                forEach(enumSymbol.declarations, declaration => {
+                    // return true if we hit a violation of the rule, false otherwise
+                    if (declaration.kind !== SyntaxKind.EnumDeclaration) {
+                        return false;
+                    }
+
+                    var enumDeclaration = <EnumDeclaration>declaration;
+                    if (!enumDeclaration.members.length) {
+                        return false;
+                    }
+
+                    var firstEnumMember = enumDeclaration.members[0];
+                    if (!firstEnumMember.initializer) {
+                        if (seenEnumMissingInitialInitializer) {
+                            error(firstEnumMember.name, Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element);
+                        }
+                        else {
+                            seenEnumMissingInitialInitializer = true;
+                        }
+                    }
+                });
+            }
         }
 
         function checkModuleDeclaration(node: ModuleDeclaration) {

src/compiler/diagnosticInformationMap.generated.ts

@@ -191,6 +191,7 @@ module ts {
         Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: { code: 4017, category: DiagnosticCategory.NoPrefix, key: "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function." },
         Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: { code: 4018, category: DiagnosticCategory.NoPrefix, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor." },
         Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_property: { code: 4019, category: DiagnosticCategory.NoPrefix, key: "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member property." },
+        In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: { code: 4024, category: DiagnosticCategory.Error, key: "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element." },
         Named_properties_0_of_types_1_and_2_are_not_identical: { code: 4032, category: DiagnosticCategory.NoPrefix, key: "Named properties '{0}' of types '{1}' and '{2}' are not identical." },
         Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
         Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" },

src/compiler/diagnosticMessages.json

@@ -763,6 +763,10 @@
         "category": "NoPrefix",
         "code": 4019
     },
+    "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.": {
+        "category": "Error",
+        "code": 4024
+    },
     "Named properties '{0}' of types '{1}' and '{2}' are not identical.": {
         "category": "NoPrefix",
         "code": 4032

tests/baselines/reference/augmentedTypesEnum.errors.txt

@@ -1,4 +1,4 @@
-==== tests/cases/compiler/augmentedTypesEnum.ts (5 errors) ====
+==== tests/cases/compiler/augmentedTypesEnum.ts (7 errors) ====
     // enum then var
     enum e1111 { One }
     var e1111 = 1; // error
@@ -25,11 +25,15 @@
     // enum then enum
     enum e5 { One }
     enum e5 { Two }
+              ~~~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
 
     enum e5a { One }
     enum e5a { One } // error
                ~~~
 !!! Duplicate identifier 'One'.
+               ~~~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
 
     // enum then internal module
     enum e6 { One } 

tests/baselines/reference/augmentedTypesEnum3.errors.txt

@@ -0,0 +1,23 @@
+==== tests/cases/compiler/augmentedTypesEnum3.ts (1 errors) ====
+    module E {
+        var t;
+    }
+    enum E { }
+    
+    enum F { }
+    module F { var t; }
+    
+    module A {
+        var o;
+    }
+    enum A {
+        b
+    }
+    enum A {
+        c
+        ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }
+    module A {
+        var p;
+    }

tests/baselines/reference/enumBasics1.errors.txt

@@ -1,4 +1,4 @@
-==== tests/cases/compiler/enumBasics1.ts (1 errors) ====
+==== tests/cases/compiler/enumBasics1.ts (2 errors) ====
     enum E {
     	A = 1,
     	B,
@@ -34,7 +34,9 @@
     	B,
     }
 
-    enum E2 { // shouldn't error
+    enum E2 { // should error for continued autonumbering
     	C,
+    	~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
     	D,
     }

tests/baselines/reference/enumBasics1.js

@@ -32,7 +32,7 @@ enum E2 {
 	B,
 }
 
-enum E2 { // shouldn't error
+enum E2 { // should error for continued autonumbering
 	C,
 	D,
 }

tests/baselines/reference/enumMergingErrors.errors.txt

@@ -0,0 +1,47 @@
+==== tests/cases/conformance/enums/enumMergingErrors.ts (2 errors) ====
+    // Enum with constant, computed, constant members split across 3 declarations with the same root module
+    module M {
+        export enum E1 { A = 0 }
+        export enum E2 { C }
+        export enum E3 { A = 0 }
+    }
+    module M {
+        export enum E1 { B = 'foo'.length }
+        export enum E2 { B = 'foo'.length }
+        export enum E3 { C }
+    }
+    module M {
+        export enum E1 { C }
+        export enum E2 { A = 0 }
+        export enum E3 { B = 'foo'.length }
+    }
+    
+    // Enum with no initializer in either declaration with constant members with the same root module
+    module M1 {
+        export enum E1 { A = 0 }
+    }
+    module M1 {
+        export enum E1 { B }
+    }
+    module M1 {
+        export enum E1 { C }
+                         ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }
+    
+    
+    // Enum with initializer in only one of three declarations with constant members with the same root module
+    module M2 {
+        export enum E1 { A }
+    }
+    module M2 {
+        export enum E1 { B = 0 }
+    }
+    module M2 {
+        export enum E1 { C }
+                         ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }
+    
+    
+    

tests/baselines/reference/enumsWithMultipleDeclarations1.errors.txt

@@ -0,0 +1,16 @@
+==== tests/cases/compiler/enumsWithMultipleDeclarations1.ts (2 errors) ====
+    enum E {
+      A
+    }
+    
+    enum E {
+      B
+      ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }
+    
+    enum E {
+      C
+      ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }

tests/baselines/reference/enumsWithMultipleDeclarations2.errors.txt

@@ -0,0 +1,14 @@
+==== tests/cases/compiler/enumsWithMultipleDeclarations2.ts (1 errors) ====
+    enum E {
+      A
+    }
+    
+    enum E {
+      B = 1
+    }
+    
+    enum E {
+      C
+      ~
+!!! In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element.
+    }

tests/cases/compiler/enumBasics1.ts

@@ -31,7 +31,7 @@ enum E2 {
 	B,
 }
 
-enum E2 { // shouldn't error
+enum E2 { // should error for continued autonumbering
 	C,
 	D,
 }