diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 952600b6017..927cc050e20 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4084,7 +4084,7 @@ module ts {
         }
 
         function isNumericName(name: string) {
-            return !isNaN(<number><any>name);
+            return (name !== "") && !isNaN(<number><any>name);
         }
 
         function checkObjectLiteral(node: ObjectLiteral, contextualMapper?: TypeMapper): Type {
@@ -6643,6 +6643,9 @@ module ts {
                 var ambient = isInAmbientContext(node);
 
                 forEach(node.members, member => {
+                    if(isNumericName(member.name.text)) {
+                        error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
+                    }
                     var initializer = member.initializer;
                     if (initializer) {
                         autoValue = getConstantValueForExpression(initializer);
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index dec1c00027b..f6e8275786d 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -114,6 +114,7 @@ module ts {
         Cannot_compile_external_modules_unless_the_module_flag_is_provided: { code: 1148, category: DiagnosticCategory.Error, key: "Cannot compile external modules unless the '--module' flag is provided." },
         Filename_0_differs_from_already_included_filename_1_only_in_casing: { code: 1149, category: DiagnosticCategory.Error, key: "Filename '{0}' differs from already included filename '{1}' only in casing" },
         new_T_cannot_be_used_to_create_an_array_Use_new_Array_T_instead: { code: 1150, category: DiagnosticCategory.Error, key: "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead." },
+        An_enum_member_cannot_have_a_numeric_name: { code: 1151, category: DiagnosticCategory.Error, key: "An enum member cannot have a numeric name." },
         Duplicate_identifier_0: { code: 2300, category: DiagnosticCategory.Error, key: "Duplicate identifier '{0}'." },
         Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: { code: 2301, category: DiagnosticCategory.Error, key: "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor." },
         Static_members_cannot_reference_class_type_parameters: { code: 2302, category: DiagnosticCategory.Error, key: "Static members cannot reference class type parameters." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 79208be1a0d..97c82a0a718 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -11,7 +11,7 @@
         "category": "Error",
         "code": 1005
     },
-	"A file cannot have a reference to itself.": {
+    "A file cannot have a reference to itself.": {
         "category": "Error",
         "code": 1006
     },
@@ -187,7 +187,7 @@
         "category": "Error",
         "code": 1066
     },
-    "Unexpected token. A constructor, method, accessor, or property was expected." : {
+    "Unexpected token. A constructor, method, accessor, or property was expected.": {
         "category": "Error",
         "code": 1068
     },
@@ -444,9 +444,13 @@
         "code": 1149
     },
     "'new T[]' cannot be used to create an array. Use 'new Array<T>()' instead.": {
-       "category": "Error",
-       "code": 1150
-   },
+        "category": "Error",
+        "code": 1150
+    },
+    "An enum member cannot have a numeric name.": {
+        "category": "Error",
+        "code":  1151
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
@@ -556,7 +560,7 @@
         "category": "Error",
         "code": 2326
     },
-	"Property '{0}' is optional in type '{1}' but required in type '{2}'.": {
+    "Property '{0}' is optional in type '{1}' but required in type '{2}'.": {
         "category": "Error",
         "code": 2327
     },
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
index e38520ef71a..9cd5a63912e 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
+++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
@@ -1,40 +1,40 @@
 //// [bitwiseNotOperatorWithEnumType.ts]
 // ~ operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = ~ENUM1;
 
 // enum type expressions
-var ResultIsNumber2 = ~ENUM1[1];
-var ResultIsNumber3 = ~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = ~ENUM1["A"];
+var ResultIsNumber3 = ~(ENUM1.A + ENUM1["B"]);
 
 // multiple ~ operators
-var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B);
 
 // miss assignment operators
 ~ENUM1;
-~ENUM1[1];
-~ENUM1[1], ~ENUM1[2];
+~ENUM1["A"];
+~ENUM1.A, ~ENUM1["B"];
 
 //// [bitwiseNotOperatorWithEnumType.js]
 // ~ operator on enum type
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
 // enum type var
 var ResultIsNumber1 = ~ENUM1;
 // enum type expressions
-var ResultIsNumber2 = ~ENUM1[1];
-var ResultIsNumber3 = ~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = ~ENUM1["A"];
+var ResultIsNumber3 = ~(0 /* A */ + ENUM1["B"]);
 // multiple ~ operators
-var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber4 = ~~~(ENUM1["A"] + 1 /* B */);
 // miss assignment operators
 ~ENUM1;
-~ENUM1[1];
-~ENUM1[1], ~ENUM1[2];
+~ENUM1["A"];
+~0 /* A */, ~ENUM1["B"];
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types
index 077b8fdd4d6..71598c6f693 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types
+++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types
@@ -1,8 +1,10 @@
 === tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts ===
 // ~ operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsNumber1 = ~ENUM1;
@@ -11,51 +13,54 @@ var ResultIsNumber1 = ~ENUM1;
 >ENUM1 : typeof ENUM1
 
 // enum type expressions
-var ResultIsNumber2 = ~ENUM1[1];
+var ResultIsNumber2 = ~ENUM1["A"];
 >ResultIsNumber2 : number
->~ENUM1[1] : number
->ENUM1[1] : ENUM1
+>~ENUM1["A"] : number
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsNumber3 = ~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber3 = ~(ENUM1.A + ENUM1["B"]);
 >ResultIsNumber3 : number
->~(ENUM1[1] + ENUM1[2]) : number
->(ENUM1[1] + ENUM1[2]) : number
->ENUM1[1] + ENUM1[2] : number
->ENUM1[1] : ENUM1
+>~(ENUM1.A + ENUM1["B"]) : number
+>(ENUM1.A + ENUM1["B"]) : number
+>ENUM1.A + ENUM1["B"] : number
+>ENUM1.A : ENUM1
 >ENUM1 : typeof ENUM1
->ENUM1[2] : ENUM1
+>A : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // multiple ~ operators
-var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B);
 >ResultIsNumber4 : number
->~~~(ENUM1[1] + ENUM1[2]) : number
->~~(ENUM1[1] + ENUM1[2]) : number
->~(ENUM1[1] + ENUM1[2]) : number
->(ENUM1[1] + ENUM1[2]) : number
->ENUM1[1] + ENUM1[2] : number
->ENUM1[1] : ENUM1
+>~~~(ENUM1["A"] + ENUM1.B) : number
+>~~(ENUM1["A"] + ENUM1.B) : number
+>~(ENUM1["A"] + ENUM1.B) : number
+>(ENUM1["A"] + ENUM1.B) : number
+>ENUM1["A"] + ENUM1.B : number
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
->ENUM1[2] : ENUM1
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
+>B : ENUM1
 
 // miss assignment operators
 ~ENUM1;
 >~ENUM1 : number
 >ENUM1 : typeof ENUM1
 
-~ENUM1[1];
->~ENUM1[1] : number
->ENUM1[1] : ENUM1
+~ENUM1["A"];
+>~ENUM1["A"] : number
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-~ENUM1[1], ~ENUM1[2];
->~ENUM1[1], ~ENUM1[2] : number
->~ENUM1[1] : number
->ENUM1[1] : ENUM1
+~ENUM1.A, ~ENUM1["B"];
+>~ENUM1.A, ~ENUM1["B"] : number
+>~ENUM1.A : number
+>ENUM1.A : ENUM1
 >ENUM1 : typeof ENUM1
->~ENUM1[2] : number
->ENUM1[2] : ENUM1
+>A : ENUM1
+>~ENUM1["B"] : number
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt
new file mode 100644
index 00000000000..d43515e84ef
--- /dev/null
+++ b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt
@@ -0,0 +1,24 @@
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(12,7): error TS2304: Cannot find name 'A'.
+
+
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts (3 errors) ====
+    // -- operator on enum type
+    
+    enum ENUM1 { A, B, "" };
+    
+    // expression
+    var ResultIsNumber1 = --ENUM1["A"];
+    var ResultIsNumber2 = ENUM1.A--;
+                          ~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+    
+    // miss assignment operator
+    --ENUM1["A"];
+    
+    ENUM1[A]--;
+    ~~~~~~~~
+!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+          ~
+!!! error TS2304: Cannot find name 'A'.
\ No newline at end of file
diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.js b/tests/baselines/reference/decrementOperatorWithEnumType.js
index 8c22fd18928..13947a6a948 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumType.js
+++ b/tests/baselines/reference/decrementOperatorWithEnumType.js
@@ -1,29 +1,29 @@
 //// [decrementOperatorWithEnumType.ts]
 // -- operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // expression
-var ResultIsNumber1 = --ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]--;
+var ResultIsNumber1 = --ENUM1["A"];
+var ResultIsNumber2 = ENUM1.A--;
 
 // miss assignment operator
---ENUM1[1];
+--ENUM1["A"];
 
-ENUM1[1]--;
+ENUM1[A]--;
 
 //// [decrementOperatorWithEnumType.js]
 // -- operator on enum type
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
 // expression
-var ResultIsNumber1 = --ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]--;
+var ResultIsNumber1 = --ENUM1["A"];
+var ResultIsNumber2 = 0 /* A */--;
 // miss assignment operator
---ENUM1[1];
-ENUM1[1]--;
+--ENUM1["A"];
+ENUM1[A]--;
diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.types b/tests/baselines/reference/decrementOperatorWithEnumType.types
deleted file mode 100644
index fc670ddc6f7..00000000000
--- a/tests/baselines/reference/decrementOperatorWithEnumType.types
+++ /dev/null
@@ -1,30 +0,0 @@
-=== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts ===
-// -- operator on enum type
-
-enum ENUM1 { 1, 2, "" };
->ENUM1 : ENUM1
-
-// expression
-var ResultIsNumber1 = --ENUM1[1];
->ResultIsNumber1 : number
->--ENUM1[1] : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-var ResultIsNumber2 = ENUM1[1]--;
->ResultIsNumber2 : number
->ENUM1[1]-- : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-// miss assignment operator
---ENUM1[1];
->--ENUM1[1] : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-ENUM1[1]--;
->ENUM1[1]-- : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
diff --git a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt
index 652aae1ab5a..079bb2a6b64 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt
@@ -2,19 +2,21 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(8,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(10,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(11,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(14,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(15,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(14,25): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(14,43): error TS2339: Property 'B' does not exist on type 'typeof ENUM'.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(15,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(15,29): error TS2339: Property 'A' does not exist on type 'typeof ENUM'.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(18,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(19,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(21,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts(22,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
 
 
-==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts (10 errors) ====
+==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts (12 errors) ====
     // -- operator on enum type
     
     enum ENUM { };
-    enum ENUM1 { 1, 2, "" };
+    enum ENUM1 { A, B, "" };
     
     // enum type var
     var ResultIsNumber1 = --ENUM;
@@ -32,12 +34,16 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp
 !!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
     
     // enum type expressions
-    var ResultIsNumber5 = --(ENUM[1] + ENUM[2]);
-                            ~~~~~~~~~~~~~~~~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
-    var ResultIsNumber6 = (ENUM[1] + ENUM[2])--;
-                          ~~~~~~~~~~~~~~~~~~~
-!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type.
+    var ResultIsNumber5 = --(ENUM["A"] + ENUM.B);
+                            ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+                                              ~
+!!! error TS2339: Property 'B' does not exist on type 'typeof ENUM'.
+    var ResultIsNumber6 = (ENUM.A + ENUM["B"])--;
+                          ~~~~~~~~~~~~~~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+                                ~
+!!! error TS2339: Property 'A' does not exist on type 'typeof ENUM'.
     
     // miss assignment operator
     --ENUM;
diff --git a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
index 410e3c144ef..66a1252cdd0 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
+++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
@@ -2,7 +2,7 @@
 // -- operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = --ENUM;
@@ -12,8 +12,8 @@ var ResultIsNumber3 = ENUM--;
 var ResultIsNumber4 = ENUM1--;
 
 // enum type expressions
-var ResultIsNumber5 = --(ENUM[1] + ENUM[2]);
-var ResultIsNumber6 = (ENUM[1] + ENUM[2])--;
+var ResultIsNumber5 = --(ENUM["A"] + ENUM.B);
+var ResultIsNumber6 = (ENUM.A + ENUM["B"])--;
 
 // miss assignment operator
 --ENUM;
@@ -30,8 +30,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
@@ -41,8 +41,8 @@ var ResultIsNumber2 = --ENUM1;
 var ResultIsNumber3 = ENUM--;
 var ResultIsNumber4 = ENUM1--;
 // enum type expressions
-var ResultIsNumber5 = --(ENUM[1] + ENUM[2]);
-var ResultIsNumber6 = (ENUM[1] + ENUM[2])--;
+var ResultIsNumber5 = --(ENUM["A"] + ENUM.B);
+var ResultIsNumber6 = (ENUM.A + ENUM["B"])--;
 // miss assignment operator
 --ENUM;
 --ENUM1;
diff --git a/tests/baselines/reference/deleteOperatorWithEnumType.js b/tests/baselines/reference/deleteOperatorWithEnumType.js
index d7fd9c95ee8..e694790091c 100644
--- a/tests/baselines/reference/deleteOperatorWithEnumType.js
+++ b/tests/baselines/reference/deleteOperatorWithEnumType.js
@@ -2,24 +2,24 @@
 // delete  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsBoolean1 = delete ENUM;
 var ResultIsBoolean2 = delete ENUM1;
 
 // enum type expressions
-var ResultIsBoolean3 = delete ENUM1[0];
-var ResultIsBoolean4 = delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean3 = delete ENUM1["A"];
+var ResultIsBoolean4 = delete (ENUM[0] + ENUM1["B"]);
 
 // multiple delete  operators
 var ResultIsBoolean5 = delete delete ENUM;
-var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1["B"]);
 
 // miss assignment operators
 delete ENUM;
 delete ENUM1;
-delete ENUM1[1];
+delete ENUM1.B;
 delete ENUM, ENUM1;
 
 //// [deleteOperatorWithEnumType.js]
@@ -30,8 +30,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
@@ -39,13 +39,13 @@ var ENUM1;
 var ResultIsBoolean1 = delete ENUM;
 var ResultIsBoolean2 = delete ENUM1;
 // enum type expressions
-var ResultIsBoolean3 = delete ENUM1[0];
-var ResultIsBoolean4 = delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean3 = delete ENUM1["A"];
+var ResultIsBoolean4 = delete (ENUM[0] + ENUM1["B"]);
 // multiple delete  operators
 var ResultIsBoolean5 = delete delete ENUM;
-var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1["B"]);
 // miss assignment operators
 delete ENUM;
 delete ENUM1;
-delete ENUM1[1];
+delete 1 /* B */;
 delete ENUM, ENUM1;
diff --git a/tests/baselines/reference/deleteOperatorWithEnumType.types b/tests/baselines/reference/deleteOperatorWithEnumType.types
index d356693616f..e436ac3373f 100644
--- a/tests/baselines/reference/deleteOperatorWithEnumType.types
+++ b/tests/baselines/reference/deleteOperatorWithEnumType.types
@@ -4,8 +4,10 @@
 enum ENUM { };
 >ENUM : ENUM
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsBoolean1 = delete ENUM;
@@ -19,20 +21,20 @@ var ResultIsBoolean2 = delete ENUM1;
 >ENUM1 : typeof ENUM1
 
 // enum type expressions
-var ResultIsBoolean3 = delete ENUM1[0];
+var ResultIsBoolean3 = delete ENUM1["A"];
 >ResultIsBoolean3 : boolean
->delete ENUM1[0] : boolean
->ENUM1[0] : string
+>delete ENUM1["A"] : boolean
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsBoolean4 = delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean4 = delete (ENUM[0] + ENUM1["B"]);
 >ResultIsBoolean4 : boolean
->delete (ENUM[0] + ENUM1[1]) : boolean
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>delete (ENUM[0] + ENUM1["B"]) : boolean
+>(ENUM[0] + ENUM1["B"]) : string
+>ENUM[0] + ENUM1["B"] : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // multiple delete  operators
@@ -42,16 +44,16 @@ var ResultIsBoolean5 = delete delete ENUM;
 >delete ENUM : boolean
 >ENUM : typeof ENUM
 
-var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1["B"]);
 >ResultIsBoolean6 : boolean
->delete delete delete (ENUM[0] + ENUM1[1]) : boolean
->delete delete (ENUM[0] + ENUM1[1]) : boolean
->delete (ENUM[0] + ENUM1[1]) : boolean
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>delete delete delete (ENUM[0] + ENUM1["B"]) : boolean
+>delete delete (ENUM[0] + ENUM1["B"]) : boolean
+>delete (ENUM[0] + ENUM1["B"]) : boolean
+>(ENUM[0] + ENUM1["B"]) : string
+>ENUM[0] + ENUM1["B"] : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // miss assignment operators
@@ -63,10 +65,11 @@ delete ENUM1;
 >delete ENUM1 : boolean
 >ENUM1 : typeof ENUM1
 
-delete ENUM1[1];
->delete ENUM1[1] : boolean
->ENUM1[1] : ENUM1
+delete ENUM1.B;
+>delete ENUM1.B : boolean
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
+>B : ENUM1
 
 delete ENUM, ENUM1;
 >delete ENUM, ENUM1 : typeof ENUM1
diff --git a/tests/baselines/reference/enumIdenticalIdentifierValues.errors.txt b/tests/baselines/reference/enumIdenticalIdentifierValues.errors.txt
deleted file mode 100644
index 551b5d9d929..00000000000
--- a/tests/baselines/reference/enumIdenticalIdentifierValues.errors.txt
+++ /dev/null
@@ -1,13 +0,0 @@
-tests/cases/compiler/enumIdenticalIdentifierValues.ts(2,5): error TS2300: Duplicate identifier '1'.
-tests/cases/compiler/enumIdenticalIdentifierValues.ts(3,5): error TS2300: Duplicate identifier '1.0'.
-
-
-==== tests/cases/compiler/enumIdenticalIdentifierValues.ts (2 errors) ====
-    enum Enum {
-        1,
-        ~
-!!! error TS2300: Duplicate identifier '1'.
-        1.0
-        ~~~
-!!! error TS2300: Duplicate identifier '1.0'.
-    }
\ No newline at end of file
diff --git a/tests/baselines/reference/enumIdenticalIdentifierValues.js b/tests/baselines/reference/enumIdenticalIdentifierValues.js
deleted file mode 100644
index 3f435ac6537..00000000000
--- a/tests/baselines/reference/enumIdenticalIdentifierValues.js
+++ /dev/null
@@ -1,12 +0,0 @@
-//// [enumIdenticalIdentifierValues.ts]
-enum Enum {
-    1,
-    1.0
-}
-
-//// [enumIdenticalIdentifierValues.js]
-var Enum;
-(function (Enum) {
-    Enum[Enum["1"] = 0] = "1";
-    Enum[Enum["1"] = 1] = "1";
-})(Enum || (Enum = {}));
diff --git a/tests/baselines/reference/enumIdentifierLiterals.errors.txt b/tests/baselines/reference/enumIdentifierLiterals.errors.txt
new file mode 100644
index 00000000000..721a6bd29ff
--- /dev/null
+++ b/tests/baselines/reference/enumIdentifierLiterals.errors.txt
@@ -0,0 +1,25 @@
+tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1151: An enum member cannot have a numeric name.
+tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1151: An enum member cannot have a numeric name.
+
+
+==== tests/cases/compiler/enumIdentifierLiterals.ts (5 errors) ====
+    enum Nums {
+        1.0,
+        ~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        11e-1,
+        ~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        0.12e1,
+        ~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        "13e-1",
+        ~~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+        0xF00D
+        ~~~~~~
+!!! error TS1151: An enum member cannot have a numeric name.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/enumIdentifierLiterals.js b/tests/baselines/reference/enumIdentifierLiterals.js
index 72a8a56570c..06cb76dd21d 100644
--- a/tests/baselines/reference/enumIdentifierLiterals.js
+++ b/tests/baselines/reference/enumIdentifierLiterals.js
@@ -1,18 +1,18 @@
-//// [enumIdentifierLiterals.ts]
+//// [enumIdentifierLiterals.ts]
 enum Nums {
     1.0,
     11e-1,
     0.12e1,
     "13e-1",
     0xF00D
-}
-
-//// [enumIdentifierLiterals.js]
-var Nums;
-(function (Nums) {
-    Nums[Nums["1"] = 0] = "1";
-    Nums[Nums["1.1"] = 1] = "1.1";
-    Nums[Nums["1.2"] = 2] = "1.2";
-    Nums[Nums["13e-1"] = 3] = "13e-1";
-    Nums[Nums["61453"] = 4] = "61453";
-})(Nums || (Nums = {}));
+}
+
+//// [enumIdentifierLiterals.js]
+var Nums;
+(function (Nums) {
+    Nums[Nums["1"] = 0] = "1";
+    Nums[Nums["1.1"] = 1] = "1.1";
+    Nums[Nums["1.2"] = 2] = "1.2";
+    Nums[Nums["13e-1"] = 3] = "13e-1";
+    Nums[Nums["61453"] = 4] = "61453";
+})(Nums || (Nums = {}));
diff --git a/tests/baselines/reference/enumIdentifierLiterals.types b/tests/baselines/reference/enumIdentifierLiterals.types
deleted file mode 100644
index b259e57d1dd..00000000000
--- a/tests/baselines/reference/enumIdentifierLiterals.types
+++ /dev/null
@@ -1,10 +0,0 @@
-=== tests/cases/compiler/enumIdentifierLiterals.ts ===
-enum Nums {
->Nums : Nums
-
-    1.0,
-    11e-1,
-    0.12e1,
-    "13e-1",
-    0xF00D
-}
diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt
new file mode 100644
index 00000000000..7617dbba379
--- /dev/null
+++ b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt
@@ -0,0 +1,21 @@
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(7,23): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(12,1): error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+
+
+==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts (2 errors) ====
+    // ++ operator on enum type
+    
+    enum ENUM1 { A, B, "" };
+    
+    // expression
+    var ResultIsNumber1 = ++ENUM1["B"];
+    var ResultIsNumber2 = ENUM1.B++;
+                          ~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
+    
+    // miss assignment operator
+    ++ENUM1["B"];
+    
+    ENUM1.B++;
+    ~~~~~~~
+!!! error TS2357: The operand of an increment or decrement operator must be a variable, property or indexer.
\ No newline at end of file
diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.js b/tests/baselines/reference/incrementOperatorWithEnumType.js
index cdea036c335..2baa326f399 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumType.js
+++ b/tests/baselines/reference/incrementOperatorWithEnumType.js
@@ -1,29 +1,29 @@
 //// [incrementOperatorWithEnumType.ts]
 // ++ operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // expression
-var ResultIsNumber1 = ++ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]++;
+var ResultIsNumber1 = ++ENUM1["B"];
+var ResultIsNumber2 = ENUM1.B++;
 
 // miss assignment operator
-++ENUM1[1];
+++ENUM1["B"];
 
-ENUM1[1]++;
+ENUM1.B++;
 
 //// [incrementOperatorWithEnumType.js]
 // ++ operator on enum type
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
 // expression
-var ResultIsNumber1 = ++ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]++;
+var ResultIsNumber1 = ++ENUM1["B"];
+var ResultIsNumber2 = 1 /* B */++;
 // miss assignment operator
-++ENUM1[1];
-ENUM1[1]++;
+++ENUM1["B"];
+1 /* B */++;
diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.types b/tests/baselines/reference/incrementOperatorWithEnumType.types
deleted file mode 100644
index 3b13c01d5df..00000000000
--- a/tests/baselines/reference/incrementOperatorWithEnumType.types
+++ /dev/null
@@ -1,30 +0,0 @@
-=== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts ===
-// ++ operator on enum type
-
-enum ENUM1 { 1, 2, "" };
->ENUM1 : ENUM1
-
-// expression
-var ResultIsNumber1 = ++ENUM1[1];
->ResultIsNumber1 : number
->++ENUM1[1] : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-var ResultIsNumber2 = ENUM1[1]++;
->ResultIsNumber2 : number
->ENUM1[1]++ : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-// miss assignment operator
-++ENUM1[1];
->++ENUM1[1] : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
-ENUM1[1]++;
->ENUM1[1]++ : number
->ENUM1[1] : ENUM1
->ENUM1 : typeof ENUM1
-
diff --git a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.errors.txt b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.errors.txt
index 81b091264bb..08a1b8ec460 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.errors.txt
+++ b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.errors.txt
@@ -14,7 +14,7 @@ tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOp
     // ++ operator on enum type
     
     enum ENUM { };
-    enum ENUM1 { 1, 2, "" };
+    enum ENUM1 { A, B, "" };
     
     // enum type var
     var ResultIsNumber1 = ++ENUM;
diff --git a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
index ed9b33e16bb..3bc43cefa4b 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
+++ b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
@@ -2,7 +2,7 @@
 // ++ operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = ++ENUM;
@@ -30,8 +30,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
diff --git a/tests/baselines/reference/logicalNotOperatorWithEnumType.js b/tests/baselines/reference/logicalNotOperatorWithEnumType.js
index 19efcc979ad..69ea283051d 100644
--- a/tests/baselines/reference/logicalNotOperatorWithEnumType.js
+++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.js
@@ -1,33 +1,33 @@
 //// [logicalNotOperatorWithEnumType.ts]
 // ! operator on enum type
 
-enum ENUM { 1, 2, 3 };
+enum ENUM { A, B, C };
 enum ENUM1 { };
 
 // enum type var
 var ResultIsBoolean1 = !ENUM;
 
 // enum type expressions
-var ResultIsBoolean2 = !ENUM[1];
-var ResultIsBoolean3 = !(ENUM[1] + ENUM[2]);
+var ResultIsBoolean2 = !ENUM["B"];
+var ResultIsBoolean3 = !(ENUM.B + ENUM["C"]);
 
 // multiple ! operators
 var ResultIsBoolean4 = !!ENUM;
-var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
+var ResultIsBoolean5 = !!!(ENUM["B"] + ENUM.C);
 
 // miss assignment operators
 !ENUM;
 !ENUM1;
-!ENUM[1];
+!ENUM.B;
 !ENUM, ENUM1;
 
 //// [logicalNotOperatorWithEnumType.js]
 // ! operator on enum type
 var ENUM;
 (function (ENUM) {
-    ENUM[ENUM["1"] = 0] = "1";
-    ENUM[ENUM["2"] = 1] = "2";
-    ENUM[ENUM["3"] = 2] = "3";
+    ENUM[ENUM["A"] = 0] = "A";
+    ENUM[ENUM["B"] = 1] = "B";
+    ENUM[ENUM["C"] = 2] = "C";
 })(ENUM || (ENUM = {}));
 ;
 var ENUM1;
@@ -37,13 +37,13 @@ var ENUM1;
 // enum type var
 var ResultIsBoolean1 = !ENUM;
 // enum type expressions
-var ResultIsBoolean2 = !ENUM[1];
-var ResultIsBoolean3 = !(ENUM[1] + ENUM[2]);
+var ResultIsBoolean2 = !ENUM["B"];
+var ResultIsBoolean3 = !(1 /* B */ + ENUM["C"]);
 // multiple ! operators
 var ResultIsBoolean4 = !!ENUM;
-var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
+var ResultIsBoolean5 = !!!(ENUM["B"] + 2 /* C */);
 // miss assignment operators
 !ENUM;
 !ENUM1;
-!ENUM[1];
+!1 /* B */;
 !ENUM, ENUM1;
diff --git a/tests/baselines/reference/logicalNotOperatorWithEnumType.types b/tests/baselines/reference/logicalNotOperatorWithEnumType.types
index 27cbb24d3bb..f3c9d98c95b 100644
--- a/tests/baselines/reference/logicalNotOperatorWithEnumType.types
+++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.types
@@ -1,8 +1,11 @@
 === tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts ===
 // ! operator on enum type
 
-enum ENUM { 1, 2, 3 };
+enum ENUM { A, B, C };
 >ENUM : ENUM
+>A : ENUM
+>B : ENUM
+>C : ENUM
 
 enum ENUM1 { };
 >ENUM1 : ENUM1
@@ -14,20 +17,21 @@ var ResultIsBoolean1 = !ENUM;
 >ENUM : typeof ENUM
 
 // enum type expressions
-var ResultIsBoolean2 = !ENUM[1];
+var ResultIsBoolean2 = !ENUM["B"];
 >ResultIsBoolean2 : boolean
->!ENUM[1] : boolean
->ENUM[1] : ENUM
+>!ENUM["B"] : boolean
+>ENUM["B"] : ENUM
 >ENUM : typeof ENUM
 
-var ResultIsBoolean3 = !(ENUM[1] + ENUM[2]);
+var ResultIsBoolean3 = !(ENUM.B + ENUM["C"]);
 >ResultIsBoolean3 : boolean
->!(ENUM[1] + ENUM[2]) : boolean
->(ENUM[1] + ENUM[2]) : number
->ENUM[1] + ENUM[2] : number
->ENUM[1] : ENUM
+>!(ENUM.B + ENUM["C"]) : boolean
+>(ENUM.B + ENUM["C"]) : number
+>ENUM.B + ENUM["C"] : number
+>ENUM.B : ENUM
 >ENUM : typeof ENUM
->ENUM[2] : ENUM
+>B : ENUM
+>ENUM["C"] : ENUM
 >ENUM : typeof ENUM
 
 // multiple ! operators
@@ -37,17 +41,18 @@ var ResultIsBoolean4 = !!ENUM;
 >!ENUM : boolean
 >ENUM : typeof ENUM
 
-var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
+var ResultIsBoolean5 = !!!(ENUM["B"] + ENUM.C);
 >ResultIsBoolean5 : boolean
->!!!(ENUM[1] + ENUM[2]) : boolean
->!!(ENUM[1] + ENUM[2]) : boolean
->!(ENUM[1] + ENUM[2]) : boolean
->(ENUM[1] + ENUM[2]) : number
->ENUM[1] + ENUM[2] : number
->ENUM[1] : ENUM
+>!!!(ENUM["B"] + ENUM.C) : boolean
+>!!(ENUM["B"] + ENUM.C) : boolean
+>!(ENUM["B"] + ENUM.C) : boolean
+>(ENUM["B"] + ENUM.C) : number
+>ENUM["B"] + ENUM.C : number
+>ENUM["B"] : ENUM
 >ENUM : typeof ENUM
->ENUM[2] : ENUM
+>ENUM.C : ENUM
 >ENUM : typeof ENUM
+>C : ENUM
 
 // miss assignment operators
 !ENUM;
@@ -58,10 +63,11 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
 >!ENUM1 : boolean
 >ENUM1 : typeof ENUM1
 
-!ENUM[1];
->!ENUM[1] : boolean
->ENUM[1] : ENUM
+!ENUM.B;
+>!ENUM.B : boolean
+>ENUM.B : ENUM
 >ENUM : typeof ENUM
+>B : ENUM
 
 !ENUM, ENUM1;
 >!ENUM, ENUM1 : typeof ENUM1
diff --git a/tests/baselines/reference/negateOperatorWithEnumType.js b/tests/baselines/reference/negateOperatorWithEnumType.js
index a3235a3ccc0..876bed45cc2 100644
--- a/tests/baselines/reference/negateOperatorWithEnumType.js
+++ b/tests/baselines/reference/negateOperatorWithEnumType.js
@@ -2,19 +2,19 @@
 // - operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = -ENUM;
 
 // expressions
-var ResultIsNumber2 = -ENUM1[1];
-var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = -ENUM1["B"];
+var ResultIsNumber3 = -(ENUM1.B + ENUM1[""]);
 
 // miss assignment operators
 -ENUM;
 -ENUM1;
--ENUM1[1];
+-ENUM1["B"];
 -ENUM, ENUM1;
 
 //// [negateOperatorWithEnumType.js]
@@ -25,18 +25,18 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
 // enum type var
 var ResultIsNumber1 = -ENUM;
 // expressions
-var ResultIsNumber2 = -ENUM1[1];
-var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = -ENUM1["B"];
+var ResultIsNumber3 = -(1 /* B */ + ENUM1[""]);
 // miss assignment operators
 -ENUM;
 -ENUM1;
--ENUM1[1];
+-ENUM1["B"];
 -ENUM, ENUM1;
diff --git a/tests/baselines/reference/negateOperatorWithEnumType.types b/tests/baselines/reference/negateOperatorWithEnumType.types
index b2e0cb91c51..96a33ff4c6e 100644
--- a/tests/baselines/reference/negateOperatorWithEnumType.types
+++ b/tests/baselines/reference/negateOperatorWithEnumType.types
@@ -4,8 +4,10 @@
 enum ENUM { };
 >ENUM : ENUM
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsNumber1 = -ENUM;
@@ -14,20 +16,21 @@ var ResultIsNumber1 = -ENUM;
 >ENUM : typeof ENUM
 
 // expressions
-var ResultIsNumber2 = -ENUM1[1];
+var ResultIsNumber2 = -ENUM1["B"];
 >ResultIsNumber2 : number
->-ENUM1[1] : number
->ENUM1[1] : ENUM1
+>-ENUM1["B"] : number
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber3 = -(ENUM1.B + ENUM1[""]);
 >ResultIsNumber3 : number
->-(ENUM1[1] + ENUM1[2]) : number
->(ENUM1[1] + ENUM1[2]) : number
->ENUM1[1] + ENUM1[2] : number
->ENUM1[1] : ENUM1
+>-(ENUM1.B + ENUM1[""]) : number
+>(ENUM1.B + ENUM1[""]) : number
+>ENUM1.B + ENUM1[""] : number
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
->ENUM1[2] : ENUM1
+>B : ENUM1
+>ENUM1[""] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // miss assignment operators
@@ -39,9 +42,9 @@ var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
 >-ENUM1 : number
 >ENUM1 : typeof ENUM1
 
--ENUM1[1];
->-ENUM1[1] : number
->ENUM1[1] : ENUM1
+-ENUM1["B"];
+>-ENUM1["B"] : number
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 -ENUM, ENUM1;
diff --git a/tests/baselines/reference/parserEnum5.errors.txt b/tests/baselines/reference/parserEnum5.errors.txt
index 6a558dc9500..40c2c933955 100644
--- a/tests/baselines/reference/parserEnum5.errors.txt
+++ b/tests/baselines/reference/parserEnum5.errors.txt
@@ -1,15 +1,24 @@
 tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(2,12): error TS1005: ',' expected.
 tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,15): error TS1005: ',' expected.
 tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,24): error TS1005: ',' expected.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(2,14): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,17): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,26): error TS1151: An enum member cannot have a numeric name.
 
 
-==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts (3 errors) ====
+==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts (6 errors) ====
     enum E2 { a, }
     enum E3 { a: 1, }
                ~
 !!! error TS1005: ',' expected.
+                 ~
+!!! error TS1151: An enum member cannot have a numeric name.
     enum E1 { a, b: 1, c, d: 2 = 3 }
                   ~
 !!! error TS1005: ',' expected.
                            ~
-!!! error TS1005: ',' expected.
\ No newline at end of file
+!!! error TS1005: ',' expected.
+                    ~
+!!! error TS1151: An enum member cannot have a numeric name.
+                             ~
+!!! error TS1151: An enum member cannot have a numeric name.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserEnum7.errors.txt b/tests/baselines/reference/parserEnum7.errors.txt
new file mode 100644
index 00000000000..48c938e02de
--- /dev/null
+++ b/tests/baselines/reference/parserEnum7.errors.txt
@@ -0,0 +1,15 @@
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,3): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,6): error TS1151: An enum member cannot have a numeric name.
+tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,9): error TS1151: An enum member cannot have a numeric name.
+
+
+==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts (3 errors) ====
+    enum E {
+      1, 2, 3
+      ~
+!!! error TS1151: An enum member cannot have a numeric name.
+         ~
+!!! error TS1151: An enum member cannot have a numeric name.
+            ~
+!!! error TS1151: An enum member cannot have a numeric name.
+    }
\ No newline at end of file
diff --git a/tests/baselines/reference/parserEnum7.js b/tests/baselines/reference/parserEnum7.js
index 3781167bbba..831090f4ce7 100644
--- a/tests/baselines/reference/parserEnum7.js
+++ b/tests/baselines/reference/parserEnum7.js
@@ -1,12 +1,12 @@
-//// [parserEnum7.ts]
+//// [parserEnum7.ts]
 enum E {
   1, 2, 3
-}
-
-//// [parserEnum7.js]
-var E;
-(function (E) {
-    E[E["1"] = 0] = "1";
-    E[E["2"] = 1] = "2";
-    E[E["3"] = 2] = "3";
-})(E || (E = {}));
+}
+
+//// [parserEnum7.js]
+var E;
+(function (E) {
+    E[E["1"] = 0] = "1";
+    E[E["2"] = 1] = "2";
+    E[E["3"] = 2] = "3";
+})(E || (E = {}));
diff --git a/tests/baselines/reference/parserEnum7.types b/tests/baselines/reference/parserEnum7.types
deleted file mode 100644
index 63a77cb9d23..00000000000
--- a/tests/baselines/reference/parserEnum7.types
+++ /dev/null
@@ -1,6 +0,0 @@
-=== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts ===
-enum E {
->E : E
-
-  1, 2, 3
-}
diff --git a/tests/baselines/reference/plusOperatorWithEnumType.js b/tests/baselines/reference/plusOperatorWithEnumType.js
index 279f3bc286b..4d6eaad892e 100644
--- a/tests/baselines/reference/plusOperatorWithEnumType.js
+++ b/tests/baselines/reference/plusOperatorWithEnumType.js
@@ -2,20 +2,20 @@
 // + operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = +ENUM;
 var ResultIsNumber2 = +ENUM1;
 
 // enum type expressions
