inline enum constant values for indexed access when index is string literal

Author: vladima

src/compiler/checker.ts

@@ -5136,6 +5136,7 @@ module ts {
                 var name = (<LiteralExpression>node.index).text;
                 var prop = getPropertyOfType(objectType, name);
                 if (prop) {
+                    getNodeLinks(node).resolvedSymbol = prop;
                     return getTypeOfSymbol(prop);
                 }
             }
@@ -8833,7 +8834,7 @@ module ts {
             return getNodeLinks(node).enumMemberValue;
         }
 
-        function getConstantValue(node: PropertyAccess): number {
+        function getConstantValue(node: PropertyAccess | IndexedAccess): number {
             var symbol = getNodeLinks(node).resolvedSymbol;
             if (symbol && (symbol.flags & SymbolFlags.EnumMember)) {
                 var declaration = symbol.valueDeclaration;

src/compiler/emitter.ts

@@ -1031,19 +1031,29 @@ module ts {
                 emitTrailingComments(node);
             }
 
-            function emitPropertyAccess(node: PropertyAccess) {
+            function tryEmitConstantValue(node: PropertyAccess | IndexedAccess): boolean {
                 var constantValue = resolver.getConstantValue(node);
                 if (constantValue !== undefined) {
-                    write(constantValue.toString() + " /* " + identifierToString(node.right) + " */");
+                    var propertyName = node.kind === SyntaxKind.PropertyAccess ? identifierToString((<PropertyAccess>node).right) : getTextOfNode((<IndexedAccess>node).index);
+                    write(constantValue.toString() + " /* " + propertyName + " */");
+                    return true;
                 }
-                else {
-                    emit(node.left);
-                    write(".");
-                    emit(node.right);
+                return false;
+            }
+
+            function emitPropertyAccess(node: PropertyAccess) {
+                if (tryEmitConstantValue(node)) {
+                    return;
                 }
+                emit(node.left);
+                write(".");
+                emit(node.right);
             }
 
             function emitIndexedAccess(node: IndexedAccess) {
+                if (tryEmitConstantValue(node)) {
+                    return;
+                }
                 emit(node.object);
                 write("[");
                 emit(node.index);

src/compiler/types.ts

@@ -774,7 +774,7 @@ module ts {
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
         isImportDeclarationEntityNameReferenceDeclarationVisibile(entityName: EntityName): SymbolAccessiblityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant
-        getConstantValue(node: PropertyAccess): number;
+        getConstantValue(node: PropertyAccess | IndexedAccess): number;
         hasEarlyErrors(sourceFile?: SourceFile): boolean;
     }
 

tests/baselines/reference/additionOperatorWithNullValueAndValidOperator.js

@@ -50,12 +50,12 @@ var r3 = null + b;
 var r4 = null + 1;
 var r5 = null + c;
 var r6 = null + 0 /* a */;
-var r7 = null + E['a'];
+var r7 = null + 0 /* 'a' */;
 var r8 = b + null;
 var r9 = 1 + null;
 var r10 = c + null;
 var r11 = 0 /* a */ + null;
-var r12 = E['a'] + null;
+var r12 = 0 /* 'a' */ + null;
 // null + string
 var r13 = null + d;
 var r14 = null + '';

tests/baselines/reference/additionOperatorWithNumberAndEnum.js

@@ -29,4 +29,4 @@ var r4 = b + b;
 var r5 = 0 + a;
 var r6 = 0 /* a */ + 0;
 var r7 = 0 /* a */ + 1 /* b */;
-var r8 = E['a'] + E['b'];
+var r8 = 0 /* 'a' */ + 1 /* 'b' */;

tests/baselines/reference/additionOperatorWithUndefinedValueAndValidOperator.js

@@ -50,12 +50,12 @@ var r3 = undefined + b;
 var r4 = undefined + 1;
 var r5 = undefined + c;
 var r6 = undefined + 0 /* a */;
-var r7 = undefined + E['a'];
+var r7 = undefined + 0 /* 'a' */;
 var r8 = b + undefined;
 var r9 = 1 + undefined;
 var r10 = c + undefined;
 var r11 = 0 /* a */ + undefined;
-var r12 = E['a'] + undefined;
+var r12 = 0 /* 'a' */ + undefined;
 // undefined + string
 var r13 = undefined + d;
 var r14 = undefined + '';

tests/baselines/reference/bitwiseNotOperatorWithEnumType.js

@@ -30,11 +30,11 @@ var ENUM1;
 // enum type var
 var ResultIsNumber1 = ~ENUM1;
 // enum type expressions
-var ResultIsNumber2 = ~ENUM1["A"];
-var ResultIsNumber3 = ~(0 /* A */ + ENUM1["B"]);
+var ResultIsNumber2 = ~0 /* "A" */;
+var ResultIsNumber3 = ~(0 /* A */ + 1 /* "B" */);
 // multiple ~ operators
-var ResultIsNumber4 = ~~~(ENUM1["A"] + 1 /* B */);
+var ResultIsNumber4 = ~~~(0 /* "A" */ + 1 /* B */);
 // miss assignment operators
 ~ENUM1;
-~ENUM1["A"];
-~0 /* A */, ~ENUM1["B"];
+~0 /* "A" */;
+~0 /* A */, ~1 /* "B" */;

tests/baselines/reference/constEnums.js

@@ -131,7 +131,7 @@ function foo(x: Enum1) {
         case Enum1.Q:
         case Enum1.R:
         case Enum1.S:
-        case Enum1.T:
+        case Enum1["T"]:
         case Enum1.U:
         case Enum1.V:
         case Enum1.W:
@@ -203,7 +203,7 @@ function foo(x) {
         case -1 /* Q */:
         case 0 /* R */:
         case 0 /* S */:
-        case 11 /* T */:
+        case 11 /* "T" */:
         case 11 /* U */:
         case 11 /* V */:
         case 11 /* W */:

tests/baselines/reference/constEnums.types

@@ -466,10 +466,9 @@ function foo(x: Enum1) {
 >Enum1 : typeof Enum1
 >S : Enum1
 
-        case Enum1.T:
->Enum1.T : Enum1
+        case Enum1["T"]:
+>Enum1["T"] : Enum1
 >Enum1 : typeof Enum1
->T : Enum1
 
         case Enum1.U:
 >Enum1.U : Enum1

tests/baselines/reference/decrementOperatorWithEnumType.js

@@ -22,8 +22,8 @@ var ENUM1;
 })(ENUM1 || (ENUM1 = {}));
 ;
 // expression
-var ResultIsNumber1 = --ENUM1["A"];
+var ResultIsNumber1 = --0 /* "A" */;
 var ResultIsNumber2 = 0 /* A */--;
 // miss assignment operator
---ENUM1["A"];
+--0 /* "A" */;
 ENUM1[A]--;