Transform call expressions on private names to properly bind this

Signed-off-by: Joseph Watts <jwatts43@bloomberg.net>

Author: Joseph Watts

src/compiler/transformers/esnext.ts

@@ -165,6 +165,8 @@ namespace ts {
                     return visitVariableStatement(node as VariableStatement);
                 case SyntaxKind.ComputedPropertyName:
                     return visitComputedPropertyName(node as ComputedPropertyName);
+                case SyntaxKind.CallExpression:
+                    return visitCallExpression(node as CallExpression);
                 default:
                     return visitEachChild(node, visitor, context);
             }
@@ -606,6 +608,40 @@ namespace ts {
             return visitEachChild(node, visitor, context);
         }
 
+        function visitCallExpression(node: CallExpression) {
+            if (isPrivateNamedPropertyAccess(node.expression)) {
+                // Transform call expressions of private names to properly bind the `this` parameter.
+                let exprForPropertyAccess: Expression = node.expression.expression;
+                let receiver = node.expression.expression;
+                if (!isSimpleInlineableExpression(node.expression.expression)) {
+                    const generatedName = getGeneratedNameForNode(node);
+                    hoistVariableDeclaration(generatedName);
+                    exprForPropertyAccess = setOriginalNode(
+                        createAssignment(generatedName, exprForPropertyAccess),
+                        node.expression.expression
+                    );
+                    receiver = generatedName;
+                }
+                return visitNode(
+                    updateCall(
+                        node,
+                        createPropertyAccess(
+                            updatePropertyAccess(
+                                node.expression,
+                                exprForPropertyAccess,
+                                node.expression.name
+                            ),
+                            "call"
+                        ),
+                        /*typeArguments*/ undefined,
+                        [receiver, ...node.arguments]
+                    ),
+                    visitor
+                );
+            }
+            return visitEachChild(node, visitor, context);
+        }
+
         function enableSubstitutionForClassAliases() {
             if ((enabledSubstitutions & ESNextSubstitutionFlags.ClassAliases) === 0) {
                 enabledSubstitutions |= ESNextSubstitutionFlags.ClassAliases;