Added support for static private fields accessors and methods.

src/compiler/checker.ts

@@ -240,6 +240,7 @@ namespace ts {
         SetAccessor = 2,
         PropertyAssignment = 4,
         Method = 8,
+        PrivateStatic = 16,
         GetOrSetAccessor = GetAccessor | SetAccessor,
         PropertyAssignmentOrMethod = PropertyAssignment | Method,
     }
@@ -32131,29 +32132,32 @@ namespace ts {
                     const isStatic = hasSyntacticModifier(member, ModifierFlags.Static);
                     const name = member.name;
                     if (!name) {
-                        return;
+                        continue;
                     }
+                    const isPrivate = isPrivateIdentifier(name);
+                    const isPrivateStatic = isPrivate && isStatic ? DeclarationMeaning.PrivateStatic : 0;
                     const names =
-                        isPrivateIdentifier(name) ? privateIdentifiers :
+                        isPrivate ? privateIdentifiers :
                         isStatic ? staticNames :
                         instanceNames;
+
                     const memberName = name && getPropertyNameForPropertyNameNode(name);
                     if (memberName) {
                         switch (member.kind) {
                             case SyntaxKind.GetAccessor:
-                                addName(names, name, memberName, DeclarationMeaning.GetAccessor);
+                                addName(names, name, memberName, DeclarationMeaning.GetAccessor | isPrivateStatic);
                                 break;
 
                             case SyntaxKind.SetAccessor:
-                                addName(names, name, memberName, DeclarationMeaning.SetAccessor);
+                                addName(names, name, memberName, DeclarationMeaning.SetAccessor | isPrivateStatic);
                                 break;
 
                             case SyntaxKind.PropertyDeclaration:
-                                addName(names, name, memberName, DeclarationMeaning.GetOrSetAccessor);
+                                addName(names, name, memberName, DeclarationMeaning.GetOrSetAccessor | isPrivateStatic);
                                 break;
 
                             case SyntaxKind.MethodDeclaration:
-                                addName(names, name, memberName, DeclarationMeaning.Method);
+                                addName(names, name, memberName, DeclarationMeaning.Method | isPrivateStatic);
                                 break;
                         }
                     }
@@ -32163,16 +32167,25 @@ namespace ts {
             function addName(names: UnderscoreEscapedMap<DeclarationMeaning>, location: Node, name: __String, meaning: DeclarationMeaning) {
                 const prev = names.get(name);
                 if (prev) {
-                    if (prev & DeclarationMeaning.Method) {
-                        if (meaning !== DeclarationMeaning.Method) {
-                            error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
-                        }
-                    }
-                    else if (prev & meaning) {
-                        error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
+                    // For private identifiers, do not allow mixing of static and instance members with the same name
+                    if ((prev & DeclarationMeaning.PrivateStatic) !== (meaning & DeclarationMeaning.PrivateStatic)) {
+                        error(location, Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name, getTextOfNode(location));
                     }
                     else {
-                        names.set(name, prev | meaning);
+                        const prevIsMethod = !!(prev & DeclarationMeaning.Method);
+                        const isMethod = !!(meaning & DeclarationMeaning.Method);
+                        if (prevIsMethod || isMethod) {
+                            if (prevIsMethod !== isMethod) {
+                                error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
+                            }
+                            // If this is a method/method duplication is might be an overload, so this will be handled when overloads are considered
+                        }
+                        else if (prev & meaning & ~DeclarationMeaning.PrivateStatic) {
+                            error(location, Diagnostics.Duplicate_identifier_0, getTextOfNode(location));
+                        }
+                        else {
+                            names.set(name, prev | meaning);
+                        }
                     }
                 }
                 else {
@@ -32296,6 +32309,9 @@ namespace ts {
                     getNodeLinks(lexicalScope).flags |= NodeCheckFlags.ContainsClassWithPrivateIdentifiers;
                 }
             }
+            if (isPrivateIdentifier(node.name) && hasStaticModifier(node) && node.initializer && languageVersion === ScriptTarget.ESNext && !compilerOptions.useDefineForClassFields) {
+                error(node.initializer, Diagnostics.Static_fields_with_private_names_can_t_have_initializers_when_the_useDefineForClassFields_flag_is_not_specified_with_a_target_of_esnext_Consider_adding_the_useDefineForClassFields_flag);
+            }
         }
 
         function checkPropertySignature(node: PropertySignature) {
@@ -36030,6 +36046,9 @@ namespace ts {
         }
 
         function checkClassDeclaration(node: ClassDeclaration) {
+            if (some(node.decorators) && some(node.members, p => hasStaticModifier(p) && isPrivateIdentifierClassElementDeclaration(p))) {
+                grammarErrorOnNode(node.decorators[0], Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator);
+            }
             if (!node.name && !hasSyntacticModifier(node, ModifierFlags.Default)) {
                 grammarErrorOnFirstToken(node, Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name);
             }
@@ -39586,9 +39605,6 @@ namespace ts {
                         else if (flags & ModifierFlags.Abstract) {
                             return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
                         }
-                        else if (isPrivateIdentifierClassElementDeclaration(node)) {
-                            return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "static");
-                        }
                         flags |= ModifierFlags.Static;
                         lastStatic = modifier;
                         break;

src/compiler/diagnosticMessages.json

@@ -3264,11 +3264,19 @@
         "category": "Error",
         "code": 2802
     },
-
     "Cannot assign to private method '{0}'. Private methods are not writable.": {
         "category": "Error",
         "code": 2803
     },
+    "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name.": {
+        "category": "Error",
+        "code": 2804
+    },
+    "Static fields with private names can't have initializers when the '--useDefineForClassFields' flag is not specified with a '--target' of 'esnext'. Consider adding the '--useDefineForClassFields' flag.": {
+        "category": "Error",
+        "code": 2805
+    },
+
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",
         "code": 4000
@@ -6358,5 +6366,9 @@
     "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name.": {
         "category": "Error",
         "code": 18035
+    },
+    "Class decorators can't be used with static private identifier. Consider removing the experimental decorator.": {
+        "category": "Error",
+        "code": 18036
     }
 }

src/compiler/factory/emitHelpers.ts

@@ -39,6 +39,14 @@ namespace ts {
         createClassPrivateWriteonlyHelper(receiver: Expression): Expression;
         createClassPrivateAccessorGetHelper(receiver: Expression, instances: Identifier, fn: Identifier): Expression;
         createClassPrivateAccessorSetHelper(receiver: Expression, instances: Identifier, fn: Identifier, value: Expression): Expression;
+        // Class Static Private Helpers
+        createClassStaticPrivateFieldGetHelper(receiver: Expression, classConstructor: Identifier, privateField: Identifier): Expression;
+        createClassStaticPrivateFieldSetHelper(receiver: Expression, classConstructor: Identifier, privateField: Identifier, value: Expression): Expression;
+        createClassStaticPrivateMethodGetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier): Expression;
+        createClassStaticPrivateReadonlyHelper(receiver: Expression, value: Expression): Expression;
+        createClassStaticPrivateWriteonlyHelper(receiver: Expression): Expression;
+        createClassStaticPrivateAccessorGetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier): Expression;
+        createClassStaticPrivateAccessorSetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier, value: Expression): Expression;
     }
 
     export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
