remove hacks

Author: mheiber

src/compiler/checker.ts

@@ -13758,7 +13758,7 @@ namespace ts {
                 (<PropertyAccessExpression>parent).name.escapedText === "length" || (
                     parent.parent.kind === SyntaxKind.CallExpression
                     && isIdentifier((parent as PropertyAccessExpression).name)
-                    && isPushOrUnshiftIdentifier((parent as PropertyAccessExpression).name as Identifier)));
+                    && isPushOrUnshiftIdentifier((parent as PropertyAccessExpression).name)));
             const isElementAssignment = parent.kind === SyntaxKind.ElementAccessExpression &&
                 (<ElementAccessExpression>parent).expression === root &&
                 parent.parent.kind === SyntaxKind.BinaryExpression &&

src/compiler/utilities.ts

@@ -768,8 +768,15 @@ namespace ts {
             case SyntaxKind.QualifiedName:
                 return entityNameToString(name.left) + "." + entityNameToString(name.right);
             case SyntaxKind.PropertyAccessExpression:
-                // TODO: PrivateName fix
-                return entityNameToString(name.expression) + "." + entityNameToString(name.name as Identifier);
+                if (isIdentifier(name.name)) {
+                    return entityNameToString(name.expression) + "." + entityNameToString(name.name);
+                }
+                else if (isPrivateName(name.name)) {
+                    return getTextOfNode(name);
+                }
+                else {
+                    throw Debug.assertNever(name.name);
+                }
             default:
                 throw Debug.assertNever(name);
         }
@@ -1849,7 +1856,6 @@ namespace ts {
                 (initializer.expression.escapedText === "window" as __String ||
                     initializer.expression.escapedText === "self" as __String ||
                     initializer.expression.escapedText === "global" as __String)) &&
-                // TODO: PrivateName fix
                 isSameEntityName(name, initializer.name as Identifier);
         }
         if (isPropertyAccessExpression(name) && isPropertyAccessExpression(initializer)) {
@@ -2640,8 +2646,8 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier && (<Identifier>node).escapedText === "Symbol";
     }
 