-var ResultIsNumber3 = +ENUM1[0];
-var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
+var ResultIsNumber3 = +ENUM1["A"];
+var ResultIsNumber4 = +(ENUM[0] + ENUM1["B"]);
 
 // miss assignment operators
 +ENUM;
 +ENUM1;
-+ENUM1[1];
++ENUM1.B;
 +ENUM, ENUM1;
 
 //// [plusOperatorWithEnumType.js]
@@ -26,8 +26,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
@@ -35,10 +35,10 @@ var ENUM1;
 var ResultIsNumber1 = +ENUM;
 var ResultIsNumber2 = +ENUM1;
 // enum type expressions
-var ResultIsNumber3 = +ENUM1[0];
-var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
+var ResultIsNumber3 = +ENUM1["A"];
+var ResultIsNumber4 = +(ENUM[0] + ENUM1["B"]);
 // miss assignment operators
 +ENUM;
 +ENUM1;
-+ENUM1[1];
++1 /* B */;
 +ENUM, ENUM1;
diff --git a/tests/baselines/reference/plusOperatorWithEnumType.types b/tests/baselines/reference/plusOperatorWithEnumType.types
index 4ac40a9359d..bc51414e4a5 100644
--- a/tests/baselines/reference/plusOperatorWithEnumType.types
+++ b/tests/baselines/reference/plusOperatorWithEnumType.types
@@ -4,8 +4,10 @@
 enum ENUM { };
 >ENUM : ENUM
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsNumber1 = +ENUM;
@@ -19,20 +21,20 @@ var ResultIsNumber2 = +ENUM1;
 >ENUM1 : typeof ENUM1
 
 // enum type expressions
