diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index ebc43e006bdfc..713708952ffae 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -3311,6 +3311,11 @@ namespace ts {
             transformFlags |= TransformFlags.ContainsPropertyInitializer;
         }
 
+        // Private names are an ESNext feature.
+        if (isPrivateName(node.name)) {
+            transformFlags |= TransformFlags.AssertESNext;
+        }
+
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
         return transformFlags & ~TransformFlags.NodeExcludes;
     }
@@ -3448,6 +3453,11 @@ namespace ts {
             transformFlags |= TransformFlags.ContainsSuper;
         }
 
+        // Private names are an ESNext feature.
+        if (isPrivateName(node.name)) {
+            transformFlags |= TransformFlags.AssertESNext;
+        }
+
         node.transformFlags = transformFlags | TransformFlags.HasComputedFlags;
         return transformFlags & ~TransformFlags.PropertyAccessExcludes;
     }
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index da0de696608fd..1822b89dbd9ad 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -3306,11 +3306,14 @@ namespace ts {
 
             // The class statements are the statements generated by visiting the first statement with initializer of the
             // body (1), while all other statements are added to remainingStatements (2)
-            const isVariableStatementWithInitializer = (stmt: Statement) => isVariableStatement(stmt) && !!first(stmt.declarationList.declarations).initializer;
+            const isVariableStatementWithInitializer = (stmt: Statement) => !isEndOfDeclarationMarker(stmt) &&
+                isVariableStatement(stmt) && !!first(stmt.declarationList.declarations).initializer;
+            const isEndOfDeclarationMarker = (stmt: Statement) => stmt.kind === SyntaxKind.EndOfDeclarationMarker;
             const bodyStatements = visitNodes(body.statements, visitor, isStatement);
             const classStatements = filter(bodyStatements, isVariableStatementWithInitializer);
             const remainingStatements = filter(bodyStatements, stmt => !isVariableStatementWithInitializer(stmt));
             const varStatement = cast(first(classStatements), isVariableStatement);
+            const endOfDeclarationMarkers = filter(bodyStatements, isEndOfDeclarationMarker);
 
             // We know there is only one variable declaration here as we verified this in an
             // earlier call to isTypeScriptClassWrapper
@@ -3382,12 +3385,17 @@ namespace ts {
                 addRange(statements, funcStatements, classBodyEnd + 1);
             }
 
+            // Add other class statements (such as the WeakMap declarations output by the 'esnext'
+            // transformer for private names).
+            addRange(statements, classStatements, /*start*/ 1);
+
             // Add the remaining statements of the outer wrapper.
             addRange(statements, remainingStatements);
 
             // The 'es2015' class transform may add an end-of-declaration marker. If so we will add it
             // after the remaining statements from the 'ts' transformer.
-            addRange(statements, classStatements, /*start*/ 1);
+            addRange(statements, endOfDeclarationMarkers);
+
 
             // Recreate any outer parentheses or partially-emitted expressions to preserve source map
             // and comment locations.
diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index b121eb315db84..3c3234b174817 100644
--- a/src/compiler/transformers/esnext.ts
+++ b/src/compiler/transformers/esnext.ts
@@ -26,6 +26,19 @@ namespace ts {
         let enclosingFunctionFlags: FunctionFlags;
         let enclosingSuperContainerFlags: NodeCheckFlags = 0;
 
+
+        /**
+         * Maps private names to the generated name of the WeakMap.
+         */
+        interface PrivateNameEnvironment {
+            [name: string]: {
+                weakMap: Identifier;
+                initializer?: Expression;
+            };
+        }
+        const privateNameEnvironmentStack: PrivateNameEnvironment[] = [];
+        let privateNameEnvironmentIndex = -1;
+
         return chainBundle(transformSourceFile);
 
         function transformSourceFile(node: SourceFile) {
@@ -101,11 +114,204 @@ namespace ts {
                     return visitParenthesizedExpression(node as ParenthesizedExpression, noDestructuringValue);
                 case SyntaxKind.CatchClause:
                     return visitCatchClause(node as CatchClause);
+                case SyntaxKind.PropertyAccessExpression:
+                    return visitPropertyAccessExpression(node as PropertyAccessExpression);
+                case SyntaxKind.ClassDeclaration:
+                    return visitClassDeclaration(node as ClassDeclaration);
+                case SyntaxKind.ClassExpression:
+                    return visitClassExpression(node as ClassExpression);
                 default:
                     return visitEachChild(node, visitor, context);
             }
         }
 
+        function currentPrivateNameEnvironment() {
+            return privateNameEnvironmentStack[privateNameEnvironmentIndex];
+        }
+
+        function addPrivateName(name: PrivateName, initializer?: Expression) {
+            const environment = currentPrivateNameEnvironment();
+            const nameString = name.escapedText as string;
+            if (nameString in environment) {
+                throw new Error("Redeclaring private name " + nameString + ".");
+            }
+            const weakMap = createFileLevelUniqueName("_" + nameString.substring(1));
+            environment[nameString] = {
+                weakMap,
+                initializer
+            };
+            return weakMap;
+        }
+
+        function accessPrivateName(name: PrivateName) {
+            const environment = currentPrivateNameEnvironment();
+            const nameString = name.escapedText as string;
+            if (nameString in environment) {
+                return environment[nameString].weakMap;
+            }
+            // Undeclared private name.
+            return undefined;
+        }
+
+        function visitPropertyAccessExpression(node: PropertyAccessExpression): Expression {
+            if (isPrivateName(node.name)) {
+                const weakMapName = accessPrivateName(node.name);
+                if (!weakMapName) {
+                    return node;
+                }
+                return setOriginalNode(
+                    setTextRange(
+                        createClassPrivateFieldGetHelper(context, node.expression, weakMapName),
+                        /* location */ node
+                    ),
+                    node
+                );
+            }
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitorCollectPrivateNames(node: Node): VisitResult<Node> {
+            if (isPrivateNamedPropertyDeclaration(node)) {
+                addPrivateName(node.name);
+                return undefined;
+            }
+            // Don't collect private names from nested classes.
+            if (isClassLike(node)) {
+                return node;
+            }
+            return visitEachChild(node, visitorCollectPrivateNames, context);
+        }
+
+        function visitClassDeclaration(node: ClassDeclaration) {
+            startPrivateNameEnvironment();
+            node = visitEachChild(node, visitorCollectPrivateNames, context);
+            node = visitEachChild(node, visitor, context);
+            const statements = createPrivateNameWeakMapDeclarations(
+                currentPrivateNameEnvironment()
+            );
+            if (statements.length) {
+                node = updateClassDeclaration(
+                    node,
+                    node.decorators,
+                    node.modifiers,
+                    node.name,
+                    node.typeParameters,
+                    node.heritageClauses,
+                    transformClassMembers(node.members)
+                );
+            }
+            statements.unshift(node);
+            endPrivateNameEnvironment();
+            return statements;
+        }
+
+        function visitClassExpression(node: ClassExpression) {
+            startPrivateNameEnvironment();
+            node = visitEachChild(node, visitorCollectPrivateNames, context);
+            node = visitEachChild(node, visitor, context);
+            const expressions = createPrivateNameWeakMapAssignments(
+                currentPrivateNameEnvironment()
+            );
+            if (expressions.length) {
+                node = updateClassExpression(
+                    node,
+                    node.modifiers,
+                    node.name,
+                    node.typeParameters,
+                    node.heritageClauses,
+                    transformClassMembers(node.members)
+                );
+            }
+            expressions.push(node);
+            endPrivateNameEnvironment();
+            return expressions.length > 1 ? createCommaList(expressions) : expressions[0];
+        }
+
+        function startPrivateNameEnvironment() {
+            // Create private name environment.
+            privateNameEnvironmentStack[++privateNameEnvironmentIndex] = {};
+            return currentPrivateNameEnvironment();
+        }
+
+        function endPrivateNameEnvironment(): PrivateNameEnvironment {
+            const privateNameEnvironment = currentPrivateNameEnvironment();
+            // Destroy private name environment.
+            delete privateNameEnvironmentStack[privateNameEnvironmentIndex--];
+            return privateNameEnvironment;
+        }
+
+        function createPrivateNameWeakMapDeclarations(environment: PrivateNameEnvironment): Statement[] {
+            return Object.keys(environment).map(name => {
+                const privateName = environment[name];
+                return createVariableStatement(
+                    /* modifiers */ undefined,
+                    [createVariableDeclaration(privateName.weakMap,
+                                               /* typeNode */ undefined,
+                        createNew(
+                            createIdentifier("WeakMap"),
+                                                   /* typeArguments */ undefined,
+                                                   /* argumentsArray */ undefined
+                        ))]
+                );
+            });
+        }
+
+        function createPrivateNameWeakMapAssignments(environment: PrivateNameEnvironment): Expression[] {
+            return Object.keys(environment).map(name => {
+                const privateName = environment[name];
+                hoistVariableDeclaration(privateName.weakMap);
+                return createBinary(
+                    privateName.weakMap,
+                    SyntaxKind.EqualsToken,
+                    createNew(createIdentifier("WeakMap"), /* typeArguments */ undefined, /* argumentsArray */ undefined)
+                );
+            });
+        }
+
+        function transformClassMembers(members: ReadonlyArray<ClassElement>): ClassElement[] {
+            // Rewrite constructor with private name initializers.
+            const privateNameEnvironment = currentPrivateNameEnvironment();
+            // Initialize private properties.
+            const initializerStatements = Object.keys(privateNameEnvironment).map(name => {
+                const privateName = privateNameEnvironment[name];
+                return createStatement(
+                    createCall(
+                        createPropertyAccess(privateName.weakMap, "set"),
+                        /* typeArguments */ undefined,
+                        [createThis(), privateName.initializer || createVoidZero()]
+                    )
+                );
+            });
+            const ctor = find(
+                members,
+                (member) => isConstructorDeclaration(member) && !!member.body
+            ) as ConstructorDeclaration | undefined;
+            if (ctor) {
+                const body = updateBlock(ctor.body!, [...initializerStatements, ...ctor.body!.statements]);
+                return members.map(member => {
+                    if (member === ctor) {
+                        return updateConstructor(
+                            ctor,
+                            ctor.decorators,
+                            ctor.modifiers,
+                            ctor.parameters,
+                            body
+                        );
+                    }
+                    return member;
+                });
+            }
+            return [
+                createConstructor(
+                    /* decorators */ undefined,
+                    /* modifiers */ undefined,
+                    /* parameters */ [],
+                    createBlock(initializerStatements)
+                ),
+                ...members
+            ];
+        }
+
         function visitAwaitExpression(node: AwaitExpression): Expression {
             if (enclosingFunctionFlags & FunctionFlags.Async && enclosingFunctionFlags & FunctionFlags.Generator) {
                 return setOriginalNode(
@@ -266,6 +472,55 @@ namespace ts {
                     visitNode(node.right, noDestructuringValue ? visitorNoDestructuringValue : visitor, isExpression)
                 );
             }
+            else if (isAssignmentOperator(node.operatorToken.kind) &&
+                     isPropertyAccessExpression(node.left) &&
+                     isPrivateName(node.left.name)) {
+
+                const weakMapName = accessPrivateName(node.left.name);
+                if (!weakMapName) {
+                    // Don't change output for undeclared private names (error).
+                    return node;
+                }
+                if (isCompoundAssignment(node.operatorToken.kind)) {
+                    let setReceiver: Expression;
+                    let getReceiver: Expression;
+                    const receiverExpr = node.left.expression;
+                    if (!isIdentifier(receiverExpr) && !isThisProperty(node.left) && !isSuperProperty(node.left)) {
+                        const tempVariable = createTempVariable(/* recordTempVariable */ undefined);
+                        hoistVariableDeclaration(tempVariable);
+                        setReceiver = createBinary(tempVariable, SyntaxKind.EqualsToken, node.left.expression);
+                        getReceiver = tempVariable;
+                    }
+                    else {
+                        getReceiver = node.left.expression;
+                        setReceiver = node.left.expression;
+                    }
+                    return setOriginalNode(
+                        createClassPrivateFieldSetHelper(
+                            context,
+                            setReceiver,
+                            weakMapName,
+                            createBinary(
+                                createClassPrivateFieldGetHelper(context, getReceiver, weakMapName),
+                                getOperatorForCompoundAssignment(node.operatorToken.kind),
+                                visitNode(node.right, visitor)
+                            )
+                        ),
+                        node
+                    );
+                }
+                else {
+                    return setOriginalNode(
+                        createClassPrivateFieldSetHelper(
+                            context,
+                            node.left.expression,
+                            weakMapName,
+                            visitNode(node.right, visitor)
+                        ),
+                        node
+                    );
+                }
+            }
             return visitEachChild(node, visitor, context);
         }
 
@@ -917,6 +1172,28 @@ namespace ts {
         );
     }
 
+    const classPrivateFieldGetHelper: EmitHelper = {
+        name: "typescript:classPrivateFieldGet",
+        scoped: false,
+        text: `var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };`
+    };
+
+    function createClassPrivateFieldGetHelper(context: TransformationContext, receiver: Expression, privateField: Identifier) {
+        context.requestEmitHelper(classPrivateFieldGetHelper);
+        return createCall(getHelperName("_classPrivateFieldGet"), /* typeArguments */ undefined, [ receiver, privateField ]);
+    }
+
+    const classPrivateFieldSetHelper: EmitHelper = {
+        name: "typescript:classPrivateFieldSet",
+        scoped: false,
+        text: `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; };`
+    };
+
+    function createClassPrivateFieldSetHelper(context: TransformationContext, receiver: Expression, privateField: Identifier, value: Expression) {
+        context.requestEmitHelper(classPrivateFieldSetHelper);
+        return createCall(getHelperName("_classPrivateFieldSet"), /* typeArguments */ undefined, [ receiver, privateField, value ]);
+    }
+
     const awaitHelper: EmitHelper = {
         name: "typescript:await",
         scoped: false,
diff --git a/src/compiler/transformers/generators.ts b/src/compiler/transformers/generators.ts
index 5778b47a4f8b4..66089c15388d3 100644
--- a/src/compiler/transformers/generators.ts
+++ b/src/compiler/transformers/generators.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`.
          *
diff --git a/src/compiler/transformers/ts.ts b/src/compiler/transformers/ts.ts
index 6eb8b6e0ef634..3ce50892297a0 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -2237,7 +2237,19 @@ namespace ts {
             return !nodeIsMissing(node.body);
         }
 
-        function visitPropertyDeclaration(node: PropertyDeclaration): undefined {
+        function visitPropertyDeclaration(node: PropertyDeclaration): PropertyDeclaration | undefined {
+            if (isPrivateName(node.name)) {
+                // Keep the private name declaration (without the initializer - which will be moved to the constructor).
+                return updateProperty(
+                    node,
+                    node.decorators,
+                    node.modifiers,
+                    node.name,
+                    node.questionToken,
+                    node.type,
+                    /*initializer*/ undefined
+                );
+            }
             const expr = getPropertyNameExpressionIfNeeded(node.name, some(node.decorators) || !!node.initializer, /*omitSimple*/ true);
             if (expr && !isSimpleInlineableExpression(expr)) {
                 (pendingExpressions || (pendingExpressions = [])).push(expr);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 4b2357bc63e77..a86badd2c56a4 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -864,6 +864,10 @@ namespace ts {
         initializer?: Expression;           // Optional initializer
     }
 
+    export interface PrivateNamedPropertyDeclaration extends PropertyDeclaration {
+        name: PrivateName;
+    }
+
     export interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrandBrand: any;
         name?: PropertyName;
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index b8e12539e07da..74c1e6086514f 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -3738,6 +3738,28 @@ namespace ts {
             && isLeftHandSideExpression(node.left);
     }
 
+    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;
+        }
+    }
+
     export function isDestructuringAssignment(node: Node): node is DestructuringAssignment {
         if (isAssignmentExpression(node, /*excludeCompoundAssignment*/ true)) {
             const kind = node.left.kind;
@@ -6069,6 +6091,10 @@ namespace ts {
         }
     }
 
+    export function isPrivateNamedPropertyDeclaration(node: Node): node is PrivateNamedPropertyDeclaration {
+        return node && isPropertyDeclaration(node) && isPrivateName(node.name);
+    }
+
     // Type members
 
     export function isTypeElement(node: Node): node is TypeElement {
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 1ab1a986d1ad1..0918ac03f824c 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -619,6 +619,9 @@ declare namespace ts {
         type?: TypeNode;
         initializer?: Expression;
     }
+    interface PrivateNamedPropertyDeclaration extends PropertyDeclaration {
+        name: PrivateName;
+    }
     interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrandBrand: any;
         name?: PropertyName;
@@ -3458,6 +3461,7 @@ declare namespace ts {
     function isClassElement(node: Node): node is ClassElement;
     function isClassLike(node: Node): node is ClassLikeDeclaration;
     function isAccessor(node: Node): node is AccessorDeclaration;
+    function isPrivateNamedPropertyDeclaration(node: Node): node is PrivateNamedPropertyDeclaration;
     function isTypeElement(node: Node): node is TypeElement;
     function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement;
     function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index ea78225538eac..acafe6f5d59a1 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -619,6 +619,9 @@ declare namespace ts {
         type?: TypeNode;
         initializer?: Expression;
     }
+    interface PrivateNamedPropertyDeclaration extends PropertyDeclaration {
+        name: PrivateName;
+    }
     interface ObjectLiteralElement extends NamedDeclaration {
         _objectLiteralBrandBrand: any;
         name?: PropertyName;
@@ -3458,6 +3461,7 @@ declare namespace ts {
     function isClassElement(node: Node): node is ClassElement;
     function isClassLike(node: Node): node is ClassLikeDeclaration;
     function isAccessor(node: Node): node is AccessorDeclaration;
+    function isPrivateNamedPropertyDeclaration(node: Node): node is PrivateNamedPropertyDeclaration;
     function isTypeElement(node: Node): node is TypeElement;
     function isClassOrTypeElement(node: Node): node is ClassElement | TypeElement;
     function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike;
diff --git a/tests/baselines/reference/privateNameField.js b/tests/baselines/reference/privateNameField.js
index f432be2b3d336..c65f812af0dd9 100644
--- a/tests/baselines/reference/privateNameField.js
+++ b/tests/baselines/reference/privateNameField.js
@@ -7,9 +7,12 @@ class A {
 }
 
 //// [privateNameField.js]
+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 A = /** @class */ (function () {
     function A(name) {
-        this.#name = name;
+        _name.set(this, void 0);
+        _classPrivateFieldSet(this, _name, name);
     }
     return A;
 }());
+var _name = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldAccess.js b/tests/baselines/reference/privateNameFieldAccess.js
new file mode 100644
index 0000000000000..60cae8f40371b
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldAccess.js
@@ -0,0 +1,21 @@
+//// [privateNameFieldAccess.ts]
+class Test {
+    #field: number;
+    method() {
+        console.log(this.#field);
+    }
+}
+
+
+//// [privateNameFieldAccess.js]
+var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };
+var Test = /** @class */ (function () {
+    function Test() {
+        _field.set(this, void 0);
+    }
+    Test.prototype.method = function () {
+        console.log(_classPrivateFieldGet(this, _field));
+    };
+    return Test;
+}());
+var _field = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldAccess.symbols b/tests/baselines/reference/privateNameFieldAccess.symbols
new file mode 100644
index 0000000000000..8410c84c92b50
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldAccess.symbols
@@ -0,0 +1,19 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts ===
+class Test {
+>Test : Symbol(Test, Decl(privateNameFieldAccess.ts, 0, 0))
+
+    #field: number;
+>#field : Symbol(Test[#field], Decl(privateNameFieldAccess.ts, 0, 12))
+
+    method() {
+>method : Symbol(Test.method, Decl(privateNameFieldAccess.ts, 1, 19))
+
+        console.log(this.#field);
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldAccess.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldAccess.ts, 0, 0))
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldAccess.types b/tests/baselines/reference/privateNameFieldAccess.types
new file mode 100644
index 0000000000000..c32358360be40
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldAccess.types
@@ -0,0 +1,20 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts ===
+class Test {
+>Test : Test
+
+    #field: number;
+>#field : number
+
+    method() {
+>method : () => void
+
+        console.log(this.#field);
+>console.log(this.#field) : void
+>console.log : (message?: any, ...optionalParams: any[]) => void
+>console : Console
+>log : (message?: any, ...optionalParams: any[]) => void
+>this.#field : number
+>this : this
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldInitializer.js b/tests/baselines/reference/privateNameFieldInitializer.js
new file mode 100644
index 0000000000000..5263b7a4e5b34
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldInitializer.js
@@ -0,0 +1,16 @@
+//// [privateNameFieldInitializer.ts]
+class Test {
+    #property: number = 100;
+}
+
+
+//// [privateNameFieldInitializer.js]
+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 Test = /** @class */ (function () {
+    function Test() {
+        _property.set(this, void 0);
+        _classPrivateFieldSet(this, _property, 100);
+    }
+    return Test;
+}());
+var _property = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldInitializer.symbols b/tests/baselines/reference/privateNameFieldInitializer.symbols
new file mode 100644
index 0000000000000..ed146bda6509e
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldInitializer.symbols
@@ -0,0 +1,8 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts ===
+class Test {
+>Test : Symbol(Test, Decl(privateNameFieldInitializer.ts, 0, 0))
+
+    #property: number = 100;
+>#property : Symbol(Test[#property], Decl(privateNameFieldInitializer.ts, 0, 12))
+}
+
diff --git a/tests/baselines/reference/privateNameFieldInitializer.types b/tests/baselines/reference/privateNameFieldInitializer.types
new file mode 100644
index 0000000000000..2aba97086ace9
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldInitializer.types
@@ -0,0 +1,9 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts ===
+class Test {
+>Test : Test
+
+    #property: number = 100;
+>#property : number
+>100 : 100
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutate.js b/tests/baselines/reference/privateNameFieldMutate.js
new file mode 100644
index 0000000000000..d8b0fb2898113
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutate.js
@@ -0,0 +1,19 @@
+//// [privateNameFieldMutate.ts]
+class Test {
+    #field: number;
+    constructor() {
+        this.#field = 100;
+    }
+}
+
+
+//// [privateNameFieldMutate.js]
+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 Test = /** @class */ (function () {
+    function Test() {
+        _field.set(this, void 0);
+        _classPrivateFieldSet(this, _field, 100);
+    }
+    return Test;
+}());
+var _field = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldMutate.symbols b/tests/baselines/reference/privateNameFieldMutate.symbols
new file mode 100644
index 0000000000000..a65469aeda9fb
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutate.symbols
@@ -0,0 +1,14 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutate.ts ===
+class Test {
+>Test : Symbol(Test, Decl(privateNameFieldMutate.ts, 0, 0))
+
+    #field: number;
+>#field : Symbol(Test[#field], Decl(privateNameFieldMutate.ts, 0, 12))
+
+    constructor() {
+        this.#field = 100;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutate.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutate.ts, 0, 0))
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutate.types b/tests/baselines/reference/privateNameFieldMutate.types
new file mode 100644
index 0000000000000..68e50b8670bf1
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutate.types
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutate.ts ===
+class Test {
+>Test : Test
+
+    #field: number;
+>#field : number
+
+    constructor() {
+        this.#field = 100;
+>this.#field = 100 : 100
+>this.#field : number
+>this : this
+>100 : 100
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutateBinaryOp.js b/tests/baselines/reference/privateNameFieldMutateBinaryOp.js
new file mode 100644
index 0000000000000..8e2a94b89e39e
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateBinaryOp.js
@@ -0,0 +1,42 @@
+//// [privateNameFieldMutateBinaryOp.ts]
+class Test {
+    #field: number;
+    constructor() {
+        this.#field += 1;
+        this.#field -= 2;
+        this.#field /= 3;
+        this.#field *= 4;
+        this.#field |= 5;
+        this.#field **= 6;
+        this.#field %= 7;
+        this.#field <<= 8;
+        this.#field >>= 9;
+        this.#field >>>= 10;
+        this.#field &= 11;
+        this.#field ^= 12;
+    }
+}
+
+
+//// [privateNameFieldMutateBinaryOp.js]
+var _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };
+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 Test = /** @class */ (function () {
+    function Test() {
+        _field.set(this, void 0);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) + 1);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) - 2);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) / 3);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) * 4);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) | 5);
+        _classPrivateFieldSet(this, _field, Math.pow(_classPrivateFieldGet(this, _field), 6));
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) % 7);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) << 8);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) >> 9);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) >>> 10);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) & 11);
+        _classPrivateFieldSet(this, _field, _classPrivateFieldGet(this, _field) ^ 12);
+    }
+    return Test;
+}());
+var _field = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldMutateBinaryOp.symbols b/tests/baselines/reference/privateNameFieldMutateBinaryOp.symbols
new file mode 100644
index 0000000000000..77dd44462f666
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateBinaryOp.symbols
@@ -0,0 +1,58 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateBinaryOp.ts ===
+class Test {
+>Test : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+    #field: number;
+>#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+
+    constructor() {
+        this.#field += 1;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field -= 2;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field /= 3;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field *= 4;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field |= 5;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field **= 6;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field %= 7;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field <<= 8;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field >>= 9;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field >>>= 10;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field &= 11;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+
+        this.#field ^= 12;
+>this.#field : Symbol(Test[#field], Decl(privateNameFieldMutateBinaryOp.ts, 0, 12))
+>this : Symbol(Test, Decl(privateNameFieldMutateBinaryOp.ts, 0, 0))
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutateBinaryOp.types b/tests/baselines/reference/privateNameFieldMutateBinaryOp.types
new file mode 100644
index 0000000000000..efd935fd68c2b
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateBinaryOp.types
@@ -0,0 +1,82 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateBinaryOp.ts ===
+class Test {
+>Test : Test
+
+    #field: number;
+>#field : number
+
+    constructor() {
+        this.#field += 1;
+>this.#field += 1 : number
+>this.#field : number
+>this : this
+>1 : 1
+
+        this.#field -= 2;
+>this.#field -= 2 : number
+>this.#field : number
+>this : this
+>2 : 2
+
+        this.#field /= 3;
+>this.#field /= 3 : number
+>this.#field : number
+>this : this
+>3 : 3
+
+        this.#field *= 4;
+>this.#field *= 4 : number
+>this.#field : number
+>this : this
+>4 : 4
+
+        this.#field |= 5;
+>this.#field |= 5 : number
+>this.#field : number
+>this : this
+>5 : 5
+
+        this.#field **= 6;
+>this.#field **= 6 : number
+>this.#field : number
+>this : this
+>6 : 6
+
+        this.#field %= 7;
+>this.#field %= 7 : number
+>this.#field : number
+>this : this
+>7 : 7
+
+        this.#field <<= 8;
+>this.#field <<= 8 : number
+>this.#field : number
+>this : this
+>8 : 8
+
+        this.#field >>= 9;
+>this.#field >>= 9 : number
+>this.#field : number
+>this : this
+>9 : 9
+
+        this.#field >>>= 10;
+>this.#field >>>= 10 : number
+>this.#field : number
+>this : this
+>10 : 10
+
+        this.#field &= 11;
+>this.#field &= 11 : number
+>this.#field : number
+>this : this
+>11 : 11
+
+        this.#field ^= 12;
+>this.#field ^= 12 : number
+>this.#field : number
+>this : this
+>12 : 12
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.js b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.js
new file mode 100644
index 0000000000000..a8ce123290523
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.js
@@ -0,0 +1,47 @@
+//// [privateNameFieldMutateNontrivialReceiver.ts]
+class Test {
+    #field: number;
+    static mutate(getReceiver: () => Test) {
+        getReceiver().#field = 100;
+        getReceiver().#field += 1;
+        getReceiver().#field -= 2;
+        getReceiver().#field /= 3;
+        getReceiver().#field *= 4;
+        getReceiver().#field |= 5;
+        getReceiver().#field **= 6;
+        getReceiver().#field %= 7;
+        getReceiver().#field <<= 8;
+        getReceiver().#field >>= 9;
+        getReceiver().#field >>>= 10;
+        getReceiver().#field &= 11;
+        getReceiver().#field ^= 12;
+    }
+}
+
+
+//// [privateNameFieldMutateNontrivialReceiver.js]
+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 _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };
+var Test = /** @class */ (function () {
+    function Test() {
+        _field.set(this, void 0);
+    }
+    Test.mutate = function (getReceiver) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        _classPrivateFieldSet(getReceiver(), _field, 100);
+        _classPrivateFieldSet(_a = getReceiver(), _field, _classPrivateFieldGet(_a, _field) + 1);
+        _classPrivateFieldSet(_b = getReceiver(), _field, _classPrivateFieldGet(_b, _field) - 2);
+        _classPrivateFieldSet(_c = getReceiver(), _field, _classPrivateFieldGet(_c, _field) / 3);
+        _classPrivateFieldSet(_d = getReceiver(), _field, _classPrivateFieldGet(_d, _field) * 4);
+        _classPrivateFieldSet(_e = getReceiver(), _field, _classPrivateFieldGet(_e, _field) | 5);
+        _classPrivateFieldSet(_f = getReceiver(), _field, Math.pow(_classPrivateFieldGet(_f, _field), 6));
+        _classPrivateFieldSet(_g = getReceiver(), _field, _classPrivateFieldGet(_g, _field) % 7);
+        _classPrivateFieldSet(_h = getReceiver(), _field, _classPrivateFieldGet(_h, _field) << 8);
+        _classPrivateFieldSet(_j = getReceiver(), _field, _classPrivateFieldGet(_j, _field) >> 9);
+        _classPrivateFieldSet(_k = getReceiver(), _field, _classPrivateFieldGet(_k, _field) >>> 10);
+        _classPrivateFieldSet(_l = getReceiver(), _field, _classPrivateFieldGet(_l, _field) & 11);
+        _classPrivateFieldSet(_m = getReceiver(), _field, _classPrivateFieldGet(_m, _field) ^ 12);
+    };
+    return Test;
+}());
+var _field = new WeakMap;
diff --git a/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.symbols b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.symbols
new file mode 100644
index 0000000000000..dc6a6487fd86f
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.symbols
@@ -0,0 +1,66 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateNontrivialReceiver.ts ===
+class Test {
+>Test : Symbol(Test, Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 0))
+
+    #field: number;
+>#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+
+    static mutate(getReceiver: () => Test) {
+>mutate : Symbol(Test.mutate, Decl(privateNameFieldMutateNontrivialReceiver.ts, 1, 19))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+>Test : Symbol(Test, Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 0))
+
+        getReceiver().#field = 100;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field += 1;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field -= 2;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field /= 3;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field *= 4;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field |= 5;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field **= 6;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field %= 7;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field <<= 8;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field >>= 9;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field >>>= 10;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field &= 11;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+
+        getReceiver().#field ^= 12;
+>getReceiver().#field : Symbol(Test[#field], Decl(privateNameFieldMutateNontrivialReceiver.ts, 0, 12))
+>getReceiver : Symbol(getReceiver, Decl(privateNameFieldMutateNontrivialReceiver.ts, 2, 18))
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.types b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.types
new file mode 100644
index 0000000000000..8083ba4e510f9
--- /dev/null
+++ b/tests/baselines/reference/privateNameFieldMutateNontrivialReceiver.types
@@ -0,0 +1,104 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateNontrivialReceiver.ts ===
+class Test {
+>Test : Test
+
+    #field: number;
+>#field : number
+
+    static mutate(getReceiver: () => Test) {
+>mutate : (getReceiver: () => Test) => void
+>getReceiver : () => Test
+
+        getReceiver().#field = 100;
+>getReceiver().#field = 100 : 100
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>100 : 100
+
+        getReceiver().#field += 1;
+>getReceiver().#field += 1 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>1 : 1
+
+        getReceiver().#field -= 2;
+>getReceiver().#field -= 2 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>2 : 2
+
+        getReceiver().#field /= 3;
+>getReceiver().#field /= 3 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>3 : 3
+
+        getReceiver().#field *= 4;
+>getReceiver().#field *= 4 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>4 : 4
+
+        getReceiver().#field |= 5;
+>getReceiver().#field |= 5 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>5 : 5
+
+        getReceiver().#field **= 6;
+>getReceiver().#field **= 6 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>6 : 6
+
+        getReceiver().#field %= 7;
+>getReceiver().#field %= 7 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>7 : 7
+
+        getReceiver().#field <<= 8;
+>getReceiver().#field <<= 8 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>8 : 8
+
+        getReceiver().#field >>= 9;
+>getReceiver().#field >>= 9 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>9 : 9
+
+        getReceiver().#field >>>= 10;
+>getReceiver().#field >>>= 10 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>10 : 10
+
+        getReceiver().#field &= 11;
+>getReceiver().#field &= 11 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>11 : 11
+
+        getReceiver().#field ^= 12;
+>getReceiver().#field ^= 12 : number
+>getReceiver().#field : number
+>getReceiver() : Test
+>getReceiver : () => Test
+>12 : 12
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameInitializationOrder.js b/tests/baselines/reference/privateNameInitializationOrder.js
new file mode 100644
index 0000000000000..daefcf894dcbe
--- /dev/null
+++ b/tests/baselines/reference/privateNameInitializationOrder.js
@@ -0,0 +1,25 @@
+//// [privateNameInitializationOrder.ts]
+let a = 0;
+class Test {
+    #one = ++a;
+    normalProp = ++a;
+    #two = this.#one + 1;
+}
+
+
+//// [privateNameInitializationOrder.js]
+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 _classPrivateFieldGet = function (receiver, privateMap) { if (!privateMap.has(receiver)) { throw new TypeError("attempted to get private field on non-instance"); } return privateMap.get(receiver); };
+var a = 0;
+var Test = /** @class */ (function () {
+    function Test() {
+        _one.set(this, void 0);
+        _two.set(this, void 0);
+        _classPrivateFieldSet(this, _one, ++a);
+        this.normalProp = ++a;
+        _classPrivateFieldSet(this, _two, _classPrivateFieldGet(this, _one) + 1);
+    }
+    return Test;
+}());
+var _one = new WeakMap;
+var _two = new WeakMap;
diff --git a/tests/baselines/reference/privateNameInitializationOrder.symbols b/tests/baselines/reference/privateNameInitializationOrder.symbols
new file mode 100644
index 0000000000000..4e1907226bb69
--- /dev/null
+++ b/tests/baselines/reference/privateNameInitializationOrder.symbols
@@ -0,0 +1,21 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameInitializationOrder.ts ===
+let a = 0;
+>a : Symbol(a, Decl(privateNameInitializationOrder.ts, 0, 3))
+
+class Test {
+>Test : Symbol(Test, Decl(privateNameInitializationOrder.ts, 0, 10))
+
+    #one = ++a;
+>#one : Symbol(Test[#one], Decl(privateNameInitializationOrder.ts, 1, 12))
+>a : Symbol(a, Decl(privateNameInitializationOrder.ts, 0, 3))
+
+    normalProp = ++a;
+>normalProp : Symbol(Test.normalProp, Decl(privateNameInitializationOrder.ts, 2, 15))
+>a : Symbol(a, Decl(privateNameInitializationOrder.ts, 0, 3))
+
+    #two = this.#one + 1;
+>#two : Symbol(Test[#two], Decl(privateNameInitializationOrder.ts, 3, 21))
+>this.#one : Symbol(Test[#one], Decl(privateNameInitializationOrder.ts, 1, 12))
+>this : Symbol(Test, Decl(privateNameInitializationOrder.ts, 0, 10))
+}
+
diff --git a/tests/baselines/reference/privateNameInitializationOrder.types b/tests/baselines/reference/privateNameInitializationOrder.types
new file mode 100644
index 0000000000000..5f12b7a054689
--- /dev/null
+++ b/tests/baselines/reference/privateNameInitializationOrder.types
@@ -0,0 +1,26 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameInitializationOrder.ts ===
+let a = 0;
+>a : number
+>0 : 0
+
+class Test {
+>Test : Test
+
+    #one = ++a;
+>#one : number
+>++a : number
+>a : number
+
+    normalProp = ++a;
+>normalProp : number
+>++a : number
+>a : number
+
+    #two = this.#one + 1;
+>#two : number
+>this.#one + 1 : number
+>this.#one : number
+>this : this
+>1 : 1
+}
+
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts
new file mode 100644
index 0000000000000..c1fbc86317788
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldAccess.ts
@@ -0,0 +1,6 @@
+class Test {
+    #field: number;
+    method() {
+        console.log(this.#field);
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts
new file mode 100644
index 0000000000000..267a29c982a83
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldInitializer.ts
@@ -0,0 +1,3 @@
+class Test {
+    #property: number = 100;
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutate.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutate.ts
new file mode 100644
index 0000000000000..f5ffdd6490c79
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutate.ts
@@ -0,0 +1,6 @@
+class Test {
+    #field: number;
+    constructor() {
+        this.#field = 100;
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateBinaryOp.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateBinaryOp.ts
new file mode 100644
index 0000000000000..056886c54e7af
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateBinaryOp.ts
@@ -0,0 +1,17 @@
+class Test {
+    #field: number;
+    constructor() {
+        this.#field += 1;
+        this.#field -= 2;
+        this.#field /= 3;
+        this.#field *= 4;
+        this.#field |= 5;
+        this.#field **= 6;
+        this.#field %= 7;
+        this.#field <<= 8;
+        this.#field >>= 9;
+        this.#field >>>= 10;
+        this.#field &= 11;
+        this.#field ^= 12;
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateNontrivialReceiver.ts b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateNontrivialReceiver.ts
new file mode 100644
index 0000000000000..1ba92e98918e1
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameFieldMutateNontrivialReceiver.ts
@@ -0,0 +1,18 @@
+class Test {
+    #field: number;
+    static mutate(getReceiver: () => Test) {
+        getReceiver().#field = 100;
+        getReceiver().#field += 1;
+        getReceiver().#field -= 2;
+        getReceiver().#field /= 3;
+        getReceiver().#field *= 4;
+        getReceiver().#field |= 5;
+        getReceiver().#field **= 6;
+        getReceiver().#field %= 7;
+        getReceiver().#field <<= 8;
+        getReceiver().#field >>= 9;
+        getReceiver().#field >>>= 10;
+        getReceiver().#field &= 11;
+        getReceiver().#field ^= 12;
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameInitializationOrder.ts b/tests/cases/conformance/classes/members/privateNames/privateNameInitializationOrder.ts
new file mode 100644
index 0000000000000..90906299640fb
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameInitializationOrder.ts
@@ -0,0 +1,6 @@
+let a = 0;
+class Test {
+    #one = ++a;
+    normalProp = ++a;
+    #two = this.#one + 1;
+}