bloomberg · acutmore · Jun 17, 2021 · Feb 18, 2021 · Feb 22, 2021 · Feb 23, 2021
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -878,6 +878,8 @@ namespace ts {
                     return (<PrefixUnaryExpression>expr).operator === SyntaxKind.ExclamationToken && isNarrowingExpression((<PrefixUnaryExpression>expr).operand);
                 case SyntaxKind.TypeOfExpression:
                     return isNarrowingExpression((<TypeOfExpression>expr).expression);
+                case SyntaxKind.PrivateIdentifierInInExpression:
+                    return isNarrowingExpression((<PrivateIdentifierInInExpression>expr).expression);
             }
             return false;
         }

diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -23232,6 +23232,33 @@ namespace ts {
                 return type;
             }
 
+            function narrowTypeByPrivateIdentifierInInExpression(type: Type, expr: PrivateIdentifierInInExpression, assumeTrue: boolean): Type {
+                const target = getReferenceCandidate(expr.expression);
+                if (!isMatchingReference(reference, target)) {
+                    return type;
+                }
+
+                const privateId = expr.name;
+                const symbol = lookupSymbolForPrivateIdentifierDeclaration(privateId.escapedText, privateId);
+                if (symbol === undefined) {
+                    return type;
+                }
+                const classSymbol = symbol.parent!;
+                const classType = <InterfaceType>getTypeOfSymbol(classSymbol);
+                const firstDecl = symbol.declarations?.[0];
+                Debug.assert(firstDecl, "should always have a declaration");
+                let targetType: Type;
+                if (hasSyntacticModifier(firstDecl, ModifierFlags.Static)) {
+                    targetType = classType;
+                }
+                else {
+                    const ctorSigs = getSignaturesOfType(classType, SignatureKind.Construct);
+                    Debug.assert(ctorSigs.length > 0, "should always have a constructor");
+                    targetType = getReturnTypeOfSignature(ctorSigs[0]);
+                }
+                return getNarrowedType(type, targetType, assumeTrue, isTypeDerivedFrom);
+            }
+
             function narrowTypeByOptionalChainContainment(type: Type, operator: SyntaxKind, value: Expression, assumeTrue: boolean): Type {
                 // We are in a branch of obj?.foo === value (or any one of the other equality operators). We narrow obj as follows:
                 // When operator is === and type of value excludes undefined, null and undefined is removed from type of obj in true branch.
@@ -23645,6 +23672,8 @@ namespace ts {
                         return narrowType(type, (<ParenthesizedExpression | NonNullExpression>expr).expression, assumeTrue);
                     case SyntaxKind.BinaryExpression:
                         return narrowTypeByBinaryExpression(type, <BinaryExpression>expr, assumeTrue);
+                    case SyntaxKind.PrivateIdentifierInInExpression:
+                        return narrowTypeByPrivateIdentifierInInExpression(type, <PrivateIdentifierInInExpression>expr, assumeTrue);
                     case SyntaxKind.PrefixUnaryExpression:
                         if ((<PrefixUnaryExpression>expr).operator === SyntaxKind.ExclamationToken) {
                             return narrowType(type, (<PrefixUnaryExpression>expr).operand, !assumeTrue);
@@ -27274,6 +27303,7 @@ namespace ts {
         }
 
         function getSuggestedSymbolForNonexistentProperty(name: Identifier | PrivateIdentifier | string, containingType: Type): Symbol | undefined {
+            const originalName = name;
             let props = getPropertiesOfType(containingType);
             if (typeof name !== "string") {
                 const parent = name.parent;
@@ -27282,7 +27312,23 @@ namespace ts {
                 }
                 name = idText(name);
             }
-            return getSpellingSuggestionForName(name, props, SymbolFlags.Value);
+            const suggestion = getSpellingSuggestionForName(name, props, SymbolFlags.Value);
+            if (suggestion) {
+                return suggestion;
+            }
+            // If we have `#typo in expr` then we can still look up potential privateIdentifiers from the surrounding classes
+            if (typeof originalName !== "string" && isPrivateIdentifierInInExpression(originalName.parent)) {
+                const privateIdentifiers: Symbol[] = [];
+                forEachEnclosingClass(originalName, (klass: ClassLikeDeclaration) => {
+                    forEach(klass.members, member => {
+                        if (isPrivateIdentifierClassElementDeclaration(member)) {
+                            privateIdentifiers.push(member.symbol);
+                        }
+                    });
+                });
+                return getSpellingSuggestionForName(name, privateIdentifiers, SymbolFlags.Value);
+            }
+            return undefined;
         }
 
         function getSuggestedSymbolForNonexistentJSXAttribute(name: Identifier | PrivateIdentifier | string, containingType: Type): Symbol | undefined {
@@ -31056,6 +31102,11 @@ namespace ts {
                   isTypeAssignableToKind(leftType, TypeFlags.Index | TypeFlags.TemplateLiteral | TypeFlags.StringMapping | TypeFlags.TypeParameter))) {
                 error(left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol);
             }
+            checkInExpressionRHS(right, rightType);
+            return booleanType;
+        }
+
+        function checkInExpressionRHS(right: Expression, rightType: Type) {
             const rightTypeConstraint = getConstraintOfType(rightType);
             if (!allTypesAssignableToKind(rightType, TypeFlags.NonPrimitive | TypeFlags.InstantiableNonPrimitive) ||
                 rightTypeConstraint && (
@@ -31065,7 +31116,6 @@ namespace ts {
             ) {
                 error(right, Diagnostics.The_right_hand_side_of_an_in_expression_must_not_be_a_primitive);
             }
-            return booleanType;
         }
 
         function checkObjectLiteralAssignment(node: ObjectLiteralExpression, sourceType: Type, rightIsThis?: boolean): Type {
@@ -31302,6 +31352,40 @@ namespace ts {
             return (target.flags & TypeFlags.Nullable) !== 0 || isTypeComparableTo(source, target);
         }
 
+        function checkPrivateIdentifierInInExpression(node: PrivateIdentifierInInExpression, checkMode?: CheckMode) {
+            const privateId = node.name;
+            const exp = node.expression;
+            let rightType = checkExpression(exp, checkMode);
+
+            const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privateId.escapedText, privateId);
+            if (lexicallyScopedSymbol === undefined) {
+                if (!getContainingClass(node)) {
+                    error(privateId, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+                }
+                else {
+                    const suggestion = getSuggestedSymbolForNonexistentProperty(privateId, rightType);
+                    if (suggestion) {
+                        const suggestedName = symbolName(suggestion);
+                        error(privateId, Diagnostics.Cannot_find_name_0_Did_you_mean_1, diagnosticName(privateId), suggestedName);
+                    }
+                    else {
+                        error(privateId, Diagnostics.Cannot_find_name_0, diagnosticName(privateId));
+                    }
+                }
+                return anyType;
+            }
+
+            markPropertyAsReferenced(lexicallyScopedSymbol, /* nodeForCheckWriteOnly: */ undefined, /* isThisAccess: */ false);
+            getNodeLinks(node).resolvedSymbol = lexicallyScopedSymbol;
+
+            if (rightType === silentNeverType) {
+                return silentNeverType;
+            }
+            rightType = checkNonNullType(rightType, exp);
+            checkInExpressionRHS(exp, rightType);
+            return booleanType;
+        }
+
         function createCheckBinaryExpression() {
             interface WorkArea {
                 readonly checkMode: CheckMode | undefined;
@@ -32483,6 +32567,8 @@ namespace ts {
                     return checkPostfixUnaryExpression(<PostfixUnaryExpression>node);
                 case SyntaxKind.BinaryExpression:
                     return checkBinaryExpression(<BinaryExpression>node, checkMode);
+                case SyntaxKind.PrivateIdentifierInInExpression:
+                    return checkPrivateIdentifierInInExpression(<PrivateIdentifierInInExpression>node, checkMode);
                 case SyntaxKind.ConditionalExpression:
                     return checkConditionalExpression(<ConditionalExpression>node, checkMode);
                 case SyntaxKind.SpreadElement:
@@ -38923,6 +39009,15 @@ namespace ts {
                 return resolveEntityName(<Identifier>name, /*meaning*/ SymbolFlags.FunctionScopedVariable);
             }
 
+            if (isPrivateIdentifier(name) && isPrivateIdentifierInInExpression(name.parent)) {
+                const links = getNodeLinks(name.parent);
+                if (links.resolvedSymbol) {
+                    return links.resolvedSymbol;
+                }
+                checkPrivateIdentifierInInExpression(name.parent);
+                return links.resolvedSymbol;
+            }
+
             // Do we want to return undefined here?
             return undefined;
         }

diff --git a/src/compiler/emitter.ts b/src/compiler/emitter.ts
@@ -1447,6 +1447,8 @@ namespace ts {
                     return emitPostfixUnaryExpression(<PostfixUnaryExpression>node);
                 case SyntaxKind.BinaryExpression:
                     return emitBinaryExpression(<BinaryExpression>node);
+                case SyntaxKind.PrivateIdentifierInInExpression:
+                    return emitPrivateIdentifierInInExpression(<PrivateIdentifierInInExpression>node);
                 case SyntaxKind.ConditionalExpression:
                     return emitConditionalExpression(<ConditionalExpression>node);
                 case SyntaxKind.TemplateExpression:
@@ -2605,6 +2607,24 @@ namespace ts {
             }
         }
 
+        function emitPrivateIdentifierInInExpression(node: PrivateIdentifierInInExpression) {
+            const linesBeforeIn = getLinesBetweenNodes(node, node.name, node.inToken);
+            const linesAfterIn = getLinesBetweenNodes(node, node.inToken, node.expression);
+
+            emitLeadingCommentsOfPosition(node.name.pos);
+            emitPrivateIdentifier(node.name);
+            emitTrailingCommentsOfPosition(node.name.end);
+
+            writeLinesAndIndent(linesBeforeIn, /*writeSpaceIfNotIndenting*/ true);
+            emitLeadingCommentsOfPosition(node.inToken.pos);
+            writeTokenNode(node.inToken, writeKeyword);
+            emitTrailingCommentsOfPosition(node.inToken.end, /*prefixSpace*/ true);
+            writeLinesAndIndent(linesAfterIn, /*writeSpaceIfNotIndenting*/ true);
+
+            emit(node.expression);
+            decreaseIndentIf(linesBeforeIn, linesAfterIn);
+        }
+
         function emitConditionalExpression(node: ConditionalExpression) {
             const linesBeforeQuestion = getLinesBetweenNodes(node, node.condition, node.questionToken);
             const linesAfterQuestion = getLinesBetweenNodes(node, node.questionToken, node.whenTrue);
@@ -6535,6 +6555,13 @@ namespace ts {
                     case SyntaxKind.BinaryExpression:
                         return preprintBinaryExpression(node as BinaryExpression);
 
+                    case SyntaxKind.PrivateIdentifierInInExpression:
+                        Debug.type<PrivateIdentifierInInExpression>(node);
+                        return factory.updatePrivateIdentifierInInExpression(node,
+                            visitMemberName(node.name, isPrivateIdentifier),
+                            visit(node.inToken, isInKeyword),
+                            visitExpression(node.expression));
+
                     case SyntaxKind.ConditionalExpression:
                         Debug.type<ConditionalExpression>(node);
                         return factory.updateConditionalExpression(node,

diff --git a/src/compiler/factory/emitHelpers.ts b/src/compiler/factory/emitHelpers.ts
@@ -34,6 +34,7 @@ namespace ts {
         // Class Fields Helpers
         createClassPrivateFieldGetHelper(receiver: Expression, state: Identifier, kind: PrivateIdentifierKind, f: Identifier | undefined): Expression;
         createClassPrivateFieldSetHelper(receiver: Expression, state: Identifier, value: Expression, kind: PrivateIdentifierKind, f: Identifier | undefined): Expression;
+        createClassPrivateFieldInHelper(receiver: Expression, state: Identifier): Expression;
     }
 
     export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
@@ -72,6 +73,7 @@ namespace ts {
             // Class Fields Helpers
             createClassPrivateFieldGetHelper,
             createClassPrivateFieldSetHelper,
+            createClassPrivateFieldInHelper
         };
 
         /**
@@ -392,6 +394,10 @@ namespace ts {
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, args);
         }
 
+        function createClassPrivateFieldInHelper(receiver: Expression, state: Identifier) {
+            context.requestEmitHelper(classPrivateFieldInHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), /* typeArguments*/ undefined, [receiver, state]);
+        }
     }
 
     /* @internal */
@@ -954,6 +960,17 @@ namespace ts {
             };`
     };
 
+    export const classPrivateFieldInHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateFieldIn",
+        importName: "__classPrivateFieldIn",
+        scoped: false,
+        text: `
+            var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(receiver, state) {
+                if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
+                return typeof state === "function" ? receiver === state : state.has(receiver);
+            };`
+    };
+
     let allUnscopedEmitHelpers: ReadonlyESMap<string, UnscopedEmitHelper> | undefined;
 
     export function getAllUnscopedEmitHelpers() {
@@ -979,6 +996,7 @@ namespace ts {
             exportStarHelper,
             classPrivateFieldGetHelper,
             classPrivateFieldSetHelper,
+            classPrivateFieldInHelper,
             createBindingHelper,
             setModuleDefaultHelper
         ], helper => helper.name));

diff --git a/src/compiler/factory/nodeFactory.ts b/src/compiler/factory/nodeFactory.ts
@@ -437,6 +437,8 @@ namespace ts {
             createMergeDeclarationMarker,
             createSyntheticReferenceExpression,
             updateSyntheticReferenceExpression,
+            createPrivateIdentifierInInExpression,
+            updatePrivateIdentifierInInExpression,
             cloneNode,
 
             // Lazily load factory methods for common operator factories and utilities
@@ -3059,6 +3061,34 @@ namespace ts {
                 : node;
         }
 
+        // @api
+        function createPrivateIdentifierInInExpression(name: PrivateIdentifier, inToken: Token<SyntaxKind.InKeyword>, expression: Expression) {
+            const node = createBaseExpression<PrivateIdentifierInInExpression>(SyntaxKind.PrivateIdentifierInInExpression);
+            node.name = name;
+            node.inToken = inToken;
+            node.expression = expression;
+            node.transformFlags |=
+                propagateChildFlags(node.name) |
+                propagateChildFlags(node.inToken) |
+                propagateChildFlags(node.expression) |
+                TransformFlags.ContainsESNext;
+            return node;
+        }
+
+        // @api
+        function updatePrivateIdentifierInInExpression(
+            node: PrivateIdentifierInInExpression,
+            name: PrivateIdentifier,
+            inToken: Token<SyntaxKind.InKeyword>,
+            expression: Expression
+        ): PrivateIdentifierInInExpression {
+            return node.name !== name
+                || node.inToken !== inToken
+                || node.expression !== expression
+                ? update(createPrivateIdentifierInInExpression(name, inToken, expression), node)
+                : node;
+        }
+
         //
         // Misc
         //

diff --git a/src/compiler/factory/nodeTests.ts b/src/compiler/factory/nodeTests.ts
@@ -87,6 +87,11 @@ namespace ts {
         return node.kind === SyntaxKind.EqualsGreaterThanToken;
     }
 
+    /*@internal*/
+    export function isInKeyword(node: Node): node is InKeyword {
+        return node.kind === SyntaxKind.InKeyword;
+    }
+
     // Identifiers
 
     export function isIdentifier(node: Node): node is Identifier {
@@ -444,6 +449,10 @@ namespace ts {
         return node.kind === SyntaxKind.CommaListExpression;
     }
 
+    export function isPrivateIdentifierInInExpression(node: Node): node is PrivateIdentifierInInExpression {
+        return node.kind === SyntaxKind.PrivateIdentifierInInExpression;
+    }
+
     // Misc
 
     export function isTemplateSpan(node: Node): node is TemplateSpan {