-var ResultIsNumber3 = +ENUM1[0];
+var ResultIsNumber3 = +ENUM1["A"];
 >ResultIsNumber3 : number
->+ENUM1[0] : number
->ENUM1[0] : string
+>+ENUM1["A"] : number
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
+var ResultIsNumber4 = +(ENUM[0] + ENUM1["B"]);
 >ResultIsNumber4 : number
->+(ENUM[0] + ENUM1[1]) : number
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>+(ENUM[0] + ENUM1["B"]) : number
+>(ENUM[0] + ENUM1["B"]) : string
+>ENUM[0] + ENUM1["B"] : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // miss assignment operators
@@ -44,10 +46,11 @@ var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
 >+ENUM1 : number
 >ENUM1 : typeof ENUM1
 
-+ENUM1[1];
->+ENUM1[1] : number
->ENUM1[1] : ENUM1
++ENUM1.B;
+>+ENUM1.B : number
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
+>B : ENUM1
 
 +ENUM, ENUM1;
 >+ENUM, ENUM1 : typeof ENUM1
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.js b/tests/baselines/reference/typeofOperatorWithEnumType.js
index 1ce2170659e..272feacf63d 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.js
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.js
@@ -2,24 +2,24 @@
 // typeof  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsString1 = typeof ENUM;
 var ResultIsString2 = typeof ENUM1;
 
 // enum type expressions