@@ -82,6 +90,13 @@ namespace ts {
             createClassPrivateWriteonlyHelper,
             createClassPrivateAccessorGetHelper,
             createClassPrivateAccessorSetHelper,
+            createClassStaticPrivateFieldGetHelper,
+            createClassStaticPrivateFieldSetHelper,
+            createClassStaticPrivateMethodGetHelper,
+            createClassStaticPrivateReadonlyHelper,
+            createClassStaticPrivateWriteonlyHelper,
+            createClassStaticPrivateAccessorGetHelper,
+            createClassStaticPrivateAccessorSetHelper,
         };
 
         /**
@@ -412,6 +427,41 @@ namespace ts {
             context.requestEmitHelper(classPrivateAccessorSetHelper);
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateAccessorSet"), /*typeArguments*/ undefined, [receiver, instances, fn, value]);
         }
+        // Class Private Static Helpers
+        function createClassStaticPrivateFieldGetHelper(receiver: Expression, classConstructor: Identifier, privateField: Identifier) {
+            context.requestEmitHelper(classStaticPrivateFieldGetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateFieldGet"), /*typeArguments*/ undefined, [receiver, classConstructor, privateField]);
+        }
+
+        function createClassStaticPrivateFieldSetHelper(receiver: Expression, classConstructor: Identifier, privateField: Identifier, value: Expression) {
+            context.requestEmitHelper(classStaticPrivateFieldSetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateFieldSet"), /*typeArguments*/ undefined, [receiver, classConstructor, privateField, value]);
+        }
+
+        function createClassStaticPrivateMethodGetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier) {
+            context.requestEmitHelper(classStaticPrivateMethodGetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateMethodGet"), /*typeArguments*/ undefined, [receiver, classConstructor, fn]);
+        }
+
+        function createClassStaticPrivateReadonlyHelper(receiver: Expression, value: Expression) {
+            context.requestEmitHelper(classStaticPrivateReadonlyHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateReadonly"), /*typeArguments*/ undefined, [receiver, value]);
+        }
+
+        function createClassStaticPrivateWriteonlyHelper(receiver: Expression) {
+            context.requestEmitHelper(classStaticPrivateWriteonlyHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateWriteonly"), /*typeArguments*/ undefined, [receiver]);
+        }
+
+        function createClassStaticPrivateAccessorGetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier) {
+            context.requestEmitHelper(classStaticPrivateAccessorGetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateAccessorGet"), /*typeArguments*/ undefined, [receiver, classConstructor, fn]);
+        }
+
+        function createClassStaticPrivateAccessorSetHelper(receiver: Expression, classConstructor: Identifier, fn: Identifier, value: Expression) {
+            context.requestEmitHelper(classStaticPrivateAccessorSetHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classStaticPrivateAccessorSet"), /*typeArguments*/ undefined, [receiver, classConstructor, fn, value]);
+        }
     }
 
     /* @internal */
@@ -939,6 +989,93 @@ namespace ts {
             };`
     };
 
+    export const classStaticPrivateFieldGetHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateFieldGet",
+        importName: "__classStaticPrivateFieldGet",
+        scoped: false,
+        text: `
+            var __classStaticPrivateFieldGet = (this && this.__classStaticPrivateFieldGet) || function (receiver, classConstructor, propertyDescriptor) {
+                if (receiver !== classConstructor) {
+                    throw new TypeError("Private static access of wrong provenance");
+                }
+                return propertyDescriptor.value;
+            };`
+    };
+
+    export const classStaticPrivateFieldSetHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateFieldSet",
+        importName: "__classStaticPrivateFieldSet",
+        scoped: false,
+        text: `
+            var __classStaticPrivateFieldSet = (this && this.__classStaticPrivateFieldSet) || function (receiver, classConstructor, propertyDescriptor, value) {
+                if (receiver !== classConstructor) {
+                    throw new TypeError("Private static access of wrong provenance");
+                }
+                propertyDescriptor.value = value;
+                return value;
+            };`
+    };
+
+    export const classStaticPrivateMethodGetHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateMethodGet",
+        importName: "__classStaticPrivateMethodGet",
+        scoped: false,
+        text: `
+            var __classStaticPrivateMethodGet = (this && this.__classStaticPrivateMethodGet) || function (receiver, classConstructor, fn) {
+                if (receiver !== classConstructor) {
+                    throw new TypeError("Private static access of wrong provenance");
+                }
+                return fn;
+            };`
+    };
+
+    export const classStaticPrivateReadonlyHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateReadonly",
+        importName: "__classStaticPrivateReadonly",
+        scoped: false,
+        text: `
+            var __classStaticPrivateReadonly = (this && this.__classStaticPrivateReadonly) || function () {
+                throw new TypeError("Private static element is not writable");
+            };`
+    };
+
+    export const classStaticPrivateWriteonlyHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateWriteonly",
+        importName: "__classStaticPrivateWriteonly",
+        scoped: false,
+        text: `
+            var __classStaticPrivateWriteonly = (this && this.__classStaticPrivateWriteonly) || function () {
+                throw new TypeError("Private static element is not readable");
+            };`
+    };
+
+    export const classStaticPrivateAccessorGetHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateAccessorGet",
+        importName: "__classStaticPrivateAccessorGet",
+        scoped: false,
+        text: `
+            var __classStaticPrivateAccessorGet = (this && this.__classStaticPrivateAccessorGet) || function (receiver, classConstructor, fn) {
+                if (receiver !== classConstructor) {
+                    throw new TypeError("Private static access of wrong provenance");
+                }
+                return fn.call(receiver);
+            };`
+    };
+
+    export const classStaticPrivateAccessorSetHelper: UnscopedEmitHelper = {
+        name: "typescript:classStaticPrivateAccessorSet",
+        importName: "__classStaticPrivateAccessorSet",
+        scoped: false,
+        text: `
+            var __classStaticPrivateAccessorSet = (this && this.__classStaticPrivateAccessorSet) || function (receiver, classConstructor, fn, value) {
+                if (receiver !== classConstructor) {
+                    throw new TypeError("Private static access of wrong provenance");
+                }
+                fn.call(receiver, value);
+                return value;
+            };`
+    };
+
     let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> | undefined;
 
     export function getAllUnscopedEmitHelpers() {