Add private named instance field transformation (#31)

Implements private instance fields on top of the class properties refactor.
Signed-off-by: Joseph Watts <[email protected]>
Signed-off-by: Max Heiber <[email protected]>

Author: joeywatts

src/compiler/binder.ts

@@ -3931,6 +3931,10 @@ namespace ts {
             case SyntaxKind.BreakStatement:
                 transformFlags |= TransformFlags.ContainsHoistedDeclarationOrCompletion;
                 break;
+
+            case SyntaxKind.PrivateName:
+                transformFlags |= TransformFlags.ContainsClassFields;
+                break;
         }
 
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;

src/compiler/transformers/classFields.ts

@@ -667,28 +667,6 @@ namespace ts {
             }
         }
 
-        function isCompoundAssignment(kind: BinaryOperator): kind is CompoundAssignmentOperator {
-            return kind >= SyntaxKind.FirstCompoundAssignment
-                && kind <= SyntaxKind.LastCompoundAssignment;
-        }
-
-        function getOperatorForCompoundAssignment(kind: CompoundAssignmentOperator): BitwiseOperatorOrHigher {
-            switch (kind) {
-                case SyntaxKind.PlusEqualsToken: return SyntaxKind.PlusToken;
-                case SyntaxKind.MinusEqualsToken: return SyntaxKind.MinusToken;
-                case SyntaxKind.AsteriskEqualsToken: return SyntaxKind.AsteriskToken;
-                case SyntaxKind.AsteriskAsteriskEqualsToken: return SyntaxKind.AsteriskAsteriskToken;
-                case SyntaxKind.SlashEqualsToken: return SyntaxKind.SlashToken;
-                case SyntaxKind.PercentEqualsToken: return SyntaxKind.PercentToken;
-                case SyntaxKind.LessThanLessThanEqualsToken: return SyntaxKind.LessThanLessThanToken;
-                case SyntaxKind.GreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanToken;
-                case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
-                case SyntaxKind.AmpersandEqualsToken: return SyntaxKind.AmpersandToken;
-                case SyntaxKind.BarEqualsToken: return SyntaxKind.BarToken;
-                case SyntaxKind.CaretEqualsToken: return SyntaxKind.CaretToken;
-            }
-        }
-
         /**
          * Visits a right-associative binary expression containing `yield`.
          *

src/compiler/transformers/generators.ts

@@ -249,6 +249,28 @@ namespace ts {
             isWellKnownSymbolSyntactically(expression);
     }
 
+    export function isCompoundAssignment(kind: BinaryOperator): kind is CompoundAssignmentOperator {
+        return kind >= SyntaxKind.FirstCompoundAssignment
+            && kind <= SyntaxKind.LastCompoundAssignment;
+    }
+
+    export function getOperatorForCompoundAssignment(kind: CompoundAssignmentOperator): BitwiseOperatorOrHigher {
+        switch (kind) {
+            case SyntaxKind.PlusEqualsToken: return SyntaxKind.PlusToken;
+            case SyntaxKind.MinusEqualsToken: return SyntaxKind.MinusToken;
+            case SyntaxKind.AsteriskEqualsToken: return SyntaxKind.AsteriskToken;
+            case SyntaxKind.AsteriskAsteriskEqualsToken: return SyntaxKind.AsteriskAsteriskToken;
+            case SyntaxKind.SlashEqualsToken: return SyntaxKind.SlashToken;
+            case SyntaxKind.PercentEqualsToken: return SyntaxKind.PercentToken;
+            case SyntaxKind.LessThanLessThanEqualsToken: return SyntaxKind.LessThanLessThanToken;
+            case SyntaxKind.GreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanToken;
+            case SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken: return SyntaxKind.GreaterThanGreaterThanGreaterThanToken;
+            case SyntaxKind.AmpersandEqualsToken: return SyntaxKind.AmpersandToken;
+            case SyntaxKind.BarEqualsToken: return SyntaxKind.BarToken;
+            case SyntaxKind.CaretEqualsToken: return SyntaxKind.CaretToken;
+        }
+    }
+
     /**
      * Adds super call and preceding prologue directives into the list of statements.
      *

src/compiler/transformers/utilities.ts

@@ -957,6 +957,11 @@ namespace ts {
         initializer?: Expression;           // Optional initializer
     }
 
+    /*@internal*/
+    export interface PrivateNamedPropertyDeclaration extends PropertyDeclaration {
+        name: PrivateName;
+    }
+
     export interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrand: any;
         name?: PropertyName;
@@ -1788,6 +1793,11 @@ namespace ts {
         name: Identifier | PrivateName;
     }
 
+    /*@internal*/
+    export interface PrivateNamedPropertyAccessExpression extends PropertyAccessExpression {
+        name: PrivateName;
+    }
+
     export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
         expression: SuperExpression;
     }

src/compiler/types.ts

@@ -6423,6 +6423,16 @@ namespace ts {
             || kind === SyntaxKind.ArrayBindingPattern;
     }
 
+    /*@internal*/
+    export function isPrivateNamedPropertyDeclaration(node: Node): node is PrivateNamedPropertyDeclaration {
+        return isPropertyDeclaration(node) && isPrivateName(node.name);
+    }
+
+    /*@internal*/
+    export function isPrivateNamedPropertyAccessExpression(node: Node): node is PrivateNamedPropertyAccessExpression {
+        return isPropertyAccessExpression(node) && isPrivateName(node.name);
+    }
+
     // Functions
 
     export function isFunctionLike(node: Node): node is SignatureDeclaration {

src/compiler/utilities.ts

@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(4,5): error TS1811: '#constructor' is a reserved word.
+tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts(4,5): error TS18012: '#constructor' is a reserved word.
 
 
 ==== tests/cases/conformance/classes/members/privateNames/privateNameConstructorReserved.ts (1 errors) ====
@@ -7,6 +7,6 @@ tests/cases/conformance/classes/members/privateNames/privateNameConstructorReser
     class A {
         #constructor() {}      // Error: `#constructor` is a reserved word.
         ~~~~~~~~~~~~
-!!! error TS1811: '#constructor' is a reserved word.
+!!! error TS18012: '#constructor' is a reserved word.
     }
 

tests/baselines/reference/privateNameConstructorReserved.errors.txt

@@ -0,0 +1,15 @@
+//// [privateNameDeclaration.ts]
+class A {
+    #name: string;
+}
+
+
+//// [privateNameDeclaration.js]
+var _name;
+var A = /** @class */ (function () {
+    function A() {
+        _name.set(this, void 0);
+    }
+    return A;
+}());
+_name = new WeakMap();

tests/baselines/reference/privateNameDeclaration.js

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameDeclaration.ts ===
+class A {
+>A : Symbol(A, Decl(privateNameDeclaration.ts, 0, 0))
+
+    #name: string;
+>#name : Symbol(A.#name, Decl(privateNameDeclaration.ts, 0, 9))
+}
+

tests/baselines/reference/privateNameDeclaration.symbols

@@ -0,0 +1,8 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameDeclaration.ts ===
+class A {
+>A : A
+
+    #name: string;
+>#name : string
+}
+