-var ResultIsString3 = typeof ENUM1[0];
-var ResultIsString4 = typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString3 = typeof ENUM1["A"];
+var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]);
 
 // multiple typeof  operators
 var ResultIsString5 = typeof typeof ENUM;
-var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1.B);
 
 // miss assignment operators
 typeof ENUM;
 typeof ENUM1;
-typeof ENUM1[1];
+typeof ENUM1["B"];
 typeof ENUM, ENUM1;
 
 // use typeof in type query
@@ -35,8 +35,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
@@ -44,15 +44,15 @@ var ENUM1;
 var ResultIsString1 = typeof ENUM;
 var ResultIsString2 = typeof ENUM1;
 // enum type expressions
-var ResultIsString3 = typeof ENUM1[0];
-var ResultIsString4 = typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString3 = typeof ENUM1["A"];
+var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]);
 // multiple typeof  operators
 var ResultIsString5 = typeof typeof ENUM;
-var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString6 = typeof typeof typeof (ENUM[0] + 1 /* B */);
 // miss assignment operators
 typeof ENUM;
 typeof ENUM1;
-typeof ENUM1[1];
+typeof ENUM1["B"];
 typeof ENUM, ENUM1;
 // use typeof in type query
 var z;
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.types b/tests/baselines/reference/typeofOperatorWithEnumType.types
index cbcc49bd9dc..2a3ccc6a3da 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.types
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.types
@@ -4,8 +4,10 @@
 enum ENUM { };
 >ENUM : ENUM
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsString1 = typeof ENUM;
@@ -19,20 +21,20 @@ var ResultIsString2 = typeof ENUM1;
 >ENUM1 : typeof ENUM1
 
 // enum type expressions
