Support ES6 built-in symbols

src/compiler/binder.ts

@@ -51,17 +51,6 @@ module ts {
         }
     }
 
-    /**
-     * A declaration has a dynamic name if both of the following are true:
-     *   1. The declaration has a computed property name
-     *   2. The computed name is *not* expressed as Symbol.<name>, where name
-     *      is a property of the Symbol constructor that denotes a built in
-     *      Symbol.
-     */
-    export function hasDynamicName(declaration: Declaration): boolean {
-        return declaration.name && declaration.name.kind === SyntaxKind.ComputedPropertyName;
-    }
-
     export function bindSourceFile(file: SourceFile): void {
         var start = new Date().getTime();
         bindSourceFileWorker(file);
@@ -98,13 +87,18 @@ module ts {
             if (symbolKind & SymbolFlags.Value && !symbol.valueDeclaration) symbol.valueDeclaration = node;
         }
 
-        // Should not be called on a declaration with a computed property name.
+        // Should not be called on a declaration with a computed property name,
+        // unless it is a well known Symbol.
         function getDeclarationName(node: Declaration): string {
             if (node.name) {
                 if (node.kind === SyntaxKind.ModuleDeclaration && node.name.kind === SyntaxKind.StringLiteral) {
                     return '"' + (<LiteralExpression>node.name).text + '"';
                 }
-                Debug.assert(!hasDynamicName(node));
+                if (node.name.kind === SyntaxKind.ComputedPropertyName) {
+                    var nameExpression = (<ComputedPropertyName>node.name).expression;
+                    Debug.assert(isWellKnownSymbolSyntactically(nameExpression));
+                    return getPropertyNameForKnownSymbolName((<PropertyAccessExpression>nameExpression).name.text);
+                }
                 return (<Identifier | LiteralExpression>node.name).text;
             }
             switch (node.kind) {

src/compiler/diagnosticMessages.json

@@ -483,27 +483,27 @@
         "category": "Error",
         "code": 1164
     },
-    "Computed property names are not allowed in an ambient context.": {
+    "A computed property name in an ambient context must directly refer to a built-in symbol.": {
         "category": "Error",
         "code": 1165
     },
-    "Computed property names are not allowed in class property declarations.": {
+    "A computed property name in a class property declaration must directly refer to a built-in symbol.": {
         "category": "Error",
         "code": 1166
     },
     "Computed property names are only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
         "code": 1167
     },
-    "Computed property names are not allowed in method overloads.": {
+    "A computed property name in a method overload must directly refer to a built-in symbol.": {
         "category": "Error",
         "code": 1168
     },
-    "Computed property names are not allowed in interfaces.": {
+    "A computed property name in an interface must directly refer to a built-in symbol.": {
         "category": "Error",
         "code": 1169
     },
-    "Computed property names are not allowed in type literals.": {
+    "A computed property name in a type literal must directly refer to a built-in symbol.": {
         "category": "Error",
         "code": 1170
     },
@@ -656,7 +656,7 @@
         "category": "Error",
         "code": 2318
     },
-    "Named properties '{0}' of types '{1}' and '{2}' are not identical.": {
+    "Named property '{0}' of types '{1}' and '{2}' are not identical.": {
         "category": "Error",
         "code": 2319
     },
@@ -744,7 +744,7 @@
         "category": "Error",
         "code": 2341
     },
-    "An index expression argument must be of type 'string', 'number', or 'any'.": {
+    "An index expression argument must be of type 'string', 'number', 'symbol, or 'any'.": {
         "category": "Error",
         "code": 2342
     },
@@ -808,7 +808,7 @@
         "category": "Error",
         "code": 2359
     },
-    "The left-hand side of an 'in' expression must be of types 'any', 'string' or 'number'.": {
+    "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'.": {
         "category": "Error",
         "code": 2360
     },
@@ -1188,7 +1188,7 @@
         "category": "Error",
         "code": 2463
     },
-    "A computed property name must be of type 'string', 'number', or 'any'.": {
+    "A computed property name must be of type 'string', 'number', 'symbol', or 'any'.": {
         "category": "Error",
         "code": 2464
     },
@@ -1202,48 +1202,64 @@
     },
     "A computed property name cannot reference a type parameter from its containing type.": {
         "category": "Error",
-        "code": 2466
+        "code": 2467
     },
-    "Spread operator in 'new' expressions is only available when targeting ECMAScript 6 and higher.": {
+    "Cannot find global value '{0}'.": {
         "category": "Error",
         "code": 2468
     },
-    "Enum declarations must all be const or non-const.": {
+    "The '{0}' operator cannot be applied to type 'symbol'.": {
         "category": "Error",
         "code": 2469
     },
-    "In 'const' enum declarations member initializer must be constant expression.": {
+    "'Symbol' reference does not refer to the global Symbol constructor object.": {
         "category": "Error",
         "code": 2470
     },
-    "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment.": {
+    "A computed property name of the form '{0}' must be of type 'symbol'.": {
         "category": "Error",
         "code": 2471
     },
-    "A const enum member can only be accessed using a string literal.": {
+    "Spread operator in 'new' expressions is only available when targeting ECMAScript 6 and higher.": {
         "category": "Error",
         "code": 2472
     },
-    "'const' enum member initializer was evaluated to a non-finite value.": {
+    "Enum declarations must all be const or non-const.": {
         "category": "Error",
         "code": 2473
     },
-    "'const' enum member initializer was evaluated to disallowed value 'NaN'.": {
+    "In 'const' enum declarations member initializer must be constant expression.": {
         "category": "Error",
         "code": 2474
     },
-    "Property '{0}' does not exist on 'const' enum '{1}'.": {
+    "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment.": {
         "category": "Error",
         "code": 2475
     },
-    "'let' is not allowed to be used as a name in 'let' or 'const' declarations.": {
+    "A const enum member can only be accessed using a string literal.": {
         "category": "Error",
         "code": 2476
     },
-    "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'.": {
+    "'const' enum member initializer was evaluated to a non-finite value.": {
         "category": "Error",
         "code": 2477
     },
+    "'const' enum member initializer was evaluated to disallowed value 'NaN'.": {
+        "category": "Error",
+        "code": 2478
+    },
+    "Property '{0}' does not exist on 'const' enum '{1}'.": {
+        "category": "Error",
+        "code": 2479
+    },
+    "'let' is not allowed to be used as a name in 'let' or 'const' declarations.": {
+        "category": "Error",
+        "code": 2480
+    },
+    "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'.": {
+        "category": "Error",
+        "code": 2481
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -275,7 +275,7 @@ module ts {
         var firstAccessor: AccessorDeclaration;
         var getAccessor: AccessorDeclaration;
         var setAccessor: AccessorDeclaration;
-        if (accessor.name.kind === SyntaxKind.ComputedPropertyName) {
+        if (hasDynamicName(accessor)) {
             firstAccessor = accessor;
             if (accessor.kind === SyntaxKind.GetAccessor) {
                 getAccessor = accessor;
@@ -289,19 +289,22 @@ module ts {
         }
         else {
             forEach(node.members,(member: Declaration) => {
-                if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor) &&
-                    (<Identifier>member.name).text === (<Identifier>accessor.name).text &&
-                    (member.flags & NodeFlags.Static) === (accessor.flags & NodeFlags.Static)) {
-                    if (!firstAccessor) {
-                        firstAccessor = <AccessorDeclaration>member;
-                    }
+                if ((member.kind === SyntaxKind.GetAccessor || member.kind === SyntaxKind.SetAccessor)
+                    && (member.flags & NodeFlags.Static) === (accessor.flags & NodeFlags.Static)) {
+                    var memberName = getPropertyNameForPropertyNameNode(member.name);
+                    var accessorName = getPropertyNameForPropertyNameNode(accessor.name);
+                    if (memberName === accessorName) {
+                        if (!firstAccessor) {
+                            firstAccessor = <AccessorDeclaration>member;
+                        }
 
-                    if (member.kind === SyntaxKind.GetAccessor && !getAccessor) {
-                        getAccessor = <AccessorDeclaration>member;
-                    }
+                        if (member.kind === SyntaxKind.GetAccessor && !getAccessor) {
+                            getAccessor = <AccessorDeclaration>member;
+                        }
 
-                    if (member.kind === SyntaxKind.SetAccessor && !setAccessor) {
-                        setAccessor = <AccessorDeclaration>member;
+                        if (member.kind === SyntaxKind.SetAccessor && !setAccessor) {
+                            setAccessor = <AccessorDeclaration>member;
+                        }
                     }
                 }
             });
@@ -579,6 +582,7 @@ module ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.StringLiteral:
                     return writeTextOfNode(currentSourceFile, type);

src/compiler/parser.ts

@@ -2593,6 +2593,7 @@ module ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.SymbolKeyword:
                     // If these are followed by a dot, then parse these out as a dotted type reference instead.
                     var node = tryParse(parseKeywordAndNoDot);
                     return node || parseTypeReference();
@@ -2617,6 +2618,7 @@ module ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
+                case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.VoidKeyword:
                 case SyntaxKind.TypeOfKeyword:
                 case SyntaxKind.OpenBraceToken:

src/compiler/scanner.ts

@@ -82,6 +82,7 @@ module ts {
         "string": SyntaxKind.StringKeyword,
         "super": SyntaxKind.SuperKeyword,
         "switch": SyntaxKind.SwitchKeyword,
+        "symbol": SyntaxKind.SymbolKeyword,
         "this": SyntaxKind.ThisKeyword,
         "throw": SyntaxKind.ThrowKeyword,
         "true": SyntaxKind.TrueKeyword,

src/compiler/types.ts

@@ -140,6 +140,7 @@ module ts {
         NumberKeyword,
         SetKeyword,
         StringKeyword,
+        SymbolKeyword,
         TypeKeyword,
 
         // Parse tree nodes
@@ -1298,9 +1299,10 @@ module ts {
         ObjectLiteral           = 0x00020000,  // Originates in an object literal
         ContainsUndefinedOrNull = 0x00040000,  // Type is or contains Undefined or Null type
         ContainsObjectLiteral   = 0x00080000,  // Type is or contains object literal type
+        ESSymbol                = 0x00100000,  // Type of symbol primitive introduced in ES6
 
-        Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,
-        Primitive = String | Number | Boolean | Void | Undefined | Null | StringLiteral | Enum,
+        Intrinsic = Any | String | Number | Boolean | ESSymbol | Void | Undefined | Null,
+        Primitive = String | Number | Boolean | ESSymbol | Void | Undefined | Null | StringLiteral | Enum,
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
         ObjectType = Class | Interface | Reference | Tuple | Anonymous,

src/compiler/utilities.ts

@@ -835,6 +835,54 @@ module ts {
         return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
     }
 
+    /**
+     * A declaration has a dynamic name if both of the following are true:
+     *   1. The declaration has a computed property name
+     *   2. The computed name is *not* expressed as Symbol.<name>, where name
+     *      is a property of the Symbol constructor that denotes a built in
+     *      Symbol.
+     */
+    export function hasDynamicName(declaration: Declaration): boolean {
+        return declaration.name &&
+            declaration.name.kind === SyntaxKind.ComputedPropertyName &&
+            !isWellKnownSymbolSyntactically((<ComputedPropertyName>declaration.name).expression);
+    }
+
+    /**
+     * Checks if the expression is of the form:
+     *    Symbol.name
+     * where Symbol is literally the word "Symbol", and name is any identifierName
+     */
+    export function isWellKnownSymbolSyntactically(node: Expression): boolean {
+        return node.kind === SyntaxKind.PropertyAccessExpression && isESSymbolIdentifier((<PropertyAccessExpression>node).expression);
+    }
+
+    export function getPropertyNameForPropertyNameNode(name: DeclarationName): string {
+        if (name.kind === SyntaxKind.Identifier || name.kind === SyntaxKind.StringLiteral || name.kind === SyntaxKind.NumericLiteral) {
+            return (<Identifier | LiteralExpression>name).text;
+        }
+        if (name.kind === SyntaxKind.ComputedPropertyName) {
+            var nameExpression = (<ComputedPropertyName>name).expression;
+            if (isWellKnownSymbolSyntactically(nameExpression)) {
+                var rightHandSideName = (<PropertyAccessExpression>nameExpression).name.text;
+                return getPropertyNameForKnownSymbolName(rightHandSideName);
+            }
+        }
+
+        return undefined;
+    }
+
+    export function getPropertyNameForKnownSymbolName(symbolName: string): string {
+        return "__@" + symbolName;
+    }
+
+    /**
+     * Includes the word "Symbol" with unicode escapes
+     */
+    export function isESSymbolIdentifier(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier && (<Identifier>node).text === "Symbol";
+    }
+
     export function isModifier(token: SyntaxKind): boolean {
         switch (token) {
             case SyntaxKind.PublicKeyword: