diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index 498f65ad366..700102a7069 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -2565,7 +2565,7 @@ namespace ts {
                 // Node names generate unique names based on their original node
                 // and are cached based on that node's id.
                 const node = getNodeForGeneratedName(name);
-                return generateNameCached(node, getTextOfNode);
+                return generateNameCached(node);
             }
             else {
                 // Auto, Loop, and Unique names are cached based on their unique
@@ -2575,9 +2575,9 @@ namespace ts {
             }
         }
 
-        function generateNameCached(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+        function generateNameCached(node: Node) {
             const nodeId = getNodeId(node);
-            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node, getTextOfNode)));
+            return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = unescapeIdentifier(generateNameForNode(node)));
         }
 
         /**
@@ -2659,7 +2659,7 @@ namespace ts {
         /**
          * Generates a unique name for a ModuleDeclaration or EnumDeclaration.
          */
-        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+        function generateNameForModuleOrEnum(node: ModuleDeclaration | EnumDeclaration) {
             const name = getTextOfNode(node.name);
             // Use module/enum name itself if it is unique, otherwise make a unique variation
             return isUniqueLocalName(name, node) ? name : makeUniqueName(name);
@@ -2689,9 +2689,9 @@ namespace ts {
             return makeUniqueName("class");
         }
 
-        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration, getTextOfNode: (node: Node, includeTrivia?: boolean) => string) {
+        function generateNameForMethodOrAccessor(node: MethodDeclaration | AccessorDeclaration) {
             if (isIdentifier(node.name)) {
-                return generateNameCached(node.name, getTextOfNode);
+                return generateNameCached(node.name);
             }
             return makeTempVariableName(TempFlags.Auto);
         }
@@ -2699,13 +2699,13 @@ namespace ts {
         /**
          * Generates a unique name from a node.
          */
-        function generateNameForNode(node: Node, getTextOfNode: (node: Node, includeTrivia?: boolean) => string): string {
+        function generateNameForNode(node: Node): string {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                     return makeUniqueName(getTextOfNode(node));
                 case SyntaxKind.ModuleDeclaration:
                 case SyntaxKind.EnumDeclaration:
-                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node, getTextOfNode);
+                    return generateNameForModuleOrEnum(<ModuleDeclaration | EnumDeclaration>node);
                 case SyntaxKind.ImportDeclaration:
                 case SyntaxKind.ExportDeclaration:
                     return generateNameForImportOrExportDeclaration(<ImportDeclaration | ExportDeclaration>node);
@@ -2718,7 +2718,7 @@ namespace ts {
                 case SyntaxKind.MethodDeclaration:
                 case SyntaxKind.GetAccessor:
                 case SyntaxKind.SetAccessor:
-                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node, getTextOfNode);
+                    return generateNameForMethodOrAccessor(<MethodDeclaration | AccessorDeclaration>node);
                 default:
                     return makeTempVariableName(TempFlags.Auto);
             }
@@ -2734,7 +2734,7 @@ namespace ts {
                 case GeneratedIdentifierKind.Loop:
                     return makeTempVariableName(TempFlags._i);
                 case GeneratedIdentifierKind.Unique:
-                    return makeUniqueName(name.text);
+                    return makeUniqueName(unescapeIdentifier(name.text));
             }
 
             Debug.fail("Unsupported GeneratedIdentifierKind.");
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index ec1e0dafb79..d5f3d920436 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -108,7 +108,7 @@ namespace ts {
 
     export function createIdentifier(text: string): Identifier {
         const node = <Identifier>createSynthesizedNode(SyntaxKind.Identifier);
-        node.text = text ? escapeIdentifier(text) : undefined;
+        node.text = escapeIdentifier(text);
         node.originalKeywordKind = text ? stringToToken(text) : SyntaxKind.Unknown;
         node.autoGenerateKind = GeneratedIdentifierKind.None;
         node.autoGenerateId = 0;
@@ -140,8 +140,7 @@ namespace ts {
 
     /** Create a unique name based on the supplied text. */
     export function createUniqueName(text: string): Identifier {
-        const name = createIdentifier("");
-        name.text = text;
+        const name = createIdentifier(text);
         name.autoGenerateKind = GeneratedIdentifierKind.Unique;
         name.autoGenerateId = nextAutoGenerateId;
         nextAutoGenerateId++;
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index 6d0c9b3c5fa..e0fd435a90d 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -2251,7 +2251,7 @@ namespace ts {
             // we don't want to emit a temporary variable for the RHS, just use it directly.
             const counter = createLoopVariable();
             const rhsReference = expression.kind === SyntaxKind.Identifier
-                ? createUniqueName((<Identifier>expression).text)
+                ? createUniqueName(unescapeIdentifier((<Identifier>expression).text))
                 : createTempVariable(/*recordTempVariable*/ undefined);
             const elementAccess = createElementAccess(rhsReference, counter);
 
@@ -2872,7 +2872,7 @@ namespace ts {
             else {
                 loopParameters.push(createParameter(/*decorators*/ undefined, /*modifiers*/ undefined, /*dotDotDotToken*/ undefined, name));
                 if (resolver.getNodeCheckFlags(decl) & NodeCheckFlags.NeedsLoopOutParameter) {
-                    const outParamName = createUniqueName("out_" + name.text);
+                    const outParamName = createUniqueName("out_" + unescapeIdentifier(name.text));
                     loopOutParameters.push({ originalName: name, outParamName });
                 }
             }
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index b18ab67381e..4ef3bd5c067 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -3119,7 +3119,7 @@ namespace ts {
         function getClassAliasIfNeeded(node: ClassDeclaration) {
             if (resolver.getNodeCheckFlags(node) & NodeCheckFlags.ClassWithConstructorReference) {
                 enableSubstitutionForClassAliases();
-                const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? node.name.text : "default");
+                const classAlias = createUniqueName(node.name && !isGeneratedIdentifier(node.name) ? unescapeIdentifier(node.name.text) : "default");
                 classAliases[getOriginalNodeId(node)] = classAlias;
                 hoistVariableDeclaration(classAlias);
                 return classAlias;