Transform private-named methods

Signed-off-by: Max Heiber <[email protected]>

Author: mheiber

src/compiler/transformers/esnext.ts

@@ -383,20 +383,18 @@ namespace ts {
 
             pendingExpressions = pendingExpressions || [];
             last(privateNameEnvironmentStack).forEach(entry => {
-                const { placement } = entry;
-                switch (placement) {
+                switch (entry.placement) {
                     case PrivateNamePlacement.InstanceField:
                         break;
                     case PrivateNamePlacement.InstanceMethod:
-                        entry = entry as PrivateNamedInstanceMethod;
-                        const func = privateNamedMethodToFunction(entry.origFunc, entry.funcName, entry.accumulator);
+                        const func = privateNamedMethodToFunction(entry.origFunc, entry.funcName);
                         (pendingExpressions = pendingExpressions || []).push(createAssignment(
                             entry.funcName,
                             func
                         ));
                         break;
                     default:
-                        Debug.assertNever(placement, "unexpected Private Name Placement");
+                        Debug.assertNever(entry, "unexpected private name placement");
                 }
             });
             const members: ClassElement[] = [];
@@ -616,29 +614,16 @@ namespace ts {
             privateNameEnvironmentStack.pop();
         }
 
-        function privateNamedMethodToFunction (declaration: MethodDeclaration, funcName: Identifier, accumulator: Identifier): FunctionExpression {
+        function privateNamedMethodToFunction (declaration: MethodDeclaration, funcName: Identifier): FunctionExpression {
             const params = declaration.parameters;
-            let body = getMutableClone(declaration.body || createBlock([], true));
-            body = visitEachChild(body, visitor, context);
-            const toPrepend = startOnNewLine(
-                createStatement(
-                    createClassPrivateNamedCallCheckHelper(context, accumulator)
-                )
-            );
-            body.statements = setTextRange(
-                createNodeArray([
-                    toPrepend,
-                    ...body.statements
-                ]),
-                body.statements
-            );
+            const body = visitEachChild(declaration.body, visitor, context) || createBlock([], /* multiLine */ true);
             const func = createFunctionExpression(
-                /* modifiers */       undefined,
-                /* asteriskToken */   undefined,
-                                      funcName,
-                /* typeParameters */  undefined,
-                                      params,
-                /* type */            undefined,
+                /* modifiers     */ undefined,
+                /* asteriskToken */ undefined,
+                                    funcName,
+                /* typeParameters*/ undefined,
+                                    params,
+                /* type          */ undefined,
                 body);
             return func;
         }
@@ -647,21 +632,22 @@ namespace ts {
         function addPrivateName(element: ClassElement & { name: PrivateName }) {
             const env = last(privateNameEnvironmentStack);
             const text = getTextOfPropertyName(element.name) as string;
-            const accumulator = createUniqueName(`_${text.substring(1)}`);
             const { escapedText } = element.name;
-            hoistVariableDeclaration(accumulator);
 
             let identifierName: string;
+            let accumulator: Identifier;
             if (hasModifier(element, ModifierFlags.Static)) {
                 // statics not supported yet
                 return;
             }
             if (isPropertyDeclaration(element)) {
                 identifierName = "WeakMap";
+                accumulator = createUniqueName(`_${text.slice(1)}WeakMap`);
                 env.set(escapedText, { placement: PrivateNamePlacement.InstanceField, accumulator });
             }
             else if (isMethodDeclaration(element)) {
                 identifierName = "WeakSet";
+                accumulator = createUniqueName(`_${text.slice(1)}WeakSet`);
                 const escapedText = element.name.escapedText;
                 const escapedTextNoHash = `_${`${escapedText}`.slice(1)}`;
                 const funcName: Identifier = createUniqueName(escapedTextNoHash);
@@ -671,6 +657,7 @@ namespace ts {
             else {
                 return;
             }
+            hoistVariableDeclaration(accumulator);
             (pendingExpressions = pendingExpressions || []).push(
                 createAssignment(
                     accumulator,
@@ -696,18 +683,36 @@ namespace ts {
         function visitPropertyAccessExpression(node: PropertyAccessExpression) {
             if (isPrivateName(node.name)) {
                 const privateNameInfo = accessPrivateName(node.name);
-                if (privateNameInfo && privateNameInfo.placement === PrivateNamePlacement.InstanceField) {
-                    return setOriginalNode(
-                        setTextRange(
-                            createClassPrivateFieldGetHelper(
-                                context,
-                                visitNode(node.expression, visitor, isExpression), 
-                                privateNameInfo.accumulator
+                if (!privateNameInfo) {
+                    return visitEachChild(node, visitor, context);
+                }
+                switch (privateNameInfo.placement) {
+                    case PrivateNamePlacement.InstanceField:
+                        return setOriginalNode(
+                            setTextRange(
+                                createClassPrivateFieldGetHelper(
+                                    context,
+                                    visitNode(node.expression, visitor, isExpression),
+                                    privateNameInfo.accumulator
+                                ),
+                                node
                             ),
                             node
-                        ),
-                        node
-                    );
+                        );
+                    case PrivateNamePlacement.InstanceMethod:
+                        return setOriginalNode(
+                            setTextRange(
+                                createClassPrivateNamedMethodGetHelper(
+                                    context,
+                                    privateNameInfo.accumulator,
+                                    privateNameInfo.funcName
+                                ),
+                                node
+                            ),
+                            node
+                        );
+                    default:
+                        Debug.assertNever(privateNameInfo, "Unexpected private name placement");
                 }
             }
             return visitEachChild(node, visitor, context);
@@ -804,13 +809,18 @@ namespace ts {
                         setTextRange(
                             createCall(
                                 createPropertyAccess(
-                                    privateNameEntry.funcName,
+                                    createClassPrivateNamedMethodGetHelper(
+                                        context,
+                                        privateNameEntry.accumulator,
+                                        privateNameEntry.funcName
+                                    ),
                                     "call"
                                 ),
-                                /*typeArguments*/ undefined,
-                                [createThis(), ...node.arguments]
+                                /* typeArguments */ undefined,
+                                // node.arguments
+                                concatenate([createThis()], node.arguments)
                             ),
-                            /* location */ node
+            /* location */ node
                         ),
                         node
                     );
@@ -1985,15 +1995,18 @@ namespace ts {
         context.requestEmitHelper(classPrivateFieldSetHelper);
         return createCall(getHelperName("_classPrivateFieldSet"), /* typeArguments */ undefined, [receiver, privateField, value]);
     }
-    const classPrivateNamedCallCheckHelper: EmitHelper = {
-        name: "typescript:classPrivateNamedCallCheck",
+
+    const classPrivateNamedMethodGet: EmitHelper = {
+        name: "typescript:classPrivateNamedMethodGet",
         scoped: false,
-        text: `var _classPrivateNamedCallCheck = function (receiver, privateSet) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get weak field on non-instance"); }};`
+        text: `function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }`
     };
 
-    function createClassPrivateNamedCallCheckHelper(context: TransformationContext, weakSet: Identifier) {
-        context.requestEmitHelper(classPrivateNamedCallCheckHelper);
-        return createCall(getHelperName("_classPrivateNamedCallCheck"), /* typeArguments */ undefined, [ createThis(), weakSet ]);
+    function createClassPrivateNamedMethodGetHelper(context: TransformationContext, weakSet: Identifier, name: Identifier) {
+
+        context.requestEmitHelper(classPrivateNamedMethodGet);
+        return createCall(getHelperName("_classPrivateNamedMethodGet"), /* typeArguments */ undefined,
+                    [ createThis(), weakSet, name ]);
     }
 
 }

tests/baselines/reference/privateNamedMemberOrder.js

@@ -9,17 +9,16 @@ class A {
 
 //// [privateNamedMemberOrder.js]
 var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };
-var _classPrivateNamedCallCheck = function (receiver, privateSet) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get weak field on non-instance"); }};
-var _foo_1, _bar_1, _bar_2;
+function _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+var _fooWeakMap_1, _bar_1, _barWeakSet_1;
 var A = /** @class */ (function () {
     function A() {
-        _bar_1.add(this);
-        _foo_1.set(this, void 0);
-        this.baz = _bar_2.call(this);
+        _barWeakSet_1.add(this);
+        _fooWeakMap_1.set(this, void 0);
+        this.baz = _classPrivateNamedMethodGet(this, _barWeakSet_1, _bar_1).call(this);
     }
     return A;
 }());
-_foo_1 = new WeakMap(), _bar_1 = new WeakSet(), _bar_2 = function _bar_2() {
-    _classPrivateNamedCallCheck(this, _bar_1);
-    return _classPrivateFieldGet(this, _foo_1);
+_fooWeakMap_1 = new WeakMap(), _barWeakSet_1 = new WeakSet(), _bar_1 = function _bar_1() {
+    return _classPrivateFieldGet(this, _fooWeakMap_1);
 };

tests/baselines/reference/privateNamedMethod.js

@@ -0,0 +1,51 @@
+//// [privateNamedMethod.ts]
+class A {
+    #foo = "hello";
+    #log(name: string) {
+        console.log(this.#foo);
+        console.log(name);
+    }
+    #logIfTallEnough(height: number, name: string) {
+        if (height >= 50) {
+            this.#log(name);
+        }
+    }
+    #logAll(height: number, ...names: string[]) {
+        for (const name of names) {
+            this.#logIfTallEnough(height, name);
+        }
+    }
+    constructor() {
+        this.#logIfTallEnough(100, "world");
+        this.#logAll(100, ...["a", "b", "c"]);
+    }
+}
+
+
+//// [privateNamedMethod.js]
+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 _classPrivateNamedMethodGet(receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return fn; }
+var _fooWeakMap_1, _log_1, _logWeakSet_1, _logIfTallEnough_1, _logIfTallEnoughWeakSet_1, _logAll_1, _logAllWeakSet_1;
+"use strict";
+class A {
+    constructor() {
+        _logWeakSet_1.add(this);
+        _logIfTallEnoughWeakSet_1.add(this);
+        _logAllWeakSet_1.add(this);
+        _fooWeakMap_1.set(this, "hello");
+        _classPrivateNamedMethodGet(this, _logIfTallEnoughWeakSet_1, _logIfTallEnough_1).call(this, 100, "world");
+        _classPrivateNamedMethodGet(this, _logAllWeakSet_1, _logAll_1).call(this, 100, ...["a", "b", "c"]);
+    }
+}
+_fooWeakMap_1 = new WeakMap(), _logWeakSet_1 = new WeakSet(), _logIfTallEnoughWeakSet_1 = new WeakSet(), _logAllWeakSet_1 = new WeakSet(), _log_1 = function _log_1(name) {
+    console.log(_classPrivateFieldGet(this, _fooWeakMap_1));
+    console.log(name);
+}, _logIfTallEnough_1 = function _logIfTallEnough_1(height, name) {
+    if (height >= 50) {
+        _classPrivateNamedMethodGet(this, _logWeakSet_1, _log_1).call(this, name);
+    }
+}, _logAll_1 = function _logAll_1(height, ...names) {
+    for (const name of names) {
+        _classPrivateNamedMethodGet(this, _logIfTallEnoughWeakSet_1, _logIfTallEnough_1).call(this, height, name);
+    }
+};

tests/baselines/reference/privateNamedMethod.symbols

@@ -0,0 +1,65 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNamedMethod.ts ===
+class A {
+>A : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+
+    #foo = "hello";
+>#foo : Symbol(A.#foo, Decl(privateNamedMethod.ts, 0, 9))
+
+    #log(name: string) {
+>#log : Symbol(A.#log, Decl(privateNamedMethod.ts, 1, 19))
+>name : Symbol(name, Decl(privateNamedMethod.ts, 2, 9))
+
+        console.log(this.#foo);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>this.#foo : Symbol(A.#foo, Decl(privateNamedMethod.ts, 0, 9))
+>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+
+        console.log(name);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>name : Symbol(name, Decl(privateNamedMethod.ts, 2, 9))
+    }
+    #logIfTallEnough(height: number, name: string) {
+>#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5))
+>height : Symbol(height, Decl(privateNamedMethod.ts, 6, 21))
+>name : Symbol(name, Decl(privateNamedMethod.ts, 6, 36))
+
+        if (height >= 50) {
+>height : Symbol(height, Decl(privateNamedMethod.ts, 6, 21))
+
+            this.#log(name);
+>this.#log : Symbol(A.#log, Decl(privateNamedMethod.ts, 1, 19))
+>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+>name : Symbol(name, Decl(privateNamedMethod.ts, 6, 36))
+        }
+    }
+    #logAll(height: number, ...names: string[]) {
+>#logAll : Symbol(A.#logAll, Decl(privateNamedMethod.ts, 10, 5))
+>height : Symbol(height, Decl(privateNamedMethod.ts, 11, 12))
+>names : Symbol(names, Decl(privateNamedMethod.ts, 11, 27))
+
+        for (const name of names) {
+>name : Symbol(name, Decl(privateNamedMethod.ts, 12, 18))
+>names : Symbol(names, Decl(privateNamedMethod.ts, 11, 27))
+
+            this.#logIfTallEnough(height, name);
+>this.#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5))
+>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+>height : Symbol(height, Decl(privateNamedMethod.ts, 11, 12))
+>name : Symbol(name, Decl(privateNamedMethod.ts, 12, 18))
+        }
+    }
+    constructor() {
+        this.#logIfTallEnough(100, "world");
+>this.#logIfTallEnough : Symbol(A.#logIfTallEnough, Decl(privateNamedMethod.ts, 5, 5))
+>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+
+        this.#logAll(100, ...["a", "b", "c"]);
+>this.#logAll : Symbol(A.#logAll, Decl(privateNamedMethod.ts, 10, 5))
+>this : Symbol(A, Decl(privateNamedMethod.ts, 0, 0))
+    }
+}
+