From cbfbae94fd866ee1912d2af0ab36b92a0998b530 Mon Sep 17 00:00:00 2001 From: Chris Bubernak Date: Sun, 5 Oct 2014 22:21:43 -0700 Subject: [PATCH 1/9] Added a message & a check for numerics in the parser --- .../diagnosticInformationMap.generated.ts | 1 + src/compiler/diagnosticMessages.json | 16 ++++++++++------ src/compiler/parser.ts | 5 +++++ 3 files changed, 16 insertions(+), 6 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index dec1c00027b..927a85ff854 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -48,6 +48,7 @@ module ts { Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, An_export_assignment_cannot_be_used_in_an_internal_module: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in an internal module." }, + An_enum_member_cannot_have_a_numeric_name: { code: 1065, category: DiagnosticCategory.Error, key: "An enum member cannot have a numeric name." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an import declaration." }, diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json index 79208be1a0d..c41bb962971 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 }, @@ -183,11 +183,15 @@ "category": "Error", "code": 1063 }, + "An enum member cannot have a numeric name.": { + "category": "Error", + "code": 1065 + }, "Ambient enum elements can only have integer literal initializers.": { "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 +448,9 @@ "code": 1149 }, "'new T[]' cannot be used to create an array. Use 'new Array()' instead.": { - "category": "Error", - "code": 1150 - }, + "category": "Error", + "code": 1150 + }, "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/src/compiler/parser.ts b/src/compiler/parser.ts index 422d133d5d0..61afdb7e546 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3673,6 +3673,11 @@ module ts { var node = createNode(SyntaxKind.EnumMember); var errorCountBeforeEnumMember = file.syntacticErrors.length; node.name = parsePropertyName(); + + if(isIntegerLiteral(node.name)) { + grammarErrorOnNode(node.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); + } + node.initializer = parseInitializer(/*inParameter*/ false); if (inAmbientContext) { From 7b9dee8df8d50ae1ce91f63fc4a9cf636d9542e6 Mon Sep 17 00:00:00 2001 From: Chris Bubernak Date: Mon, 6 Oct 2014 16:05:50 -0700 Subject: [PATCH 2/9] Fixed bug where numeric check wasn't catching everything --- src/compiler/parser.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index 61afdb7e546..eee0ee92001 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3674,7 +3674,7 @@ module ts { var errorCountBeforeEnumMember = file.syntacticErrors.length; node.name = parsePropertyName(); - if(isIntegerLiteral(node.name)) { + if(!isNaN(Number(node.name.text))) { grammarErrorOnNode(node.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); } From c77135d3d969b554444ac9da34d124955a34e97d Mon Sep 17 00:00:00 2001 From: Chris Bubernak Date: Mon, 6 Oct 2014 16:14:45 -0700 Subject: [PATCH 3/9] Removed Numeric members from a bunch of tests -in these tests it wasn't really in the spirit of the tests for them to be there -also removed a test that no longer made sense --- tests/cases/compiler/enumIdenticalIdentifierValues.ts | 4 ---- .../bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts | 2 +- .../decrementOperator/decrementOperatorWithEnumType.ts | 2 +- .../decrementOperatorWithEnumTypeInvalidOperations.ts | 2 +- .../deleteOperator/deleteOperatorWithEnumType.ts | 2 +- .../incrementOperator/incrementOperatorWithEnumType.ts | 2 +- .../incrementOperatorWithEnumTypeInvalidOperations.ts | 2 +- .../logicalNotOperator/logicalNotOperatorWithEnumType.ts | 2 +- .../negateOperator/negateOperatorWithEnumType.ts | 2 +- .../unaryOperators/plusOperator/plusOperatorWithEnumType.ts | 2 +- .../typeofOperator/typeofOperatorWithEnumType.ts | 2 +- .../unaryOperators/voidOperator/voidOperatorWithEnumType.ts | 2 +- 12 files changed, 11 insertions(+), 15 deletions(-) delete mode 100644 tests/cases/compiler/enumIdenticalIdentifierValues.ts 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..3ea75ce6158 100644 --- a/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts @@ -1,6 +1,6 @@ // ~ operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsNumber1 = ~ENUM1; diff --git a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts index 9af7d33dbe7..6ca08e2adf4 100644 --- a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts @@ -1,6 +1,6 @@ // -- operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // expression var ResultIsNumber1 = --ENUM1[1]; diff --git a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts index 97b9bd48841..436e9a66a81 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; diff --git a/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts index 522e62a2748..fe0f4616ce5 100644 --- a/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts @@ -1,7 +1,7 @@ // delete operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsBoolean1 = delete ENUM; diff --git a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts index a58941feca9..50fe1d2c038 100644 --- a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts @@ -1,6 +1,6 @@ // ++ operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // expression var ResultIsNumber1 = ++ENUM1[1]; 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..1d218a55b43 100644 --- a/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts @@ -1,6 +1,6 @@ // ! operator on enum type -enum ENUM { 1, 2, 3 }; +enum ENUM { A, B, C }; enum ENUM1 { }; // enum type var diff --git a/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts index a5e277f2b6e..7511b736532 100644 --- a/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.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/plusOperator/plusOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts index 47a6991d8ce..11c13e098f7 100644 --- a/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.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/typeofOperator/typeofOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts index 0d1ddd67f31..d770d35f4c3 100644 --- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts @@ -1,7 +1,7 @@ // typeof operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsString1 = typeof ENUM; diff --git a/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts index debbc65f148..117618b19a4 100644 --- a/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts @@ -1,7 +1,7 @@ // void operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsAny1 = void ENUM; From 8286b67c09de6a0ad0653ec49b9fd90d914fb422 Mon Sep 17 00:00:00 2001 From: Chris Bubernak Date: Mon, 6 Oct 2014 22:27:22 -0700 Subject: [PATCH 4/9] Fixed another bug in parser & fixed up baselines --- src/compiler/parser.ts | 3 +- .../bitwiseNotOperatorWithEnumType.js | 6 ++-- .../bitwiseNotOperatorWithEnumType.types | 28 +++++++++-------- .../decrementOperatorWithEnumType.errors.txt | 27 +++++++++++++++++ .../decrementOperatorWithEnumType.js | 6 ++-- .../decrementOperatorWithEnumType.types | 30 ------------------- ...orWithEnumTypeInvalidOperations.errors.txt | 2 +- ...ntOperatorWithEnumTypeInvalidOperations.js | 6 ++-- .../reference/deleteOperatorWithEnumType.js | 6 ++-- .../deleteOperatorWithEnumType.types | 10 ++++--- .../enumIdenticalIdentifierValues.errors.txt | 13 -------- .../enumIdenticalIdentifierValues.js | 12 -------- .../enumIdentifierLiterals.errors.txt | 25 ++++++++++++++++ .../reference/enumIdentifierLiterals.js | 18 ----------- .../reference/enumIdentifierLiterals.types | 10 ------- .../incrementOperatorWithEnumType.errors.txt | 27 +++++++++++++++++ .../incrementOperatorWithEnumType.js | 6 ++-- .../incrementOperatorWithEnumType.types | 30 ------------------- ...orWithEnumTypeInvalidOperations.errors.txt | 2 +- ...ntOperatorWithEnumTypeInvalidOperations.js | 6 ++-- .../logicalNotOperatorWithEnumType.js | 8 ++--- .../logicalNotOperatorWithEnumType.types | 25 +++++++++------- .../reference/negateOperatorWithEnumType.js | 6 ++-- .../negateOperatorWithEnumType.types | 16 +++++----- .../reference/parserEnum5.errors.txt | 13 ++++++-- .../reference/parserEnum7.errors.txt | 15 ++++++++++ tests/baselines/reference/parserEnum7.js | 12 -------- tests/baselines/reference/parserEnum7.types | 6 ---- .../reference/plusOperatorWithEnumType.js | 6 ++-- .../reference/plusOperatorWithEnumType.types | 8 +++-- .../reference/typeofOperatorWithEnumType.js | 6 ++-- .../typeofOperatorWithEnumType.types | 10 ++++--- .../reference/voidOperatorWithEnumType.js | 6 ++-- .../reference/voidOperatorWithEnumType.types | 10 ++++--- 34 files changed, 204 insertions(+), 216 deletions(-) create mode 100644 tests/baselines/reference/decrementOperatorWithEnumType.errors.txt delete mode 100644 tests/baselines/reference/decrementOperatorWithEnumType.types delete mode 100644 tests/baselines/reference/enumIdenticalIdentifierValues.errors.txt delete mode 100644 tests/baselines/reference/enumIdenticalIdentifierValues.js create mode 100644 tests/baselines/reference/enumIdentifierLiterals.errors.txt delete mode 100644 tests/baselines/reference/enumIdentifierLiterals.js delete mode 100644 tests/baselines/reference/enumIdentifierLiterals.types create mode 100644 tests/baselines/reference/incrementOperatorWithEnumType.errors.txt delete mode 100644 tests/baselines/reference/incrementOperatorWithEnumType.types create mode 100644 tests/baselines/reference/parserEnum7.errors.txt delete mode 100644 tests/baselines/reference/parserEnum7.js delete mode 100644 tests/baselines/reference/parserEnum7.types diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts index eee0ee92001..85ed78f540c 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3674,7 +3674,8 @@ module ts { var errorCountBeforeEnumMember = file.syntacticErrors.length; node.name = parsePropertyName(); - if(!isNaN(Number(node.name.text))) { + // number("") returns 0 so we have to special case it + if(node.name.text !== "" && !isNaN(Number(node.name.text))) { grammarErrorOnNode(node.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); } diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js index e38520ef71a..77eca066c58 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js @@ -1,7 +1,7 @@ //// [bitwiseNotOperatorWithEnumType.ts] // ~ operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsNumber1 = ~ENUM1; @@ -22,8 +22,8 @@ var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]); // ~ 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 = {})); ; diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types index 077b8fdd4d6..20c13b022ab 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; @@ -14,17 +16,17 @@ var ResultIsNumber1 = ~ENUM1; var ResultIsNumber2 = ~ENUM1[1]; >ResultIsNumber2 : number >~ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 var ResultIsNumber3 = ~(ENUM1[1] + ENUM1[2]); >ResultIsNumber3 : number >~(ENUM1[1] + ENUM1[2]) : number ->(ENUM1[1] + ENUM1[2]) : number ->ENUM1[1] + ENUM1[2] : number ->ENUM1[1] : ENUM1 +>(ENUM1[1] + ENUM1[2]) : string +>ENUM1[1] + ENUM1[2] : string +>ENUM1[1] : string >ENUM1 : typeof ENUM1 ->ENUM1[2] : ENUM1 +>ENUM1[2] : string >ENUM1 : typeof ENUM1 // multiple ~ operators @@ -33,11 +35,11 @@ var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]); >~~~(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[1] + ENUM1[2]) : string +>ENUM1[1] + ENUM1[2] : string +>ENUM1[1] : string >ENUM1 : typeof ENUM1 ->ENUM1[2] : ENUM1 +>ENUM1[2] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -47,15 +49,15 @@ var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]); ~ENUM1[1]; >~ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 ~ENUM1[1], ~ENUM1[2]; >~ENUM1[1], ~ENUM1[2] : number >~ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 >~ENUM1[2] : number ->ENUM1[2] : ENUM1 +>ENUM1[2] : string >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..d65254ab76e --- /dev/null +++ b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt @@ -0,0 +1,27 @@ +tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(6,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(7,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(10,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +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 (4 errors) ==== + // -- operator on enum type + + enum ENUM1 { A, B, "" }; + + // expression + var ResultIsNumber1 = --ENUM1[1]; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + var ResultIsNumber2 = ENUM1[1]--; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + + // miss assignment operator + --ENUM1[1]; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + + ENUM1[1]--; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. \ No newline at end of file diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.js b/tests/baselines/reference/decrementOperatorWithEnumType.js index 8c22fd18928..b010fbf495e 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumType.js +++ b/tests/baselines/reference/decrementOperatorWithEnumType.js @@ -1,7 +1,7 @@ //// [decrementOperatorWithEnumType.ts] // -- operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // expression var ResultIsNumber1 = --ENUM1[1]; @@ -16,8 +16,8 @@ ENUM1[1]--; // -- 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 = {})); ; 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..fcb0fc9f969 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt +++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt @@ -14,7 +14,7 @@ tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOp // -- 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/decrementOperatorWithEnumTypeInvalidOperations.js b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js index 410e3c144ef..204d14bc11b 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; @@ -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/deleteOperatorWithEnumType.js b/tests/baselines/reference/deleteOperatorWithEnumType.js index d7fd9c95ee8..a1f7d858ac1 100644 --- a/tests/baselines/reference/deleteOperatorWithEnumType.js +++ b/tests/baselines/reference/deleteOperatorWithEnumType.js @@ -2,7 +2,7 @@ // delete operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsBoolean1 = delete 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/deleteOperatorWithEnumType.types b/tests/baselines/reference/deleteOperatorWithEnumType.types index d356693616f..10ab690a211 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; @@ -32,7 +34,7 @@ var ResultIsBoolean4 = delete (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // multiple delete operators @@ -51,7 +53,7 @@ var ResultIsBoolean6 = delete delete delete (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -65,7 +67,7 @@ delete ENUM1; delete ENUM1[1]; >delete ENUM1[1] : boolean ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 delete ENUM, 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..12ee1a0e079 --- /dev/null +++ b/tests/baselines/reference/enumIdentifierLiterals.errors.txt @@ -0,0 +1,25 @@ +tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1065: An enum member cannot have a numeric name. +tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1065: An enum member cannot have a numeric name. +tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1065: An enum member cannot have a numeric name. +tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1065: An enum member cannot have a numeric name. +tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1065: An enum member cannot have a numeric name. + + +==== tests/cases/compiler/enumIdentifierLiterals.ts (5 errors) ==== + enum Nums { + 1.0, + ~~~ +!!! error TS1065: An enum member cannot have a numeric name. + 11e-1, + ~~~~~ +!!! error TS1065: An enum member cannot have a numeric name. + 0.12e1, + ~~~~~~ +!!! error TS1065: An enum member cannot have a numeric name. + "13e-1", + ~~~~~~~ +!!! error TS1065: An enum member cannot have a numeric name. + 0xF00D + ~~~~~~ +!!! error TS1065: 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 deleted file mode 100644 index 72a8a56570c..00000000000 --- a/tests/baselines/reference/enumIdentifierLiterals.js +++ /dev/null @@ -1,18 +0,0 @@ -//// [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 = {})); 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..033e0c45136 --- /dev/null +++ b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt @@ -0,0 +1,27 @@ +tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(6,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(7,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(10,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(12,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + + +==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts (4 errors) ==== + // ++ operator on enum type + + enum ENUM1 { A, B, "" }; + + // expression + var ResultIsNumber1 = ++ENUM1[1]; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + var ResultIsNumber2 = ENUM1[1]++; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + + // miss assignment operator + ++ENUM1[1]; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + + ENUM1[1]++; + ~~~~~~~~ +!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. \ No newline at end of file diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.js b/tests/baselines/reference/incrementOperatorWithEnumType.js index cdea036c335..90a602cf249 100644 --- a/tests/baselines/reference/incrementOperatorWithEnumType.js +++ b/tests/baselines/reference/incrementOperatorWithEnumType.js @@ -1,7 +1,7 @@ //// [incrementOperatorWithEnumType.ts] // ++ operator on enum type -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // expression var ResultIsNumber1 = ++ENUM1[1]; @@ -16,8 +16,8 @@ ENUM1[1]++; // ++ 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 = {})); ; 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..f608bd4751f 100644 --- a/tests/baselines/reference/logicalNotOperatorWithEnumType.js +++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.js @@ -1,7 +1,7 @@ //// [logicalNotOperatorWithEnumType.ts] // ! operator on enum type -enum ENUM { 1, 2, 3 }; +enum ENUM { A, B, C }; enum ENUM1 { }; // enum type var @@ -25,9 +25,9 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]); // ! 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; diff --git a/tests/baselines/reference/logicalNotOperatorWithEnumType.types b/tests/baselines/reference/logicalNotOperatorWithEnumType.types index 27cbb24d3bb..32a946d5be0 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 @@ -17,17 +20,17 @@ var ResultIsBoolean1 = !ENUM; var ResultIsBoolean2 = !ENUM[1]; >ResultIsBoolean2 : boolean >!ENUM[1] : boolean ->ENUM[1] : ENUM +>ENUM[1] : string >ENUM : typeof ENUM var ResultIsBoolean3 = !(ENUM[1] + ENUM[2]); >ResultIsBoolean3 : boolean >!(ENUM[1] + ENUM[2]) : boolean ->(ENUM[1] + ENUM[2]) : number ->ENUM[1] + ENUM[2] : number ->ENUM[1] : ENUM +>(ENUM[1] + ENUM[2]) : string +>ENUM[1] + ENUM[2] : string +>ENUM[1] : string >ENUM : typeof ENUM ->ENUM[2] : ENUM +>ENUM[2] : string >ENUM : typeof ENUM // multiple ! operators @@ -42,11 +45,11 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]); >!!!(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[1] + ENUM[2]) : string +>ENUM[1] + ENUM[2] : string +>ENUM[1] : string >ENUM : typeof ENUM ->ENUM[2] : ENUM +>ENUM[2] : string >ENUM : typeof ENUM // miss assignment operators @@ -60,7 +63,7 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]); !ENUM[1]; >!ENUM[1] : boolean ->ENUM[1] : ENUM +>ENUM[1] : string >ENUM : typeof ENUM !ENUM, ENUM1; diff --git a/tests/baselines/reference/negateOperatorWithEnumType.js b/tests/baselines/reference/negateOperatorWithEnumType.js index a3235a3ccc0..5cd7459ddd7 100644 --- a/tests/baselines/reference/negateOperatorWithEnumType.js +++ b/tests/baselines/reference/negateOperatorWithEnumType.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; @@ -25,8 +25,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/negateOperatorWithEnumType.types b/tests/baselines/reference/negateOperatorWithEnumType.types index b2e0cb91c51..d1b24793099 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; @@ -17,17 +19,17 @@ var ResultIsNumber1 = -ENUM; var ResultIsNumber2 = -ENUM1[1]; >ResultIsNumber2 : number >-ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]); >ResultIsNumber3 : number >-(ENUM1[1] + ENUM1[2]) : number ->(ENUM1[1] + ENUM1[2]) : number ->ENUM1[1] + ENUM1[2] : number ->ENUM1[1] : ENUM1 +>(ENUM1[1] + ENUM1[2]) : string +>ENUM1[1] + ENUM1[2] : string +>ENUM1[1] : string >ENUM1 : typeof ENUM1 ->ENUM1[2] : ENUM1 +>ENUM1[2] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -41,7 +43,7 @@ var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]); -ENUM1[1]; >-ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 -ENUM, ENUM1; diff --git a/tests/baselines/reference/parserEnum5.errors.txt b/tests/baselines/reference/parserEnum5.errors.txt index 6a558dc9500..ab1ec6230b3 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(2,14): error TS1065: An enum member cannot have a numeric name. tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,15): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,17): error TS1065: An enum member cannot have a numeric name. tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,24): error TS1005: ',' expected. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,26): error TS1065: 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 TS1065: An enum member cannot have a numeric name. enum E1 { a, b: 1, c, d: 2 = 3 } ~ !!! error TS1005: ',' expected. + ~ +!!! error TS1065: An enum member cannot have a numeric name. ~ -!!! error TS1005: ',' expected. \ No newline at end of file +!!! error TS1005: ',' expected. + ~ +!!! error TS1065: 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..1f253fe3ab9 --- /dev/null +++ b/tests/baselines/reference/parserEnum7.errors.txt @@ -0,0 +1,15 @@ +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,3): error TS1065: An enum member cannot have a numeric name. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,6): error TS1065: An enum member cannot have a numeric name. +tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,9): error TS1065: An enum member cannot have a numeric name. + + +==== tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts (3 errors) ==== + enum E { + 1, 2, 3 + ~ +!!! error TS1065: An enum member cannot have a numeric name. + ~ +!!! error TS1065: An enum member cannot have a numeric name. + ~ +!!! error TS1065: 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 deleted file mode 100644 index 3781167bbba..00000000000 --- a/tests/baselines/reference/parserEnum7.js +++ /dev/null @@ -1,12 +0,0 @@ -//// [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 = {})); 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..1f97699c72d 100644 --- a/tests/baselines/reference/plusOperatorWithEnumType.js +++ b/tests/baselines/reference/plusOperatorWithEnumType.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; @@ -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 = {})); ; diff --git a/tests/baselines/reference/plusOperatorWithEnumType.types b/tests/baselines/reference/plusOperatorWithEnumType.types index 4ac40a9359d..94e0b06cf72 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; @@ -32,7 +34,7 @@ var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -46,7 +48,7 @@ var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]); +ENUM1[1]; >+ENUM1[1] : number ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 +ENUM, ENUM1; diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.js b/tests/baselines/reference/typeofOperatorWithEnumType.js index 1ce2170659e..b7954321cfb 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.js +++ b/tests/baselines/reference/typeofOperatorWithEnumType.js @@ -2,7 +2,7 @@ // typeof operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsString1 = typeof ENUM; @@ -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 = {})); ; diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.types b/tests/baselines/reference/typeofOperatorWithEnumType.types index cbcc49bd9dc..41a0741a9f4 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; @@ -32,7 +34,7 @@ var ResultIsString4 = typeof (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // multiple typeof operators @@ -51,7 +53,7 @@ var ResultIsString6 = typeof typeof typeof (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -65,7 +67,7 @@ typeof ENUM1; typeof ENUM1[1]; >typeof ENUM1[1] : string ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 typeof ENUM, ENUM1; diff --git a/tests/baselines/reference/voidOperatorWithEnumType.js b/tests/baselines/reference/voidOperatorWithEnumType.js index a168acaa1b6..6d43b906a93 100644 --- a/tests/baselines/reference/voidOperatorWithEnumType.js +++ b/tests/baselines/reference/voidOperatorWithEnumType.js @@ -2,7 +2,7 @@ // void operator on enum type enum ENUM { }; -enum ENUM1 { 1, 2, "" }; +enum ENUM1 { A, B, "" }; // enum type var var ResultIsAny1 = void 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/voidOperatorWithEnumType.types b/tests/baselines/reference/voidOperatorWithEnumType.types index 2433a00ca44..6b7d8aaa805 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; @@ -32,7 +34,7 @@ var ResultIsAny4 = void (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // multiple void operators @@ -51,7 +53,7 @@ var ResultIsAny6 = void void void (ENUM[0] + ENUM1[1]); >ENUM[0] + ENUM1[1] : string >ENUM[0] : string >ENUM : typeof ENUM ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 // miss assignment operators @@ -65,7 +67,7 @@ void ENUM1; void ENUM1[1]; >void ENUM1[1] : undefined ->ENUM1[1] : ENUM1 +>ENUM1[1] : string >ENUM1 : typeof ENUM1 void ENUM, ENUM1; From 15c5c7770443856e52b8e9f1f7b11caaf74dee70 Mon Sep 17 00:00:00 2001 From: ChrisBubernak Date: Wed, 8 Oct 2014 11:11:36 -0700 Subject: [PATCH 5/9] Fixing tests and baselines --- .../bitwiseNotOperatorWithEnumType.js | 20 +++---- .../bitwiseNotOperatorWithEnumType.types | 55 ++++++++++--------- .../decrementOperatorWithEnumType.errors.txt | 27 ++++----- .../decrementOperatorWithEnumType.js | 16 +++--- ...orWithEnumTypeInvalidOperations.errors.txt | 24 +++++--- ...ntOperatorWithEnumTypeInvalidOperations.js | 8 +-- .../reference/deleteOperatorWithEnumType.js | 16 +++--- .../deleteOperatorWithEnumType.types | 37 +++++++------ .../incrementOperatorWithEnumType.errors.txt | 28 ++++------ .../incrementOperatorWithEnumType.js | 16 +++--- .../logicalNotOperatorWithEnumType.js | 16 +++--- .../logicalNotOperatorWithEnumType.types | 43 ++++++++------- .../reference/negateOperatorWithEnumType.js | 12 ++-- .../negateOperatorWithEnumType.types | 25 +++++---- .../reference/plusOperatorWithEnumType.js | 12 ++-- .../reference/plusOperatorWithEnumType.types | 23 ++++---- .../reference/typeofOperatorWithEnumType.js | 16 +++--- .../typeofOperatorWithEnumType.types | 37 +++++++------ .../reference/voidOperatorWithEnumType.js | 16 +++--- .../reference/voidOperatorWithEnumType.types | 37 +++++++------ .../bitwiseNotOperatorWithEnumType.ts | 10 ++-- .../decrementOperatorWithEnumType.ts | 8 +-- ...ntOperatorWithEnumTypeInvalidOperations.ts | 4 +- .../deleteOperatorWithEnumType.ts | 8 +-- .../incrementOperatorWithEnumType.ts | 8 +-- .../logicalNotOperatorWithEnumType.ts | 8 +-- .../negateOperatorWithEnumType.ts | 6 +- .../plusOperator/plusOperatorWithEnumType.ts | 6 +- .../typeofOperatorWithEnumType.ts | 8 +-- .../voidOperator/voidOperatorWithEnumType.ts | 8 +-- 30 files changed, 283 insertions(+), 275 deletions(-) diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js index 77eca066c58..9cd5a63912e 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js @@ -7,16 +7,16 @@ enum ENUM1 { A, B, "" }; 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 @@ -30,11 +30,11 @@ var 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 20c13b022ab..71598c6f693 100644 --- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types +++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.types @@ -13,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] : string +>~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]) : string ->ENUM1[1] + ENUM1[2] : string ->ENUM1[1] : string +>~(ENUM1.A + ENUM1["B"]) : number +>(ENUM1.A + ENUM1["B"]) : number +>ENUM1.A + ENUM1["B"] : number +>ENUM1.A : ENUM1 >ENUM1 : typeof ENUM1 ->ENUM1[2] : string +>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]) : string ->ENUM1[1] + ENUM1[2] : string ->ENUM1[1] : string +>~~~(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] : string +>ENUM1.B : ENUM1 >ENUM1 : typeof ENUM1 +>B : ENUM1 // miss assignment operators ~ENUM1; >~ENUM1 : number >ENUM1 : typeof ENUM1 -~ENUM1[1]; ->~ENUM1[1] : number ->ENUM1[1] : string +~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] : string +~ENUM1.A, ~ENUM1["B"]; +>~ENUM1.A, ~ENUM1["B"] : number +>~ENUM1.A : number +>ENUM1.A : ENUM1 >ENUM1 : typeof ENUM1 ->~ENUM1[2] : number ->ENUM1[2] : string +>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 index d65254ab76e..d43515e84ef 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt +++ b/tests/baselines/reference/decrementOperatorWithEnumType.errors.txt @@ -1,27 +1,24 @@ -tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(6,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(7,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts(10,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +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 (4 errors) ==== +==== tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts (3 errors) ==== // -- operator on enum type enum ENUM1 { A, B, "" }; // expression - var ResultIsNumber1 = --ENUM1[1]; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. - var ResultIsNumber2 = ENUM1[1]--; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + 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[1]; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + --ENUM1["A"]; - ENUM1[1]--; + ENUM1[A]--; ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. \ No newline at end of file +!!! 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 b010fbf495e..13947a6a948 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumType.js +++ b/tests/baselines/reference/decrementOperatorWithEnumType.js @@ -4,13 +4,13 @@ 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 @@ -22,8 +22,8 @@ var ENUM1; })(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/decrementOperatorWithEnumTypeInvalidOperations.errors.txt b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt index fcb0fc9f969..079bb2a6b64 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt +++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.errors.txt @@ -2,15 +2,17 @@ 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 { }; @@ -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 204d14bc11b..66a1252cdd0 100644 --- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js +++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js @@ -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; @@ -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 a1f7d858ac1..e694790091c 100644 --- a/tests/baselines/reference/deleteOperatorWithEnumType.js +++ b/tests/baselines/reference/deleteOperatorWithEnumType.js @@ -9,17 +9,17 @@ 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] @@ -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 10ab690a211..e436ac3373f 100644 --- a/tests/baselines/reference/deleteOperatorWithEnumType.types +++ b/tests/baselines/reference/deleteOperatorWithEnumType.types @@ -21,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] : string +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 // multiple delete operators @@ -44,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] : string +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 // miss assignment operators @@ -65,10 +65,11 @@ delete ENUM1; >delete ENUM1 : boolean >ENUM1 : typeof ENUM1 -delete ENUM1[1]; ->delete ENUM1[1] : boolean ->ENUM1[1] : string +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/incrementOperatorWithEnumType.errors.txt b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt index 033e0c45136..7617dbba379 100644 --- a/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt +++ b/tests/baselines/reference/incrementOperatorWithEnumType.errors.txt @@ -1,27 +1,21 @@ -tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(6,25): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(7,23): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(10,3): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. -tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts(12,1): error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. +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 (4 errors) ==== +==== tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts (2 errors) ==== // ++ operator on enum type enum ENUM1 { A, B, "" }; // expression - var ResultIsNumber1 = ++ENUM1[1]; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. - var ResultIsNumber2 = ENUM1[1]++; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + 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[1]; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. + ++ENUM1["B"]; - ENUM1[1]++; - ~~~~~~~~ -!!! error TS2356: An arithmetic operand must be of type 'any', 'number' or an enum type. \ No newline at end of file + 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 90a602cf249..2baa326f399 100644 --- a/tests/baselines/reference/incrementOperatorWithEnumType.js +++ b/tests/baselines/reference/incrementOperatorWithEnumType.js @@ -4,13 +4,13 @@ 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 @@ -22,8 +22,8 @@ var ENUM1; })(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/logicalNotOperatorWithEnumType.js b/tests/baselines/reference/logicalNotOperatorWithEnumType.js index f608bd4751f..69ea283051d 100644 --- a/tests/baselines/reference/logicalNotOperatorWithEnumType.js +++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.js @@ -8,17 +8,17 @@ enum ENUM1 { }; 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] @@ -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 32a946d5be0..f3c9d98c95b 100644 --- a/tests/baselines/reference/logicalNotOperatorWithEnumType.types +++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.types @@ -17,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] : string +>!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]) : string ->ENUM[1] + ENUM[2] : string ->ENUM[1] : string +>!(ENUM.B + ENUM["C"]) : boolean +>(ENUM.B + ENUM["C"]) : number +>ENUM.B + ENUM["C"] : number +>ENUM.B : ENUM >ENUM : typeof ENUM ->ENUM[2] : string +>B : ENUM +>ENUM["C"] : ENUM >ENUM : typeof ENUM // multiple ! operators @@ -40,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]) : string ->ENUM[1] + ENUM[2] : string ->ENUM[1] : string +>!!!(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] : string +>ENUM.C : ENUM >ENUM : typeof ENUM +>C : ENUM // miss assignment operators !ENUM; @@ -61,10 +63,11 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]); >!ENUM1 : boolean >ENUM1 : typeof ENUM1 -!ENUM[1]; ->!ENUM[1] : boolean ->ENUM[1] : string +!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 5cd7459ddd7..876bed45cc2 100644 --- a/tests/baselines/reference/negateOperatorWithEnumType.js +++ b/tests/baselines/reference/negateOperatorWithEnumType.js @@ -8,13 +8,13 @@ enum ENUM1 { A, B, "" }; 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] @@ -33,10 +33,10 @@ var 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 d1b24793099..96a33ff4c6e 100644 --- a/tests/baselines/reference/negateOperatorWithEnumType.types +++ b/tests/baselines/reference/negateOperatorWithEnumType.types @@ -16,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] : string +>-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]) : string ->ENUM1[1] + ENUM1[2] : string ->ENUM1[1] : string +>-(ENUM1.B + ENUM1[""]) : number +>(ENUM1.B + ENUM1[""]) : number +>ENUM1.B + ENUM1[""] : number +>ENUM1.B : ENUM1 >ENUM1 : typeof ENUM1 ->ENUM1[2] : string +>B : ENUM1 +>ENUM1[""] : ENUM1 >ENUM1 : typeof ENUM1 // miss assignment operators @@ -41,9 +42,9 @@ var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]); >-ENUM1 : number >ENUM1 : typeof ENUM1 --ENUM1[1]; ->-ENUM1[1] : number ->ENUM1[1] : string +-ENUM1["B"]; +>-ENUM1["B"] : number +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 -ENUM, ENUM1; diff --git a/tests/baselines/reference/plusOperatorWithEnumType.js b/tests/baselines/reference/plusOperatorWithEnumType.js index 1f97699c72d..4d6eaad892e 100644 --- a/tests/baselines/reference/plusOperatorWithEnumType.js +++ b/tests/baselines/reference/plusOperatorWithEnumType.js @@ -9,13 +9,13 @@ 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] @@ -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 94e0b06cf72..bc51414e4a5 100644 --- a/tests/baselines/reference/plusOperatorWithEnumType.types +++ b/tests/baselines/reference/plusOperatorWithEnumType.types @@ -21,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] : string +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 // miss assignment operators @@ -46,10 +46,11 @@ var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]); >+ENUM1 : number >ENUM1 : typeof ENUM1 -+ENUM1[1]; ->+ENUM1[1] : number ->ENUM1[1] : string ++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 b7954321cfb..272feacf63d 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.js +++ b/tests/baselines/reference/typeofOperatorWithEnumType.js @@ -9,17 +9,17 @@ 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 @@ -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 41a0741a9f4..2a3ccc6a3da 100644 --- a/tests/baselines/reference/typeofOperatorWithEnumType.types +++ b/tests/baselines/reference/typeofOperatorWithEnumType.types @@ -21,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] : string +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 // multiple typeof operators @@ -44,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] : string +>ENUM1.B : ENUM1 >ENUM1 : typeof ENUM1 +>B : ENUM1 // miss assignment operators typeof ENUM; @@ -65,9 +66,9 @@ typeof ENUM1; >typeof ENUM1 : string >ENUM1 : typeof ENUM1 -typeof ENUM1[1]; ->typeof ENUM1[1] : string ->ENUM1[1] : string +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 6d43b906a93..8d20842ea7b 100644 --- a/tests/baselines/reference/voidOperatorWithEnumType.js +++ b/tests/baselines/reference/voidOperatorWithEnumType.js @@ -9,17 +9,17 @@ 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] @@ -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 6b7d8aaa805..82f4108bee3 100644 --- a/tests/baselines/reference/voidOperatorWithEnumType.types +++ b/tests/baselines/reference/voidOperatorWithEnumType.types @@ -21,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] : string +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 // multiple void operators @@ -44,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] : string +>ENUM1.B : ENUM1 >ENUM1 : typeof ENUM1 +>B : ENUM1 // miss assignment operators void ENUM; @@ -65,9 +66,9 @@ void ENUM1; >void ENUM1 : undefined >ENUM1 : typeof ENUM1 -void ENUM1[1]; ->void ENUM1[1] : undefined ->ENUM1[1] : string +void ENUM1["B"]; +>void ENUM1["B"] : undefined +>ENUM1["B"] : ENUM1 >ENUM1 : typeof ENUM1 void ENUM, ENUM1; diff --git a/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts index 3ea75ce6158..60370469692 100644 --- a/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/bitwiseNotOperator/bitwiseNotOperatorWithEnumType.ts @@ -6,13 +6,13 @@ enum ENUM1 { A, B, "" }; 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 6ca08e2adf4..022ed405a0b 100644 --- a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumType.ts @@ -3,10 +3,10 @@ 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 436e9a66a81..fca19d38daa 100644 --- a/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts +++ b/tests/cases/conformance/expressions/unaryOperators/decrementOperator/decrementOperatorWithEnumTypeInvalidOperations.ts @@ -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 fe0f4616ce5..a4c8020fdfe 100644 --- a/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/deleteOperator/deleteOperatorWithEnumType.ts @@ -8,15 +8,15 @@ 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 50fe1d2c038..6b116a7ca3d 100644 --- a/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/incrementOperator/incrementOperatorWithEnumType.ts @@ -3,10 +3,10 @@ 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/logicalNotOperator/logicalNotOperatorWithEnumType.ts b/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts index 1d218a55b43..a7a6f12b99d 100644 --- a/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/logicalNotOperator/logicalNotOperatorWithEnumType.ts @@ -7,15 +7,15 @@ enum ENUM1 { }; 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 7511b736532..6545588913c 100644 --- a/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/negateOperator/negateOperatorWithEnumType.ts @@ -7,11 +7,11 @@ enum ENUM1 { A, B, "" }; 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 11c13e098f7..288d716e231 100644 --- a/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/plusOperator/plusOperatorWithEnumType.ts @@ -8,11 +8,11 @@ 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 d770d35f4c3..9abb602db06 100644 --- a/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/typeofOperator/typeofOperatorWithEnumType.ts @@ -8,17 +8,17 @@ 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 117618b19a4..038aaed6483 100644 --- a/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts +++ b/tests/cases/conformance/expressions/unaryOperators/voidOperator/voidOperatorWithEnumType.ts @@ -8,15 +8,15 @@ 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 From 16f91b1ef340e6c9665aa11dcfa9fcd4a75edb20 Mon Sep 17 00:00:00 2001 From: Chris Bubernak Date: Wed, 8 Oct 2014 17:23:16 -0700 Subject: [PATCH 6/9] fixed error message and updated necessary baselines --- .../diagnosticInformationMap.generated.ts | 2 +- src/compiler/diagnosticMessages.json | 8 ++++---- .../enumIdentifierLiterals.errors.txt | 20 +++++++++---------- .../reference/parserEnum5.errors.txt | 12 +++++------ .../reference/parserEnum7.errors.txt | 12 +++++------ 5 files changed, 27 insertions(+), 27 deletions(-) diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts index 927a85ff854..f6e8275786d 100644 --- a/src/compiler/diagnosticInformationMap.generated.ts +++ b/src/compiler/diagnosticInformationMap.generated.ts @@ -48,7 +48,6 @@ module ts { Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: { code: 1056, category: DiagnosticCategory.Error, key: "Accessors are only available when targeting ECMAScript 5 and higher." }, Enum_member_must_have_initializer: { code: 1061, category: DiagnosticCategory.Error, key: "Enum member must have initializer." }, An_export_assignment_cannot_be_used_in_an_internal_module: { code: 1063, category: DiagnosticCategory.Error, key: "An export assignment cannot be used in an internal module." }, - An_enum_member_cannot_have_a_numeric_name: { code: 1065, category: DiagnosticCategory.Error, key: "An enum member cannot have a numeric name." }, Ambient_enum_elements_can_only_have_integer_literal_initializers: { code: 1066, category: DiagnosticCategory.Error, key: "Ambient enum elements can only have integer literal initializers." }, Unexpected_token_A_constructor_method_accessor_or_property_was_expected: { code: 1068, category: DiagnosticCategory.Error, key: "Unexpected token. A constructor, method, accessor, or property was expected." }, A_declare_modifier_cannot_be_used_with_an_import_declaration: { code: 1079, category: DiagnosticCategory.Error, key: "A 'declare' modifier cannot be used with an import declaration." }, @@ -115,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()' 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 c41bb962971..97c82a0a718 100644 --- a/src/compiler/diagnosticMessages.json +++ b/src/compiler/diagnosticMessages.json @@ -183,10 +183,6 @@ "category": "Error", "code": 1063 }, - "An enum member cannot have a numeric name.": { - "category": "Error", - "code": 1065 - }, "Ambient enum elements can only have integer literal initializers.": { "category": "Error", "code": 1066 @@ -451,6 +447,10 @@ "category": "Error", "code": 1150 }, + "An enum member cannot have a numeric name.": { + "category": "Error", + "code": 1151 + }, "Duplicate identifier '{0}'.": { "category": "Error", diff --git a/tests/baselines/reference/enumIdentifierLiterals.errors.txt b/tests/baselines/reference/enumIdentifierLiterals.errors.txt index 12ee1a0e079..721a6bd29ff 100644 --- a/tests/baselines/reference/enumIdentifierLiterals.errors.txt +++ b/tests/baselines/reference/enumIdentifierLiterals.errors.txt @@ -1,25 +1,25 @@ -tests/cases/compiler/enumIdentifierLiterals.ts(2,5): error TS1065: An enum member cannot have a numeric name. -tests/cases/compiler/enumIdentifierLiterals.ts(3,5): error TS1065: An enum member cannot have a numeric name. -tests/cases/compiler/enumIdentifierLiterals.ts(4,5): error TS1065: An enum member cannot have a numeric name. -tests/cases/compiler/enumIdentifierLiterals.ts(5,5): error TS1065: An enum member cannot have a numeric name. -tests/cases/compiler/enumIdentifierLiterals.ts(6,5): error TS1065: An enum member cannot have a numeric name. +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 TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. 11e-1, ~~~~~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. 0.12e1, ~~~~~~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. "13e-1", ~~~~~~~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. 0xF00D ~~~~~~ -!!! error TS1065: 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/parserEnum5.errors.txt b/tests/baselines/reference/parserEnum5.errors.txt index ab1ec6230b3..6192eadd42c 100644 --- a/tests/baselines/reference/parserEnum5.errors.txt +++ b/tests/baselines/reference/parserEnum5.errors.txt @@ -1,9 +1,9 @@ tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(2,12): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(2,14): error TS1065: An enum member cannot have a numeric name. +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,15): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,17): error TS1065: 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,24): error TS1005: ',' expected. -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,26): error TS1065: 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 (6 errors) ==== @@ -12,13 +12,13 @@ tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,26) ~ !!! error TS1005: ',' expected. ~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. enum E1 { a, b: 1, c, d: 2 = 3 } ~ !!! error TS1005: ',' expected. ~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. ~ !!! error TS1005: ',' expected. ~ -!!! error TS1065: An enum member cannot have a numeric name. \ No newline at end of file +!!! 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 index 1f253fe3ab9..48c938e02de 100644 --- a/tests/baselines/reference/parserEnum7.errors.txt +++ b/tests/baselines/reference/parserEnum7.errors.txt @@ -1,15 +1,15 @@ -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,3): error TS1065: An enum member cannot have a numeric name. -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,6): error TS1065: An enum member cannot have a numeric name. -tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum7.ts(2,9): error TS1065: An enum member cannot have a numeric name. +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 TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. ~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. ~ -!!! error TS1065: An enum member cannot have a numeric name. +!!! error TS1151: An enum member cannot have a numeric name. } \ No newline at end of file From 2b4f48996ebf6a0534c5ed5c5cfd6f8cfd05d8cd Mon Sep 17 00:00:00 2001 From: ChrisBubernak Date: Thu, 9 Oct 2014 08:52:53 -0700 Subject: [PATCH 7/9] Moved the error check from parser to checker & updated baselines --- src/compiler/checker.ts | 4 ++++ src/compiler/parser.ts | 6 ------ .../reference/enumIdentifierLiterals.js | 18 ++++++++++++++++++ .../baselines/reference/parserEnum5.errors.txt | 8 ++++---- tests/baselines/reference/parserEnum7.js | 12 ++++++++++++ 5 files changed, 38 insertions(+), 10 deletions(-) create mode 100644 tests/baselines/reference/enumIdentifierLiterals.js create mode 100644 tests/baselines/reference/parserEnum7.js diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 33d4008885d..59106a6bca2 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6639,6 +6639,10 @@ module ts { var ambient = isInAmbientContext(node); forEach(node.members, member => { + // todo: remove first check here when isNumericName gets fixed + if(!(member.name.text === "") && 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/parser.ts b/src/compiler/parser.ts index 85ed78f540c..422d133d5d0 100644 --- a/src/compiler/parser.ts +++ b/src/compiler/parser.ts @@ -3673,12 +3673,6 @@ module ts { var node = createNode(SyntaxKind.EnumMember); var errorCountBeforeEnumMember = file.syntacticErrors.length; node.name = parsePropertyName(); - - // number("") returns 0 so we have to special case it - if(node.name.text !== "" && !isNaN(Number(node.name.text))) { - grammarErrorOnNode(node.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); - } - node.initializer = parseInitializer(/*inParameter*/ false); if (inAmbientContext) { diff --git a/tests/baselines/reference/enumIdentifierLiterals.js b/tests/baselines/reference/enumIdentifierLiterals.js new file mode 100644 index 00000000000..06cb76dd21d --- /dev/null +++ b/tests/baselines/reference/enumIdentifierLiterals.js @@ -0,0 +1,18 @@ +//// [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 = {})); diff --git a/tests/baselines/reference/parserEnum5.errors.txt b/tests/baselines/reference/parserEnum5.errors.txt index 6192eadd42c..40c2c933955 100644 --- a/tests/baselines/reference/parserEnum5.errors.txt +++ b/tests/baselines/reference/parserEnum5.errors.txt @@ -1,8 +1,8 @@ tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(2,12): 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,15): error TS1005: ',' expected. -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,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. @@ -16,9 +16,9 @@ tests/cases/conformance/parser/ecmascript5/EnumDeclarations/parserEnum5.ts(3,26) enum E1 { a, b: 1, c, d: 2 = 3 } ~ !!! error TS1005: ',' expected. - ~ -!!! error TS1151: An enum member cannot have a numeric name. ~ !!! 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.js b/tests/baselines/reference/parserEnum7.js new file mode 100644 index 00000000000..831090f4ce7 --- /dev/null +++ b/tests/baselines/reference/parserEnum7.js @@ -0,0 +1,12 @@ +//// [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 = {})); From facd52f5933941ab0fcc7ae362fb9c23cb0c31ac Mon Sep 17 00:00:00 2001 From: ChrisBubernak Date: Thu, 9 Oct 2014 09:36:32 -0700 Subject: [PATCH 8/9] removed hidden tabs + moved check into isNumericName --- src/compiler/checker.ts | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 59106a6bca2..82ca3851a00 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -4093,7 +4093,7 @@ module ts { } function isNumericName(name: string) { - return !isNaN(name); + return (name !== "") && !isNaN(name); } function checkObjectLiteral(node: ObjectLiteral, contextualMapper?: TypeMapper): Type { @@ -6639,10 +6639,10 @@ module ts { var ambient = isInAmbientContext(node); forEach(node.members, member => { - // todo: remove first check here when isNumericName gets fixed - if(!(member.name.text === "") && isNumericName(member.name.text)) { - error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); - } + // todo: remove first check here when isNumericName gets fixed + 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); From 708ddf19e71f957bba073b7bdbad8d723304281f Mon Sep 17 00:00:00 2001 From: ChrisBubernak Date: Thu, 9 Oct 2014 09:43:40 -0700 Subject: [PATCH 9/9] removed old comment --- src/compiler/checker.ts | 1 - 1 file changed, 1 deletion(-) diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 82ca3851a00..50ef86eb7b9 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -6639,7 +6639,6 @@ module ts { var ambient = isInAmbientContext(node); forEach(node.members, member => { - // todo: remove first check here when isNumericName gets fixed if(isNumericName(member.name.text)) { error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name); }