-    export function isPushOrUnshiftIdentifier(node: Identifier) {
-        return node.escapedText === "push" || node.escapedText === "unshift";
+    export function isPushOrUnshiftIdentifier(node: Identifier | PrivateName) {
+        return isIdentifier(node) && node.escapedText === "push" || node.escapedText === "unshift";
     }
 
     export function isParameterDeclaration(node: VariableLikeDeclaration) {
@@ -3276,7 +3282,7 @@ namespace ts {
     }
 
     export function isThisIdentifier(node: Node | undefined): boolean {
-        return !!node && node.kind === SyntaxKind.Identifier && identifierIsThisKeyword(node as Identifier);
+        return !!node && isIdentifier(node) && identifierIsThisKeyword(node);
     }
 
     export function identifierIsThisKeyword(id: Identifier): boolean {
@@ -4814,7 +4820,7 @@ namespace ts {
      * attempt to draw the name from the node the declaration is on (as that declaration is what its' symbol
      * will be merged with)
      */
-    function nameForNamelessJSDocTypedef(declaration: JSDocTypedefTag): Identifier | undefined {
+    function nameForNamelessJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateName | undefined {
         const hostNode = declaration.parent.parent;
         if (!hostNode) {
             return undefined;
@@ -4834,8 +4840,7 @@ namespace ts {
                 const expr = hostNode.expression;
                 switch (expr.kind) {
                     case SyntaxKind.PropertyAccessExpression:
-                        // TODO: PrivateName fix
-                        return (expr as PropertyAccessExpression).name as Identifier;
+                        return (expr as PropertyAccessExpression).name;
                     case SyntaxKind.ElementAccessExpression:
                         const arg = (expr as ElementAccessExpression).argumentExpression;
                         if (isIdentifier(arg)) {

src/services/codefixes/convertToEs6Module.ts

@@ -65,10 +65,9 @@ namespace ts.codefix {
     function collectExportRenames(sourceFile: SourceFile, checker: TypeChecker, identifiers: Identifiers): ExportRenames {
         const res = createMap<string>();
         forEachExportReference(sourceFile, node => {
-            const name = node.name as Identifier;
-            const { text, originalKeywordKind } = name;
+            const { text, originalKeywordKind } = node.name;
             if (!res.has(text) && (originalKeywordKind !== undefined && isNonContextualKeyword(originalKeywordKind)
-                || checker.resolveName(name.text, node, SymbolFlags.Value, /*excludeGlobals*/ true))) {
+                || checker.resolveName(node.name.text, node, SymbolFlags.Value, /*excludeGlobals*/ true))) {
                 // Unconditionally add an underscore in case `text` is a keyword.
                 res.set(text, makeUniqueName(`_${text}`, identifiers));
             }
@@ -81,7 +80,7 @@ namespace ts.codefix {
             if (isAssignmentLhs) {
                 return;
             }
-            const { text } = node.name as Identifier;
+            const { text } = node.name;
             changes.replaceNode(sourceFile, node, createIdentifier(exports.get(text) || text));
         });
     }
@@ -151,7 +150,7 @@ namespace ts.codefix {
                 }
                 else if (isPropertyAccessExpression(initializer) && isRequireCall(initializer.expression, /*checkArgumentIsStringLiteralLike*/ true)) {
                     foundImport = true;
-                    return convertPropertyAccessImport(name, (initializer.name as Identifier).text, initializer.expression.arguments[0], identifiers, quotePreference);
+                    return convertPropertyAccessImport(name, initializer.name.text, initializer.expression.arguments[0], identifiers, quotePreference);
                 }
             }
             // Move it out to its own variable statement. (This will not be used if `!foundImport`)
@@ -252,7 +251,7 @@ namespace ts.codefix {
         exports: ExportRenames,
     ): void {
         // If "originalKeywordKind" was set, this is e.g. `exports.
-        const { text } = assignment.left.name as Identifier;
+        const { text } = assignment.left.name;
         const rename = exports.get(text);
         if (rename !== undefined) {
             /*
@@ -290,7 +289,7 @@ namespace ts.codefix {
     }
 
     function convertExportsPropertyAssignment({ left, right, parent }: BinaryExpression & { left: PropertyAccessExpression }, sourceFile: SourceFile, changes: textChanges.ChangeTracker): void {
-        const name = (left.name as Identifier).text;
+        const name = left.name.text;
         if ((isFunctionExpression(right) || isArrowFunction(right) || isClassExpression(right)) && (!right.name || right.name.text === name)) {
             // `exports.f = function() {}` -> `export function f() {}` -- Replace `exports.f = ` with `export `, and insert the name after `function`.
             changes.replaceRange(sourceFile, { pos: left.getStart(sourceFile), end: right.getStart(sourceFile) }, createToken(SyntaxKind.ExportKeyword), { suffix: " " });
@@ -399,9 +398,7 @@ namespace ts.codefix {
 
             const { parent } = use;
             if (isPropertyAccessExpression(parent)) {
-                const { expression, name } = parent;
-                // TODO: PrivateName fix
-                const { text: propertyName } = name as Identifier;
+                const { expression, name: { text: propertyName } } = parent;
                 Debug.assert(expression === use); // Else shouldn't have been in `collectIdentifiers`
                 let idName = namedBindingsNames.get(propertyName);
                 if (idName === undefined) {

src/services/refactors/moveToNewFile.ts

@@ -665,7 +665,7 @@ namespace ts.refactor {
     }
 
     function nameOfTopLevelDeclaration(d: TopLevelDeclaration): Identifier | undefined {
-        return d.kind === SyntaxKind.ExpressionStatement ? d.expression.left.name as Identifier : tryCast(d.name, isIdentifier);
+        return d.kind === SyntaxKind.ExpressionStatement ? d.expression.left.name : tryCast(d.name, isIdentifier);
     }
 
     function getTopLevelDeclarationStatement(d: TopLevelDeclaration): TopLevelDeclarationStatement {