From 84fa5b421aa0f3690e41edf3b301ae1ec1b94729 Mon Sep 17 00:00:00 2001
From: Sheetal Nandi <shkamat@microsoft.com>
Date: Thu, 14 Aug 2014 06:48:40 -0700
Subject: [PATCH] Emit commens for enum and enum members

---
 src/compiler/emitter.ts                                   | 4 ++++
 .../additionOperatorWithNullValueAndValidOperator.js      | 1 +
 .../reference/additionOperatorWithTypeParameter.js        | 1 +
 .../additionOperatorWithUndefinedValueAndValidOperator.js | 1 +
 tests/baselines/reference/arithmeticOperatorWithEnum.js   | 1 +
 .../reference/arithmeticOperatorWithInvalidOperands.js    | 2 ++
 .../arithmeticOperatorWithNullValueAndValidOperands.js    | 2 ++
 ...rithmeticOperatorWithUndefinedValueAndValidOperands.js | 2 ++
 tests/baselines/reference/arrowFunctionContexts.js        | 2 ++
 tests/baselines/reference/augmentedTypesEnum.js           | 5 +++++
 tests/baselines/reference/augmentedTypesEnum2.js          | 3 +++
 .../baselines/reference/bitwiseNotOperatorWithEnumType.js | 1 +
 tests/baselines/reference/commentsEnums.js                | 3 +++
 .../compoundAdditionAssignmentLHSCannotBeAssigned.js      | 1 +
 .../baselines/reference/decrementOperatorWithEnumType.js  | 1 +
 .../decrementOperatorWithEnumTypeInvalidOperations.js     | 1 +
 tests/baselines/reference/deleteOperatorWithEnumType.js   | 1 +
 tests/baselines/reference/enumAssignability.js            | 1 +
 .../baselines/reference/enumAssignabilityInInheritance.js | 1 +
 tests/baselines/reference/enumBasics.js                   | 8 ++++++++
 tests/baselines/reference/enumErrors.js                   | 5 +++++
 .../reference/enumIsNotASubtypeOfAnythingButNumber.js     | 1 +
 .../baselines/reference/incrementOperatorWithEnumType.js  | 1 +
 .../incrementOperatorWithEnumTypeInvalidOperations.js     | 1 +
 .../reference/logicalAndOperatorWithEveryType.js          | 2 ++
 .../baselines/reference/logicalNotOperatorWithEnumType.js | 1 +
 .../baselines/reference/logicalOrOperatorWithEveryType.js | 4 ++++
 tests/baselines/reference/negateOperatorWithEnumType.js   | 1 +
 tests/baselines/reference/plusOperatorWithEnumType.js     | 1 +
 tests/baselines/reference/typeofOperatorWithEnumType.js   | 2 ++
 tests/baselines/reference/voidOperatorWithEnumType.js     | 1 +
 31 files changed, 62 insertions(+)

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 06b0f8ec433..6dc2b67c27c 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -1498,6 +1498,7 @@ module ts {
             }
 
             function emitEnumDeclaration(node: EnumDeclaration) {
+                emitLeadingComments(node);
                 if (!(node.flags & NodeFlags.Export)) {
                     emitStart(node);
                     write("var ");
@@ -1516,6 +1517,7 @@ module ts {
                 scopeEmitStart(node);
                 forEach(node.members, member => {
                     writeLine();
+                    emitLeadingComments(member);
                     emitStart(member);
                     write(resolver.getLocalNameOfContainer(node));
                     write("[");
@@ -1533,6 +1535,7 @@ module ts {
                     emitQuotedIdentifier(member.name);
                     emitEnd(member);
                     write(";");
+                    emitTrailingComments(member);
                 });
                 decreaseIndent();
                 writeLine();
@@ -1554,6 +1557,7 @@ module ts {
                     emitEnd(node);
                     write(";");
                 }
+                emitTrailingComments(node);
             }
 
             function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration: ModuleDeclaration): ModuleDeclaration {
diff --git a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
index bf260153c83..f34ac61d86d 100644
--- a/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
+++ b/tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js
@@ -31,6 +31,7 @@ var r15 = d + null;
 var r16 = '' + null;
 
 //// [additionOperatorWithNullValueAndValidOperator.js]
+// If one operand is the null or undefined value, it is treated as having the type of the other operand.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/additionOperatorWithTypeParameter.js b/tests/baselines/reference/additionOperatorWithTypeParameter.js
index 1684182f002..6405bf897b9 100644
--- a/tests/baselines/reference/additionOperatorWithTypeParameter.js
+++ b/tests/baselines/reference/additionOperatorWithTypeParameter.js
@@ -39,6 +39,7 @@ function foo<T, U>(t: T, u: U) {
 }
 
 //// [additionOperatorWithTypeParameter.js]
+// type parameter type is not a valid operand of addition operator
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
index 8dc995f9d9e..a6a1b2ef555 100644
--- a/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
+++ b/tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js
@@ -31,6 +31,7 @@ var r15 = d + undefined;
 var r16 = '' + undefined;
 
 //// [additionOperatorWithUndefinedValueAndValidOperator.js]
+// If one operand is the null or undefined value, it is treated as having the type of the other operand.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/arithmeticOperatorWithEnum.js b/tests/baselines/reference/arithmeticOperatorWithEnum.js
index 349266c4fb3..9ef2790b4ce 100644
--- a/tests/baselines/reference/arithmeticOperatorWithEnum.js
+++ b/tests/baselines/reference/arithmeticOperatorWithEnum.js
@@ -151,6 +151,7 @@ var rj11 = b | E.b;
 var rj12 = 1 | E.b;
 
 //// [arithmeticOperatorWithEnum.js]
+// operands of an enum type are treated as having the primitive type Number.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
index b41e3969b77..26cbf5ffac3 100644
--- a/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithInvalidOperands.js
@@ -582,6 +582,8 @@ var r10h5 = e | E.b;
 var r10h6 = f | E.b;
 
 //// [arithmeticOperatorWithInvalidOperands.js]
+// these operators require their operands to be of type Any, the Number primitive type, or
+// an enum type
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
index a60302bf0b2..40676ef4495 100644
--- a/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithNullValueAndValidOperands.js
@@ -111,6 +111,8 @@ var rj7 = 0 | null;
 var rj8 = E.b | null;
 
 //// [arithmeticOperatorWithNullValueAndValidOperands.js]
+// If one operand is the null or undefined value, it is treated as having the type of the
+// other operand.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
index c608ccfa909..ddc2c87dd7a 100644
--- a/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
+++ b/tests/baselines/reference/arithmeticOperatorWithUndefinedValueAndValidOperands.js
@@ -111,6 +111,8 @@ var rj7 = 0 | undefined;
 var rj8 = E.b | undefined;
 
 //// [arithmeticOperatorWithUndefinedValueAndValidOperands.js]
+// If one operand is the undefined or undefined value, it is treated as having the type of the
+// other operand.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/arrowFunctionContexts.js b/tests/baselines/reference/arrowFunctionContexts.js
index bf25769c107..7b0e2223a87 100644
--- a/tests/baselines/reference/arrowFunctionContexts.js
+++ b/tests/baselines/reference/arrowFunctionContexts.js
@@ -126,6 +126,7 @@ var obj = function (n) { return ''; };
 var obj;
 var arr = [function (n) { return ''; }];
 var arr;
+// Arrow function as enum value
 var E;
 (function (E) {
     E[E["x"] = function () { return 4; }] = "x";
@@ -161,6 +162,7 @@ var M2;
     var obj;
     var arr = [function (n) { return ''; }];
     var arr;
+    // Arrow function as enum value
     var E;
     (function (E) {
         E[E["x"] = function () { return 4; }] = "x";
diff --git a/tests/baselines/reference/augmentedTypesEnum.js b/tests/baselines/reference/augmentedTypesEnum.js
index 55ba96b210a..4aaf83ee081 100644
--- a/tests/baselines/reference/augmentedTypesEnum.js
+++ b/tests/baselines/reference/augmentedTypesEnum.js
@@ -36,11 +36,13 @@ module e6b { export var y = 2; } // should be error
 //import e7 = require(''); // should be error
 
 //// [augmentedTypesEnum.js]
+// enum then var
 var e1111;
 (function (e1111) {
     e1111[e1111["One"] = 0] = "One";
 })(e1111 || (e1111 = {}));
 var e1111 = 1;
+// enum then function
 var e2;
 (function (e2) {
     e2[e2["One"] = 0] = "One";
@@ -53,6 +55,7 @@ var e3;
 })(e3 || (e3 = {}));
 var e3 = function () {
 };
+// enum then class
 var e4;
 (function (e4) {
     e4[e4["One"] = 0] = "One";
@@ -64,6 +67,7 @@ var e4 = (function () {
     };
     return e4;
 })();
+// enum then enum
 var e5;
 (function (e5) {
     e5[e5["One"] = 0] = "One";
@@ -80,6 +84,7 @@ var e5a;
 (function (e5a) {
     e5a[e5a["One"] = 0] = "One";
 })(e5a || (e5a = {}));
+// enum then internal module
 var e6;
 (function (e6) {
     e6[e6["One"] = 0] = "One";
diff --git a/tests/baselines/reference/augmentedTypesEnum2.js b/tests/baselines/reference/augmentedTypesEnum2.js
index a89f6c8df51..13656b33411 100644
--- a/tests/baselines/reference/augmentedTypesEnum2.js
+++ b/tests/baselines/reference/augmentedTypesEnum2.js
@@ -20,10 +20,13 @@ class e2 { // error
 //enum then import - covered
 
 //// [augmentedTypesEnum2.js]
+// enum then interface
 var e1;
 (function (e1) {
     e1[e1["One"] = 0] = "One";
 })(e1 || (e1 = {}));
+// interface then enum works
+// enum then class
 var e2;
 (function (e2) {
     e2[e2["One"] = 0] = "One";
diff --git a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
index ccf34db8b83..f09678cefdc 100644
--- a/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
+++ b/tests/baselines/reference/bitwiseNotOperatorWithEnumType.js
@@ -19,6 +19,7 @@ var ResultIsNumber4 = ~~~(ENUM1[1] + ENUM1[2]);
 ~ENUM1[1], ~ENUM1[2];
 
 //// [bitwiseNotOperatorWithEnumType.js]
+// ~ operator on enum type
 var ENUM1;
 (function (ENUM1) {
     ENUM1[ENUM1["1"] = 0] = "1";
diff --git a/tests/baselines/reference/commentsEnums.js b/tests/baselines/reference/commentsEnums.js
index 59da3de0141..91f9416070e 100644
--- a/tests/baselines/reference/commentsEnums.js
+++ b/tests/baselines/reference/commentsEnums.js
@@ -13,9 +13,12 @@ x = Colors.FancyPink;
 
 
 //// [commentsEnums.js]
+/** Enum of colors*/
 var Colors;
 (function (Colors) {
+    /** Fancy name for 'blue'*/
     Colors[Colors["Cornflower"] = 0] = "Cornflower";
+    /** Fancy name for 'pink'*/
     Colors[Colors["FancyPink"] = 1] = "FancyPink";
 })(Colors || (Colors = {}));
 var x = 0 /* Cornflower */;
diff --git a/tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.js b/tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.js
index bb255b3809e..24fa635a0a1 100644
--- a/tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.js
+++ b/tests/baselines/reference/compoundAdditionAssignmentLHSCannotBeAssigned.js
@@ -18,6 +18,7 @@ var x5: void;
 x5 += '';
 
 //// [compoundAdditionAssignmentLHSCannotBeAssigned.js]
+// string can add every type, and result string cannot be assigned to below types
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/decrementOperatorWithEnumType.js b/tests/baselines/reference/decrementOperatorWithEnumType.js
index 8d180fc308e..d6a2d892386 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumType.js
+++ b/tests/baselines/reference/decrementOperatorWithEnumType.js
@@ -13,6 +13,7 @@ var ResultIsNumber2 = ENUM1[1]--;
 ENUM1[1]--;
 
 //// [decrementOperatorWithEnumType.js]
+// -- operator on enum type
 var ENUM1;
 (function (ENUM1) {
     ENUM1[ENUM1["1"] = 0] = "1";
diff --git a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
index 4964e79d573..3ee0c88dc9e 100644
--- a/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
+++ b/tests/baselines/reference/decrementOperatorWithEnumTypeInvalidOperations.js
@@ -23,6 +23,7 @@ ENUM--;
 ENUM1--;
 
 //// [decrementOperatorWithEnumTypeInvalidOperations.js]
+// -- operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
diff --git a/tests/baselines/reference/deleteOperatorWithEnumType.js b/tests/baselines/reference/deleteOperatorWithEnumType.js
index 7d1398ce7ad..b8df20ea1dd 100644
--- a/tests/baselines/reference/deleteOperatorWithEnumType.js
+++ b/tests/baselines/reference/deleteOperatorWithEnumType.js
@@ -23,6 +23,7 @@ delete ENUM1[1];
 delete ENUM, ENUM1;
 
 //// [deleteOperatorWithEnumType.js]
+// delete  operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
diff --git a/tests/baselines/reference/enumAssignability.js b/tests/baselines/reference/enumAssignability.js
index 0b38e3a314a..f602829eaf8 100644
--- a/tests/baselines/reference/enumAssignability.js
+++ b/tests/baselines/reference/enumAssignability.js
@@ -55,6 +55,7 @@ module Others {
 }
 
 //// [enumAssignability.js]
+// enums assignable to number, any, Object, errors unless otherwise noted
 var E;
 (function (E) {
     E[E["A"] = 0] = "A";
diff --git a/tests/baselines/reference/enumAssignabilityInInheritance.js b/tests/baselines/reference/enumAssignabilityInInheritance.js
index 39457d6dcd1..5d44c28bde9 100644
--- a/tests/baselines/reference/enumAssignabilityInInheritance.js
+++ b/tests/baselines/reference/enumAssignabilityInInheritance.js
@@ -110,6 +110,7 @@ declare function foo17(x: E): E;
 var r4 = foo16(E.A);
 
 //// [enumAssignabilityInInheritance.js]
+// enum is only a subtype of number, no types are subtypes of enum, all of these except the first are errors
 var E;
 (function (E) {
     E[E["A"] = 0] = "A";
diff --git a/tests/baselines/reference/enumBasics.js b/tests/baselines/reference/enumBasics.js
index 10ef73e8d27..45a393be502 100644
--- a/tests/baselines/reference/enumBasics.js
+++ b/tests/baselines/reference/enumBasics.js
@@ -81,6 +81,7 @@ var doPropagate = [
 
 
 //// [enumBasics.js]
+// Enum without initializers have first member = 0 and successive members = N + 1
 var E1;
 (function (E1) {
     E1[E1["A"] = 0] = "A";
@@ -96,24 +97,28 @@ var e;
 // Reverse mapping of enum returns string name of property 
 var s = E1[0 /* A */];
 var s;
+// Enum with only constant members
 var E2;
 (function (E2) {
     E2[E2["A"] = 1] = "A";
     E2[E2["B"] = 2] = "B";
     E2[E2["C"] = 3] = "C";
 })(E2 || (E2 = {}));
+// Enum with only computed members
 var E3;
 (function (E3) {
     E3[E3["X"] = 'foo'.length] = "X";
     E3[E3["Y"] = 4 + 3] = "Y";
     E3[E3["Z"] = +'foo'] = "Z";
 })(E3 || (E3 = {}));
+// Enum with constant members followed by computed members
 var E4;
 (function (E4) {
     E4[E4["X"] = 0] = "X";
     E4[E4["Y"] = 1] = "Y";
     E4[E4["Z"] = 'foo'.length] = "Z";
 })(E4 || (E4 = {}));
+// Enum with > 2 constant members with no initializer for first member, non zero initializer for second element
 var E5;
 (function (E5) {
     E5[E5["A"] = 0] = "A";
@@ -126,14 +131,17 @@ var E6;
     E6[E6["B"] = 0] = "B";
     E6[E6["C"] = 1] = "C";
 })(E6 || (E6 = {}));
+// Enum with computed member initializer of type 'any'
 var E7;
 (function (E7) {
     E7[E7["A"] = 'foo'['foo']] = "A";
 })(E7 || (E7 = {}));
+// Enum with computed member initializer of type number
 var E8;
 (function (E8) {
     E8[E8["B"] = 'foo'['foo']] = "B";
 })(E8 || (E8 = {}));
+//Enum with computed member intializer of same enum type
 var E9;
 (function (E9) {
     E9[E9["A"] = 0] = "A";
diff --git a/tests/baselines/reference/enumErrors.js b/tests/baselines/reference/enumErrors.js
index 44830d14f3f..44aa2f90162 100644
--- a/tests/baselines/reference/enumErrors.js
+++ b/tests/baselines/reference/enumErrors.js
@@ -32,6 +32,7 @@ enum E11 {
 
 
 //// [enumErrors.js]
+// Enum named with PredefinedTypes
 var any;
 (function (any) {
 })(any || (any = {}));
@@ -44,6 +45,7 @@ var string;
 var boolean;
 (function (boolean) {
 })(boolean || (boolean = {}));
+// Enum with computed member initializer of type Number
 var E5;
 (function (E5) {
     E5[E5["C"] = new Number(30)] = "C";
@@ -53,11 +55,14 @@ var E9;
     E9[E9["A"] = 0] = "A";
     E9[E9["B"] = E9.A] = "B";
 })(E9 || (E9 = {}));
+//Enum with computed member intializer of different enum type
+// Bug 707850: This should be allowed
 var E10;
 (function (E10) {
     E10[E10["A"] = 0 /* A */] = "A";
     E10[E10["B"] = E9.B] = "B";
 })(E10 || (E10 = {}));
+// Enum with computed member intializer of other types
 var E11;
 (function (E11) {
     E11[E11["A"] = ''] = "A";
diff --git a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.js b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.js
index a3ac71b5200..f9ac7661e3d 100644
--- a/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.js
+++ b/tests/baselines/reference/enumIsNotASubtypeOfAnythingButNumber.js
@@ -131,6 +131,7 @@ interface I20 {
 }
 
 //// [enumIsNotASubtypeOfAnythingButNumber.js]
+// enums are only subtypes of number, any and no other types
 var E;
 (function (E) {
     E[E["A"] = 0] = "A";
diff --git a/tests/baselines/reference/incrementOperatorWithEnumType.js b/tests/baselines/reference/incrementOperatorWithEnumType.js
index cd92b6b1e5e..50b122df2d1 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumType.js
+++ b/tests/baselines/reference/incrementOperatorWithEnumType.js
@@ -13,6 +13,7 @@ var ResultIsNumber2 = ENUM1[1]++;
 ENUM1[1]++;
 
 //// [incrementOperatorWithEnumType.js]
+// ++ operator on enum type
 var ENUM1;
 (function (ENUM1) {
     ENUM1[ENUM1["1"] = 0] = "1";
diff --git a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
index 23149c23874..0f39b0b154a 100644
--- a/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
+++ b/tests/baselines/reference/incrementOperatorWithEnumTypeInvalidOperations.js
@@ -23,6 +23,7 @@ ENUM++;
 ENUM1++;
 
 //// [incrementOperatorWithEnumTypeInvalidOperations.js]
+// ++ operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
diff --git a/tests/baselines/reference/logicalAndOperatorWithEveryType.js b/tests/baselines/reference/logicalAndOperatorWithEveryType.js
index a9e714e8820..12bc06e8357 100644
--- a/tests/baselines/reference/logicalAndOperatorWithEveryType.js
+++ b/tests/baselines/reference/logicalAndOperatorWithEveryType.js
@@ -124,6 +124,8 @@ var rj9 = null && undefined;
 var rj10 = undefined && undefined;
 
 //// [logicalAndOperatorWithEveryType.js]
+// The && operator permits the operands to be of any type and produces a result of the same
+// type as the second operand.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/logicalNotOperatorWithEnumType.js b/tests/baselines/reference/logicalNotOperatorWithEnumType.js
index 7c32b423c18..a2351eba940 100644
--- a/tests/baselines/reference/logicalNotOperatorWithEnumType.js
+++ b/tests/baselines/reference/logicalNotOperatorWithEnumType.js
@@ -22,6 +22,7 @@ var ResultIsBoolean5 = !!!(ENUM[1] + ENUM[2]);
 !ENUM, ENUM1;
 
 //// [logicalNotOperatorWithEnumType.js]
+// ! operator on enum type
 var ENUM;
 (function (ENUM) {
     ENUM[ENUM["1"] = 0] = "1";
diff --git a/tests/baselines/reference/logicalOrOperatorWithEveryType.js b/tests/baselines/reference/logicalOrOperatorWithEveryType.js
index 47b88946cc0..31d19c5a802 100644
--- a/tests/baselines/reference/logicalOrOperatorWithEveryType.js
+++ b/tests/baselines/reference/logicalOrOperatorWithEveryType.js
@@ -126,6 +126,10 @@ var rf9 = null || undefined;       // null      || undefined is any
 var rf10 = undefined || undefined; // undefined || undefined is any
 
 //// [logicalOrOperatorWithEveryType.js]
+// The || operator permits the operands to be of any type.
+// If the || expression is not contextually typed, the right operand is contextually typed
+// by the type of the left operand and the result is of the best common type of the two
+// operand types.
 var E;
 (function (E) {
     E[E["a"] = 0] = "a";
diff --git a/tests/baselines/reference/negateOperatorWithEnumType.js b/tests/baselines/reference/negateOperatorWithEnumType.js
index d4759e1dc10..db28d6fadc1 100644
--- a/tests/baselines/reference/negateOperatorWithEnumType.js
+++ b/tests/baselines/reference/negateOperatorWithEnumType.js
@@ -18,6 +18,7 @@ var ResultIsNumber3 = -(ENUM1[1] + ENUM1[2]);
 -ENUM, ENUM1;
 
 //// [negateOperatorWithEnumType.js]
+// - operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
diff --git a/tests/baselines/reference/plusOperatorWithEnumType.js b/tests/baselines/reference/plusOperatorWithEnumType.js
index c66fd951d45..4fab550d520 100644
--- a/tests/baselines/reference/plusOperatorWithEnumType.js
+++ b/tests/baselines/reference/plusOperatorWithEnumType.js
@@ -19,6 +19,7 @@ var ResultIsNumber4 = +(ENUM[0] + ENUM1[1]);
 +ENUM, ENUM1;
 
 //// [plusOperatorWithEnumType.js]
+// + operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
diff --git a/tests/baselines/reference/typeofOperatorWithEnumType.js b/tests/baselines/reference/typeofOperatorWithEnumType.js
index bf061a7cbed..745203b9d21 100644
--- a/tests/baselines/reference/typeofOperatorWithEnumType.js
+++ b/tests/baselines/reference/typeofOperatorWithEnumType.js
@@ -28,6 +28,7 @@ z: typeof ENUM;
 z: typeof ENUM1;
 
 //// [typeofOperatorWithEnumType.js]
+// typeof  operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));
@@ -52,6 +53,7 @@ typeof ENUM;
 typeof ENUM1;
 typeof ENUM1[1];
 typeof ENUM, ENUM1;
+// use typeof in type query
 var z;
 (function (z) {
 })(z || (z = {}));
diff --git a/tests/baselines/reference/voidOperatorWithEnumType.js b/tests/baselines/reference/voidOperatorWithEnumType.js
index 411b0aafaa5..2ac8e99af0f 100644
--- a/tests/baselines/reference/voidOperatorWithEnumType.js
+++ b/tests/baselines/reference/voidOperatorWithEnumType.js
@@ -23,6 +23,7 @@ void ENUM1[1];
 void ENUM, ENUM1;
 
 //// [voidOperatorWithEnumType.js]
+// void  operator on enum type
 var ENUM;
 (function (ENUM) {
 })(ENUM || (ENUM = {}));