diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
index 44e6487c7c423..713708952ffae 100644
--- a/src/compiler/binder.ts
+++ b/src/compiler/binder.ts
@@ -266,6 +266,9 @@ namespace ts {
                     Debug.assert(isWellKnownSymbolSyntactically(nameExpression));
                     return getPropertyNameForKnownSymbolName(idText((<PropertyAccessExpression>nameExpression).name));
                 }
+                if (isPrivateName(node)) {
+                    return nodePosToString(node) as __String;
+                }
                 return isPropertyNameLiteral(name) ? getEscapedTextOfIdentifierOrLiteral(name) : undefined;
             }
             switch (node.kind) {
@@ -1394,7 +1397,7 @@ namespace ts {
             }
             if (node.expression.kind === SyntaxKind.PropertyAccessExpression) {
                 const propertyAccess = <PropertyAccessExpression>node.expression;
-                if (isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) {
+                if (isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && isPushOrUnshiftIdentifier(propertyAccess.name)) {
                     currentFlow = createFlowArrayMutation(currentFlow, node);
                 }
             }
@@ -2359,7 +2362,7 @@ namespace ts {
                 return;
             }
             const lhs = node.left as PropertyAccessEntityNameExpression;
-            const symbol = forEachIdentifierInEntityName(lhs.expression, /*parent*/ undefined, (id, symbol) => {
+            const symbol = forEachIdentifierOrPrivateNameInEntityName(lhs.expression, /*parent*/ undefined, (id, symbol) => {
                 if (symbol) {
                     addDeclarationToSymbol(symbol, id, SymbolFlags.Module | SymbolFlags.JSContainer);
                 }
@@ -2518,7 +2521,7 @@ namespace ts {
                 // make symbols or add declarations for intermediate containers
                 const flags = SymbolFlags.Module | SymbolFlags.JSContainer;
                 const excludeFlags = SymbolFlags.ValueModuleExcludes & ~SymbolFlags.JSContainer;
-                namespaceSymbol = forEachIdentifierInEntityName(propertyAccess.expression, namespaceSymbol, (id, symbol, parent) => {
+                namespaceSymbol = forEachIdentifierOrPrivateNameInEntityName(propertyAccess.expression, namespaceSymbol, (id, symbol, parent) => {
                     if (symbol) {
                         addDeclarationToSymbol(symbol, id, flags);
                         return symbol;
@@ -2590,7 +2593,7 @@ namespace ts {
             }
         }
 
-        function forEachIdentifierInEntityName(e: EntityNameExpression, parent: Symbol | undefined, action: (e: Identifier, symbol: Symbol | undefined, parent: Symbol | undefined) => Symbol | undefined): Symbol | undefined {
+        function forEachIdentifierOrPrivateNameInEntityName(e: EntityNameExpression, parent: Symbol | undefined, action: (e: Identifier | PrivateName, symbol: Symbol | undefined, parent: Symbol | undefined) => Symbol | undefined): Symbol | undefined {
             if (isExportsOrModuleExportsOrAlias(file, e)) {
                 return file.symbol;
             }
@@ -2598,7 +2601,7 @@ namespace ts {
                 return action(e, lookupSymbolForPropertyAccess(e), parent);
             }
             else {
-                const s = forEachIdentifierInEntityName(e.expression, parent, action);
+                const s = forEachIdentifierOrPrivateNameInEntityName(e.expression, parent, action);
                 if (!s || !s.exports) return Debug.fail();
                 return action(e.name, s.exports.get(e.name.escapedText), s);
             }
@@ -3308,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;
     }
@@ -3445,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/checker.ts b/src/compiler/checker.ts
index 0b357bd771da4..bb68b71a02e2d 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -14346,8 +14346,10 @@ namespace ts {
             const root = getReferenceRoot(node);
             const parent = root.parent;
             const isLengthPushOrUnshift = parent.kind === SyntaxKind.PropertyAccessExpression && (
-                (<PropertyAccessExpression>parent).name.escapedText === "length" ||
-                parent.parent.kind === SyntaxKind.CallExpression && isPushOrUnshiftIdentifier((<PropertyAccessExpression>parent).name));
+                (<PropertyAccessExpression>parent).name.escapedText === "length" || (
+                    parent.parent.kind === SyntaxKind.CallExpression
+                    && isIdentifier((parent as PropertyAccessExpression).name)
+                    && isPushOrUnshiftIdentifier((parent as PropertyAccessExpression).name as Identifier)));
             const isElementAssignment = parent.kind === SyntaxKind.ElementAccessExpression &&
                 (<ElementAccessExpression>parent).expression === root &&
                 parent.parent.kind === SyntaxKind.BinaryExpression &&
@@ -17972,7 +17974,7 @@ namespace ts {
             return checkPropertyAccessExpressionOrQualifiedName(node, node.left, node.right);
         }
 
-        function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier) {
+        function checkPropertyAccessExpressionOrQualifiedName(node: PropertyAccessExpression | QualifiedName, left: Expression | QualifiedName, right: Identifier | PrivateName) {
             let propType: Type;
             const leftType = checkNonNullExpression(left);
             const parentSymbol = getNodeLinks(left).resolvedSymbol;
@@ -17990,7 +17992,7 @@ namespace ts {
             }
             if (!prop) {
                 const indexInfo = getIndexInfoOfType(apparentType, IndexKind.String);
-                if (!(indexInfo && indexInfo.type)) {
+                if (!(indexInfo && indexInfo.type) || isPrivateName(right)) {
                     if (isJSLiteralType(leftType)) {
                         return anyType;
                     }
@@ -18048,7 +18050,7 @@ namespace ts {
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
 
-        function checkPropertyNotUsedBeforeDeclaration(prop: Symbol, node: PropertyAccessExpression | QualifiedName, right: Identifier): void {
+        function checkPropertyNotUsedBeforeDeclaration(prop: Symbol, node: PropertyAccessExpression | QualifiedName, right: Identifier | PrivateName): void {
             const { valueDeclaration } = prop;
             if (!valueDeclaration) {
                 return;
@@ -18118,7 +18120,7 @@ namespace ts {
             return getIntersectionType(x);
         }
 
-        function reportNonexistentProperty(propNode: Identifier, containingType: Type) {
+        function reportNonexistentProperty(propNode: Identifier | PrivateName, containingType: Type) {
             let errorInfo: DiagnosticMessageChain | undefined;
             let relatedInfo: Diagnostic | undefined;
             if (containingType.flags & TypeFlags.Union && !(containingType.flags & TypeFlags.Primitive)) {
@@ -18161,11 +18163,11 @@ namespace ts {
             return prop !== undefined && prop.valueDeclaration && hasModifier(prop.valueDeclaration, ModifierFlags.Static);
         }
 
-        function getSuggestedSymbolForNonexistentProperty(name: Identifier | string, containingType: Type): Symbol | undefined {
+        function getSuggestedSymbolForNonexistentProperty(name: Identifier | PrivateName | string, containingType: Type): Symbol | undefined {
             return getSpellingSuggestionForName(isString(name) ? name : idText(name), getPropertiesOfType(containingType), SymbolFlags.Value);
         }
 
-        function getSuggestionForNonexistentProperty(name: Identifier | string, containingType: Type): string | undefined {
+        function getSuggestionForNonexistentProperty(name: Identifier | PrivateName | string, containingType: Type): string | undefined {
             const suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType);
             return suggestion && symbolName(suggestion);
         }
@@ -21876,6 +21878,9 @@ namespace ts {
             checkGrammarDecoratorsAndModifiers(node);
 
             checkVariableLikeDeclaration(node);
+            if (node.name && isIdentifier(node.name) && node.name.originalKeywordKind === SyntaxKind.PrivateName) {
+                error(node, Diagnostics.Private_names_cannot_be_used_as_parameters);
+            }
             const func = getContainingFunction(node)!;
             if (hasModifier(node, ModifierFlags.ParameterPropertyModifier)) {
                 if (!(func.kind === SyntaxKind.Constructor && nodeIsPresent(func.body))) {
@@ -23523,9 +23528,9 @@ namespace ts {
             }
         }
 
-        function getIdentifierFromEntityNameExpression(node: Identifier | PropertyAccessExpression): Identifier;
-        function getIdentifierFromEntityNameExpression(node: Expression): Identifier | undefined;
-        function getIdentifierFromEntityNameExpression(node: Expression): Identifier | undefined {
+        function getIdentifierFromEntityNameExpression(node: Identifier | PropertyAccessExpression): Identifier | PrivateName;
+        function getIdentifierFromEntityNameExpression(node: Expression): Identifier | PrivateName | undefined;
+        function getIdentifierFromEntityNameExpression(node: Expression): Identifier | PrivateName | undefined {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                     return node as Identifier;
@@ -29288,6 +29293,10 @@ namespace ts {
                 checkESModuleMarker(node.name);
             }
 
+            if (isIdentifier(node.name) && node.name.originalKeywordKind === SyntaxKind.PrivateName) {
+                return grammarErrorOnNode(node.name, Diagnostics.Private_names_are_not_allowed_in_variable_declarations);
+            }
+
             const checkLetConstNames = (isLet(node) || isVarConst(node));
 
             // 1. LexicalDeclaration : LetOrConst BindingList ;
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index 6000c48de4dc3..a1d6859db7154 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -4166,6 +4166,14 @@
         "category": "Error",
         "code": 18003
     },
+    "Private names are not allowed in variable declarations.": {
+        "category": "Error",
+        "code": 18004
+    },
+    "Private names cannot be used as parameters": {
+        "category": "Error",
+        "code": 18005
+    },
 
     "File is a CommonJS module; it may be converted to an ES6 module.": {
         "category": "Suggestion",
diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
index badbfc4fa3fa6..a9abafc38123e 100644
--- a/src/compiler/emitter.ts
+++ b/src/compiler/emitter.ts
@@ -609,6 +609,10 @@ namespace ts {
                     case SyntaxKind.Identifier:
                         return emitIdentifier(<Identifier>node);
 
+                    // PrivateNames
+                    case SyntaxKind.PrivateName:
+                        return emitPrivateName(node as PrivateName);
+
                     // Parse tree nodes
 
                     // Names
@@ -878,6 +882,10 @@ namespace ts {
                     case SyntaxKind.Identifier:
                         return emitIdentifier(<Identifier>node);
 
+                    // Private Names
+                    case SyntaxKind.PrivateName:
+                        return emitPrivateName(node as PrivateName);
+
                     // Reserved words
                     case SyntaxKind.FalseKeyword:
                     case SyntaxKind.NullKeyword:
@@ -1067,6 +1075,12 @@ namespace ts {
             emitList(node, node.typeArguments, ListFormat.TypeParameters); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments
         }
 
+        function emitPrivateName(node: PrivateName) {
+            const writeText = node.symbol ? writeSymbol : write;
+            writeText(getTextOfNode(node, /*includeTrivia*/ false), node.symbol);
+            emitList(node, /*typeArguments*/ undefined, ListFormat.TypeParameters); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments
+        }
+
         //
         // Names
         //
@@ -3302,7 +3316,7 @@ namespace ts {
         function getLiteralTextOfNode(node: LiteralLikeNode): string {
             if (node.kind === SyntaxKind.StringLiteral && (<StringLiteral>node).textSourceNode) {
                 const textSourceNode = (<StringLiteral>node).textSourceNode!;
-                if (isIdentifier(textSourceNode)) {
+                if (isIdentifierOrPrivateName(textSourceNode)) {
                     return getEmitFlags(node) & EmitFlags.NoAsciiEscaping ?
                         `"${escapeString(getTextOfNode(textSourceNode))}"` :
                         `"${escapeNonAsciiString(getTextOfNode(textSourceNode))}"`;
diff --git a/src/compiler/factory.ts b/src/compiler/factory.ts
index 4bb374682e087..154416b78567c 100644
--- a/src/compiler/factory.ts
+++ b/src/compiler/factory.ts
@@ -105,7 +105,7 @@ namespace ts {
         return node;
     }
 
-    function createLiteralFromNode(sourceNode: PropertyNameLiteral): StringLiteral {
+    function createLiteralFromNode(sourceNode: Exclude<PropertyNameLiteral, PrivateName>): StringLiteral {
         const node = createStringLiteral(getTextOfIdentifierOrLiteral(sourceNode));
         node.textSourceNode = sourceNode;
         return node;
@@ -995,7 +995,7 @@ namespace ts {
             : node;
     }
 
-    export function createPropertyAccess(expression: Expression, name: string | Identifier | undefined) {
+    export function createPropertyAccess(expression: Expression, name: string | Identifier | PrivateName | undefined) {
         const node = <PropertyAccessExpression>createSynthesizedNode(SyntaxKind.PropertyAccessExpression);
         node.expression = parenthesizeForAccess(expression);
         node.name = asName(name)!; // TODO: GH#18217
@@ -1003,7 +1003,7 @@ namespace ts {
         return node;
     }
 
-    export function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier) {
+    export function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateName) {
         // Because we are updating existed propertyAccess we want to inherit its emitFlags
         // instead of using the default from createPropertyAccess
         return node.expression !== expression
@@ -2714,7 +2714,7 @@ namespace ts {
 
     // Utilities
 
-    function asName<T extends Identifier | BindingName | PropertyName | EntityName | ThisTypeNode | undefined>(name: string | T): T | Identifier {
+    function asName<T extends Identifier | PrivateName | BindingName | PropertyName | EntityName | ThisTypeNode | undefined>(name: string | T): T | Identifier {
         return isString(name) ? createIdentifier(name) : name;
     }
 
@@ -3099,7 +3099,7 @@ namespace ts {
         }
         else {
             const expression = setTextRange(
-                isIdentifier(memberName)
+                (isIdentifier(memberName) || isPrivateName(memberName))
                     ? createPropertyAccess(target, memberName)
                     : createElementAccess(target, memberName),
                 memberName
@@ -3529,7 +3529,7 @@ namespace ts {
         }
     }
 
-    export function createExpressionForPropertyName(memberName: PropertyName): Expression {
+    export function createExpressionForPropertyName(memberName: Exclude<PropertyName, PrivateName>): Expression {
         if (isIdentifier(memberName)) {
             return createLiteral(memberName);
         }
@@ -3541,11 +3541,17 @@ namespace ts {
         }
     }
 
+    /**
+     * accessor declaration that can be converted to an expression (`name` field cannot be a `PrivateName`)
+     */
+    type ExpressionableAccessorDeclaration = AccessorDeclaration & {name: Exclude<PropertyName, PrivateName>};
+
     export function createExpressionForObjectLiteralElementLike(node: ObjectLiteralExpression, property: ObjectLiteralElementLike, receiver: Expression): Expression | undefined {
         switch (property.kind) {
             case SyntaxKind.GetAccessor:
             case SyntaxKind.SetAccessor:
-                return createExpressionForAccessorDeclaration(node.properties, property, receiver, !!node.multiLine);
+                // type assertion `as ExpressionableAccessorDeclaration` is safe because PrivateNames are not allowed in object literals
+                return createExpressionForAccessorDeclaration(node.properties, property as ExpressionableAccessorDeclaration, receiver, !!node.multiLine);
             case SyntaxKind.PropertyAssignment:
                 return createExpressionForPropertyAssignment(property, receiver);
             case SyntaxKind.ShorthandPropertyAssignment:
@@ -3555,7 +3561,7 @@ namespace ts {
         }
     }
 
-    function createExpressionForAccessorDeclaration(properties: NodeArray<Declaration>, property: AccessorDeclaration, receiver: Expression, multiLine: boolean) {
+    function createExpressionForAccessorDeclaration(properties: NodeArray<Declaration>, property: ExpressionableAccessorDeclaration, receiver: Expression, multiLine: boolean) {
         const { firstAccessor, getAccessor, setAccessor } = getAllAccessorDeclarations(properties, property);
         if (property === firstAccessor) {
             const properties: ObjectLiteralElementLike[] = [];
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index 096c3f163543c..bf7454d46c296 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1365,6 +1365,9 @@ namespace ts {
             if (allowComputedPropertyNames && token() === SyntaxKind.OpenBracketToken) {
                 return parseComputedPropertyName();
             }
+            if (token() === SyntaxKind.PrivateName) {
+                return parsePrivateName();
+            }
             return parseIdentifierName();
         }
 
@@ -1388,6 +1391,17 @@ namespace ts {
             return finishNode(node);
         }
 
+        function createPrivateName(): PrivateName {
+                const node = createNode(SyntaxKind.PrivateName) as PrivateName;
+                node.escapedText = escapeLeadingUnderscores(scanner.getTokenText());
+                nextToken();
+                return finishNode(node);
+        }
+
+        function parsePrivateName(): PrivateName {
+            return createPrivateName();
+        }
+
         function parseContextualModifier(t: SyntaxKind): boolean {
             return token() === t && tryParse(nextTokenCanFollowModifier);
         }
@@ -2131,7 +2145,7 @@ namespace ts {
                     break;
                 }
                 dotPos = scanner.getStartPos();
-                entity = createQualifiedName(entity, parseRightSideOfDot(allowReservedWords));
+                entity = createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, /* allowPrivateNames */ false) as Identifier);
             }
             return entity;
         }
@@ -2143,7 +2157,7 @@ namespace ts {
             return finishNode(node);
         }
 
-        function parseRightSideOfDot(allowIdentifierNames: boolean): Identifier {
+        function parseRightSideOfDot(allowIdentifierNames: boolean, allowPrivateNames: boolean): Identifier | PrivateName {
             // Technically a keyword is valid here as all identifiers and keywords are identifier names.
             // However, often we'll encounter this in error situations when the identifier or keyword
             // is actually starting another valid construct.
@@ -2174,6 +2188,10 @@ namespace ts {
                 }
             }
 
+            if (allowPrivateNames && token() === SyntaxKind.PrivateName) {
+                return parsePrivateName();
+            }
+
             return allowIdentifierNames ? parseIdentifierName() : parseIdentifier();
         }
 
@@ -4169,7 +4187,8 @@ namespace ts {
             const node = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
             node.expression = expression;
             parseExpectedToken(SyntaxKind.DotToken, Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access);
-            node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+            // private names will never work with `super` (`super.#foo`), but that's a semantic error, not syntactic
+            node.name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateNames*/ true);
             return finishNode(node);
         }
 
@@ -4339,7 +4358,7 @@ namespace ts {
             while (parseOptional(SyntaxKind.DotToken)) {
                 const propertyAccess: JsxTagNamePropertyAccess = <JsxTagNamePropertyAccess>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
                 propertyAccess.expression = expression;
-                propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+                propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateNames*/ true);
                 expression = finishNode(propertyAccess);
             }
             return expression;
@@ -4442,7 +4461,7 @@ namespace ts {
                 if (dotToken) {
                     const propertyAccess = <PropertyAccessExpression>createNode(SyntaxKind.PropertyAccessExpression, expression.pos);
                     propertyAccess.expression = expression;
-                    propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true);
+                    propertyAccess.name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateNames*/ true);
                     expression = finishNode(propertyAccess);
                     continue;
                 }
diff --git a/src/compiler/scanner.ts b/src/compiler/scanner.ts
index 61ce8330bff77..98a3c6c96cdb6 100644
--- a/src/compiler/scanner.ts
+++ b/src/compiler/scanner.ts
@@ -1723,6 +1723,20 @@ namespace ts {
                         error(Diagnostics.Invalid_character);
                         pos++;
                         return token = SyntaxKind.Unknown;
+                    case CharacterCodes.hash:
+                        pos++;
+                        if (isIdentifierStart(ch = text.charCodeAt(pos), languageVersion)) {
+                            pos++;
+                            while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion)) pos++;
+                            tokenValue = text.substring(tokenPos, pos);
+                            if (ch === CharacterCodes.backslash) {
+                                tokenValue += scanIdentifierParts();
+                            }
+                            return token = SyntaxKind.PrivateName;
+                        }
+                        error(Diagnostics.Invalid_character);
+                        // no `pos++` because already advanced at beginning of this `case` statement
+                        return token = SyntaxKind.Unknown;
                     default:
                         if (isIdentifierStart(ch, languageVersion)) {
                             pos++;
diff --git a/src/compiler/transformers/destructuring.ts b/src/compiler/transformers/destructuring.ts
index 14d1659dc7626..115cb76663c8d 100644
--- a/src/compiler/transformers/destructuring.ts
+++ b/src/compiler/transformers/destructuring.ts
@@ -535,7 +535,8 @@ namespace ts {
         const propertyNames: Expression[] = [];
         let computedTempVariableOffset = 0;
         for (let i = 0; i < elements.length - 1; i++) {
-            const propertyName = getPropertyNameOfBindingOrAssignmentElement(elements[i]);
+            // can safely assume property name is not a PrivateName because PrivateNames are not allowed in object literals
+            const propertyName = getPropertyNameOfBindingOrAssignmentElement(elements[i]) as Exclude<PropertyName, PrivateName>;
             if (propertyName) {
                 if (isComputedPropertyName(propertyName)) {
                     const temp = computedTempVariables[computedTempVariableOffset];
diff --git a/src/compiler/transformers/es2015.ts b/src/compiler/transformers/es2015.ts
index bffdc5809b0e8..1822b89dbd9ad 100644
--- a/src/compiler/transformers/es2015.ts
+++ b/src/compiler/transformers/es2015.ts
@@ -1642,7 +1642,8 @@ namespace ts {
             setEmitFlags(target, EmitFlags.NoComments | EmitFlags.NoTrailingSourceMap);
             setSourceMapRange(target, firstAccessor.name); // TODO: GH#18217
 
-            const propertyName = createExpressionForPropertyName(visitNode(firstAccessor.name, visitor, isPropertyName));
+            // TODO: GH#9950 get rid of this type assertion and handle private names
+            const propertyName = createExpressionForPropertyName(visitNode(firstAccessor.name, visitor, isPropertyName) as Exclude<PropertyName, PrivateName>);
             setEmitFlags(propertyName, EmitFlags.NoComments | EmitFlags.NoLeadingSourceMap);
             setSourceMapRange(propertyName, firstAccessor.name);
 
@@ -3305,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
@@ -3381,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/es5.ts b/src/compiler/transformers/es5.ts
index 1c85e684e8cba..36ff996dca594 100644
--- a/src/compiler/transformers/es5.ts
+++ b/src/compiler/transformers/es5.ts
@@ -82,7 +82,10 @@ namespace ts {
          * @param node A PropertyAccessExpression
          */
         function substitutePropertyAccessExpression(node: PropertyAccessExpression): Expression {
-            const literalName = trySubstituteReservedName(node.name);
+            if (isPrivateName(node)) {
+                return node;
+            }
+            const literalName = trySubstituteReservedName(node.name as Identifier);
             if (literalName) {
                 return setTextRange(createElementAccess(node.expression, literalName), node);
             }
diff --git a/src/compiler/transformers/esnext.ts b/src/compiler/transformers/esnext.ts
index b121eb315db84..7cd08e90e614b 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,202 @@ 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);
+                case SyntaxKind.CallExpression:
+                    return visitCallExpression(node as CallExpression);
                 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;
+            }
+            throw new Error("Accessing undeclared private name.");
+        }
+
+        function visitPropertyAccessExpression(node: PropertyAccessExpression): Expression {
+            if (isPrivateName(node.name)) {
+                const weakMapName = accessPrivateName(node.name);
+                return setOriginalNode(
+                    setTextRange(
+                        createClassPrivateFieldGetHelper(context, node.expression, weakMapName),
+                        /* location */ node
+                    ),
+                    node
+                );
+            }
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitorCollectPrivateNames(node: Node): VisitResult<Node> {
+            if (isPropertyDeclaration(node) && isPrivateName(node.name)) {
+                addPrivateName(node.name, node.initializer);
+                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 +470,88 @@ 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 (isCompoundAssignment(node.operatorToken.kind)) {
+                    let setReceiver: Expression;
+                    let getReceiver: Identifier;
+                    if (!isIdentifier(node.left.expression) && !isKeyword(node.left.expression.kind)) {
+                        getReceiver = createTempVariable(/* recordTempVariable */ undefined);
+                        hoistVariableDeclaration(getReceiver);
+                        setReceiver = createBinary(getReceiver, SyntaxKind.EqualsToken, node.left.expression);
+                    }
+                    else {
+                        getReceiver = node.left.expression as Identifier;
+                        setReceiver = node.left.expression as Identifier;
+                    }
+                    return setOriginalNode(
+                        createClassPrivateFieldSetHelper(
+                            context,
+                            setReceiver,
+                            weakMapName,
+                            createBinary(
+                                createClassPrivateFieldGetHelper(context, getReceiver, weakMapName),
+                                getOperatorForCompoundAssignment(node.operatorToken.kind),
+                                node.right
+                            )
+                        ),
+                        node
+                    );
+                }
+                else {
+                    return setOriginalNode(
+                        createClassPrivateFieldSetHelper(context, node.left.expression, weakMapName, node.right),
+                        node
+                    );
+                }
+            }
+            return visitEachChild(node, visitor, context);
+        }
+
+        function visitCallExpression(node: CallExpression) {
+            if (isPropertyAccessExpression(node.expression) &&
+                isPrivateName(node.expression.name)) {
+
+                return updateCall(
+                    node,
+                    createPropertyAccess(
+                        setOriginalNode(
+                            createClassPrivateFieldGetHelper(
+                                context,
+                                node.expression.expression,
+                                accessPrivateName(node.expression.name)
+                            ),
+                            node.expression
+                        ),
+                        "call"
+                    ),
+                    node.typeArguments,
+                    [node.expression.expression, ...node.arguments]
+                );
+            }
+            else if (isParenthesizedExpression(node.expression) &&
+                     isPropertyAccessExpression(node.expression.expression) &&
+                     isPrivateName(node.expression.expression.name)) {
+                return updateCall(
+                    node,
+                    createPropertyAccess(
+                        updateParen(
+                            node.expression,
+                            createClassPrivateFieldGetHelper(
+                                context,
+                                node.expression.expression.expression,
+                                accessPrivateName(node.expression.expression.name)
+                            )
+                        ),
+                        "call"
+                    ),
+                    node.typeArguments,
+                    [node.expression.expression.expression, ...node.arguments]
+                );
+            }
             return visitEachChild(node, visitor, context);
         }
 
@@ -917,6 +1203,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 7af0b7c5ad77c..7a4c0f4e06e50 100644
--- a/src/compiler/transformers/ts.ts
+++ b/src/compiler/transformers/ts.ts
@@ -973,7 +973,7 @@ namespace ts {
             // Check if we have property assignment inside class declaration.
             // If there is a property assignment, we need to emit constructor whether users define it or not
             // If there is no property assignment, we can omit constructor if users do not define it
-            const hasInstancePropertyWithInitializer = forEach(node.members, isInstanceInitializedProperty);
+            const hasInstancePropertyWithInitializer = forEach(node.members, member => isInstanceInitializedProperty(member) && !isPrivateProperty(member));
             const hasParameterPropertyAssignments = node.transformFlags & TransformFlags.ContainsParameterPropertyAssignments;
             const constructor = getFirstConstructorWithBody(node);
 
@@ -1194,6 +1194,11 @@ namespace ts {
             );
         }
 
+        function isPrivateProperty(member: ClassElement): member is PropertyDeclaration {
+            return member.kind === SyntaxKind.PropertyDeclaration &&
+                !!member.name && isPrivateName(member.name);
+        }
+
         /**
          * Gets all property declarations with initializers on either the static or instance side of a class.
          *
@@ -1242,10 +1247,12 @@ namespace ts {
          */
         function addInitializedPropertyStatements(statements: Statement[], properties: ReadonlyArray<PropertyDeclaration>, receiver: LeftHandSideExpression) {
             for (const property of properties) {
-                const statement = createExpressionStatement(transformInitializedProperty(property, receiver));
+                if (isPrivateProperty(property)) {
+                    continue;
+                }
+                const statement = createStatement(transformInitializedProperty(property, receiver));
                 setSourceMapRange(statement, moveRangePastModifiers(property));
                 setCommentRange(statement, property);
-                setOriginalNode(statement, property);
                 statements.push(statement);
             }
         }
@@ -1259,6 +1266,9 @@ namespace ts {
         function generateInitializedPropertyExpressions(properties: ReadonlyArray<PropertyDeclaration>, receiver: LeftHandSideExpression) {
             const expressions: Expression[] = [];
             for (const property of properties) {
+                if (isPrivateProperty(property)) {
+                    continue;
+                }
                 const expression = transformInitializedProperty(property, receiver);
                 startOnNewLine(expression);
                 setSourceMapRange(expression, moveRangePastModifiers(property));
@@ -2136,7 +2146,7 @@ namespace ts {
                     ? getGeneratedNameForNode(name)
                     : name.expression;
             }
-            else if (isIdentifier(name)) {
+            else if (isIdentifier(name) || isPrivateName(name)) {
                 return createLiteral(idText(name));
             }
             else {
@@ -2237,7 +2247,11 @@ 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.
+                return node;
+            }
             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 8696512071d54..4b2357bc63e77 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -116,8 +116,9 @@ namespace ts {
         AmpersandEqualsToken,
         BarEqualsToken,
         CaretEqualsToken,
-        // Identifiers
+        // Identifiers and PrivateNames
         Identifier,
+        PrivateName,
         // Reserved words
         BreakKeyword,
         CaseKeyword,
@@ -711,9 +712,9 @@ namespace ts {
 
     export type EntityName = Identifier | QualifiedName;
 
-    export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
+    export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName;
 
-    export type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern;
+    export type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName | BindingPattern;
 
     export interface Declaration extends Node {
         _declarationBrand: any;
@@ -743,6 +744,13 @@ namespace ts {
         expression: Expression;
     }
 
+    export interface PrivateName extends Declaration {
+        kind: SyntaxKind.PrivateName;
+        // escaping not strictly necessary
+        // avoids gotchas in transforms and utils
+        escapedText: __String;
+    }
+
     /* @internal */
     // A name that supports late-binding (used in checker)
     export interface LateBoundName extends ComputedPropertyName {
@@ -1180,7 +1188,7 @@ namespace ts {
 
     export interface StringLiteral extends LiteralExpression {
         kind: SyntaxKind.StringLiteral;
-        /* @internal */ textSourceNode?: Identifier | StringLiteralLike | NumericLiteral; // Allows a StringLiteral to get its text from another node (used by transforms).
+        /* @internal */ textSourceNode?: Identifier | PrivateName | StringLiteralLike | NumericLiteral; // Allows a StringLiteral to get its text from another node (used by transforms).
         /** Note: this is only set when synthesizing a node, not during parsing. */
         /* @internal */ singleQuote?: boolean;
     }
@@ -1661,7 +1669,7 @@ namespace ts {
     export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
         kind: SyntaxKind.PropertyAccessExpression;
         expression: LeftHandSideExpression;
-        name: Identifier;
+        name: Identifier | PrivateName;
     }
 
     export interface SuperPropertyAccessExpression extends PropertyAccessExpression {
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
index 33dfd2617c979..a7fa1b63b438e 100644
--- a/src/compiler/utilities.ts
+++ b/src/compiler/utilities.ts
@@ -766,6 +766,7 @@ namespace ts {
     export function getTextOfPropertyName(name: PropertyName): __String {
         switch (name.kind) {
             case SyntaxKind.Identifier:
+            case SyntaxKind.PrivateName:
                 return name.escapedText;
             case SyntaxKind.StringLiteral:
             case SyntaxKind.NumericLiteral:
@@ -784,7 +785,15 @@ namespace ts {
             case SyntaxKind.QualifiedName:
                 return entityNameToString(name.left) + "." + entityNameToString(name.right);
             case SyntaxKind.PropertyAccessExpression:
-                return entityNameToString(name.expression) + "." + entityNameToString(name.name);
+                if (isIdentifier(name.name)) {
+                    return entityNameToString(name.expression) + "." + entityNameToString(name.name);
+                }
+                else if (isPrivateName(name.name)) {
+                    return getTextOfNode(name);
+                }
+                else {
+                    throw Debug.assertNever(name.name);
+                }
             default:
                 throw Debug.assertNever(name);
         }
@@ -1869,7 +1878,7 @@ namespace ts {
                 (initializer.expression.escapedText === "window" as __String ||
                     initializer.expression.escapedText === "self" as __String ||
                     initializer.expression.escapedText === "global" as __String)) &&
-                isSameEntityName(name, initializer.name);
+                isSameEntityName(name, initializer.name as Identifier);
         }
         if (isPropertyAccessExpression(name) && isPropertyAccessExpression(initializer)) {
             return name.name.escapedText === initializer.name.escapedText && isSameEntityName(name.expression, initializer.expression);
@@ -2618,6 +2627,7 @@ namespace ts {
     export function getPropertyNameForPropertyNameNode(name: PropertyName): __String | undefined {
         switch (name.kind) {
             case SyntaxKind.Identifier:
+            case SyntaxKind.PrivateName:
                 return name.escapedText;
             case SyntaxKind.StringLiteral:
             case SyntaxKind.NumericLiteral:
@@ -2636,10 +2646,12 @@ namespace ts {
         }
     }
 
-    export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;
+    export type PropertyNameLiteral = Identifier | PrivateName | StringLiteralLike | NumericLiteral;
     export function isPropertyNameLiteral(node: Node): node is PropertyNameLiteral {
         switch (node.kind) {
             case SyntaxKind.Identifier:
+            // TODO: should this be here?
+            case SyntaxKind.PrivateName:
             case SyntaxKind.StringLiteral:
             case SyntaxKind.NoSubstitutionTemplateLiteral:
             case SyntaxKind.NumericLiteral:
@@ -2649,11 +2661,11 @@ namespace ts {
         }
     }
     export function getTextOfIdentifierOrLiteral(node: PropertyNameLiteral): string {
-        return node.kind === SyntaxKind.Identifier ? idText(node) : node.text;
+        return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateName ? idText(node) : node.text;
     }
 
     export function getEscapedTextOfIdentifierOrLiteral(node: PropertyNameLiteral): __String {
-        return node.kind === SyntaxKind.Identifier ? node.escapedText : escapeLeadingUnderscores(node.text);
+        return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateName ? node.escapedText : escapeLeadingUnderscores(node.text);
     }
 
     export function getPropertyNameForKnownSymbolName(symbolName: string): __String {
@@ -3313,7 +3325,7 @@ namespace ts {
     }
 
     export function isThisIdentifier(node: Node | undefined): boolean {
-        return !!node && node.kind === SyntaxKind.Identifier && identifierIsThisKeyword(node as Identifier);
+        return !!node && isIdentifier(node) && identifierIsThisKeyword(node);
     }
 
     export function identifierIsThisKeyword(id: Identifier): boolean {
@@ -3726,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;
@@ -4832,8 +4866,8 @@ namespace ts {
         return id.length >= 3 && id.charCodeAt(0) === CharacterCodes._ && id.charCodeAt(1) === CharacterCodes._ && id.charCodeAt(2) === CharacterCodes._ ? id.substr(1) : id;
     }
 
-    export function idText(identifier: Identifier): string {
-        return unescapeLeadingUnderscores(identifier.escapedText);
+    export function idText(identifierOrPrivateName: Identifier | PrivateName): string {
+        return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText);
     }
     export function symbolName(symbol: Symbol): string {
         return unescapeLeadingUnderscores(symbol.escapedName);
@@ -4844,7 +4878,7 @@ namespace ts {
      * attempt to draw the name from the node the declaration is on (as that declaration is what its' symbol
      * will be merged with)
      */
-    function nameForNamelessJSDocTypedef(declaration: JSDocTypedefTag): Identifier | undefined {
+    function nameForNamelessJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateName | undefined {
         const hostNode = declaration.parent.parent;
         if (!hostNode) {
             return undefined;
@@ -4893,7 +4927,7 @@ namespace ts {
         return name && isIdentifier(name) ? name : undefined;
     }
 
-    export function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | undefined {
+    export function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateName | undefined {
         return declaration.name || nameForNamelessJSDocTypedef(declaration);
     }
 
@@ -5172,6 +5206,10 @@ namespace ts {
         return node.kind === SyntaxKind.Identifier;
     }
 
+    export function isIdentifierOrPrivateName(node: Node): node is Identifier | PrivateName {
+        return node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.PrivateName;
+    }
+
     // Names
 
     export function isQualifiedName(node: Node): node is QualifiedName {
@@ -5182,6 +5220,10 @@ namespace ts {
         return node.kind === SyntaxKind.ComputedPropertyName;
     }
 
+    export function isPrivateName(node: Node): node is PrivateName {
+        return node.kind === SyntaxKind.PrivateName;
+    }
+
     // Signature elements
 
     export function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration {
diff --git a/src/compiler/visitor.ts b/src/compiler/visitor.ts
index 2cfb469f15296..f4cfacda7d87a 100644
--- a/src/compiler/visitor.ts
+++ b/src/compiler/visitor.ts
@@ -464,7 +464,7 @@ namespace ts {
             case SyntaxKind.PropertyAccessExpression:
                 return updatePropertyAccess(<PropertyAccessExpression>node,
                     visitNode((<PropertyAccessExpression>node).expression, visitor, isExpression),
-                    visitNode((<PropertyAccessExpression>node).name, visitor, isIdentifier));
+                    visitNode((<PropertyAccessExpression>node).name, visitor, isIdentifierOrPrivateName));
 
             case SyntaxKind.ElementAccessExpression:
                 return updateElementAccess(<ElementAccessExpression>node,
diff --git a/src/services/codefixes/convertToEs6Module.ts b/src/services/codefixes/convertToEs6Module.ts
index 87a1f49cc4864..da486b47b1192 100644
--- a/src/services/codefixes/convertToEs6Module.ts
+++ b/src/services/codefixes/convertToEs6Module.ts
@@ -65,7 +65,7 @@ namespace ts.codefix {
     function collectExportRenames(sourceFile: SourceFile, checker: TypeChecker, identifiers: Identifiers): ExportRenames {
         const res = createMap<string>();
         forEachExportReference(sourceFile, node => {
-            const { text, originalKeywordKind } = node.name;
+            const { text, originalKeywordKind } = node.name as Identifier;
             if (!res.has(text) && (originalKeywordKind !== undefined && isNonContextualKeyword(originalKeywordKind)
                 || checker.resolveName(node.name.text, node, SymbolFlags.Value, /*excludeGlobals*/ true))) {
                 // Unconditionally add an underscore in case `text` is a keyword.
diff --git a/src/services/refactors/moveToNewFile.ts b/src/services/refactors/moveToNewFile.ts
index 9953293e3d1fa..7161e26f28ace 100644
--- a/src/services/refactors/moveToNewFile.ts
+++ b/src/services/refactors/moveToNewFile.ts
@@ -665,7 +665,7 @@ namespace ts.refactor {
     }
 
     function nameOfTopLevelDeclaration(d: TopLevelDeclaration): Identifier | undefined {
-        return d.kind === SyntaxKind.ExpressionStatement ? d.expression.left.name : tryCast(d.name, isIdentifier);
+        return d.kind === SyntaxKind.ExpressionStatement ? d.expression.left.name as Identifier : tryCast(d.name, isIdentifier);
     }
 
     function getTopLevelDeclarationStatement(d: TopLevelDeclaration): TopLevelDeclarationStatement {
diff --git a/src/services/types.ts b/src/services/types.ts
index 51c98724c0957..6f919b07ec6c0 100644
--- a/src/services/types.ts
+++ b/src/services/types.ts
@@ -28,6 +28,10 @@ namespace ts {
         readonly text: string;
     }
 
+    export interface PrivateName {
+        readonly text: string;
+    }
+
     export interface Symbol {
         readonly name: string;
         getFlags(): SymbolFlags;
diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt b/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt
index 94198b36c9033..00b2ae4b02942 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt
+++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.errors.txt
@@ -9,7 +9,7 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration
     class C {
       foo() {
         // Make sure we don't think of *bar as the start of a generator method.
-        if (a) # * bar;
+        if (a) ¬ * bar;
             ~
 !!! error TS2304: Cannot find name 'a'.
                
@@ -22,4 +22,5 @@ tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration
                ~~~
 !!! error TS2304: Cannot find name 'bar'.
       }
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.js b/tests/baselines/reference/MemberFunctionDeclaration8_es6.js
index 853310e5a3efe..4fba30e9659b8 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.js
+++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.js
@@ -2,10 +2,11 @@
 class C {
   foo() {
     // Make sure we don't think of *bar as the start of a generator method.
-    if (a) # * bar;
+    if (a) ¬ * bar;
     return bar;
   }
-}
+}
+
 
 //// [MemberFunctionDeclaration8_es6.js]
 class C {
diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols b/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols
index 0229450477c63..35041420d6aa5 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols
+++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.symbols
@@ -6,7 +6,8 @@ class C {
 >foo : Symbol(C.foo, Decl(MemberFunctionDeclaration8_es6.ts, 0, 9))
 
     // Make sure we don't think of *bar as the start of a generator method.
-    if (a) # * bar;
+    if (a) ¬ * bar;
     return bar;
   }
 }
+
diff --git a/tests/baselines/reference/MemberFunctionDeclaration8_es6.types b/tests/baselines/reference/MemberFunctionDeclaration8_es6.types
index b0234b4135ee3..9eacffd080c9d 100644
--- a/tests/baselines/reference/MemberFunctionDeclaration8_es6.types
+++ b/tests/baselines/reference/MemberFunctionDeclaration8_es6.types
@@ -6,7 +6,7 @@ class C {
 >foo : () => any
 
     // Make sure we don't think of *bar as the start of a generator method.
-    if (a) # * bar;
+    if (a) ¬ * bar;
 >a : any
 > : any
 >* bar : number
@@ -17,3 +17,4 @@ class C {
 >bar : any
   }
 }
+
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
index 5e992f3847a8b..1ab1a986d1ad1 100644
--- a/tests/baselines/reference/api/tsserverlibrary.d.ts
+++ b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -144,261 +144,262 @@ declare namespace ts {
         BarEqualsToken = 69,
         CaretEqualsToken = 70,
         Identifier = 71,
-        BreakKeyword = 72,
-        CaseKeyword = 73,
-        CatchKeyword = 74,
-        ClassKeyword = 75,
-        ConstKeyword = 76,
-        ContinueKeyword = 77,
-        DebuggerKeyword = 78,
-        DefaultKeyword = 79,
-        DeleteKeyword = 80,
-        DoKeyword = 81,
-        ElseKeyword = 82,
-        EnumKeyword = 83,
-        ExportKeyword = 84,
-        ExtendsKeyword = 85,
-        FalseKeyword = 86,
-        FinallyKeyword = 87,
-        ForKeyword = 88,
-        FunctionKeyword = 89,
-        IfKeyword = 90,
-        ImportKeyword = 91,
-        InKeyword = 92,
-        InstanceOfKeyword = 93,
-        NewKeyword = 94,
-        NullKeyword = 95,
-        ReturnKeyword = 96,
-        SuperKeyword = 97,
-        SwitchKeyword = 98,
-        ThisKeyword = 99,
-        ThrowKeyword = 100,
-        TrueKeyword = 101,
-        TryKeyword = 102,
-        TypeOfKeyword = 103,
-        VarKeyword = 104,
-        VoidKeyword = 105,
-        WhileKeyword = 106,
-        WithKeyword = 107,
-        ImplementsKeyword = 108,
-        InterfaceKeyword = 109,
-        LetKeyword = 110,
-        PackageKeyword = 111,
-        PrivateKeyword = 112,
-        ProtectedKeyword = 113,
-        PublicKeyword = 114,
-        StaticKeyword = 115,
-        YieldKeyword = 116,
-        AbstractKeyword = 117,
-        AsKeyword = 118,
-        AnyKeyword = 119,
-        AsyncKeyword = 120,
-        AwaitKeyword = 121,
-        BooleanKeyword = 122,
-        ConstructorKeyword = 123,
-        DeclareKeyword = 124,
-        GetKeyword = 125,
-        InferKeyword = 126,
-        IsKeyword = 127,
-        KeyOfKeyword = 128,
-        ModuleKeyword = 129,
-        NamespaceKeyword = 130,
-        NeverKeyword = 131,
-        ReadonlyKeyword = 132,
-        RequireKeyword = 133,
-        NumberKeyword = 134,
-        ObjectKeyword = 135,
-        SetKeyword = 136,
-        StringKeyword = 137,
-        SymbolKeyword = 138,
-        TypeKeyword = 139,
-        UndefinedKeyword = 140,
-        UniqueKeyword = 141,
-        UnknownKeyword = 142,
-        FromKeyword = 143,
-        GlobalKeyword = 144,
-        OfKeyword = 145,
-        QualifiedName = 146,
-        ComputedPropertyName = 147,
-        TypeParameter = 148,
-        Parameter = 149,
-        Decorator = 150,
-        PropertySignature = 151,
-        PropertyDeclaration = 152,
-        MethodSignature = 153,
-        MethodDeclaration = 154,
-        Constructor = 155,
-        GetAccessor = 156,
-        SetAccessor = 157,
-        CallSignature = 158,
-        ConstructSignature = 159,
-        IndexSignature = 160,
-        TypePredicate = 161,
-        TypeReference = 162,
-        FunctionType = 163,
-        ConstructorType = 164,
-        TypeQuery = 165,
-        TypeLiteral = 166,
-        ArrayType = 167,
-        TupleType = 168,
-        OptionalType = 169,
-        RestType = 170,
-        UnionType = 171,
-        IntersectionType = 172,
-        ConditionalType = 173,
-        InferType = 174,
-        ParenthesizedType = 175,
-        ThisType = 176,
-        TypeOperator = 177,
-        IndexedAccessType = 178,
-        MappedType = 179,
-        LiteralType = 180,
-        ImportType = 181,
-        ObjectBindingPattern = 182,
-        ArrayBindingPattern = 183,
-        BindingElement = 184,
-        ArrayLiteralExpression = 185,
-        ObjectLiteralExpression = 186,
-        PropertyAccessExpression = 187,
-        ElementAccessExpression = 188,
-        CallExpression = 189,
-        NewExpression = 190,
-        TaggedTemplateExpression = 191,
-        TypeAssertionExpression = 192,
-        ParenthesizedExpression = 193,
-        FunctionExpression = 194,
-        ArrowFunction = 195,
-        DeleteExpression = 196,
-        TypeOfExpression = 197,
-        VoidExpression = 198,
-        AwaitExpression = 199,
-        PrefixUnaryExpression = 200,
-        PostfixUnaryExpression = 201,
-        BinaryExpression = 202,
-        ConditionalExpression = 203,
-        TemplateExpression = 204,
-        YieldExpression = 205,
-        SpreadElement = 206,
-        ClassExpression = 207,
-        OmittedExpression = 208,
-        ExpressionWithTypeArguments = 209,
-        AsExpression = 210,
-        NonNullExpression = 211,
-        MetaProperty = 212,
-        SyntheticExpression = 213,
-        TemplateSpan = 214,
-        SemicolonClassElement = 215,
-        Block = 216,
-        VariableStatement = 217,
-        EmptyStatement = 218,
-        ExpressionStatement = 219,
-        IfStatement = 220,
-        DoStatement = 221,
-        WhileStatement = 222,
-        ForStatement = 223,
-        ForInStatement = 224,
-        ForOfStatement = 225,
-        ContinueStatement = 226,
-        BreakStatement = 227,
-        ReturnStatement = 228,
-        WithStatement = 229,
-        SwitchStatement = 230,
-        LabeledStatement = 231,
-        ThrowStatement = 232,
-        TryStatement = 233,
-        DebuggerStatement = 234,
-        VariableDeclaration = 235,
-        VariableDeclarationList = 236,
-        FunctionDeclaration = 237,
-        ClassDeclaration = 238,
-        InterfaceDeclaration = 239,
-        TypeAliasDeclaration = 240,
-        EnumDeclaration = 241,
-        ModuleDeclaration = 242,
-        ModuleBlock = 243,
-        CaseBlock = 244,
-        NamespaceExportDeclaration = 245,
-        ImportEqualsDeclaration = 246,
-        ImportDeclaration = 247,
-        ImportClause = 248,
-        NamespaceImport = 249,
-        NamedImports = 250,
-        ImportSpecifier = 251,
-        ExportAssignment = 252,
-        ExportDeclaration = 253,
-        NamedExports = 254,
-        ExportSpecifier = 255,
-        MissingDeclaration = 256,
-        ExternalModuleReference = 257,
-        JsxElement = 258,
-        JsxSelfClosingElement = 259,
-        JsxOpeningElement = 260,
-        JsxClosingElement = 261,
-        JsxFragment = 262,
-        JsxOpeningFragment = 263,
-        JsxClosingFragment = 264,
-        JsxAttribute = 265,
-        JsxAttributes = 266,
-        JsxSpreadAttribute = 267,
-        JsxExpression = 268,
-        CaseClause = 269,
-        DefaultClause = 270,
-        HeritageClause = 271,
-        CatchClause = 272,
-        PropertyAssignment = 273,
-        ShorthandPropertyAssignment = 274,
-        SpreadAssignment = 275,
-        EnumMember = 276,
-        SourceFile = 277,
-        Bundle = 278,
-        UnparsedSource = 279,
-        InputFiles = 280,
-        JSDocTypeExpression = 281,
-        JSDocAllType = 282,
-        JSDocUnknownType = 283,
-        JSDocNullableType = 284,
-        JSDocNonNullableType = 285,
-        JSDocOptionalType = 286,
-        JSDocFunctionType = 287,
-        JSDocVariadicType = 288,
-        JSDocComment = 289,
-        JSDocTypeLiteral = 290,
-        JSDocSignature = 291,
-        JSDocTag = 292,
-        JSDocAugmentsTag = 293,
-        JSDocClassTag = 294,
-        JSDocCallbackTag = 295,
-        JSDocEnumTag = 296,
-        JSDocParameterTag = 297,
-        JSDocReturnTag = 298,
-        JSDocThisTag = 299,
-        JSDocTypeTag = 300,
-        JSDocTemplateTag = 301,
-        JSDocTypedefTag = 302,
-        JSDocPropertyTag = 303,
-        SyntaxList = 304,
-        NotEmittedStatement = 305,
-        PartiallyEmittedExpression = 306,
-        CommaListExpression = 307,
-        MergeDeclarationMarker = 308,
-        EndOfDeclarationMarker = 309,
-        Count = 310,
+        PrivateName = 72,
+        BreakKeyword = 73,
+        CaseKeyword = 74,
+        CatchKeyword = 75,
+        ClassKeyword = 76,
+        ConstKeyword = 77,
+        ContinueKeyword = 78,
+        DebuggerKeyword = 79,
+        DefaultKeyword = 80,
+        DeleteKeyword = 81,
+        DoKeyword = 82,
+        ElseKeyword = 83,
+        EnumKeyword = 84,
+        ExportKeyword = 85,
+        ExtendsKeyword = 86,
+        FalseKeyword = 87,
+        FinallyKeyword = 88,
+        ForKeyword = 89,
+        FunctionKeyword = 90,
+        IfKeyword = 91,
+        ImportKeyword = 92,
+        InKeyword = 93,
+        InstanceOfKeyword = 94,
+        NewKeyword = 95,
+        NullKeyword = 96,
+        ReturnKeyword = 97,
+        SuperKeyword = 98,
+        SwitchKeyword = 99,
+        ThisKeyword = 100,
+        ThrowKeyword = 101,
+        TrueKeyword = 102,
+        TryKeyword = 103,
+        TypeOfKeyword = 104,
+        VarKeyword = 105,
+        VoidKeyword = 106,
+        WhileKeyword = 107,
+        WithKeyword = 108,
+        ImplementsKeyword = 109,
+        InterfaceKeyword = 110,
+        LetKeyword = 111,
+        PackageKeyword = 112,
+        PrivateKeyword = 113,
+        ProtectedKeyword = 114,
+        PublicKeyword = 115,
+        StaticKeyword = 116,
+        YieldKeyword = 117,
+        AbstractKeyword = 118,
+        AsKeyword = 119,
+        AnyKeyword = 120,
+        AsyncKeyword = 121,
+        AwaitKeyword = 122,
+        BooleanKeyword = 123,
+        ConstructorKeyword = 124,
+        DeclareKeyword = 125,
+        GetKeyword = 126,
+        InferKeyword = 127,
+        IsKeyword = 128,
+        KeyOfKeyword = 129,
+        ModuleKeyword = 130,
+        NamespaceKeyword = 131,
+        NeverKeyword = 132,
+        ReadonlyKeyword = 133,
+        RequireKeyword = 134,
+        NumberKeyword = 135,
+        ObjectKeyword = 136,
+        SetKeyword = 137,
+        StringKeyword = 138,
+        SymbolKeyword = 139,
+        TypeKeyword = 140,
+        UndefinedKeyword = 141,
+        UniqueKeyword = 142,
+        UnknownKeyword = 143,
+        FromKeyword = 144,
+        GlobalKeyword = 145,
+        OfKeyword = 146,
+        QualifiedName = 147,
+        ComputedPropertyName = 148,
+        TypeParameter = 149,
+        Parameter = 150,
+        Decorator = 151,
+        PropertySignature = 152,
+        PropertyDeclaration = 153,
+        MethodSignature = 154,
+        MethodDeclaration = 155,
+        Constructor = 156,
+        GetAccessor = 157,
+        SetAccessor = 158,
+        CallSignature = 159,
+        ConstructSignature = 160,
+        IndexSignature = 161,
+        TypePredicate = 162,
+        TypeReference = 163,
+        FunctionType = 164,
+        ConstructorType = 165,
+        TypeQuery = 166,
+        TypeLiteral = 167,
+        ArrayType = 168,
+        TupleType = 169,
+        OptionalType = 170,
+        RestType = 171,
+        UnionType = 172,
+        IntersectionType = 173,
+        ConditionalType = 174,
+        InferType = 175,
+        ParenthesizedType = 176,
+        ThisType = 177,
+        TypeOperator = 178,
+        IndexedAccessType = 179,
+        MappedType = 180,
+        LiteralType = 181,
+        ImportType = 182,
+        ObjectBindingPattern = 183,
+        ArrayBindingPattern = 184,
+        BindingElement = 185,
+        ArrayLiteralExpression = 186,
+        ObjectLiteralExpression = 187,
+        PropertyAccessExpression = 188,
+        ElementAccessExpression = 189,
+        CallExpression = 190,
+        NewExpression = 191,
+        TaggedTemplateExpression = 192,
+        TypeAssertionExpression = 193,
+        ParenthesizedExpression = 194,
+        FunctionExpression = 195,
+        ArrowFunction = 196,
+        DeleteExpression = 197,
+        TypeOfExpression = 198,
+        VoidExpression = 199,
+        AwaitExpression = 200,
+        PrefixUnaryExpression = 201,
+        PostfixUnaryExpression = 202,
+        BinaryExpression = 203,
+        ConditionalExpression = 204,
+        TemplateExpression = 205,
+        YieldExpression = 206,
+        SpreadElement = 207,
+        ClassExpression = 208,
+        OmittedExpression = 209,
+        ExpressionWithTypeArguments = 210,
+        AsExpression = 211,
+        NonNullExpression = 212,
+        MetaProperty = 213,
+        SyntheticExpression = 214,
+        TemplateSpan = 215,
+        SemicolonClassElement = 216,
+        Block = 217,
+        VariableStatement = 218,
+        EmptyStatement = 219,
+        ExpressionStatement = 220,
+        IfStatement = 221,
+        DoStatement = 222,
+        WhileStatement = 223,
+        ForStatement = 224,
+        ForInStatement = 225,
+        ForOfStatement = 226,
+        ContinueStatement = 227,
+        BreakStatement = 228,
+        ReturnStatement = 229,
+        WithStatement = 230,
+        SwitchStatement = 231,
+        LabeledStatement = 232,
+        ThrowStatement = 233,
+        TryStatement = 234,
+        DebuggerStatement = 235,
+        VariableDeclaration = 236,
+        VariableDeclarationList = 237,
+        FunctionDeclaration = 238,
+        ClassDeclaration = 239,
+        InterfaceDeclaration = 240,
+        TypeAliasDeclaration = 241,
+        EnumDeclaration = 242,
+        ModuleDeclaration = 243,
+        ModuleBlock = 244,
+        CaseBlock = 245,
+        NamespaceExportDeclaration = 246,
+        ImportEqualsDeclaration = 247,
+        ImportDeclaration = 248,
+        ImportClause = 249,
+        NamespaceImport = 250,
+        NamedImports = 251,
+        ImportSpecifier = 252,
+        ExportAssignment = 253,
+        ExportDeclaration = 254,
+        NamedExports = 255,
+        ExportSpecifier = 256,
+        MissingDeclaration = 257,
+        ExternalModuleReference = 258,
+        JsxElement = 259,
+        JsxSelfClosingElement = 260,
+        JsxOpeningElement = 261,
+        JsxClosingElement = 262,
+        JsxFragment = 263,
+        JsxOpeningFragment = 264,
+        JsxClosingFragment = 265,
+        JsxAttribute = 266,
+        JsxAttributes = 267,
+        JsxSpreadAttribute = 268,
+        JsxExpression = 269,
+        CaseClause = 270,
+        DefaultClause = 271,
+        HeritageClause = 272,
+        CatchClause = 273,
+        PropertyAssignment = 274,
+        ShorthandPropertyAssignment = 275,
+        SpreadAssignment = 276,
+        EnumMember = 277,
+        SourceFile = 278,
+        Bundle = 279,
+        UnparsedSource = 280,
+        InputFiles = 281,
+        JSDocTypeExpression = 282,
+        JSDocAllType = 283,
+        JSDocUnknownType = 284,
+        JSDocNullableType = 285,
+        JSDocNonNullableType = 286,
+        JSDocOptionalType = 287,
+        JSDocFunctionType = 288,
+        JSDocVariadicType = 289,
+        JSDocComment = 290,
+        JSDocTypeLiteral = 291,
+        JSDocSignature = 292,
+        JSDocTag = 293,
+        JSDocAugmentsTag = 294,
+        JSDocClassTag = 295,
+        JSDocCallbackTag = 296,
+        JSDocEnumTag = 297,
+        JSDocParameterTag = 298,
+        JSDocReturnTag = 299,
+        JSDocThisTag = 300,
+        JSDocTypeTag = 301,
+        JSDocTemplateTag = 302,
+        JSDocTypedefTag = 303,
+        JSDocPropertyTag = 304,
+        SyntaxList = 305,
+        NotEmittedStatement = 306,
+        PartiallyEmittedExpression = 307,
+        CommaListExpression = 308,
+        MergeDeclarationMarker = 309,
+        EndOfDeclarationMarker = 310,
+        Count = 311,
         FirstAssignment = 58,
         LastAssignment = 70,
         FirstCompoundAssignment = 59,
         LastCompoundAssignment = 70,
-        FirstReservedWord = 72,
-        LastReservedWord = 107,
-        FirstKeyword = 72,
-        LastKeyword = 145,
-        FirstFutureReservedWord = 108,
-        LastFutureReservedWord = 116,
-        FirstTypeNode = 161,
-        LastTypeNode = 181,
+        FirstReservedWord = 73,
+        LastReservedWord = 108,
+        FirstKeyword = 73,
+        LastKeyword = 146,
+        FirstFutureReservedWord = 109,
+        LastFutureReservedWord = 117,
+        FirstTypeNode = 162,
+        LastTypeNode = 182,
         FirstPunctuation = 17,
         LastPunctuation = 70,
         FirstToken = 0,
-        LastToken = 145,
+        LastToken = 146,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -407,11 +408,11 @@ declare namespace ts {
         LastTemplateToken = 16,
         FirstBinaryOperator = 27,
         LastBinaryOperator = 70,
-        FirstNode = 146,
-        FirstJSDocNode = 281,
-        LastJSDocNode = 303,
-        FirstJSDocTagNode = 292,
-        LastJSDocTagNode = 303
+        FirstNode = 147,
+        FirstJSDocNode = 282,
+        LastJSDocNode = 304,
+        FirstJSDocTagNode = 293,
+        LastJSDocTagNode = 304
     }
     enum NodeFlags {
         None = 0,
@@ -524,8 +525,8 @@ declare namespace ts {
         right: Identifier;
     }
     type EntityName = Identifier | QualifiedName;
-    type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
-    type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern;
+    type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName;
+    type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName | BindingPattern;
     interface Declaration extends Node {
         _declarationBrand: any;
     }
@@ -539,6 +540,10 @@ declare namespace ts {
         kind: SyntaxKind.ComputedPropertyName;
         expression: Expression;
     }
+    interface PrivateName extends Declaration {
+        kind: SyntaxKind.PrivateName;
+        escapedText: __String;
+    }
     interface Decorator extends Node {
         kind: SyntaxKind.Decorator;
         parent: NamedDeclaration;
@@ -1046,7 +1051,7 @@ declare namespace ts {
     interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
         kind: SyntaxKind.PropertyAccessExpression;
         expression: LeftHandSideExpression;
-        name: Identifier;
+        name: Identifier | PrivateName;
     }
     interface SuperPropertyAccessExpression extends PropertyAccessExpression {
         expression: SuperExpression;
@@ -3194,9 +3199,9 @@ declare namespace ts {
      * @returns The unescaped identifier text.
      */
     function unescapeLeadingUnderscores(identifier: __String): string;
-    function idText(identifier: Identifier): string;
+    function idText(identifierOrPrivateName: Identifier | PrivateName): string;
     function symbolName(symbol: Symbol): string;
-    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | undefined;
+    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateName | undefined;
     function getNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined;
     /**
      * Gets the JSDoc parameter tags for the node if present.
@@ -3273,8 +3278,10 @@ declare namespace ts {
     function isTemplateMiddle(node: Node): node is TemplateMiddle;
     function isTemplateTail(node: Node): node is TemplateTail;
     function isIdentifier(node: Node): node is Identifier;
+    function isIdentifierOrPrivateName(node: Node): node is Identifier | PrivateName;
     function isQualifiedName(node: Node): node is QualifiedName;
     function isComputedPropertyName(node: Node): node is ComputedPropertyName;
+    function isPrivateName(node: Node): node is PrivateName;
     function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
     function isParameter(node: Node): node is ParameterDeclaration;
     function isDecorator(node: Node): node is Decorator;
@@ -3734,8 +3741,8 @@ declare namespace ts {
     function updateArrayLiteral(node: ArrayLiteralExpression, elements: ReadonlyArray<Expression>): ArrayLiteralExpression;
     function createObjectLiteral(properties?: ReadonlyArray<ObjectLiteralElementLike>, multiLine?: boolean): ObjectLiteralExpression;
     function updateObjectLiteral(node: ObjectLiteralExpression, properties: ReadonlyArray<ObjectLiteralElementLike>): ObjectLiteralExpression;
-    function createPropertyAccess(expression: Expression, name: string | Identifier | undefined): PropertyAccessExpression;
-    function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier): PropertyAccessExpression;
+    function createPropertyAccess(expression: Expression, name: string | Identifier | PrivateName | undefined): PropertyAccessExpression;
+    function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateName): PropertyAccessExpression;
     function createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression;
     function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
     function createCall(expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression> | undefined): CallExpression;
@@ -4510,6 +4517,9 @@ declare namespace ts {
     interface Identifier {
         readonly text: string;
     }
+    interface PrivateName {
+        readonly text: string;
+    }
     interface Symbol {
         readonly name: string;
         getFlags(): SymbolFlags;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
index 32761156558fd..ea78225538eac 100644
--- a/tests/baselines/reference/api/typescript.d.ts
+++ b/tests/baselines/reference/api/typescript.d.ts
@@ -144,261 +144,262 @@ declare namespace ts {
         BarEqualsToken = 69,
         CaretEqualsToken = 70,
         Identifier = 71,
-        BreakKeyword = 72,
-        CaseKeyword = 73,
-        CatchKeyword = 74,
-        ClassKeyword = 75,
-        ConstKeyword = 76,
-        ContinueKeyword = 77,
-        DebuggerKeyword = 78,
-        DefaultKeyword = 79,
-        DeleteKeyword = 80,
-        DoKeyword = 81,
-        ElseKeyword = 82,
-        EnumKeyword = 83,
-        ExportKeyword = 84,
-        ExtendsKeyword = 85,
-        FalseKeyword = 86,
-        FinallyKeyword = 87,
-        ForKeyword = 88,
-        FunctionKeyword = 89,
-        IfKeyword = 90,
-        ImportKeyword = 91,
-        InKeyword = 92,
-        InstanceOfKeyword = 93,
-        NewKeyword = 94,
-        NullKeyword = 95,
-        ReturnKeyword = 96,
-        SuperKeyword = 97,
-        SwitchKeyword = 98,
-        ThisKeyword = 99,
-        ThrowKeyword = 100,
-        TrueKeyword = 101,
-        TryKeyword = 102,
-        TypeOfKeyword = 103,
-        VarKeyword = 104,
-        VoidKeyword = 105,
-        WhileKeyword = 106,
-        WithKeyword = 107,
-        ImplementsKeyword = 108,
-        InterfaceKeyword = 109,
-        LetKeyword = 110,
-        PackageKeyword = 111,
-        PrivateKeyword = 112,
-        ProtectedKeyword = 113,
-        PublicKeyword = 114,
-        StaticKeyword = 115,
-        YieldKeyword = 116,
-        AbstractKeyword = 117,
-        AsKeyword = 118,
-        AnyKeyword = 119,
-        AsyncKeyword = 120,
-        AwaitKeyword = 121,
-        BooleanKeyword = 122,
-        ConstructorKeyword = 123,
-        DeclareKeyword = 124,
-        GetKeyword = 125,
-        InferKeyword = 126,
-        IsKeyword = 127,
-        KeyOfKeyword = 128,
-        ModuleKeyword = 129,
-        NamespaceKeyword = 130,
-        NeverKeyword = 131,
-        ReadonlyKeyword = 132,
-        RequireKeyword = 133,
-        NumberKeyword = 134,
-        ObjectKeyword = 135,
-        SetKeyword = 136,
-        StringKeyword = 137,
-        SymbolKeyword = 138,
-        TypeKeyword = 139,
-        UndefinedKeyword = 140,
-        UniqueKeyword = 141,
-        UnknownKeyword = 142,
-        FromKeyword = 143,
-        GlobalKeyword = 144,
-        OfKeyword = 145,
-        QualifiedName = 146,
-        ComputedPropertyName = 147,
-        TypeParameter = 148,
-        Parameter = 149,
-        Decorator = 150,
-        PropertySignature = 151,
-        PropertyDeclaration = 152,
-        MethodSignature = 153,
-        MethodDeclaration = 154,
-        Constructor = 155,
-        GetAccessor = 156,
-        SetAccessor = 157,
-        CallSignature = 158,
-        ConstructSignature = 159,
-        IndexSignature = 160,
-        TypePredicate = 161,
-        TypeReference = 162,
-        FunctionType = 163,
-        ConstructorType = 164,
-        TypeQuery = 165,
-        TypeLiteral = 166,
-        ArrayType = 167,
-        TupleType = 168,
-        OptionalType = 169,
-        RestType = 170,
-        UnionType = 171,
-        IntersectionType = 172,
-        ConditionalType = 173,
-        InferType = 174,
-        ParenthesizedType = 175,
-        ThisType = 176,
-        TypeOperator = 177,
-        IndexedAccessType = 178,
-        MappedType = 179,
-        LiteralType = 180,
-        ImportType = 181,
-        ObjectBindingPattern = 182,
-        ArrayBindingPattern = 183,
-        BindingElement = 184,
-        ArrayLiteralExpression = 185,
-        ObjectLiteralExpression = 186,
-        PropertyAccessExpression = 187,
-        ElementAccessExpression = 188,
-        CallExpression = 189,
-        NewExpression = 190,
-        TaggedTemplateExpression = 191,
-        TypeAssertionExpression = 192,
-        ParenthesizedExpression = 193,
-        FunctionExpression = 194,
-        ArrowFunction = 195,
-        DeleteExpression = 196,
-        TypeOfExpression = 197,
-        VoidExpression = 198,
-        AwaitExpression = 199,
-        PrefixUnaryExpression = 200,
-        PostfixUnaryExpression = 201,
-        BinaryExpression = 202,
-        ConditionalExpression = 203,
-        TemplateExpression = 204,
-        YieldExpression = 205,
-        SpreadElement = 206,
-        ClassExpression = 207,
-        OmittedExpression = 208,
-        ExpressionWithTypeArguments = 209,
-        AsExpression = 210,
-        NonNullExpression = 211,
-        MetaProperty = 212,
-        SyntheticExpression = 213,
-        TemplateSpan = 214,
-        SemicolonClassElement = 215,
-        Block = 216,
-        VariableStatement = 217,
-        EmptyStatement = 218,
-        ExpressionStatement = 219,
-        IfStatement = 220,
-        DoStatement = 221,
-        WhileStatement = 222,
-        ForStatement = 223,
-        ForInStatement = 224,
-        ForOfStatement = 225,
-        ContinueStatement = 226,
-        BreakStatement = 227,
-        ReturnStatement = 228,
-        WithStatement = 229,
-        SwitchStatement = 230,
-        LabeledStatement = 231,
-        ThrowStatement = 232,
-        TryStatement = 233,
-        DebuggerStatement = 234,
-        VariableDeclaration = 235,
-        VariableDeclarationList = 236,
-        FunctionDeclaration = 237,
-        ClassDeclaration = 238,
-        InterfaceDeclaration = 239,
-        TypeAliasDeclaration = 240,
-        EnumDeclaration = 241,
-        ModuleDeclaration = 242,
-        ModuleBlock = 243,
-        CaseBlock = 244,
-        NamespaceExportDeclaration = 245,
-        ImportEqualsDeclaration = 246,
-        ImportDeclaration = 247,
-        ImportClause = 248,
-        NamespaceImport = 249,
-        NamedImports = 250,
-        ImportSpecifier = 251,
-        ExportAssignment = 252,
-        ExportDeclaration = 253,
-        NamedExports = 254,
-        ExportSpecifier = 255,
-        MissingDeclaration = 256,
-        ExternalModuleReference = 257,
-        JsxElement = 258,
-        JsxSelfClosingElement = 259,
-        JsxOpeningElement = 260,
-        JsxClosingElement = 261,
-        JsxFragment = 262,
-        JsxOpeningFragment = 263,
-        JsxClosingFragment = 264,
-        JsxAttribute = 265,
-        JsxAttributes = 266,
-        JsxSpreadAttribute = 267,
-        JsxExpression = 268,
-        CaseClause = 269,
-        DefaultClause = 270,
-        HeritageClause = 271,
-        CatchClause = 272,
-        PropertyAssignment = 273,
-        ShorthandPropertyAssignment = 274,
-        SpreadAssignment = 275,
-        EnumMember = 276,
-        SourceFile = 277,
-        Bundle = 278,
-        UnparsedSource = 279,
-        InputFiles = 280,
-        JSDocTypeExpression = 281,
-        JSDocAllType = 282,
-        JSDocUnknownType = 283,
-        JSDocNullableType = 284,
-        JSDocNonNullableType = 285,
-        JSDocOptionalType = 286,
-        JSDocFunctionType = 287,
-        JSDocVariadicType = 288,
-        JSDocComment = 289,
-        JSDocTypeLiteral = 290,
-        JSDocSignature = 291,
-        JSDocTag = 292,
-        JSDocAugmentsTag = 293,
-        JSDocClassTag = 294,
-        JSDocCallbackTag = 295,
-        JSDocEnumTag = 296,
-        JSDocParameterTag = 297,
-        JSDocReturnTag = 298,
-        JSDocThisTag = 299,
-        JSDocTypeTag = 300,
-        JSDocTemplateTag = 301,
-        JSDocTypedefTag = 302,
-        JSDocPropertyTag = 303,
-        SyntaxList = 304,
-        NotEmittedStatement = 305,
-        PartiallyEmittedExpression = 306,
-        CommaListExpression = 307,
-        MergeDeclarationMarker = 308,
-        EndOfDeclarationMarker = 309,
-        Count = 310,
+        PrivateName = 72,
+        BreakKeyword = 73,
+        CaseKeyword = 74,
+        CatchKeyword = 75,
+        ClassKeyword = 76,
+        ConstKeyword = 77,
+        ContinueKeyword = 78,
+        DebuggerKeyword = 79,
+        DefaultKeyword = 80,
+        DeleteKeyword = 81,
+        DoKeyword = 82,
+        ElseKeyword = 83,
+        EnumKeyword = 84,
+        ExportKeyword = 85,
+        ExtendsKeyword = 86,
+        FalseKeyword = 87,
+        FinallyKeyword = 88,
+        ForKeyword = 89,
+        FunctionKeyword = 90,
+        IfKeyword = 91,
+        ImportKeyword = 92,
+        InKeyword = 93,
+        InstanceOfKeyword = 94,
+        NewKeyword = 95,
+        NullKeyword = 96,
+        ReturnKeyword = 97,
+        SuperKeyword = 98,
+        SwitchKeyword = 99,
+        ThisKeyword = 100,
+        ThrowKeyword = 101,
+        TrueKeyword = 102,
+        TryKeyword = 103,
+        TypeOfKeyword = 104,
+        VarKeyword = 105,
+        VoidKeyword = 106,
+        WhileKeyword = 107,
+        WithKeyword = 108,
+        ImplementsKeyword = 109,
+        InterfaceKeyword = 110,
+        LetKeyword = 111,
+        PackageKeyword = 112,
+        PrivateKeyword = 113,
+        ProtectedKeyword = 114,
+        PublicKeyword = 115,
+        StaticKeyword = 116,
+        YieldKeyword = 117,
+        AbstractKeyword = 118,
+        AsKeyword = 119,
+        AnyKeyword = 120,
+        AsyncKeyword = 121,
+        AwaitKeyword = 122,
+        BooleanKeyword = 123,
+        ConstructorKeyword = 124,
+        DeclareKeyword = 125,
+        GetKeyword = 126,
+        InferKeyword = 127,
+        IsKeyword = 128,
+        KeyOfKeyword = 129,
+        ModuleKeyword = 130,
+        NamespaceKeyword = 131,
+        NeverKeyword = 132,
+        ReadonlyKeyword = 133,
+        RequireKeyword = 134,
+        NumberKeyword = 135,
+        ObjectKeyword = 136,
+        SetKeyword = 137,
+        StringKeyword = 138,
+        SymbolKeyword = 139,
+        TypeKeyword = 140,
+        UndefinedKeyword = 141,
+        UniqueKeyword = 142,
+        UnknownKeyword = 143,
+        FromKeyword = 144,
+        GlobalKeyword = 145,
+        OfKeyword = 146,
+        QualifiedName = 147,
+        ComputedPropertyName = 148,
+        TypeParameter = 149,
+        Parameter = 150,
+        Decorator = 151,
+        PropertySignature = 152,
+        PropertyDeclaration = 153,
+        MethodSignature = 154,
+        MethodDeclaration = 155,
+        Constructor = 156,
+        GetAccessor = 157,
+        SetAccessor = 158,
+        CallSignature = 159,
+        ConstructSignature = 160,
+        IndexSignature = 161,
+        TypePredicate = 162,
+        TypeReference = 163,
+        FunctionType = 164,
+        ConstructorType = 165,
+        TypeQuery = 166,
+        TypeLiteral = 167,
+        ArrayType = 168,
+        TupleType = 169,
+        OptionalType = 170,
+        RestType = 171,
+        UnionType = 172,
+        IntersectionType = 173,
+        ConditionalType = 174,
+        InferType = 175,
+        ParenthesizedType = 176,
+        ThisType = 177,
+        TypeOperator = 178,
+        IndexedAccessType = 179,
+        MappedType = 180,
+        LiteralType = 181,
+        ImportType = 182,
+        ObjectBindingPattern = 183,
+        ArrayBindingPattern = 184,
+        BindingElement = 185,
+        ArrayLiteralExpression = 186,
+        ObjectLiteralExpression = 187,
+        PropertyAccessExpression = 188,
+        ElementAccessExpression = 189,
+        CallExpression = 190,
+        NewExpression = 191,
+        TaggedTemplateExpression = 192,
+        TypeAssertionExpression = 193,
+        ParenthesizedExpression = 194,
+        FunctionExpression = 195,
+        ArrowFunction = 196,
+        DeleteExpression = 197,
+        TypeOfExpression = 198,
+        VoidExpression = 199,
+        AwaitExpression = 200,
+        PrefixUnaryExpression = 201,
+        PostfixUnaryExpression = 202,
+        BinaryExpression = 203,
+        ConditionalExpression = 204,
+        TemplateExpression = 205,
+        YieldExpression = 206,
+        SpreadElement = 207,
+        ClassExpression = 208,
+        OmittedExpression = 209,
+        ExpressionWithTypeArguments = 210,
+        AsExpression = 211,
+        NonNullExpression = 212,
+        MetaProperty = 213,
+        SyntheticExpression = 214,
+        TemplateSpan = 215,
+        SemicolonClassElement = 216,
+        Block = 217,
+        VariableStatement = 218,
+        EmptyStatement = 219,
+        ExpressionStatement = 220,
+        IfStatement = 221,
+        DoStatement = 222,
+        WhileStatement = 223,
+        ForStatement = 224,
+        ForInStatement = 225,
+        ForOfStatement = 226,
+        ContinueStatement = 227,
+        BreakStatement = 228,
+        ReturnStatement = 229,
+        WithStatement = 230,
+        SwitchStatement = 231,
+        LabeledStatement = 232,
+        ThrowStatement = 233,
+        TryStatement = 234,
+        DebuggerStatement = 235,
+        VariableDeclaration = 236,
+        VariableDeclarationList = 237,
+        FunctionDeclaration = 238,
+        ClassDeclaration = 239,
+        InterfaceDeclaration = 240,
+        TypeAliasDeclaration = 241,
+        EnumDeclaration = 242,
+        ModuleDeclaration = 243,
+        ModuleBlock = 244,
+        CaseBlock = 245,
+        NamespaceExportDeclaration = 246,
+        ImportEqualsDeclaration = 247,
+        ImportDeclaration = 248,
+        ImportClause = 249,
+        NamespaceImport = 250,
+        NamedImports = 251,
+        ImportSpecifier = 252,
+        ExportAssignment = 253,
+        ExportDeclaration = 254,
+        NamedExports = 255,
+        ExportSpecifier = 256,
+        MissingDeclaration = 257,
+        ExternalModuleReference = 258,
+        JsxElement = 259,
+        JsxSelfClosingElement = 260,
+        JsxOpeningElement = 261,
+        JsxClosingElement = 262,
+        JsxFragment = 263,
+        JsxOpeningFragment = 264,
+        JsxClosingFragment = 265,
+        JsxAttribute = 266,
+        JsxAttributes = 267,
+        JsxSpreadAttribute = 268,
+        JsxExpression = 269,
+        CaseClause = 270,
+        DefaultClause = 271,
+        HeritageClause = 272,
+        CatchClause = 273,
+        PropertyAssignment = 274,
+        ShorthandPropertyAssignment = 275,
+        SpreadAssignment = 276,
+        EnumMember = 277,
+        SourceFile = 278,
+        Bundle = 279,
+        UnparsedSource = 280,
+        InputFiles = 281,
+        JSDocTypeExpression = 282,
+        JSDocAllType = 283,
+        JSDocUnknownType = 284,
+        JSDocNullableType = 285,
+        JSDocNonNullableType = 286,
+        JSDocOptionalType = 287,
+        JSDocFunctionType = 288,
+        JSDocVariadicType = 289,
+        JSDocComment = 290,
+        JSDocTypeLiteral = 291,
+        JSDocSignature = 292,
+        JSDocTag = 293,
+        JSDocAugmentsTag = 294,
+        JSDocClassTag = 295,
+        JSDocCallbackTag = 296,
+        JSDocEnumTag = 297,
+        JSDocParameterTag = 298,
+        JSDocReturnTag = 299,
+        JSDocThisTag = 300,
+        JSDocTypeTag = 301,
+        JSDocTemplateTag = 302,
+        JSDocTypedefTag = 303,
+        JSDocPropertyTag = 304,
+        SyntaxList = 305,
+        NotEmittedStatement = 306,
+        PartiallyEmittedExpression = 307,
+        CommaListExpression = 308,
+        MergeDeclarationMarker = 309,
+        EndOfDeclarationMarker = 310,
+        Count = 311,
         FirstAssignment = 58,
         LastAssignment = 70,
         FirstCompoundAssignment = 59,
         LastCompoundAssignment = 70,
-        FirstReservedWord = 72,
-        LastReservedWord = 107,
-        FirstKeyword = 72,
-        LastKeyword = 145,
-        FirstFutureReservedWord = 108,
-        LastFutureReservedWord = 116,
-        FirstTypeNode = 161,
-        LastTypeNode = 181,
+        FirstReservedWord = 73,
+        LastReservedWord = 108,
+        FirstKeyword = 73,
+        LastKeyword = 146,
+        FirstFutureReservedWord = 109,
+        LastFutureReservedWord = 117,
+        FirstTypeNode = 162,
+        LastTypeNode = 182,
         FirstPunctuation = 17,
         LastPunctuation = 70,
         FirstToken = 0,
-        LastToken = 145,
+        LastToken = 146,
         FirstTriviaToken = 2,
         LastTriviaToken = 7,
         FirstLiteralToken = 8,
@@ -407,11 +408,11 @@ declare namespace ts {
         LastTemplateToken = 16,
         FirstBinaryOperator = 27,
         LastBinaryOperator = 70,
-        FirstNode = 146,
-        FirstJSDocNode = 281,
-        LastJSDocNode = 303,
-        FirstJSDocTagNode = 292,
-        LastJSDocTagNode = 303
+        FirstNode = 147,
+        FirstJSDocNode = 282,
+        LastJSDocNode = 304,
+        FirstJSDocTagNode = 293,
+        LastJSDocTagNode = 304
     }
     enum NodeFlags {
         None = 0,
@@ -524,8 +525,8 @@ declare namespace ts {
         right: Identifier;
     }
     type EntityName = Identifier | QualifiedName;
-    type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;
-    type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern;
+    type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName;
+    type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateName | BindingPattern;
     interface Declaration extends Node {
         _declarationBrand: any;
     }
@@ -539,6 +540,10 @@ declare namespace ts {
         kind: SyntaxKind.ComputedPropertyName;
         expression: Expression;
     }
+    interface PrivateName extends Declaration {
+        kind: SyntaxKind.PrivateName;
+        escapedText: __String;
+    }
     interface Decorator extends Node {
         kind: SyntaxKind.Decorator;
         parent: NamedDeclaration;
@@ -1046,7 +1051,7 @@ declare namespace ts {
     interface PropertyAccessExpression extends MemberExpression, NamedDeclaration {
         kind: SyntaxKind.PropertyAccessExpression;
         expression: LeftHandSideExpression;
-        name: Identifier;
+        name: Identifier | PrivateName;
     }
     interface SuperPropertyAccessExpression extends PropertyAccessExpression {
         expression: SuperExpression;
@@ -3194,9 +3199,9 @@ declare namespace ts {
      * @returns The unescaped identifier text.
      */
     function unescapeLeadingUnderscores(identifier: __String): string;
-    function idText(identifier: Identifier): string;
+    function idText(identifierOrPrivateName: Identifier | PrivateName): string;
     function symbolName(symbol: Symbol): string;
-    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | undefined;
+    function getNameOfJSDocTypedef(declaration: JSDocTypedefTag): Identifier | PrivateName | undefined;
     function getNameOfDeclaration(declaration: Declaration | Expression): DeclarationName | undefined;
     /**
      * Gets the JSDoc parameter tags for the node if present.
@@ -3273,8 +3278,10 @@ declare namespace ts {
     function isTemplateMiddle(node: Node): node is TemplateMiddle;
     function isTemplateTail(node: Node): node is TemplateTail;
     function isIdentifier(node: Node): node is Identifier;
+    function isIdentifierOrPrivateName(node: Node): node is Identifier | PrivateName;
     function isQualifiedName(node: Node): node is QualifiedName;
     function isComputedPropertyName(node: Node): node is ComputedPropertyName;
+    function isPrivateName(node: Node): node is PrivateName;
     function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration;
     function isParameter(node: Node): node is ParameterDeclaration;
     function isDecorator(node: Node): node is Decorator;
@@ -3734,8 +3741,8 @@ declare namespace ts {
     function updateArrayLiteral(node: ArrayLiteralExpression, elements: ReadonlyArray<Expression>): ArrayLiteralExpression;
     function createObjectLiteral(properties?: ReadonlyArray<ObjectLiteralElementLike>, multiLine?: boolean): ObjectLiteralExpression;
     function updateObjectLiteral(node: ObjectLiteralExpression, properties: ReadonlyArray<ObjectLiteralElementLike>): ObjectLiteralExpression;
-    function createPropertyAccess(expression: Expression, name: string | Identifier | undefined): PropertyAccessExpression;
-    function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier): PropertyAccessExpression;
+    function createPropertyAccess(expression: Expression, name: string | Identifier | PrivateName | undefined): PropertyAccessExpression;
+    function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier | PrivateName): PropertyAccessExpression;
     function createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression;
     function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression;
     function createCall(expression: Expression, typeArguments: ReadonlyArray<TypeNode> | undefined, argumentsArray: ReadonlyArray<Expression> | undefined): CallExpression;
@@ -4510,6 +4517,9 @@ declare namespace ts {
     interface Identifier {
         readonly text: string;
     }
+    interface PrivateName {
+        readonly text: string;
+    }
     interface Symbol {
         readonly name: string;
         getFlags(): SymbolFlags;
diff --git a/tests/baselines/reference/functionValuedProperty.js b/tests/baselines/reference/functionValuedProperty.js
new file mode 100644
index 0000000000000..e976b365358c1
--- /dev/null
+++ b/tests/baselines/reference/functionValuedProperty.js
@@ -0,0 +1,36 @@
+//// [functionValuedProperty.ts]
+class A {
+    #func: (x: string) => number;
+    test() {
+        const x = this.#func("hello");
+        this.#func = function (x: string) {
+            return parseInt(x);
+        };
+        const y = (this.#func)("test");
+        (this.#func = function (x: string) {
+            return 4;
+        })("");
+    }
+}
+
+
+//// [functionValuedProperty.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 A = /** @class */ (function () {
+    function A() {
+        _func.set(this, void 0);
+    }
+    A.prototype.test = function () {
+        var x = _classPrivateFieldGet(this, _func).call(this, "hello");
+        _classPrivateFieldSet(this, _func, function (x) {
+            return parseInt(x);
+        });
+        var y = (_classPrivateFieldGet(this, _func)).call(this, "test");
+        (_classPrivateFieldSet(this, _func, function (x) {
+            return 4;
+        }))("");
+    };
+    return A;
+}());
+var _func = new WeakMap;
diff --git a/tests/baselines/reference/functionValuedProperty.symbols b/tests/baselines/reference/functionValuedProperty.symbols
new file mode 100644
index 0000000000000..87b7f6d9991cf
--- /dev/null
+++ b/tests/baselines/reference/functionValuedProperty.symbols
@@ -0,0 +1,41 @@
+=== tests/cases/conformance/classes/members/privateNames/functionValuedProperty.ts ===
+class A {
+>A : Symbol(A, Decl(functionValuedProperty.ts, 0, 0))
+
+    #func: (x: string) => number;
+>#func : Symbol(A[#func], Decl(functionValuedProperty.ts, 0, 9))
+>x : Symbol(x, Decl(functionValuedProperty.ts, 1, 12))
+
+    test() {
+>test : Symbol(A.test, Decl(functionValuedProperty.ts, 1, 33))
+
+        const x = this.#func("hello");
+>x : Symbol(x, Decl(functionValuedProperty.ts, 3, 13))
+>this.#func : Symbol(A[#func], Decl(functionValuedProperty.ts, 0, 9))
+>this : Symbol(A, Decl(functionValuedProperty.ts, 0, 0))
+
+        this.#func = function (x: string) {
+>this.#func : Symbol(A[#func], Decl(functionValuedProperty.ts, 0, 9))
+>this : Symbol(A, Decl(functionValuedProperty.ts, 0, 0))
+>x : Symbol(x, Decl(functionValuedProperty.ts, 4, 31))
+
+            return parseInt(x);
+>parseInt : Symbol(parseInt, Decl(lib.es5.d.ts, --, --))
+>x : Symbol(x, Decl(functionValuedProperty.ts, 4, 31))
+
+        };
+        const y = (this.#func)("test");
+>y : Symbol(y, Decl(functionValuedProperty.ts, 7, 13))
+>this.#func : Symbol(A[#func], Decl(functionValuedProperty.ts, 0, 9))
+>this : Symbol(A, Decl(functionValuedProperty.ts, 0, 0))
+
+        (this.#func = function (x: string) {
+>this.#func : Symbol(A[#func], Decl(functionValuedProperty.ts, 0, 9))
+>this : Symbol(A, Decl(functionValuedProperty.ts, 0, 0))
+>x : Symbol(x, Decl(functionValuedProperty.ts, 8, 32))
+
+            return 4;
+        })("");
+    }
+}
+
diff --git a/tests/baselines/reference/functionValuedProperty.types b/tests/baselines/reference/functionValuedProperty.types
new file mode 100644
index 0000000000000..74c72745c3078
--- /dev/null
+++ b/tests/baselines/reference/functionValuedProperty.types
@@ -0,0 +1,56 @@
+=== tests/cases/conformance/classes/members/privateNames/functionValuedProperty.ts ===
+class A {
+>A : A
+
+    #func: (x: string) => number;
+>#func : (x: string) => number
+>x : string
+
+    test() {
+>test : () => void
+
+        const x = this.#func("hello");
+>x : number
+>this.#func("hello") : number
+>this.#func : (x: string) => number
+>this : this
+>"hello" : "hello"
+
+        this.#func = function (x: string) {
+>this.#func = function (x: string) {            return parseInt(x);        } : (x: string) => number
+>this.#func : (x: string) => number
+>this : this
+>function (x: string) {            return parseInt(x);        } : (x: string) => number
+>x : string
+
+            return parseInt(x);
+>parseInt(x) : number
+>parseInt : (s: string, radix?: number) => number
+>x : string
+
+        };
+        const y = (this.#func)("test");
+>y : number
+>(this.#func)("test") : number
+>(this.#func) : (x: string) => number
+>this.#func : (x: string) => number
+>this : this
+>"test" : "test"
+
+        (this.#func = function (x: string) {
+>(this.#func = function (x: string) {            return 4;        })("") : number
+>(this.#func = function (x: string) {            return 4;        }) : (x: string) => number
+>this.#func = function (x: string) {            return 4;        } : (x: string) => number
+>this.#func : (x: string) => number
+>this : this
+>function (x: string) {            return 4;        } : (x: string) => number
+>x : string
+
+            return 4;
+>4 : 4
+
+        })("");
+>"" : ""
+    }
+}
+
diff --git a/tests/baselines/reference/parseErrorInHeritageClause1.errors.txt b/tests/baselines/reference/parseErrorInHeritageClause1.errors.txt
index 67564442b3abc..722004686f23c 100644
--- a/tests/baselines/reference/parseErrorInHeritageClause1.errors.txt
+++ b/tests/baselines/reference/parseErrorInHeritageClause1.errors.txt
@@ -3,9 +3,10 @@ tests/cases/compiler/parseErrorInHeritageClause1.ts(1,19): error TS1127: Invalid
 
 
 ==== tests/cases/compiler/parseErrorInHeritageClause1.ts (2 errors) ====
-    class C extends A # {
+    class C extends A ¬ {
                     ~
 !!! error TS2304: Cannot find name 'A'.
                       
 !!! error TS1127: Invalid character.
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/parseErrorInHeritageClause1.js b/tests/baselines/reference/parseErrorInHeritageClause1.js
index 25724868d7acb..570eb51200a20 100644
--- a/tests/baselines/reference/parseErrorInHeritageClause1.js
+++ b/tests/baselines/reference/parseErrorInHeritageClause1.js
@@ -1,6 +1,7 @@
 //// [parseErrorInHeritageClause1.ts]
-class C extends A # {
-}
+class C extends A ¬ {
+}
+
 
 //// [parseErrorInHeritageClause1.js]
 var __extends = (this && this.__extends) || (function () {
diff --git a/tests/baselines/reference/parseErrorInHeritageClause1.symbols b/tests/baselines/reference/parseErrorInHeritageClause1.symbols
index 5e0d3d26d38da..45d6ba5f5fac3 100644
--- a/tests/baselines/reference/parseErrorInHeritageClause1.symbols
+++ b/tests/baselines/reference/parseErrorInHeritageClause1.symbols
@@ -1,4 +1,5 @@
 === tests/cases/compiler/parseErrorInHeritageClause1.ts ===
-class C extends A # {
+class C extends A ¬ {
 >C : Symbol(C, Decl(parseErrorInHeritageClause1.ts, 0, 0))
 }
+
diff --git a/tests/baselines/reference/parseErrorInHeritageClause1.types b/tests/baselines/reference/parseErrorInHeritageClause1.types
index 53f0a622054d3..0a8c72e1f8c92 100644
--- a/tests/baselines/reference/parseErrorInHeritageClause1.types
+++ b/tests/baselines/reference/parseErrorInHeritageClause1.types
@@ -1,5 +1,6 @@
 === tests/cases/compiler/parseErrorInHeritageClause1.ts ===
-class C extends A # {
+class C extends A ¬ {
 >C : C
 >A : any
 }
+
diff --git a/tests/baselines/reference/parserErrorRecovery_Block2.errors.txt b/tests/baselines/reference/parserErrorRecovery_Block2.errors.txt
index 53279be443f66..ff29d9389760b 100644
--- a/tests/baselines/reference/parserErrorRecovery_Block2.errors.txt
+++ b/tests/baselines/reference/parserErrorRecovery_Block2.errors.txt
@@ -3,8 +3,9 @@ tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecov
 
 ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block2.ts (1 errors) ====
     function f() {
-        #
+        ¬
         
 !!! error TS1127: Invalid character.
         return;
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/parserErrorRecovery_Block2.js b/tests/baselines/reference/parserErrorRecovery_Block2.js
index 24ddaf0db3f2a..024684a9e2b03 100644
--- a/tests/baselines/reference/parserErrorRecovery_Block2.js
+++ b/tests/baselines/reference/parserErrorRecovery_Block2.js
@@ -1,8 +1,9 @@
 //// [parserErrorRecovery_Block2.ts]
 function f() {
-    #
+    ¬
     return;
-}
+}
+
 
 //// [parserErrorRecovery_Block2.js]
 function f() {
diff --git a/tests/baselines/reference/parserErrorRecovery_Block2.symbols b/tests/baselines/reference/parserErrorRecovery_Block2.symbols
index 3d5a09d567ce6..ce4725e609a64 100644
--- a/tests/baselines/reference/parserErrorRecovery_Block2.symbols
+++ b/tests/baselines/reference/parserErrorRecovery_Block2.symbols
@@ -2,6 +2,7 @@
 function f() {
 >f : Symbol(f, Decl(parserErrorRecovery_Block2.ts, 0, 0))
 
-    #
+    ¬
     return;
 }
+
diff --git a/tests/baselines/reference/parserErrorRecovery_Block2.types b/tests/baselines/reference/parserErrorRecovery_Block2.types
index 9850dc1cf0ea2..0a0a0fbec23c8 100644
--- a/tests/baselines/reference/parserErrorRecovery_Block2.types
+++ b/tests/baselines/reference/parserErrorRecovery_Block2.types
@@ -2,6 +2,7 @@
 function f() {
 >f : () => void
 
-    #
+    ¬
     return;
 }
+
diff --git a/tests/baselines/reference/parserErrorRecovery_ClassElement3.errors.txt b/tests/baselines/reference/parserErrorRecovery_ClassElement3.errors.txt
index 7f81c6114f6d2..52f99265d2c51 100644
--- a/tests/baselines/reference/parserErrorRecovery_ClassElement3.errors.txt
+++ b/tests/baselines/reference/parserErrorRecovery_ClassElement3.errors.txt
@@ -1,12 +1,12 @@
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts(2,4): error TS1127: Invalid character.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts(6,4): error TS1109: Expression expected.
 tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts(7,4): error TS1127: Invalid character.
-tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts(7,5): error TS1005: '}' expected.
+tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts(8,1): error TS1005: '}' expected.
 
 
 ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts (4 errors) ====
     module M {
-       #
+       ¬
        
 !!! error TS1127: Invalid character.
        class C {
@@ -15,8 +15,9 @@ tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErr
        enum E {
        ~~~~
 !!! error TS1109: Expression expected.
-       #
+       ¬
        
 !!! error TS1127: Invalid character.
-        
+    
+    
 !!! error TS1005: '}' expected.
\ No newline at end of file
diff --git a/tests/baselines/reference/parserErrorRecovery_ClassElement3.js b/tests/baselines/reference/parserErrorRecovery_ClassElement3.js
index 36d98fa54003e..ef9afde66f7f0 100644
--- a/tests/baselines/reference/parserErrorRecovery_ClassElement3.js
+++ b/tests/baselines/reference/parserErrorRecovery_ClassElement3.js
@@ -1,11 +1,12 @@
 //// [parserErrorRecovery_ClassElement3.ts]
 module M {
-   #
+   ¬
    class C {
    }
    @
    enum E {
-   #
+   ¬
+
 
 //// [parserErrorRecovery_ClassElement3.js]
 var M;
diff --git a/tests/baselines/reference/parserErrorRecovery_ClassElement3.symbols b/tests/baselines/reference/parserErrorRecovery_ClassElement3.symbols
index 5c1edc5b8f09f..5ea7444c974c9 100644
--- a/tests/baselines/reference/parserErrorRecovery_ClassElement3.symbols
+++ b/tests/baselines/reference/parserErrorRecovery_ClassElement3.symbols
@@ -2,7 +2,7 @@
 module M {
 >M : Symbol(M, Decl(parserErrorRecovery_ClassElement3.ts, 0, 0))
 
-   #
+   ¬
    class C {
 >C : Symbol(C, Decl(parserErrorRecovery_ClassElement3.ts, 1, 4))
    }
@@ -10,4 +10,5 @@ module M {
    enum E {
 >E : Symbol(E, Decl(parserErrorRecovery_ClassElement3.ts, 3, 4))
 
-   #
+   ¬
+
diff --git a/tests/baselines/reference/parserErrorRecovery_ClassElement3.types b/tests/baselines/reference/parserErrorRecovery_ClassElement3.types
index 68df4b2bbe22b..f509a0d4fb574 100644
--- a/tests/baselines/reference/parserErrorRecovery_ClassElement3.types
+++ b/tests/baselines/reference/parserErrorRecovery_ClassElement3.types
@@ -2,7 +2,7 @@
 module M {
 >M : typeof M
 
-   #
+   ¬
    class C {
 >C : C
    }
@@ -11,4 +11,5 @@ module M {
 > : any
 >E : E
 
-   #
+   ¬
+
diff --git a/tests/baselines/reference/parserErrorRecovery_ParameterList4.errors.txt b/tests/baselines/reference/parserErrorRecovery_ParameterList4.errors.txt
index fa97550dd192f..9e404df184199 100644
--- a/tests/baselines/reference/parserErrorRecovery_ParameterList4.errors.txt
+++ b/tests/baselines/reference/parserErrorRecovery_ParameterList4.errors.txt
@@ -2,7 +2,8 @@ tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserEr
 
 
 ==== tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts (1 errors) ====
-    function f(a,#) {
+    function f(a,¬) {
                  
 !!! error TS1127: Invalid character.
-    }
\ No newline at end of file
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/parserErrorRecovery_ParameterList4.js b/tests/baselines/reference/parserErrorRecovery_ParameterList4.js
index 53775cad92ea3..1a1a124eb493d 100644
--- a/tests/baselines/reference/parserErrorRecovery_ParameterList4.js
+++ b/tests/baselines/reference/parserErrorRecovery_ParameterList4.js
@@ -1,6 +1,7 @@
 //// [parserErrorRecovery_ParameterList4.ts]
-function f(a,#) {
-}
+function f(a,¬) {
+}
+
 
 //// [parserErrorRecovery_ParameterList4.js]
 function f(a) {
diff --git a/tests/baselines/reference/parserErrorRecovery_ParameterList4.symbols b/tests/baselines/reference/parserErrorRecovery_ParameterList4.symbols
index df48ebfe04dec..7c433c8c3b461 100644
--- a/tests/baselines/reference/parserErrorRecovery_ParameterList4.symbols
+++ b/tests/baselines/reference/parserErrorRecovery_ParameterList4.symbols
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts ===
-function f(a,#) {
+function f(a,¬) {
 >f : Symbol(f, Decl(parserErrorRecovery_ParameterList4.ts, 0, 0))
 >a : Symbol(a, Decl(parserErrorRecovery_ParameterList4.ts, 0, 11))
 }
+
diff --git a/tests/baselines/reference/parserErrorRecovery_ParameterList4.types b/tests/baselines/reference/parserErrorRecovery_ParameterList4.types
index 77b105f1d4cef..093d99193d21f 100644
--- a/tests/baselines/reference/parserErrorRecovery_ParameterList4.types
+++ b/tests/baselines/reference/parserErrorRecovery_ParameterList4.types
@@ -1,5 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts ===
-function f(a,#) {
+function f(a,¬) {
 >f : (a: any) => void
 >a : any
 }
+
diff --git a/tests/baselines/reference/parserSkippedTokens16.errors.txt b/tests/baselines/reference/parserSkippedTokens16.errors.txt
index c35e013a22852..d27faccd2c9e7 100644
--- a/tests/baselines/reference/parserSkippedTokens16.errors.txt
+++ b/tests/baselines/reference/parserSkippedTokens16.errors.txt
@@ -19,7 +19,7 @@ tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.t
 !!! error TS2304: Cannot find name 'Bar'.
                ~
 !!! error TS1005: ';' expected.
-    function Foo      () #   { }
+    function Foo      () ¬   { }
                          
 !!! error TS1127: Invalid character.
     4+:5
@@ -33,4 +33,5 @@ tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.t
     }
     var x       =
                  
-!!! error TS1109: Expression expected.
\ No newline at end of file
+!!! error TS1109: Expression expected.
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/parserSkippedTokens16.js b/tests/baselines/reference/parserSkippedTokens16.js
index 2c3a9be876df5..cf5b8c55ecc8a 100644
--- a/tests/baselines/reference/parserSkippedTokens16.js
+++ b/tests/baselines/reference/parserSkippedTokens16.js
@@ -1,12 +1,13 @@
 //// [parserSkippedTokens16.ts]
 foo(): Bar { }
-function Foo      () #   { }
+function Foo      () ¬   { }
 4+:5
 module M {
 function a(
     : T) { }
 }
-var x       =
+var x       =
+
 
 //// [parserSkippedTokens16.js]
 foo();
diff --git a/tests/baselines/reference/parserSkippedTokens16.symbols b/tests/baselines/reference/parserSkippedTokens16.symbols
index 213dc9965f98f..576a1dfd97d8d 100644
--- a/tests/baselines/reference/parserSkippedTokens16.symbols
+++ b/tests/baselines/reference/parserSkippedTokens16.symbols
@@ -1,6 +1,6 @@
 === tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.ts ===
 foo(): Bar { }
-function Foo      () #   { }
+function Foo      () ¬   { }
 >Foo : Symbol(Foo, Decl(parserSkippedTokens16.ts, 0, 14))
 
 4+:5
diff --git a/tests/baselines/reference/parserSkippedTokens16.types b/tests/baselines/reference/parserSkippedTokens16.types
index b9c24cfafbaf0..cb62505802fe9 100644
--- a/tests/baselines/reference/parserSkippedTokens16.types
+++ b/tests/baselines/reference/parserSkippedTokens16.types
@@ -4,7 +4,7 @@ foo(): Bar { }
 >foo : any
 >Bar : any
 
-function Foo      () #   { }
+function Foo      () ¬   { }
 >Foo : () => any
 
 4+:5
@@ -24,5 +24,6 @@ function a(
 }
 var x       =
 >x : any
+
 > : any
 
diff --git a/tests/baselines/reference/privateNameAndIndexSignature.errors.txt b/tests/baselines/reference/privateNameAndIndexSignature.errors.txt
new file mode 100644
index 0000000000000..1b4895bf23d64
--- /dev/null
+++ b/tests/baselines/reference/privateNameAndIndexSignature.errors.txt
@@ -0,0 +1,13 @@
+tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts(4,14): error TS2339: Property '#f' does not exist on type 'A'.
+
+
+==== tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts (1 errors) ====
+    class A {
+        [k: string]: any;
+        constructor(message: string) {
+            this.#f = 3                 // Error Property '#f' does not exist on type 'A'.
+                 ~~
+!!! error TS2339: Property '#f' does not exist on type 'A'.
+        }
+    }
+    
\ No newline at end of file
diff --git a/tests/baselines/reference/privateNameAndIndexSignature.js b/tests/baselines/reference/privateNameAndIndexSignature.js
new file mode 100644
index 0000000000000..d1271acca8ce9
--- /dev/null
+++ b/tests/baselines/reference/privateNameAndIndexSignature.js
@@ -0,0 +1,16 @@
+//// [privateNameAndIndexSignature.ts]
+class A {
+    [k: string]: any;
+    constructor(message: string) {
+        this.#f = 3                 // Error Property '#f' does not exist on type 'A'.
+    }
+}
+
+
+//// [privateNameAndIndexSignature.js]
+var A = /** @class */ (function () {
+    function A(message) {
+        this.#f = 3; // Error Property '#f' does not exist on type 'A'.
+    }
+    return A;
+}());
diff --git a/tests/baselines/reference/privateNameAndIndexSignature.symbols b/tests/baselines/reference/privateNameAndIndexSignature.symbols
new file mode 100644
index 0000000000000..d8a153c04270e
--- /dev/null
+++ b/tests/baselines/reference/privateNameAndIndexSignature.symbols
@@ -0,0 +1,15 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts ===
+class A {
+>A : Symbol(A, Decl(privateNameAndIndexSignature.ts, 0, 0))
+
+    [k: string]: any;
+>k : Symbol(k, Decl(privateNameAndIndexSignature.ts, 1, 5))
+
+    constructor(message: string) {
+>message : Symbol(message, Decl(privateNameAndIndexSignature.ts, 2, 16))
+
+        this.#f = 3                 // Error Property '#f' does not exist on type 'A'.
+>this : Symbol(A, Decl(privateNameAndIndexSignature.ts, 0, 0))
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameAndIndexSignature.types b/tests/baselines/reference/privateNameAndIndexSignature.types
new file mode 100644
index 0000000000000..d663d5b9517cc
--- /dev/null
+++ b/tests/baselines/reference/privateNameAndIndexSignature.types
@@ -0,0 +1,18 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts ===
+class A {
+>A : A
+
+    [k: string]: any;
+>k : string
+
+    constructor(message: string) {
+>message : string
+
+        this.#f = 3                 // Error Property '#f' does not exist on type 'A'.
+>this.#f = 3 : 3
+>this.#f : any
+>this : this
+>3 : 3
+    }
+}
+
diff --git a/tests/baselines/reference/privateNameField.js b/tests/baselines/reference/privateNameField.js
new file mode 100644
index 0000000000000..f432be2b3d336
--- /dev/null
+++ b/tests/baselines/reference/privateNameField.js
@@ -0,0 +1,15 @@
+//// [privateNameField.ts]
+class A {
+    #name: string;
+    constructor(name: string) {
+        this.#name = name;
+    }
+}
+
+//// [privateNameField.js]
+var A = /** @class */ (function () {
+    function A(name) {
+        this.#name = name;
+    }
+    return A;
+}());
diff --git a/tests/baselines/reference/privateNameField.symbols b/tests/baselines/reference/privateNameField.symbols
new file mode 100644
index 0000000000000..a9ab08325a0e1
--- /dev/null
+++ b/tests/baselines/reference/privateNameField.symbols
@@ -0,0 +1,16 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameField.ts ===
+class A {
+>A : Symbol(A, Decl(privateNameField.ts, 0, 0))
+
+    #name: string;
+>#name : Symbol(A[#name], Decl(privateNameField.ts, 0, 9))
+
+    constructor(name: string) {
+>name : Symbol(name, Decl(privateNameField.ts, 2, 16))
+
+        this.#name = name;
+>this.#name : Symbol(A[#name], Decl(privateNameField.ts, 0, 9))
+>this : Symbol(A, Decl(privateNameField.ts, 0, 0))
+>name : Symbol(name, Decl(privateNameField.ts, 2, 16))
+    }
+}
diff --git a/tests/baselines/reference/privateNameField.types b/tests/baselines/reference/privateNameField.types
new file mode 100644
index 0000000000000..1eb30eda52590
--- /dev/null
+++ b/tests/baselines/reference/privateNameField.types
@@ -0,0 +1,17 @@
+=== tests/cases/conformance/classes/members/privateNames/privateNameField.ts ===
+class A {
+>A : A
+
+    #name: string;
+>#name : string
+
+    constructor(name: string) {
+>name : string
+
+        this.#name = name;
+>this.#name = name : string
+>this.#name : string
+>this : this
+>name : string
+    }
+}
diff --git a/tests/baselines/reference/shebangError.errors.txt b/tests/baselines/reference/shebangError.errors.txt
index e8197d8bc5f53..894739d5a4170 100644
--- a/tests/baselines/reference/shebangError.errors.txt
+++ b/tests/baselines/reference/shebangError.errors.txt
@@ -1,14 +1,17 @@
-tests/cases/compiler/shebangError.ts(2,1): error TS1127: Invalid character.
+tests/cases/compiler/shebangError.ts(2,1): error TS1128: Declaration or statement expected.
+tests/cases/compiler/shebangError.ts(2,2): error TS1127: Invalid character.
 tests/cases/compiler/shebangError.ts(2,2): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
 tests/cases/compiler/shebangError.ts(2,12): error TS2304: Cannot find name 'env'.
 tests/cases/compiler/shebangError.ts(2,16): error TS1005: ';' expected.
 tests/cases/compiler/shebangError.ts(2,16): error TS2304: Cannot find name 'node'.
 
 
-==== tests/cases/compiler/shebangError.ts (5 errors) ====
+==== tests/cases/compiler/shebangError.ts (6 errors) ====
     var foo = 'Shebang is only allowed on the first line';
     #!/usr/bin/env node
-    
+    ~
+!!! error TS1128: Declaration or statement expected.
+     
 !!! error TS1127: Invalid character.
      ~~~~~~~~~
 !!! error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number' or an enum type.
diff --git a/tests/cases/compiler/parseErrorInHeritageClause1.ts b/tests/cases/compiler/parseErrorInHeritageClause1.ts
index 84223192c7ad1..5c4a21e4f9371 100644
--- a/tests/cases/compiler/parseErrorInHeritageClause1.ts
+++ b/tests/cases/compiler/parseErrorInHeritageClause1.ts
@@ -1,2 +1,2 @@
-class C extends A # {
-}
\ No newline at end of file
+class C extends A ¬ {
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/functionValuedProperty.ts b/tests/cases/conformance/classes/members/privateNames/functionValuedProperty.ts
new file mode 100644
index 0000000000000..8f2dce067de1b
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/functionValuedProperty.ts
@@ -0,0 +1,13 @@
+class A {
+    #func: (x: string) => number;
+    test() {
+        const x = this.#func("hello");
+        this.#func = function (x: string) {
+            return parseInt(x);
+        };
+        const y = (this.#func)("test");
+        (this.#func = function (x: string) {
+            return 4;
+        })("");
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts
new file mode 100644
index 0000000000000..d4c0b8ad46efb
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameAndIndexSignature.ts
@@ -0,0 +1,6 @@
+class A {
+    [k: string]: any;
+    constructor(message: string) {
+        this.#f = 3                 // Error Property '#f' does not exist on type 'A'.
+    }
+}
diff --git a/tests/cases/conformance/classes/members/privateNames/privateNameField.ts b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts
new file mode 100644
index 0000000000000..02e449fb3e002
--- /dev/null
+++ b/tests/cases/conformance/classes/members/privateNames/privateNameField.ts
@@ -0,0 +1,6 @@
+class A {
+    #name: string;
+    constructor(name: string) {
+        this.#name = name;
+    }
+}
\ No newline at end of file
diff --git a/tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts b/tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts
index e698257e94068..f75eaaa1aca5c 100644
--- a/tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts
+++ b/tests/cases/conformance/es6/memberFunctionDeclarations/MemberFunctionDeclaration8_es6.ts
@@ -2,7 +2,7 @@
 class C {
   foo() {
     // Make sure we don't think of *bar as the start of a generator method.
-    if (a) # * bar;
+    if (a) ¬ * bar;
     return bar;
   }
-}
\ No newline at end of file
+}
diff --git a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block2.ts b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block2.ts
index 2473a9d1ffb1c..2652211f3ea50 100644
--- a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block2.ts
+++ b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/Blocks/parserErrorRecovery_Block2.ts
@@ -1,4 +1,4 @@
 function f() {
-    #
+    ¬
     return;
-}
\ No newline at end of file
+}
diff --git a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts
index d4ea9d6078719..0f81401c1b8b2 100644
--- a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts
+++ b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ClassElements/parserErrorRecovery_ClassElement3.ts
@@ -1,7 +1,7 @@
 module M {
-   #
+   ¬
    class C {
    }
    @
    enum E {
-   #
\ No newline at end of file
+   ¬
diff --git a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts
index f46e46951454e..9eb5c87804e11 100644
--- a/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts
+++ b/tests/cases/conformance/parser/ecmascript5/ErrorRecovery/ParameterLists/parserErrorRecovery_ParameterList4.ts
@@ -1,2 +1,2 @@
-function f(a,#) {
-}
\ No newline at end of file
+function f(a,¬) {
+}
diff --git a/tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.ts b/tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.ts
index c583fc13d8229..a12294be4bb9e 100644
--- a/tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.ts
+++ b/tests/cases/conformance/parser/ecmascript5/SkippedTokens/parserSkippedTokens16.ts
@@ -1,8 +1,8 @@
 foo(): Bar { }
-function Foo      () #   { }
+function Foo      () ¬   { }
 4+:5
 module M {
 function a(
     : T) { }
 }
-var x       =
\ No newline at end of file
+var x       =
diff --git a/tests/cases/fourslash/hoverOverPrivateName.ts b/tests/cases/fourslash/hoverOverPrivateName.ts
new file mode 100644
index 0000000000000..28e748b9aa43c
--- /dev/null
+++ b/tests/cases/fourslash/hoverOverPrivateName.ts
@@ -0,0 +1,15 @@
+/// <reference path="fourslash.ts" />
+
+////class A {
+////    #foo: number;
+////
+////    constructor () {
+////        this./**/#foo = 3;
+////    }
+////
+////}
+
+goTo.marker();
+verify.quickInfoIs("");
+verify.goToDefinitionIs([]);
+verify.noReferences();
\ No newline at end of file