Const enums

src/compiler/checker.ts

@@ -489,10 +489,12 @@ module ts {
         }
 
         // Resolves a qualified name and any involved import aliases
-        function resolveEntityName(location: Node, name: EntityName, meaning: SymbolFlags): Symbol {
+        function resolveEntityName(location: Node, name: EntityName, meaning: SymbolFlags, suppressErrors?: boolean): Symbol {
             if (name.kind === SyntaxKind.Identifier) {
                 // TODO: Investigate error recovery for symbols not found
-                var symbol = resolveName(location, (<Identifier>name).text, meaning, Diagnostics.Cannot_find_name_0, identifierToString(<Identifier>name));
+                var nameNotFoundMessage = !suppressErrors && Diagnostics.Cannot_find_name_0;
+                var nameArg = !suppressErrors && identifierToString(<Identifier>name);
+                var symbol = resolveName(location, (<Identifier>name).text, meaning, nameNotFoundMessage, nameArg);
                 if (!symbol) {
                     return;
                 }
@@ -502,8 +504,10 @@ module ts {
                 if (!namespace || namespace === unknownSymbol || (<QualifiedName>name).right.kind === SyntaxKind.Missing) return;
                 var symbol = getSymbol(namespace.exports, (<QualifiedName>name).right.text, meaning);
                 if (!symbol) {
-                    error(location, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace),
-                        identifierToString((<QualifiedName>name).right));
+                    if (!suppressErrors) {
+                        error(location, Diagnostics.Module_0_has_no_exported_member_1, getFullyQualifiedName(namespace),
+                            identifierToString((<QualifiedName>name).right));
+                    }
                     return;
                 }
             }
@@ -7397,23 +7401,6 @@ module ts {
             }
         }
 
-        function getConstantValueForExpression(node: Expression): number {
-            var isNegative = false;
-            if (node.kind === SyntaxKind.PrefixOperator) {
-                var unaryExpression = <UnaryExpression>node;
-                if (unaryExpression.operator === SyntaxKind.MinusToken || unaryExpression.operator === SyntaxKind.PlusToken) {
-                    node = unaryExpression.operand;
-                    isNegative = unaryExpression.operator === SyntaxKind.MinusToken;
-                }
-            }
-            if (node.kind === SyntaxKind.NumericLiteral) {
-                var literalText = (<LiteralExpression>node).text;
-                return isNegative ? -literalText : +literalText;
-            }
-
-            return undefined;
-        }
-
         function computeEnumMemberValues(node: EnumDeclaration) {
             var nodeLinks = getNodeLinks(node);
 
@@ -7423,13 +7410,13 @@ module ts {
                 var autoValue = 0;
                 var ambient = isInAmbientContext(node);
 
-                forEach(node.members, member => {
+                forEach(node.members, member =>  {
                     if(isNumericName(member.name.text)) {
                         error(member.name, Diagnostics.An_enum_member_cannot_have_a_numeric_name);
                     }
                     var initializer = member.initializer;
                     if (initializer) {
-                        autoValue = getConstantValueForExpression(initializer);
+                        autoValue = getConstantValueForEnumMemberInitializer(member, initializer);
                         if (autoValue === undefined && !ambient) {
                             // Only here do we need to check that the initializer is assignable to the enum type.
                             // If it is a constant value (not undefined), it is syntactically constrained to be a number. 
@@ -7449,6 +7436,71 @@ module ts {
 
                 nodeLinks.flags |= NodeCheckFlags.EnumValuesComputed;
             }
+
+            function getConstantValueForEnumMemberInitializer(member: EnumMember, initializer: Expression): number {
+                return evalConstant(initializer);
+
+                function evalConstant(e: Node): number {
+                    switch (e.kind) {
+                        case SyntaxKind.PrefixOperator:
+                            var value = evalConstant((<UnaryExpression>e).operand);
+                            if (value === undefined) return undefined;
+                            switch ((<UnaryExpression>e).operator) {
+                                case SyntaxKind.PlusToken: return value;
+                                case SyntaxKind.MinusToken: return -value;
+                                case SyntaxKind.TildeToken: return ~value;
+                            }
+                            return undefined;
+                        case SyntaxKind.BinaryExpression:
+                            if (!program.getCompilerOptions().propagateEnumConstants) return undefined;
+
+                            var left = evalConstant((<BinaryExpression>e).left);
+                            if (left === undefined) return undefined;
+                            var right = evalConstant((<BinaryExpression>e).right);
+                            if (right === undefined) return undefined;
+                            switch ((<BinaryExpression>e).operator) {
+                                case SyntaxKind.BarToken: return left | right;
+                                case SyntaxKind.AmpersandToken: return left & right;
+                                case SyntaxKind.PlusToken: return left + right;
+                                case SyntaxKind.MinusToken: return left - right;
+                                case SyntaxKind.GreaterThanGreaterThanToken: return left >> right;
+                                case SyntaxKind.LessThanLessThanToken: return left << right;
+                            }
+                            return undefined;
+                        case SyntaxKind.NumericLiteral:
+                            return +(<LiteralExpression>e).text;
+                        case SyntaxKind.Identifier:
+                        case SyntaxKind.PropertyAccess:
+                            if (!program.getCompilerOptions().propagateEnumConstants) return undefined;
+
+                            var enumSymbol: Symbol;
+                            var propertyName: string;
+
+                            if (e.kind === SyntaxKind.Identifier) {
+                                // unqualified names can refer to member that reside in different declaration of the enum so just doing name resolution won't work.
+                                // instead pick symbol that correspond of enum declaration and later try to fetch member from the symbol
+                                enumSymbol = getSymbolOfNode(member.parent);
+                                propertyName = (<Identifier>e).text;
+                            }
+                            else {
+                                // left part in PropertyAccess should be resolved to the symbol of enum that declared 'member' 
+                                enumSymbol = resolveEntityName(member, (<PropertyAccess>e).left, SymbolFlags.Enum, /*suppressErrors*/ true);
+
+                                if (enumSymbol !== getSymbolOfNode(member.parent)) return undefined;
+                                propertyName = (<Identifier>(<PropertyAccess>e).right).text;
+                            }
+
+                            var propertySymbol = enumSymbol.exports[propertyName];
+                            if (!propertyName || !(propertySymbol.flags & SymbolFlags.EnumMember)) return undefined;
+                            var propertyDecl = <EnumMember>propertySymbol.valueDeclaration;
+                            // self references are illegal
+                            if (member === propertyDecl) return undefined;
+                            // enumMemberValue might be undefined if corresponding enum value was not yet computed 
+                            // and it is ok to return undefined in this case (use before defition)
+                            return <number>getNodeLinks(propertyDecl).enumMemberValue;
+                    }
+                }
+            }
         }
 
         function checkEnumDeclaration(node: EnumDeclaration) {

src/compiler/commandLineParser.ts

@@ -24,7 +24,7 @@ module ts {
             type: "boolean",
         },
         {
-            name: "emitBOM", 
+            name: "emitBOM",
             type: "boolean"
         },
         {
@@ -102,7 +102,7 @@ module ts {
         {
             name: "target",
             shortName: "t",
-            type: { "es3": ScriptTarget.ES3, "es5": ScriptTarget.ES5 , "es6": ScriptTarget.ES6 },
+            type: { "es3": ScriptTarget.ES3, "es5": ScriptTarget.ES5, "es6": ScriptTarget.ES6 },
             description: Diagnostics.Specify_ECMAScript_target_version_Colon_ES3_default_ES5_or_ES6_experimental,
             paramType: Diagnostics.VERSION,
             error: Diagnostics.Argument_for_target_option_must_be_es3_es5_or_es6
@@ -118,6 +118,11 @@ module ts {
             shortName: "w",
             type: "boolean",
             description: Diagnostics.Watch_input_files,
+        },
+        {
+            name: "propagateEnumConstants",
+            type: "boolean",
+            description: Diagnostics.Propagate_constant_values_in_enum_member_initializers
         }
     ];
 

src/compiler/diagnosticInformationMap.generated.ts

@@ -369,6 +369,7 @@ module ts {
         Specify_module_code_generation_Colon_commonjs_or_amd: { code: 6016, category: DiagnosticCategory.Message, key: "Specify module code generation: 'commonjs' or 'amd'" },
         Print_this_message: { code: 6017, category: DiagnosticCategory.Message, key: "Print this message." },
         Print_the_compiler_s_version: { code: 6019, category: DiagnosticCategory.Message, key: "Print the compiler's version." },
+        Propagate_constant_values_in_enum_member_initializers: { code: 6020, category: DiagnosticCategory.Message, key: "Propagate constant values in enum member initializers." },
         Syntax_Colon_0: { code: 6023, category: DiagnosticCategory.Message, key: "Syntax: {0}" },
         options: { code: 6024, category: DiagnosticCategory.Message, key: "options" },
         file: { code: 6025, category: DiagnosticCategory.Message, key: "file" },

src/compiler/diagnosticMessages.json

@@ -1476,6 +1476,10 @@
         "category": "Message",
         "code": 6019
     },
+    "Propagate constant values in enum member initializers.": {
+        "category": "Message",
+        "code": 6020
+    },
     "Syntax: {0}": {
         "category": "Message",
         "code": 6023

src/compiler/types.ts

@@ -1093,6 +1093,7 @@ module ts {
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
+        propagateEnumConstants?: boolean;
         [option: string]: any;
     }
 

src/harness/harness.ts

@@ -749,6 +749,9 @@ module Harness {
                         case 'usecasesensitivefilenames':
                             useCaseSensitiveFileNames = setting.value === 'true';
                             break;
+                        case 'propagateenumconstants':
+                            options.propagateEnumConstants = setting.value === 'true';
+                            break;
 
                         case 'mapsourcefiles':
                         case 'maproot':
@@ -757,7 +760,6 @@ module Harness {
                         case 'codepage':
                         case 'createFileLog':
                         case 'filename':
-                        case 'propagateenumconstants':
                         case 'removecomments':
                         case 'watch':
                         case 'allowautomaticsemicoloninsertion':
@@ -772,7 +774,6 @@ module Harness {
                         case 'errortruncation':
                             options.noErrorTruncation = setting.value === 'false';
                             break;
-
                         default:
                             throw new Error('Unsupported compiler setting ' + setting.flag);
                     }
@@ -1147,7 +1148,7 @@ module Harness {
         var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
 
         // List of allowed metadata names
-        var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames"];
+        var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "propagateenumconstants"];
 
         function extractCompilerSettings(content: string): CompilerSetting[] {
 

tests/baselines/reference/constantsInEnumMembers.js

@@ -0,0 +1,153 @@
+//// [constantsInEnumMembers.ts]
+
+enum Enum1 {
+   A0 = 100,
+}
+
+enum Enum1 {
+    // correct cases
+    A,
+    B,
+    C = 10,
+    D = A + B,
+    E = A + 1,
+    F = 1 + A,
+    G = 1 + 1,
+    H = A - B,
+    I = A - 1,
+    J = 1 - A,
+    K = 1 - 1,
+    L = ~D,
+    M = E << B,
+    N = E << 1,
+    O = E >> B,
+    P = E >> 1,
+    Q = -D,
+    R = C & 5,
+    S = 5 & C,
+    T = C | D,
+    U = C | 1,
+    V = 10 | D,
+    W = Enum1.V,
+
+    // correct cases: reference to the enum member from different enum declaration
+    W1 = A0,
+    W2 = Enum1.A0,
+
+    // illegal case
+    // forward reference to the element of the same enum
+    X = Y, 
+    // forward reference to the element of the same enum
+    Y = Enum1.Z,
+    Z = 100,
+}
+
+
+function foo(x: Enum1) {
+    switch (x) {
+        case Enum1.A:
+        case Enum1.B:
+        case Enum1.C:
+        case Enum1.D:
+        case Enum1.E:
+        case Enum1.F:
+        case Enum1.G:
+        case Enum1.H:
+        case Enum1.I:
+        case Enum1.J:
+        case Enum1.K:
+        case Enum1.L:
+        case Enum1.M:
+        case Enum1.N:
+        case Enum1.O:
+        case Enum1.P:
+        case Enum1.Q:
+        case Enum1.R:
+        case Enum1.S:
+        case Enum1.T:
+        case Enum1.U:
+        case Enum1.V:
+        case Enum1.W:
+        case Enum1.W1:
+        case Enum1.W2:
+        case Enum1.X:
+        case Enum1.Y:
+        case Enum1.Z:
+            break;
+    }
+}
+
+//// [constantsInEnumMembers.js]
+var Enum1;
+(function (Enum1) {
+    Enum1[Enum1["A0"] = 100] = "A0";
+})(Enum1 || (Enum1 = {}));
+var Enum1;
+(function (Enum1) {
+    // correct cases
+    Enum1[Enum1["A"] = 0] = "A";
+    Enum1[Enum1["B"] = 1] = "B";
+    Enum1[Enum1["C"] = 10] = "C";
+    Enum1[Enum1["D"] = A + B] = "D";
+    Enum1[Enum1["E"] = A + 1] = "E";
+    Enum1[Enum1["F"] = 1 + A] = "F";
+    Enum1[Enum1["G"] = 1 + 1] = "G";
+    Enum1[Enum1["H"] = A - B] = "H";
+    Enum1[Enum1["I"] = A - 1] = "I";
+    Enum1[Enum1["J"] = 1 - A] = "J";
+    Enum1[Enum1["K"] = 1 - 1] = "K";
+    Enum1[Enum1["L"] = ~D] = "L";
+    Enum1[Enum1["M"] = E << B] = "M";
+    Enum1[Enum1["N"] = E << 1] = "N";
+    Enum1[Enum1["O"] = E >> B] = "O";
+    Enum1[Enum1["P"] = E >> 1] = "P";
+    Enum1[Enum1["Q"] = -D] = "Q";
+    Enum1[Enum1["R"] = C & 5] = "R";
+    Enum1[Enum1["S"] = 5 & C] = "S";
+    Enum1[Enum1["T"] = C | D] = "T";
+    Enum1[Enum1["U"] = C | 1] = "U";
+    Enum1[Enum1["V"] = 10 | D] = "V";
+    Enum1[Enum1["W"] = Enum1.V] = "W";
+    // correct cases: reference to the enum member from different enum declaration
+    Enum1[Enum1["W1"] = A0] = "W1";
+    Enum1[Enum1["W2"] = Enum1.A0] = "W2";
+    // illegal case
+    // forward reference to the element of the same enum
+    Enum1[Enum1["X"] = Enum1.Y] = "X";
+    // forward reference to the element of the same enum
+    Enum1[Enum1["Y"] = 100 /* Z */] = "Y";
+    Enum1[Enum1["Z"] = 100] = "Z";
+})(Enum1 || (Enum1 = {}));
+function foo(x) {
+    switch (x) {
+        case 0 /* A */:
+        case 1 /* B */:
+        case 10 /* C */:
+        case 1 /* D */:
+        case 1 /* E */:
+        case 1 /* F */:
+        case 2 /* G */:
+        case -1 /* H */:
+        case -1 /* I */:
+        case 1 /* J */:
+        case 0 /* K */:
+        case -2 /* L */:
+        case 2 /* M */:
+        case 2 /* N */:
+        case 0 /* O */:
+        case 0 /* P */:
+        case -1 /* Q */:
+        case 0 /* R */:
+        case 0 /* S */:
+        case 11 /* T */:
+        case 11 /* U */:
+        case 11 /* V */:
+        case 11 /* W */:
+        case 100 /* W1 */:
+        case 100 /* W2 */:
+        case Enum1.X:
+        case Enum1.Y:
+        case 100 /* Z */:
+            break;
+    }
+}