-var ResultIsString3 = typeof ENUM1[0];
+var ResultIsString3 = typeof ENUM1["A"];
 >ResultIsString3 : string
->typeof ENUM1[0] : string
->ENUM1[0] : string
+>typeof ENUM1["A"] : string
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsString4 = typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]);
 >ResultIsString4 : string
->typeof (ENUM[0] + ENUM1[1]) : string
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>typeof (ENUM[0] + ENUM1["B"]) : string
+>(ENUM[0] + ENUM1["B"]) : string
+>ENUM[0] + ENUM1["B"] : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // multiple typeof  operators
@@ -42,17 +44,18 @@ var ResultIsString5 = typeof typeof ENUM;
 >typeof ENUM : string
 >ENUM : typeof ENUM
 
-var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1.B);
 >ResultIsString6 : string
->typeof typeof typeof (ENUM[0] + ENUM1[1]) : string
->typeof typeof (ENUM[0] + ENUM1[1]) : string
->typeof (ENUM[0] + ENUM1[1]) : string
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>typeof typeof typeof (ENUM[0] + ENUM1.B) : string
+>typeof typeof (ENUM[0] + ENUM1.B) : string
+>typeof (ENUM[0] + ENUM1.B) : string
+>(ENUM[0] + ENUM1.B) : string
+>ENUM[0] + ENUM1.B : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
+>B : ENUM1
 
 // miss assignment operators
 typeof ENUM;
