Merge pull request #48 from bloomberg/es-private-methods-emit

Private methods emit

Author: dragomirtitian

src/compiler/checker.ts

@@ -32226,7 +32226,7 @@ namespace ts {
             }
 
             // Private named methods are only allowed in class declarations
-            if (isPrivateIdentifier(node.name) && !isClassDeclaration(node.parent)) {
+            if (isPrivateIdentifier(node.name) && !getContainingClass(node)) {
                 error(node, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
             }
         }

src/compiler/factory/emitHelpers.ts

@@ -34,6 +34,11 @@ namespace ts {
         // Class Fields Helpers
         createClassPrivateFieldGetHelper(receiver: Expression, privateField: Identifier): Expression;
         createClassPrivateFieldSetHelper(receiver: Expression, privateField: Identifier, value: Expression): Expression;
+        createClassPrivateMethodGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
+        createClassPrivateReadonlyHelper(receiver: Expression, value: Expression): Expression;
+        createClassPrivateWriteonlyHelper(receiver: Expression): Expression;
+        createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
+        createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression): Expression;
     }
 
     export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
@@ -72,6 +77,11 @@ namespace ts {
             // Class Fields Helpers
             createClassPrivateFieldGetHelper,
             createClassPrivateFieldSetHelper,
+            createClassPrivateMethodGetHelper,
+            createClassPrivateReadonlyHelper,
+            createClassPrivateWriteonlyHelper,
+            createClassPrivateAccessorGetHelper,
+            createClassPrivateAccessorSetHelper,
         };
 
         /**
@@ -377,6 +387,31 @@ namespace ts {
             context.requestEmitHelper(classPrivateFieldSetHelper);
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, privateField, value]);
         }
+
+        function createClassPrivateMethodGetHelper(receiver: Expression, instances: Identifier, fn: Identifier) {
+            context.requestEmitHelper(classPrivateMethodGetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateMethodGet"), /*typeArguments*/ undefined, [receiver, instances, fn]);
+        }
+
+        function createClassPrivateReadonlyHelper(receiver: Expression, value: Expression) {
+            context.requestEmitHelper(classPrivateReadonlyHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateReadonly"), /*typeArguments*/ undefined, [receiver, value]);
+        }
+
+        function createClassPrivateWriteonlyHelper(receiver: Expression) {
+            context.requestEmitHelper(classPrivateWriteonlyHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateWriteonly"), /*typeArguments*/ undefined, [receiver]);
+        }
+
+        function createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier) {
+            context.requestEmitHelper(classPrivateAccessorGetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorGet"), /*typeArguments*/ undefined, [receiver, instances, fn]);
+        }
+
+        function createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression) {
+            context.requestEmitHelper(classPrivateAccessorSetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorSet"), /*typeArguments*/ undefined, [receiver, instances, fn, value]);
+        }
     }
 
     /* @internal */
@@ -844,6 +879,66 @@ namespace ts {
             };`
     };
 
+    export const classPrivateMethodGetHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateMethodGet",
+        importName: "__classPrivateMethodGet",
+        scoped: false,
+        text: `
+            var __classPrivateMethodGet = (this && this.__classPrivateMethodGet) || function (receiver, instances, fn) {
+                if (!instances.has(receiver)) {
+                    throw new TypeError("attempted to get private method on non-instance");
+                }
+                return fn;
+            };`
+    };
+
+    export const classPrivateReadonlyHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateReadonly",
+        importName: "__classPrivateReadonly",
+        scoped: false,
+        text: `
+            var __classPrivateReadonly = (this && this.__classPrivateReadonly) || function () {
+                throw new TypeError("private element is not writable");
+            };`
+    };
+
+    export const classPrivateWriteonlyHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateWriteonly",
+        importName: "__classPrivateWriteonly",
+        scoped: false,
+        text: `
+            var __classPrivateWriteonly = (this && this.__classPrivateWriteonly) || function () {
+                throw new TypeError("private setter was defined without a getter");
+            };`
+    };
+
+    export const classPrivateAccessorGetHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateAccessorGet",
+        importName: "__classPrivateAccessorGet",
+        scoped: false,
+        text: `
+            var __classPrivateAccessorGet = (this && this.__classPrivateAccessorGet) || function (receiver, instances, fn) {
+                if (!instances.has(receiver)) {
+                    throw new TypeError("attempted to get private accessor on non-instance");
+                }
+                return fn.call(receiver);
+            };`
+    };
+
+    export const classPrivateAccessorSetHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateAccessorSet",
+        importName: "__classPrivateAccessorSet",
+        scoped: false,
+        text: `
+            var __classPrivateAccessorSet = (this && this.__classPrivateAccessorSet) || function (receiver, instances, fn, value) {
+                if (!instances.has(receiver)) {
+                    throw new TypeError("attempted to set private accessor on non-instance");
+                }
+                fn.call(receiver, value);
+                return value;
+            };`
+    };
+
     let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> | undefined;
 
     export function getAllUnscopedEmitHelpers() {
@@ -869,6 +964,11 @@ namespace ts {
             exportStarHelper,
             classPrivateFieldGetHelper,
             classPrivateFieldSetHelper,
+            classPrivateMethodGetHelper,
+            classPrivateReadonlyHelper,
+            classPrivateWriteonlyHelper,
+            classPrivateAccessorGetHelper,
+            classPrivateAccessorSetHelper,
             createBindingHelper,
             setModuleDefaultHelper
         ], helper => helper.name));
@@ -897,4 +997,4 @@ namespace ts {
             && (getEmitFlags(firstSegment.expression) & EmitFlags.HelperName)
             && firstSegment.expression.escapedText === helperName;
     }
-}
+}