update checker for private names

accessiblity modifiers cannot be used with private names

rm del

no delete permitted

update checker to disallow delete of private name

move private names cases

private constructor class field invalid

compiler error on #constructor

Author: mheiber

src/compiler/binder.ts

@@ -1793,6 +1793,18 @@ namespace ts {
             return Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode;
         }
 
+        // The binder visits every node, so this is a good place to check for
+        // the reserved private name (there is only one)
+        function checkPrivateName(node: PrivateName) {
+            if (node.escapedText === "#constructor") {
+                // Report error only if there are no parse errors in file
+                if (!file.parseDiagnostics.length) {
+                    file.bindDiagnostics.push(createDiagnosticForNode(node,
+                        Diagnostics.constructor_is_a_reserved_word, declarationNameToString(node)));
+                }
+            }
+        }
+
         function checkStrictModeBinaryExpression(node: BinaryExpression) {
             if (inStrictMode && isLeftHandSideExpression(node.left) && isAssignmentOperator(node.operatorToken.kind)) {
                 // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an
@@ -2065,6 +2077,8 @@ namespace ts {
                         node.flowNode = currentFlow;
                     }
                     return checkStrictModeIdentifier(<Identifier>node);
+                case SyntaxKind.PrivateName:
+                    return checkPrivateName(node as PrivateName);
                 case SyntaxKind.PropertyAccessExpression:
                     if (currentFlow && isNarrowableReference(<Expression>node)) {
                         node.flowNode = currentFlow;

src/compiler/checker.ts

@@ -20746,10 +20746,16 @@ namespace ts {
                 error(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference);
                 return booleanType;
             }
+            if (expr.kind === SyntaxKind.PropertyAccessExpression && isPrivateName((expr as PropertyAccessExpression).name)) {
+                error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_name);
+
+            }
             const links = getNodeLinks(expr);
             const symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol);
-            if (symbol && isReadonlySymbol(symbol)) {
-                error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
+            if (symbol) {
+                if (isReadonlySymbol(symbol)) {
+                    error(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
+                }
             }
             return booleanType;
         }
@@ -28462,6 +28468,9 @@ namespace ts {
             else if (node.kind === SyntaxKind.Parameter && (flags & ModifierFlags.ParameterPropertyModifier) && (<ParameterDeclaration>node).dotDotDotToken) {
                 return grammarErrorOnNode(node, Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter);
             }
+            else if (isNamedDeclaration(node) && (flags & ModifierFlags.AccessibilityModifier) && node.name.kind === SyntaxKind.PrivateName) {
+                return grammarErrorOnNode(node, Diagnostics.Accessibility_modifiers_cannot_be_used_with_private_names);
+            }
             if (flags & ModifierFlags.Async) {
                 return checkGrammarAsyncModifier(node, lastAsync!);
             }

src/compiler/diagnosticMessages.json

@@ -4142,6 +4142,19 @@
         "category": "Error",
         "code": 18005
     },
+    "Accessibility modifiers cannot be used with private names.": {
+        "category": "Error",
+        "code": 18006
+    },
+    "The operand of a delete operator cannot be a private name.": {
+        "category": "Error",
+        "code": 18007
+    },
+    "#constructor is a reserved word.": {
+        "category": "Error",
+        "code": 18008
+    },
+
 
     "File is a CommonJS module; it may be converted to an ES6 module.": {
         "category": "Suggestion",

tests/baselines/reference/privateNameContructorReserved.errors.txt

@@ -0,0 +1,22 @@
+tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts(1,7): error TS2300: Duplicate identifier 'A'.
+tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts(2,5): error TS18008: #constructor is a reserved word.
+tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts(5,7): error TS2300: Duplicate identifier 'A'.
+tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts(6,5): error TS18008: #constructor is a reserved word.
+
+
+==== tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts (4 errors) ====
+    class A {
+          ~
+!!! error TS2300: Duplicate identifier 'A'.
+        #constructor() {}      // Error: `#constructor` is a reserved word.
+        ~~~~~~~~~~~~
+!!! error TS18008: #constructor is a reserved word.
+    }
+    
+    class A {
+          ~
+!!! error TS2300: Duplicate identifier 'A'.
+        #constructor = 5       // Error: `#constructor` is a reserved word.
+        ~~~~~~~~~~~~
+!!! error TS18008: #constructor is a reserved word.
+    }

tests/baselines/reference/privateNameContructorReserved.js

@@ -0,0 +1,22 @@
+//// [privateNameContructorReserved.ts]
+class A {
+    #constructor() {}      // Error: `#constructor` is a reserved word.
+}
+
+class A {
+    #constructor = 5       // Error: `#constructor` is a reserved word.
+}
+
+//// [privateNameContructorReserved.js]
+var A = /** @class */ (function () {
+    function A() {
+    }
+    A.prototype.#constructor = function () { }; // Error: `#constructor` is a reserved word.
+    return A;
+}());
+var A = /** @class */ (function () {
+    function A() {
+        this.#constructor = 5; // Error: `#constructor` is a reserved word.
+    }
+    return A;
+}());

tests/baselines/reference/privateNameContructorReserved.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts ===
+class A {
+>A : Symbol(A, Decl(privateNameContructorReserved.ts, 0, 0))
+
+    #constructor() {}      // Error: `#constructor` is a reserved word.
+>#constructor : Symbol(A[#constructor], Decl(privateNameContructorReserved.ts, 0, 9))
+}
+
+class A {
+>A : Symbol(A, Decl(privateNameContructorReserved.ts, 2, 1))
+
+    #constructor = 5       // Error: `#constructor` is a reserved word.
+>#constructor : Symbol(A[#constructor], Decl(privateNameContructorReserved.ts, 4, 9))
+}

tests/baselines/reference/privateNameContructorReserved.types

@@ -0,0 +1,15 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts ===
+class A {
+>A : A
+
+    #constructor() {}      // Error: `#constructor` is a reserved word.
+>#constructor : () => void
+}
+
+class A {
+>A : A
+
+    #constructor = 5       // Error: `#constructor` is a reserved word.
+>#constructor : number
+>5 : 5
+}

tests/baselines/reference/privateNameField.symbols

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNameField.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNameField.ts ===
 class A {
 >A : Symbol(A, Decl(privateNameField.ts, 0, 0))
 

tests/baselines/reference/privateNameField.types

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNameField.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNameField.ts ===
 class A {
 >A : A
 

tests/baselines/reference/privateNameNotAllowedOutsideClass.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/classes/privateNames/privateNameNotAllowedOutsideClass.ts(1,7): error TS18004: Private names are not allowed outside class bodies.
+tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts(1,7): error TS18004: Private names are not allowed outside class bodies.
 
 
-==== tests/cases/conformance/classes/privateNames/privateNameNotAllowedOutsideClass.ts (1 errors) ====
+==== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts (1 errors) ====
     const #foo = 3;
           ~~~~
 !!! error TS18004: Private names are not allowed outside class bodies.

tests/baselines/reference/privateNameNotAllowedOutsideClass.symbols

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNameNotAllowedOutsideClass.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts ===
 const #foo = 3;
 >#foo : Symbol(#foo, Decl(privateNameNotAllowedOutsideClass.ts, 0, 5))
 

tests/baselines/reference/privateNameNotAllowedOutsideClass.types

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNameNotAllowedOutsideClass.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNameNotAllowedOutsideClass.ts ===
 const #foo = 3;
 >#foo : 3
 >3 : 3

tests/baselines/reference/privateNamesNoDelete.errors.txt

@@ -0,0 +1,13 @@
+tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts(4,16): error TS18007: The operand of a delete operator cannot be a private name.
+
+
+==== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts (1 errors) ====
+    class A {
+        #v = 1;
+        constructor() {
+            delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+                   ~~~~~~~
+!!! error TS18007: The operand of a delete operator cannot be a private name.
+        }
+    }
+    

tests/baselines/reference/privateNamesNoDelete.js

@@ -0,0 +1,17 @@
+//// [privateNamesNoDelete.ts]
+class A {
+    #v = 1;
+    constructor() {
+        delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+    }
+}
+
+
+//// [privateNamesNoDelete.js]
+var A = /** @class */ (function () {
+    function A() {
+        this.#v = 1;
+        delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+    }
+    return A;
+}());

tests/baselines/reference/privateNamesNoDelete.symbols

@@ -0,0 +1,14 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts ===
+class A {
+>A : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0))
+
+    #v = 1;
+>#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9))
+
+    constructor() {
+        delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+>this.#v : Symbol(A[#v], Decl(privateNamesNoDelete.ts, 0, 9))
+>this : Symbol(A, Decl(privateNamesNoDelete.ts, 0, 0))
+    }
+}
+

tests/baselines/reference/privateNamesNoDelete.types

@@ -0,0 +1,16 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNamesNoDelete.ts ===
+class A {
+>A : A
+
+    #v = 1;
+>#v : number
+>1 : 1
+
+    constructor() {
+        delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+>delete this.#v : boolean
+>this.#v : number
+>this : this
+    }
+}
+

tests/baselines/reference/privateNamesNotAllowedAsParameters.errors.txt

@@ -1,7 +1,7 @@
-tests/cases/conformance/classes/privateNames/privateNamesNotAllowedAsParameters.ts(2,12): error TS18005: Private names cannot be used as parameters
+tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts(2,12): error TS18005: Private names cannot be used as parameters
 
 
-==== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedAsParameters.ts (1 errors) ====
+==== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts (1 errors) ====
     class A {
         setFoo(#foo: string) {}
                ~~~~~~~~~~~~

tests/baselines/reference/privateNamesNotAllowedAsParameters.symbols

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedAsParameters.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts ===
 class A {
 >A : Symbol(A, Decl(privateNamesNotAllowedAsParameters.ts, 0, 0))
 

tests/baselines/reference/privateNamesNotAllowedAsParameters.types

@@ -1,4 +1,4 @@
-=== tests/cases/conformance/classes/privateNames/privateNamesNotAllowedAsParameters.ts ===
+=== tests/cases/conformance/classes/members/privateNames/privateNamesNotAllowedAsParameters.ts ===
 class A {
 >A : A
 

tests/cases/conformance/classes/members/privateNames/privateNameContructorReserved.ts

@@ -0,0 +1,7 @@
+class A {
+    #constructor() {}      // Error: `#constructor` is a reserved word.
+}
+
+class A {
+    #constructor = 5       // Error: `#constructor` is a reserved word.
+}

tests/cases/conformance/classes/privateNames/privateNameField.ts renamed to tests/cases/conformance/classes/members/privateNames/privateNameField.ts

@@ -0,0 +1,6 @@
+class A {
+    #v = 1;
+    constructor() {
+        delete this.#v; // Error: The operand of a delete operator cannot be a private name.
+    }
+}