@@ -63,9 +66,9 @@ typeof ENUM1;
 >typeof ENUM1 : string
 >ENUM1 : typeof ENUM1
 
-typeof ENUM1[1];
->typeof ENUM1[1] : string
->ENUM1[1] : ENUM1
+typeof ENUM1["B"];
+>typeof ENUM1["B"] : string
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 typeof ENUM, ENUM1;
diff --git a/tests/baselines/reference/voidOperatorWithEnumType.js b/tests/baselines/reference/voidOperatorWithEnumType.js
index a168acaa1b6..8d20842ea7b 100644
--- a/tests/baselines/reference/voidOperatorWithEnumType.js
+++ b/tests/baselines/reference/voidOperatorWithEnumType.js
@@ -2,24 +2,24 @@
 // void  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsAny1 = void ENUM;
 var ResultIsAny2 = void ENUM1;
 
 // enum type expressions
-var ResultIsAny3 = void ENUM1[0];
-var ResultIsAny4 = void (ENUM[0] + ENUM1[1]);
+var ResultIsAny3 = void ENUM1["A"];
+var ResultIsAny4 = void (ENUM[0] + ENUM1["B"]);
 
 // multiple void  operators
 var ResultIsAny5 = void void ENUM;
-var ResultIsAny6 = void void void (ENUM[0] + ENUM1[1]);
+var ResultIsAny6 = void void void (ENUM[0] + ENUM1.B);
 
 // miss assignment operators
 void ENUM;
 void ENUM1;
