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/transformers/classProperties.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

@@ -250,6 +250,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

@@ -951,6 +951,11 @@ namespace ts {
         initializer?: Expression;           // Optional initializer
     }
 
+    /*@internal*/
+    export interface PrivateNamedPropertyDeclaration extends PropertyDeclaration {
+        name: PrivateName;
+    }
+
     export interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrandBrand: any;
         name?: PropertyName;
@@ -1775,6 +1780,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

@@ -6341,6 +6341,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

@@ -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
+}
+

tests/baselines/reference/privateNameDeclaration.types

@@ -8,12 +8,14 @@ class A {
 
 
 //// [privateNameDuplicateField.js]
-"use strict";
 // @target es6
+var _foo, _foo_1;
+"use strict";
 var A = /** @class */ (function () {
     function A() {
-        this.#foo = "foo";
-        this.#foo = "foo";
+        _foo_1.set(this, "foo");
+        _foo_1.set(this, "foo");
     }
     return A;
 }());
+_foo = new WeakMap(), _foo_1 = new WeakMap();

tests/baselines/reference/privateNameDuplicateField.js

@@ -9,11 +9,15 @@ class A {
 }
 
 //// [privateNameField.js]
-"use strict";
 // @target es6
+var _classPrivateFieldSet = function (receiver, privateMap, value) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to set private field on non-instance"); } privateMap.set(receiver, value); return value; };
+var _name;
+"use strict";
 var A = /** @class */ (function () {
     function A(name) {
-        this.#name = name;
+        _name.set(this, void 0);
+        _classPrivateFieldSet(this, _name, name);
     }
     return A;
 }());
+_name = new WeakMap();