Check function body for the unique name

Author: agentcooper

src/compiler/transformers/es2015.ts

@@ -424,7 +424,7 @@ namespace ts {
                     return visitFunctionDeclaration(node as FunctionDeclaration);
 
                 case SyntaxKind.ArrowFunction:
-                    let name: string | undefined = undefined;
+                    let name: string | undefined;
                     if (node.parent && isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) {
                         name = `${node.parent.name.escapedText}`;
                     }
@@ -1786,7 +1786,7 @@ namespace ts {
             const func = factory.createFunctionExpression(
                 /*modifiers*/ undefined,
                 /*asteriskToken*/ undefined,
-                /*name*/ name,
+                /*name*/ name ? createNonCollidingName(name, node) : undefined,
                 /*typeParameters*/ undefined,
                 visitParameterList(node.parameters, visitor, context),
                 /*type*/ undefined,
@@ -4421,4 +4421,40 @@ namespace ts {
             return isIdentifier(expression) && expression.escapedText === "arguments";
         }
     }
+
+    function forEachFreeIdentifier(node: Node, cb: (id: Identifier) => void): void {
+        if (isIdentifier(node) && isFreeIdentifier(node)) cb(node);
+        forEachChild(node, child => forEachFreeIdentifier(child, cb));
+    }
+
+    function isFreeIdentifier(node: Identifier): boolean {
+        const { parent } = node;
+        switch (parent.kind) {
+            case SyntaxKind.PropertyAccessExpression:
+                return (parent as PropertyAccessExpression).name !== node;
+            case SyntaxKind.BindingElement:
+                return (parent as BindingElement).propertyName !== node;
+            case SyntaxKind.ImportSpecifier:
+                return (parent as ImportSpecifier).propertyName !== node;
+            default:
+                return true;
+        }
+    }
+
+    function createNonCollidingName(name: string, node: Node): string {
+        const identifiers = new Set<string>()
+        forEachFreeIdentifier(node, (identifier) => {
+            identifiers.add(`${identifier.escapedText}`)
+        })
+
+        return createUniqueName(name, 0, identifiers)
+    }
+
+    function createUniqueName(name: string, counter: number, existingNames: Set<string>): string {
+        const fullName = counter === 0 ? name : `${name}_${counter}`
+        if (!existingNames.has(fullName)) {
+            return fullName
+        }
+        return createUniqueName(name, counter + 1, existingNames)
+    }
 }

tests/baselines/reference/declFileTypeofFunction.js

@@ -47,7 +47,7 @@ var foo2 = foo;
 var foo3 = function () {
     return foo3;
 };
-var x = function x() {
+var x = function x_1() {
     return x;
 };
 function foo5(x) {

tests/baselines/reference/functionExpressionContextualTyping1.js

@@ -76,7 +76,7 @@ var Class = /** @class */ (function () {
     Class.prototype.foo = function () { };
     return Class;
 }());
-var a1 = function a1(a1) {
+var a1 = function a1_1(a1) {
     a1.foo();
     return 1;
 };
@@ -112,7 +112,7 @@ b6 = function (i) {
 b7 = function (j, m) { }; // Per spec, no contextual signature can be extracted in this case. (Otherwise clause)
 var C = /** @class */ (function () {
     function C() {
-        var k = function k(j, k) {
+        var k = function k_1(j, k) {
             return [j, k];
         }; // Per spec, no contextual signature can be extracted in this case.
     }

tests/baselines/reference/implicitAnyFromCircularInference.js

@@ -65,7 +65,7 @@ var f1 = function () {
     return f1();
 };
 // Error expected
-var f2 = function f2() { return f2(); };
+var f2 = function f2_1() { return f2(); };
 // Error expected
 function h() {
     return foo();

tests/baselines/reference/templateStringInArrowFunction.js

@@ -2,4 +2,4 @@
 var x = x => `abc${ x }def`;
 
 //// [templateStringInArrowFunction.js]
-var x = function x(x) { return "abc" + x + "def"; };
+var x = function x_1(x) { return "abc" + x + "def"; };