-void ENUM1[1];
+void ENUM1["B"];
 void ENUM, ENUM1;
 
 //// [voidOperatorWithEnumType.js]
@@ -30,8 +30,8 @@ var ENUM;
 ;
 var ENUM1;
 (function (ENUM1) {
-    ENUM1[ENUM1["1"] = 0] = "1";
-    ENUM1[ENUM1["2"] = 1] = "2";
+    ENUM1[ENUM1["A"] = 0] = "A";
+    ENUM1[ENUM1["B"] = 1] = "B";
     ENUM1[ENUM1[""] = 2] = "";
 })(ENUM1 || (ENUM1 = {}));
 ;
@@ -39,13 +39,13 @@ var ENUM1;
 var ResultIsAny1 = void ENUM;
 var ResultIsAny2 = void ENUM1;
 // enum type expressions
-var ResultIsAny3 = void ENUM1[0];
-var ResultIsAny4 = void (ENUM[0] + ENUM1[1]);
+var ResultIsAny3 = void ENUM1["A"];
+var ResultIsAny4 = void (ENUM[0] + ENUM1["B"]);
 // multiple void  operators
 var ResultIsAny5 = void void ENUM;
-var ResultIsAny6 = void void void (ENUM[0] + ENUM1[1]);
+var ResultIsAny6 = void void void (ENUM[0] + 1 /* B */);
 // miss assignment operators
 void ENUM;
 void ENUM1;
-void ENUM1[1];
+void ENUM1["B"];
 void ENUM, ENUM1;
diff --git a/tests/baselines/reference/voidOperatorWithEnumType.types b/tests/baselines/reference/voidOperatorWithEnumType.types
index 2433a00ca44..82f4108bee3 100644
--- a/tests/baselines/reference/voidOperatorWithEnumType.types
+++ b/tests/baselines/reference/voidOperatorWithEnumType.types
@@ -4,8 +4,10 @@
 enum ENUM { };
 >ENUM : ENUM
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 >ENUM1 : ENUM1
+>A : ENUM1
+>B : ENUM1
 
 // enum type var
 var ResultIsAny1 = void ENUM;
@@ -19,20 +21,20 @@ var ResultIsAny2 = void ENUM1;
 >ENUM1 : typeof ENUM1
 
 // enum type expressions
-var ResultIsAny3 = void ENUM1[0];
+var ResultIsAny3 = void ENUM1["A"];
 >ResultIsAny3 : any
->void ENUM1[0] : undefined
->ENUM1[0] : string
+>void ENUM1["A"] : undefined
+>ENUM1["A"] : ENUM1
 >ENUM1 : typeof ENUM1
 
-var ResultIsAny4 = void (ENUM[0] + ENUM1[1]);
+var ResultIsAny4 = void (ENUM[0] + ENUM1["B"]);
 >ResultIsAny4 : any
->void (ENUM[0] + ENUM1[1]) : undefined
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>void (ENUM[0] + ENUM1["B"]) : undefined
+>(ENUM[0] + ENUM1["B"]) : string
+>ENUM[0] + ENUM1["B"] : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 // multiple void  operators
@@ -42,17 +44,18 @@ var ResultIsAny5 = void void ENUM;
 >void ENUM : undefined
 >ENUM : typeof ENUM
 
-var ResultIsAny6 = void void void (ENUM[0] + ENUM1[1]);
+var ResultIsAny6 = void void void (ENUM[0] + ENUM1.B);
 >ResultIsAny6 : any
->void void void (ENUM[0] + ENUM1[1]) : undefined
->void void (ENUM[0] + ENUM1[1]) : undefined
->void (ENUM[0] + ENUM1[1]) : undefined
->(ENUM[0] + ENUM1[1]) : string
->ENUM[0] + ENUM1[1] : string
+>void void void (ENUM[0] + ENUM1.B) : undefined
+>void void (ENUM[0] + ENUM1.B) : undefined
+>void (ENUM[0] + ENUM1.B) : undefined
+>(ENUM[0] + ENUM1.B) : string
+>ENUM[0] + ENUM1.B : string
 >ENUM[0] : string
 >ENUM : typeof ENUM
->ENUM1[1] : ENUM1
+>ENUM1.B : ENUM1
 >ENUM1 : typeof ENUM1
+>B : ENUM1
 
 // miss assignment operators
 void ENUM;
@@ -63,9 +66,9 @@ void ENUM1;
 >void ENUM1 : undefined
 >ENUM1 : typeof ENUM1
 
-void ENUM1[1];
->void ENUM1[1] : undefined
->ENUM1[1] : ENUM1
+void ENUM1["B"];
+>void ENUM1["B"] : undefined
+>ENUM1["B"] : ENUM1
 >ENUM1 : typeof ENUM1
 
 void ENUM, ENUM1;
diff --git a/tests/cases/compiler/enumIdenticalIdentifierValues.ts b/tests/cases/compiler/enumIdenticalIdentifierValues.ts
deleted file mode 100644
index 2b5bc78650b..00000000000
--- a/tests/cases/compiler/enumIdenticalIdentifierValues.ts
+++ /dev/null
@@ -1,4 +0,0 @@
-enum Enum {
-    1,
-    1.0
-}
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts
index 8dac812d702..60370469692 100644
--- a/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts
@@ -1,18 +1,18 @@
 // ~ operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = ~ENUM1;
 
 // enum type expressions
-var ResultIsNumber2 = ~ENUM1[1];
-var ResultIsNumber3 = ~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = ~ENUM1["A"];
+var ResultIsNumber3 = ~(ENUM1.A + ENUM1["B"]);
 
 // multiple ~ operators
