Allow dynamic names in types

src/compiler/declarationEmitter.ts

@@ -425,6 +425,8 @@ namespace ts {
                 case SyntaxKind.ThisType:
                 case SyntaxKind.LiteralType:
                     return writeTextOfNode(currentText, type);
+                case SyntaxKind.ESSymbolType:
+                    return write("symbol()");
                 case SyntaxKind.ExpressionWithTypeArguments:
                     return emitExpressionWithTypeArguments(<ExpressionWithTypeArguments>type);
                 case SyntaxKind.TypeReference:
@@ -460,19 +462,6 @@ namespace ts {
                     return emitTypePredicate(<TypePredicateNode>type);
             }
 
-            function writeEntityName(entityName: EntityName | Expression) {
-                if (entityName.kind === SyntaxKind.Identifier) {
-                    writeTextOfNode(currentText, entityName);
-                }
-                else {
-                    const left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
-                    const right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
-                    writeEntityName(left);
-                    write(".");
-                    writeTextOfNode(currentText, right);
-                }
-            }
-
             function emitEntityName(entityName: EntityNameOrEntityNameExpression) {
                 const visibilityResult = resolver.isEntityNameVisible(entityName,
                     // Aliases can be written asynchronously so use correct enclosing declaration
@@ -592,6 +581,19 @@ namespace ts {
             }
         }
 
+        function writeEntityName(entityName: EntityName | Expression) {
+            if (entityName.kind === SyntaxKind.Identifier) {
+                writeTextOfNode(currentText, entityName);
+            }
+            else {
+                const left = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).left : (<PropertyAccessExpression>entityName).expression;
+                const right = entityName.kind === SyntaxKind.QualifiedName ? (<QualifiedName>entityName).right : (<PropertyAccessExpression>entityName).name;
+                writeEntityName(left);
+                write(".");
+                writeTextOfNode(currentText, right);
+            }
+        }
+
         function emitSourceFile(node: SourceFile) {
             currentText = node.text;
             currentLineMap = getLineStarts(node);
@@ -1227,7 +1229,7 @@ namespace ts {
         }
 
         function emitPropertyDeclaration(node: Declaration) {
-            if (hasDynamicName(node)) {
+            if (hasDynamicName(node) && !resolver.isLiteralDynamicName(<ComputedPropertyName>getNameOfDeclaration(node))) {
                 return;
             }
 
@@ -1246,10 +1248,17 @@ namespace ts {
                     emitBindingPattern(<BindingPattern>node.name);
                 }
                 else {
-                    // If this node is a computed name, it can only be a symbol, because we've already skipped
-                    // it if it's not a well known symbol. In that case, the text of the name will be exactly
-                    // what we want, namely the name expression enclosed in brackets.
-                    writeTextOfNode(currentText, node.name);
+                    if (isDynamicName(node.name)) {
+                        // If this node has a dynamic name, it can only be an identifier or property access because
+                        // we've already skipped it otherwise.
+                        emitDynamicName(<EntityNameExpression>(<ComputedPropertyName>node.name).expression);
+                    }
+                    else {
+                        // If this node is a computed name, it can only be a symbol, because we've already skipped
+                        // it if it's not a well known symbol. In that case, the text of the name will be exactly
+                        // what we want, namely the name expression enclosed in brackets.
+                        writeTextOfNode(currentText, node.name);
+                    }
                     // If optional property emit ? but in the case of parameterProperty declaration with "?" indicating optional parameter for the constructor
                     // we don't want to emit property declaration with "?"
                     if ((node.kind === SyntaxKind.PropertyDeclaration || node.kind === SyntaxKind.PropertySignature ||
@@ -1314,6 +1323,14 @@ namespace ts {
                 } : undefined;
             }
 
+            function emitDynamicName(entityName: EntityNameExpression) {
+                writer.getSymbolAccessibilityDiagnostic = getVariableDeclarationTypeVisibilityError;
+                const visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration);
+                handleSymbolAccessibilityError(visibilityResult);
+                recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName));
+                writeTextOfNode(currentText, node.name);
+            }
+
             function emitBindingPattern(bindingPattern: BindingPattern) {
                 // Only select non-omitted expression from the bindingPattern's elements.
                 // We have to do this to avoid emitting trailing commas.

src/compiler/diagnosticMessages.json

@@ -491,23 +491,23 @@
         "category": "Error",
         "code": 1164
     },
-    "A computed property name in an ambient context must directly refer to a built-in symbol.": {
+    "A computed property name in an ambient context must refer to an expression whose type is a literal type or a unique 'symbol()' type.": {
         "category": "Error",
         "code": 1165
     },
-    "A computed property name in a class property declaration must directly refer to a built-in symbol.": {
+    "A computed property name in a class property declaration must refer to an expression whose type is a literal type or a unique 'symbol()' type.": {
         "category": "Error",
         "code": 1166
     },
-    "A computed property name in a method overload must directly refer to a built-in symbol.": {
+    "A computed property name in a method overload must refer to an expression whose type is a literal type or a unique 'symbol()' type.": {
         "category": "Error",
         "code": 1168
     },
-    "A computed property name in an interface must directly refer to a built-in symbol.": {
+    "A computed property name in an interface must refer to an expression whose type is a literal type or a unique 'symbol()' type.": {
         "category": "Error",
         "code": 1169
     },
-    "A computed property name in a type literal must directly refer to a built-in symbol.": {
+    "A computed property name in a type literal must refer to an expression whose type is a literal type or a unique 'symbol()' type.": {
         "category": "Error",
         "code": 1170
     },
@@ -907,6 +907,50 @@
         "category": "Error",
         "code": 1328
     },
+    "Unique 'symbol()' types are not allowed in a union type.": {
+        "category": "Error",
+        "code": 1329
+    },
+    "Unique 'symbol()' types are not allowed in an intersection type.": {
+        "category": "Error",
+        "code": 1330
+    },
+    "Unique 'symbol()' types are not allowed in an array type.": {
+        "category": "Error",
+        "code": 1331
+    },
+    "Unique 'symbol()' types are not allowed in a tuple type.": {
+        "category": "Error",
+        "code": 1332
+    },
+    "Unique 'symbol()' types are not allowed in a mapped type.": {
+        "category": "Error",
+        "code": 1333
+    },
+    "A property of an interface or type literal whose type is a unique 'symbol()' type must be 'readonly'.": {
+        "category": "Error",
+        "code": 1334
+    },
+    "A property of a class whose type is a unique 'symbol()' type must be both 'static' and 'readonly'.": {
+        "category": "Error",
+        "code": 1335
+    },
+    "A variable whose type is a unique 'symbol()' type must be 'const'.": {
+        "category": "Error",
+        "code": 1336
+    },
+    "Unique 'symbol()' types may not be used on a variable declaration with a binding name.": {
+        "category": "Error",
+        "code": 1337
+    },
+    "Unique 'symbol()' types are only allowed on variables in a variable statement.": {
+        "category": "Error",
+        "code": 1338
+    },
+    "Unique 'symbol()' types are not allowed here.": {
+        "category": "Error",
+        "code": 1339
+    },
 
     "Duplicate identifier '{0}'.": {
         "category": "Error",
@@ -2216,6 +2260,14 @@
         "category": "Error",
         "code": 2714
     },
+    "Subsequent property declarations must have the same type.  Property '{0}' must be of type '{1}', but here has type '{2}'.": {
+        "category": "Error",
+        "code": 2715
+    },
+    "Duplicate declaration '{0}'.": {
+        "category": "Error",
+        "code": 2716
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/emitter.ts

@@ -574,6 +574,8 @@ namespace ts {
                     return emitMappedType(<MappedTypeNode>node);
                 case SyntaxKind.LiteralType:
                     return emitLiteralType(<LiteralTypeNode>node);
+                case SyntaxKind.ESSymbolType:
+                    return write("symbol()");
 
                 // Binding patterns
                 case SyntaxKind.ObjectBindingPattern:

src/compiler/factory.ts

@@ -785,6 +785,10 @@ namespace ts {
             : node;
     }
 
+    export function createESSymbolTypeNode() {
+        return <ESSymbolTypeNode>createSynthesizedNode(SyntaxKind.ESSymbolType);
+    }
+
     // Binding Patterns
 
     export function createObjectBindingPattern(elements: ReadonlyArray<BindingElement>) {

src/compiler/parser.ts

@@ -2609,6 +2609,19 @@ namespace ts {
             return token() === SyntaxKind.DotToken ? undefined : node;
         }
 
+        function parseSymbolType(): TypeNode | undefined {
+            const fullStart = scanner.getStartPos();
+            parseExpected(SyntaxKind.SymbolKeyword);
+            if (token() === SyntaxKind.DotToken) return undefined;
+            if (parseOptional(SyntaxKind.OpenParenToken)) {
+                parseExpected(SyntaxKind.CloseParenToken);
+                return finishNode(<ESSymbolTypeNode>createNode(SyntaxKind.ESSymbolType, fullStart));
+            }
+            else {
+                return finishNode(<TypeNode>createNode(SyntaxKind.SymbolKeyword, fullStart));
+            }
+        }
+
         function parseLiteralTypeNode(negative?: boolean): LiteralTypeNode {
             const node = createNode(SyntaxKind.LiteralType) as LiteralTypeNode;
             let unaryMinusExpression: PrefixUnaryExpression;
@@ -2639,12 +2652,13 @@ namespace ts {
                 case SyntaxKind.StringKeyword:
                 case SyntaxKind.NumberKeyword:
                 case SyntaxKind.BooleanKeyword:
-                case SyntaxKind.SymbolKeyword:
                 case SyntaxKind.UndefinedKeyword:
                 case SyntaxKind.NeverKeyword:
                 case SyntaxKind.ObjectKeyword:
                     // If these are followed by a dot, then parse these out as a dotted type reference instead.
                     return tryParse(parseKeywordAndNoDot) || parseTypeReference();
+                case SyntaxKind.SymbolKeyword:
+                    return tryParse(parseSymbolType) || parseTypeReference();
                 case SyntaxKind.AsteriskToken:
                     return parseJSDocAllType();
                 case SyntaxKind.QuestionToken: