Transform property access for private named instance fields

Author: Joseph Watts

src/compiler/binder.ts

@@ -3833,6 +3833,11 @@ namespace ts {
             case SyntaxKind.BreakStatement:
                 transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion;
                 break;
+
+            case SyntaxKind.PrivateName:
+                // Private names are ESNext syntax.
+                transformFlags |= TransformFlags.AssertESNext;
+                break;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;

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.PropertyAccessExpression:
+                    return visitPropertyAccessExpression(node as PropertyAccessExpression);
                 default:
                     return visitEachChild(node, visitor, context);
             }
@@ -573,6 +575,19 @@ namespace ts {
             return undefined;
         }
 
+        function visitPropertyAccessExpression(node: PropertyAccessExpression) {
+            if (isPrivateName(node.name)) {
+                const privateNameInfo = accessPrivateName(node.name);
+                if (privateNameInfo) {
+                    switch (privateNameInfo.type) {
+                        case PrivateNameType.InstanceField:
+                            return createClassPrivateFieldGetHelper(context, node.expression, privateNameInfo.weakMapName);
+                    }
+                }
+            }
+            return node;
+        }
+
         function enableSubstitutionForClassAliases() {
             if ((enabledSubstitutions & ESNextSubstitutionFlags.ClassAliases) === 0) {
                 enabledSubstitutions |= ESNextSubstitutionFlags.ClassAliases;
@@ -1573,4 +1588,15 @@ namespace ts {
             location
         );
     }
+
+    const classPrivateFieldGetHelper: EmitHelper = {
+        name: "typescript:classPrivateFieldGet",
+        scoped: false,
+        text: `var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };`
+    };
+
+    function createClassPrivateFieldGetHelper(context: TransformationContext, receiver: Expression, privateField: Identifier) {
+        context.requestEmitHelper(classPrivateFieldGetHelper);
+        return createCall(getHelperName("_classPrivateFieldGet"), /* typeArguments */ undefined, [receiver, privateField]);
+    }
 }