-var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber4 = ~~~(ENUM1["A"] + ENUM1.B);
 
 // miss assignment operators
 ~ENUM1;
-~ENUM1[1];
-~ENUM1[1], ~ENUM1[2];
\ No newline at end of file
+~ENUM1["A"];
+~ENUM1.A, ~ENUM1["B"];
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts
index 9af7d33dbe7..022ed405a0b 100644
--- a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts
@@ -1,12 +1,12 @@
 // -- operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // expression
-var ResultIsNumber1 = --ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]--;
+var ResultIsNumber1 = --ENUM1["A"];
+var ResultIsNumber2 = ENUM1.A--;
 
 // miss assignment operator
---ENUM1[1];
+--ENUM1["A"];
 
-ENUM1[1]--;
\ No newline at end of file
+ENUM1[A]--;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts
index 97b9bd48841..fca19d38daa 100644
--- a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts
@@ -1,7 +1,7 @@
 // -- operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = --ENUM;
@@ -11,8 +11,8 @@ var ResultIsNumber3 = ENUM--;
 var ResultIsNumber4 = ENUM1--;
 
 // enum type expressions
-var ResultIsNumber5 = --(ENUM[1] + ENUM[2]);
-var ResultIsNumber6 = (ENUM[1] + ENUM[2])--;
+var ResultIsNumber5 = --(ENUM["A"] + ENUM.B);
+var ResultIsNumber6 = (ENUM.A + ENUM["B"])--;
 
 // miss assignment operator
 --ENUM;
diff --git a/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts
index 522e62a2748..a4c8020fdfe 100644
--- a/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts
@@ -1,22 +1,22 @@
 // delete  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsBoolean1 = delete ENUM;
 var ResultIsBoolean2 = delete ENUM1;
 
 // enum type expressions
-var ResultIsBoolean3 = delete ENUM1[0];
-var ResultIsBoolean4 = delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean3 = delete ENUM1["A"];
+var ResultIsBoolean4 = delete (ENUM[0] + ENUM1["B"]);
 
 // multiple delete  operators
 var ResultIsBoolean5 = delete delete ENUM;
-var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1[1]);
+var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1["B"]);
 
 // miss assignment operators
 delete ENUM;
 delete ENUM1;
-delete ENUM1[1];
+delete ENUM1.B;
 delete ENUM, ENUM1;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts
index a58941feca9..6b116a7ca3d 100644
--- a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts
@@ -1,12 +1,12 @@
 // ++ operator on enum type
 
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // expression
-var ResultIsNumber1 = ++ENUM1[1];
-var ResultIsNumber2 = ENUM1[1]++;
+var ResultIsNumber1 = ++ENUM1["B"];
+var ResultIsNumber2 = ENUM1.B++;
 
 // miss assignment operator
-++ENUM1[1];
+++ENUM1["B"];
 
-ENUM1[1]++;
\ No newline at end of file
+ENUM1.B++;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumTypeInvalidOperations.ts b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumTypeInvalidOperations.ts
index 5eab1420f98..78726cb152a 100644
--- a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumTypeInvalidOperations.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumTypeInvalidOperations.ts
@@ -1,7 +1,7 @@
 // ++ operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = ++ENUM;
diff --git a/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts
index 69b9566937a..a7a6f12b99d 100644
--- a/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts
@@ -1,21 +1,21 @@
 // ! operator on enum type
 
-enum ENUM { 1, 2, 3 };
+enum ENUM { A, B, C };
 enum ENUM1 { };
 
 // enum type var
 var ResultIsBoolean1 = !ENUM;
 
 // enum type expressions
-var ResultIsBoolean2 = !ENUM[1];
-var ResultIsBoolean3 = !(ENUM[1] + ENUM[2]);
+var ResultIsBoolean2 = !ENUM["B"];
+var ResultIsBoolean3 = !(ENUM.B + ENUM["C"]);
 
 // multiple ! operators
 var ResultIsBoolean4 = !!ENUM;
-var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
+var ResultIsBoolean5 = !!!(ENUM["B"] + ENUM.C);
 
 // miss assignment operators
 !ENUM;
 !ENUM1;
-!ENUM[1];
+!ENUM.B;
 !ENUM, ENUM1;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts
index a5e277f2b6e..6545588913c 100644
--- a/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts
@@ -1,17 +1,17 @@
 // - operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = -ENUM;
 
 // expressions
-var ResultIsNumber2 = -ENUM1[1];
-var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
+var ResultIsNumber2 = -ENUM1["B"];
+var ResultIsNumber3 = -(ENUM1.B + ENUM1[""]);
 
 // miss assignment operators
 -ENUM;
 -ENUM1;
--ENUM1[1];
+-ENUM1["B"];
 -ENUM, ENUM1;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts
index 47a6991d8ce..288d716e231 100644
--- a/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts
@@ -1,18 +1,18 @@
 // + operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsNumber1 = +ENUM;
 var ResultIsNumber2 = +ENUM1;
 
 // enum type expressions
-var ResultIsNumber3 = +ENUM1[0];
-var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
+var ResultIsNumber3 = +ENUM1["A"];
+var ResultIsNumber4 = +(ENUM[0] + ENUM1["B"]);
 
 // miss assignment operators
 +ENUM;
 +ENUM1;
-+ENUM1[1];
++ENUM1.B;
 +ENUM, ENUM1;
\ No newline at end of file
diff --git a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
index 0d1ddd67f31..9abb602db06 100644
--- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts
@@ -1,24 +1,24 @@
 // typeof  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsString1 = typeof ENUM;
 var ResultIsString2 = typeof ENUM1;
 
 // enum type expressions
-var ResultIsString3 = typeof ENUM1[0];
-var ResultIsString4 = typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString3 = typeof ENUM1["A"];
+var ResultIsString4 = typeof (ENUM[0] + ENUM1["B"]);
 
 // multiple typeof  operators
 var ResultIsString5 = typeof typeof ENUM;
-var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1[1]);
+var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1.B);
 
 // miss assignment operators
 typeof ENUM;
 typeof ENUM1;
-typeof ENUM1[1];
+typeof ENUM1["B"];
 typeof ENUM, ENUM1;
 
 // use typeof in type query
diff --git a/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts
index debbc65f148..038aaed6483 100644
--- a/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts
+++ b/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts
@@ -1,22 +1,22 @@
 // void  operator on enum type
 
 enum ENUM { };
-enum ENUM1 { 1, 2, "" };
+enum ENUM1 { A, B, "" };
 
 // enum type var
 var ResultIsAny1 = void ENUM;
 var ResultIsAny2 = void ENUM1;
 
 // enum type expressions
-var ResultIsAny3 = void ENUM1[0];
-var ResultIsAny4 = void (ENUM[0] + ENUM1[1]);
+var ResultIsAny3 = void ENUM1["A"];
+var ResultIsAny4 = void (ENUM[0] + ENUM1["B"]);
 
 // multiple void  operators
 var ResultIsAny5 = void void ENUM;
-var ResultIsAny6 = void void void (ENUM[0] + ENUM1[1]);
+var ResultIsAny6 = void void void (ENUM[0] + ENUM1.B);
 
 // miss assignment operators
 void ENUM;
 void ENUM1;
-void ENUM1[1];
+void ENUM1["B"];
 void ENUM, ENUM1;
\ No newline at end of file