Const enums

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

src/compiler/diagnosticInformationMap.generated.ts

@@ -353,6 +353,9 @@ module ts {
         Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: { code: 4076, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named." },
         Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: { code: 4077, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'." },
         Parameter_0_of_exported_function_has_or_is_using_private_name_1: { code: 4078, category: DiagnosticCategory.Error, key: "Parameter '{0}' of exported function has or is using private name '{1}'." },
+        Enum_declarations_must_all_be_const_or_non_const: { code: 4079, category: DiagnosticCategory.Error, key: "Enum declarations must all be const or non-const." },
+        In_const_enum_declarations_member_initializer_must_be_constant_expression: { code: 4079, category: DiagnosticCategory.Error, key: "In 'const' enum declarations member initializer must be constant expression." },
+        const_enums_can_only_be_used_in_property_access_expressions: { code: 4079, category: DiagnosticCategory.Error, key: "'const' enums can only be used in property access expressions." },
         The_current_host_does_not_support_the_0_option: { code: 5001, category: DiagnosticCategory.Error, key: "The current host does not support the '{0}' option." },
         Cannot_find_the_common_subdirectory_path_for_the_input_files: { code: 5009, category: DiagnosticCategory.Error, key: "Cannot find the common subdirectory path for the input files." },
         Cannot_read_file_0_Colon_1: { code: 5012, category: DiagnosticCategory.Error, key: "Cannot read file '{0}': {1}" },

src/compiler/diagnosticMessages.json

@@ -1409,13 +1409,22 @@
         "category": "Error",
         "code": 4078
     },
-
-
+    "Enum declarations must all be const or non-const.": {
+        "category": "Error",
+        "code": 4079
+    },
+    "In 'const' enum declarations member initializer must be constant expression.": {
+        "category": "Error",
+        "code": 4079
+    },
+    "'const' enums can only be used in property access expressions.": {
+        "category": "Error",
+        "code": 4079
+    },    
     "The current host does not support the '{0}' option.": {
         "category": "Error",
         "code": 5001
     },
-
     "Cannot find the common subdirectory path for the input files.": {
         "category": "Error",
         "code": 5009

src/compiler/emitter.ts

@@ -1760,6 +1760,9 @@ module ts {
             }
 
             function emitEnumDeclaration(node: EnumDeclaration) {
+                if (isConstEnumDeclaration(node)) {
+                    return;
+                }
                 emitLeadingComments(node);
                 if (!(node.flags & NodeFlags.Export)) {
                     emitStart(node);
@@ -2570,6 +2573,9 @@ module ts {
                 if (resolver.isDeclarationVisible(node)) {
                     emitJsDocComments(node);
                     emitDeclarationFlags(node);
+                    if (isConstEnumDeclaration(node)) {
+                        write("const ")
+                    }
                     write("enum ");
                     emitSourceTextOfNode(node.name);
                     write(" {");

src/compiler/parser.ts

@@ -186,6 +186,10 @@ module ts {
         return (file.flags & NodeFlags.DeclarationFile) !== 0;
     }
 
+    export function isConstEnumDeclaration(node: EnumDeclaration): boolean {
+        return (node.flags & NodeFlags.Const) !== 0;
+    }
+
     export function isPrologueDirective(node: Node): boolean {
         return node.kind === SyntaxKind.ExpressionStatement && (<ExpressionStatement>node).expression.kind === SyntaxKind.StringLiteral;
     }
@@ -3146,7 +3150,6 @@ module ts {
                 case SyntaxKind.OpenBraceToken:
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
-                case SyntaxKind.ConstKeyword:
                 case SyntaxKind.FunctionKeyword:
                 case SyntaxKind.IfKeyword:
                 case SyntaxKind.DoKeyword:
@@ -3165,6 +3168,12 @@ module ts {
                 case SyntaxKind.CatchKeyword:
                 case SyntaxKind.FinallyKeyword:
                     return true;
+                case SyntaxKind.ConstKeyword:
+                    // const keyword can precede enum keyword when defining constant enums
+                    // 'const enum' do not start statement.
+                    // In ES 6 'enum' is a future reserved keyword, so it should not be used as identifier
+                    var isConstEnum = lookAhead(() => nextToken() === SyntaxKind.EnumKeyword);
+                    return !isConstEnum;
                 case SyntaxKind.InterfaceKeyword:
                 case SyntaxKind.ClassKeyword:
                 case SyntaxKind.ModuleKeyword:
@@ -3174,6 +3183,7 @@ module ts {
                     if (isDeclaration()) {
                         return false;
                     }
+
                 case SyntaxKind.PublicKeyword:
                 case SyntaxKind.PrivateKeyword:
                 case SyntaxKind.ProtectedKeyword:
@@ -3195,6 +3205,7 @@ module ts {
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
                 case SyntaxKind.ConstKeyword:
+                    // const here should always be parsed as const declaration because of check in 'isStatement' 
                     return parseVariableStatement(allowLetAndConstDeclarations);
                 case SyntaxKind.FunctionKeyword:
                     return parseFunctionDeclaration();
@@ -3748,6 +3759,7 @@ module ts {
         }
 
         function parseAndCheckEnumDeclaration(pos: number, flags: NodeFlags): EnumDeclaration {
+            var enumIsConst = flags & NodeFlags.Const;
             function isIntegerLiteral(expression: Expression): boolean {
                 function isInteger(literalExpression: LiteralExpression): boolean {
                     // Allows for scientific notation since literalExpression.text was formed by
@@ -3782,22 +3794,29 @@ module ts {
                 node.name = parsePropertyName();
                 node.initializer = parseInitializer(/*inParameter*/ false);
 
-                if (inAmbientContext) {
-                    if (node.initializer && !isIntegerLiteral(node.initializer) && errorCountBeforeEnumMember === file.syntacticErrors.length) {
-                        grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers);
+                // skip checks below for const enums  - they allow arbitrary initializers as long as they can be evaluated to constant expressions.
+                // since all values are known in compile time - it is not necessary to check that constant enum section precedes computed enum members.
+                if (!enumIsConst) {
+                    if (inAmbientContext) {
+                        if (node.initializer && !isIntegerLiteral(node.initializer) && errorCountBeforeEnumMember === file.syntacticErrors.length) {
+                            grammarErrorOnNode(node.name, Diagnostics.Ambient_enum_elements_can_only_have_integer_literal_initializers);
+                        }
+                    }
+                    else if (node.initializer) {
+                        inConstantEnumMemberSection = isIntegerLiteral(node.initializer);
+                    }
+                    else if (!inConstantEnumMemberSection && errorCountBeforeEnumMember === file.syntacticErrors.length) {
+                        grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer);
                     }
-                }
-                else if (node.initializer) {
-                    inConstantEnumMemberSection = isIntegerLiteral(node.initializer);
-                }
-                else if (!inConstantEnumMemberSection && errorCountBeforeEnumMember === file.syntacticErrors.length) {
-                    grammarErrorOnNode(node.name, Diagnostics.Enum_member_must_have_initializer);
                 }
                 return finishNode(node);
             }
 
             var node = <EnumDeclaration>createNode(SyntaxKind.EnumDeclaration, pos);
             node.flags = flags;
+            if (enumIsConst) {
+                parseExpected(SyntaxKind.ConstKeyword);
+            }
             parseExpected(SyntaxKind.EnumKeyword);
             node.name = parseIdentifier();
             if (parseExpected(SyntaxKind.OpenBraceToken)) {
@@ -3953,9 +3972,17 @@ module ts {
             switch (token) {
                 case SyntaxKind.VarKeyword:
                 case SyntaxKind.LetKeyword:
-                case SyntaxKind.ConstKeyword:
                     result = parseVariableStatement(/*allowLetAndConstDeclarations*/ true, pos, flags);
                     break;
+                case SyntaxKind.ConstKeyword:
+                    var isConstEnum = lookAhead(() => nextToken() === SyntaxKind.EnumKeyword);
+                    if (isConstEnum) {
+                        result = parseAndCheckEnumDeclaration(pos, flags | NodeFlags.Const);
+                    }
+                    else {
+                        result = parseVariableStatement(/*allowLetAndConstDeclarations*/ true, pos, flags);
+                    }
+                    break;
                 case SyntaxKind.FunctionKeyword:
                     result = parseFunctionDeclaration(pos, flags);
                     break;

src/harness/harness.ts

@@ -757,7 +757,6 @@ module Harness {
                         case 'codepage':
                         case 'createFileLog':
                         case 'filename':
-                        case 'propagateenumconstants':
                         case 'removecomments':
                         case 'watch':
                         case 'allowautomaticsemicoloninsertion':
@@ -772,7 +771,6 @@ module Harness {
                         case 'errortruncation':
                             options.noErrorTruncation = setting.value === 'false';
                             break;
-
                         default:
                             throw new Error('Unsupported compiler setting ' + setting.flag);
                     }

tests/baselines/reference/constantsInEnumMembers.errors.txt

@@ -0,0 +1,122 @@
+tests/cases/compiler/constantsInEnumMembers.ts(38,9): error TS4079: In 'const' enum declarations member initializer must be constant expression.
+tests/cases/compiler/constantsInEnumMembers.ts(40,9): error TS4079: In 'const' enum declarations member initializer must be constant expression.
+tests/cases/compiler/constantsInEnumMembers.ts(41,10): error TS4079: In 'const' enum declarations member initializer must be constant expression.
+
+
+==== tests/cases/compiler/constantsInEnumMembers.ts (3 errors) ====
+    const enum Enum1 {
+       A0 = 100,
+    }
+
+    const 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,
+        W3 = Enum1["A0"],
+        W4 = Enum1["W"],
+        // illegal case
+        // forward reference to the element of the same enum
+        X = Y, 
+            ~
+!!! error TS4079: In 'const' enum declarations member initializer must be constant expression.
+        // forward reference to the element of the same enum
+        Y = Enum1.Z,
+            ~~~~~~~
+!!! error TS4079: In 'const' enum declarations member initializer must be constant expression.
+        Y1 = Enum1["Z"],
+             ~~~~~~~~~~
+!!! error TS4079: In 'const' enum declarations member initializer must be constant expression.
+        Z = 100,
+    }
+
+
+    module A {
+        export module B {
+            export module C {
+                export const enum E {
+                    V1 = 1,
+                    V2 = A.B.C.E.V1 + 100
+                }
+            }
+        }
+    }
+
+    module A {
+        export module B {
+            export module C {
+                export const enum E {
+                    V3 = A.B.C.E["V2"] + 200,
+                }
+            }
+        }
+    }
+
+    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.W3:
+            case Enum1.W4:
+            case Enum1.X:
+            case Enum1.Y:
+            case Enum1.Y1:
+            case Enum1.Z:
+                break;
+        }
+    }
+
+    function bar(e: A.B.C.E): number {
+        switch (e) {
+            case A.B.C.E.V1: return 1;
+            case A.B.C.E.V2: return 1;
+            case A.B.C.E.V3: return 1;
+        }
+    }