ES private field check

src/compiler/checker.ts

@@ -23846,6 +23846,9 @@ namespace ts {
                     case SyntaxKind.InstanceOfKeyword:
                         return narrowTypeByInstanceof(type, expr, assumeTrue);
                     case SyntaxKind.InKeyword:
+                        if (isPrivateIdentifier(expr.left)) {
+                            return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue);
+                        }
                         const target = getReferenceCandidate(expr.right);
                         const leftType = getTypeOfNode(expr.left);
                         if (leftType.flags & TypeFlags.StringLiteral) {
@@ -23876,6 +23879,25 @@ namespace ts {
                 return type;
             }
 
+            function narrowTypeByPrivateIdentifierInInExpression(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                const target = getReferenceCandidate(expr.right);
+                if (!isMatchingReference(reference, target)) {
+                    return type;
+                }
+
+                const privateId = expr.left;
+                Debug.assertNode(privateId, isPrivateIdentifier);
+                const symbol = lookupSymbolForPrivateIdentifierDeclaration(privateId.escapedText, privateId);
+                if (symbol === undefined) {
+                    return type;
+                }
+                const classSymbol = symbol.parent!;
+                const targetType = hasStaticModifier(Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration"))
+                    ? getTypeOfSymbol(classSymbol) as InterfaceType
+                    : getDeclaredTypeOfSymbol(classSymbol);
+                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.
@@ -32023,14 +32045,46 @@ namespace ts {
         }
 
         function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
-            if (leftType === silentNeverType || rightType === silentNeverType) {
-                return silentNeverType;
+            if (isPrivateIdentifier(left)) {
+                const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(left.escapedText, left);
+                if (lexicallyScopedSymbol === undefined) {
+                    if (!getContainingClass(left)) {
+                        error(left, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+                    }
+                    else {
+                        const suggestion = getSuggestedSymbolForNonexistentProperty(left, rightType);
+                        if (suggestion) {
+                            const suggestedName = symbolName(suggestion);
+                            error(left, Diagnostics.Cannot_find_name_0_Did_you_mean_1, diagnosticName(left), suggestedName);
+                        }
+                        else {
+                            error(left, Diagnostics.Cannot_find_name_0, diagnosticName(left));
+                        }
+                    }
+                    return anyType;
+                }
+
+                markPropertyAsReferenced(lexicallyScopedSymbol, /* nodeForCheckWriteOnly: */ undefined, /* isThisAccess: */ false);
+                getNodeLinks(left.parent).resolvedSymbol = lexicallyScopedSymbol;
+                if (rightType === silentNeverType) {
+                    return silentNeverType;
+                }
+            }
+            else {
+                if (leftType === silentNeverType || rightType === silentNeverType) {
+                    return silentNeverType;
+                }
+                leftType = checkNonNullType(leftType, left);
+                // TypeScript 1.0 spec (April 2014): 4.15.5
+                // Require the left operand to be of type Any, the String primite type, or the Number primite type.
+                if (!(allTypesAssignableToKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbolLike) ||
+                    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);
+                }
             }
-            leftType = checkNonNullType(leftType, left);
             rightType = checkNonNullType(rightType, right);
             // TypeScript 1.0 spec (April 2014): 4.15.5
-            // The in operator requires the left operand to be of type Any, the String primitive type, or the Number primitive type,
-            // and the right operand to be
+            // The in operator requires the right operand to be
             //
             //   1. assignable to the non-primitive type,
             //   2. an unconstrained type parameter,
@@ -32048,10 +32102,6 @@ namespace ts {
             // unless *all* instantiations would result in an error.
             //
             // The result is always of the Boolean primitive type.
-            if (!(allTypesAssignableToKind(leftType, TypeFlags.StringLike | TypeFlags.NumberLike | TypeFlags.ESSymbolLike) ||
-                  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);
-            }
             const rightTypeConstraint = getConstraintOfType(rightType);
             if (!allTypesAssignableToKind(rightType, TypeFlags.NonPrimitive | TypeFlags.InstantiableNonPrimitive) ||
                 rightTypeConstraint && (
@@ -40219,6 +40269,15 @@ namespace ts {
                 return resolveEntityName(name as Identifier, /*meaning*/ SymbolFlags.FunctionScopedVariable);
             }
 
+            if (isPrivateIdentifier(name) && isBinaryExpression(name.parent)) {
+                const links = getNodeLinks(name.parent);
+                if (links.resolvedSymbol) {
+                    return links.resolvedSymbol;
+                }
+                checkBinaryExpression(name.parent, CheckMode.Normal);
+                return links.resolvedSymbol;
+            }
+
             return undefined;
         }
 

src/compiler/emitter.ts

@@ -1680,6 +1680,8 @@ namespace ts {
                     // Identifiers
                     case SyntaxKind.Identifier:
                         return emitIdentifier(node as Identifier);
+                    case SyntaxKind.PrivateIdentifier:
+                        return emitPrivateIdentifier(node as PrivateIdentifier);
 
                     // Expressions
                     case SyntaxKind.ArrayLiteralExpression:

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(state: Identifier, receiver: Expression): Expression;
     }
 
     export function createEmitHelperFactory(context: TransformationContext): EmitHelperFactory {
@@ -75,6 +76,7 @@ namespace ts {
             // Class Fields Helpers
             createClassPrivateFieldGetHelper,
             createClassPrivateFieldSetHelper,
+            createClassPrivateFieldInHelper
         };
 
         /**
@@ -395,6 +397,10 @@ namespace ts {
             return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, args);
         }
 
+        function createClassPrivateFieldInHelper(state: Identifier, receiver: Expression) {
+            context.requestEmitHelper(classPrivateFieldInHelper);
+            return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), /* typeArguments*/ undefined, [state, receiver]);
+        }
     }
 
     /* @internal */
@@ -961,6 +967,29 @@ namespace ts {
             };`
     };
 
+    /**
+     * Parameters:
+     *  @param state — One of the following:
+     *      - A WeakMap when the member is a private instance field.
+     *      - A WeakSet when the member is a private instance method or accessor.
+     *      - A function value that should be the undecorated class constructor when the member is a private static field, method, or accessor.
+     *  @param receiver — The object being checked if it has the private member.
+     *
+     * Usage:
+     * This helper is used to transform `#field in expression` to
+     *      `__classPrivateFieldIn(expression, <weakMap/weakSet/constructor>)`
+     */
+    export const classPrivateFieldInHelper: UnscopedEmitHelper = {
+        name: "typescript:classPrivateFieldIn",
+        importName: "__classPrivateFieldIn",
+        scoped: false,
+        text: `
+            var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {
+                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() {
@@ -986,6 +1015,7 @@ namespace ts {
             exportStarHelper,
             classPrivateFieldGetHelper,
             classPrivateFieldSetHelper,
+            classPrivateFieldInHelper,
             createBindingHelper,
             setModuleDefaultHelper
         ], helper => helper.name));

src/compiler/factory/parenthesizerRules.ts

@@ -452,4 +452,4 @@ namespace ts {
         parenthesizeConstituentTypesOfUnionOrIntersectionType: nodes => cast(nodes, isNodeArray),
         parenthesizeTypeArguments: nodes => nodes && cast(nodes, isNodeArray),
     };
-}
+}

src/compiler/parser.ts

@@ -4602,8 +4602,15 @@ namespace ts {
         }
 
         function parseBinaryExpressionOrHigher(precedence: OperatorPrecedence): Expression {
+            // parse a BinaryExpression the LHS is either:
+            // 1) a PrivateIdentifier when 'in' flag allowed and lookahead matches 'PrivateIdentifier in'
+            // 2) a UnaryExpression
+
             const pos = getNodePos();
-            const leftOperand = parseUnaryExpressionOrHigher();
+            const lookaheadMatchesPrivateIdentifierIn = token() === SyntaxKind.PrivateIdentifier && !inDisallowInContext() && lookAhead(nextTokenIsInKeyword);
+            const leftOperand = lookaheadMatchesPrivateIdentifierIn
+                ? parsePrivateIdentifier()
+                : parseUnaryExpressionOrHigher();
             return parseBinaryExpressionRest(precedence, leftOperand, pos);
         }
 
@@ -4640,9 +4647,11 @@ namespace ts {
                 //            ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand
                 //      a ** b - c
                 //             ^token; leftOperand = b. Return b to the caller as a rightOperand
-                const consumeCurrentOperator = token() === SyntaxKind.AsteriskAsteriskToken ?
-                    newPrecedence >= precedence :
-                    newPrecedence > precedence;
+                const isPrivateIdentifierInInExpression = token() === SyntaxKind.InKeyword && isPrivateIdentifier(leftOperand);
+                const consumeCurrentOperator = isPrivateIdentifierInInExpression ||
+                    (token() === SyntaxKind.AsteriskAsteriskToken ?
+                        newPrecedence >= precedence :
+                        newPrecedence > precedence);
 
                 if (!consumeCurrentOperator) {
                     break;
@@ -6131,6 +6140,11 @@ namespace ts {
             return (tokenIsIdentifierOrKeyword(token()) || token() === SyntaxKind.NumericLiteral || token() === SyntaxKind.BigIntLiteral || token() === SyntaxKind.StringLiteral) && !scanner.hasPrecedingLineBreak();
         }
 
+        function nextTokenIsInKeyword() {
+            nextToken();
+            return token() === SyntaxKind.InKeyword;
+        }
+
         function isDeclaration(): boolean {
             while (true) {
                 switch (token()) {

src/compiler/transformers/classFields.ts

@@ -275,6 +275,29 @@ namespace ts {
             return setOriginalNode(factory.createIdentifier(""), node);
         }
 
+        /**
+         * Visits `#id in expr`
+         */
+        function visitPrivateIdentifierInInExpression(node: BinaryExpression) {
+            if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
+                return node;
+            }
+            const privId = node.left;
+            Debug.assertNode(privId, isPrivateIdentifier);
+            const info = accessPrivateIdentifier(privId);
+            if (info) {
+                const receiver = visitNode(node.right, visitor, isExpression);
+
+                return setOriginalNode(
+                    context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver),
+                    node
+                );
+            }
+
+            // Private name has not been declared. Subsequent transformers will handle this error
+            return visitEachChild(node, visitor, context);
+        }
+
         /**
          * Visits the members of a class that has fields.
          *
@@ -827,6 +850,9 @@ namespace ts {
                     }
                 }
             }
+            if (node.operatorToken.kind === SyntaxKind.InKeyword && isPrivateIdentifier(node.left)) {
+                return visitPrivateIdentifierInInExpression(node);
+            }
             return visitEachChild(node, visitor, context);
         }
 

src/compiler/types.ts

@@ -1209,7 +1209,8 @@ namespace ts {
         readonly expression: Expression;
     }
 
-    export interface PrivateIdentifier extends Node {
+    // Typed as a PrimaryExpression due to its presence in BinaryExpressions (#field in expr)
+    export interface PrivateIdentifier extends PrimaryExpression {
         readonly kind: SyntaxKind.PrivateIdentifier;
         // escaping not strictly necessary
         // avoids gotchas in transforms and utils

src/compiler/utilities.ts

@@ -3706,6 +3706,7 @@ namespace ts {
             case SyntaxKind.ThisKeyword:
             case SyntaxKind.SuperKeyword:
             case SyntaxKind.Identifier:
+            case SyntaxKind.PrivateIdentifier:
             case SyntaxKind.NullKeyword:
             case SyntaxKind.TrueKeyword:
             case SyntaxKind.FalseKeyword:

src/services/codefixes/fixSpelling.ts

@@ -57,6 +57,10 @@ namespace ts.codefix {
             }
             suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, containingType);
         }
+        else if (isBinaryExpression(parent) && parent.operatorToken.kind === SyntaxKind.InKeyword && parent.left === node && isPrivateIdentifier(node)) {
+            const receiverType = checker.getTypeAtLocation(parent.right);
+            suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, receiverType);
+        }
         else if (isQualifiedName(parent) && parent.right === node) {
             const symbol = checker.getSymbolAtLocation(parent.left);
             if (symbol && symbol.flags & SymbolFlags.Module) {

src/services/services.ts

@@ -401,6 +401,12 @@ namespace ts {
         public kind!: SyntaxKind.PrivateIdentifier;
         public escapedText!: __String;
         public symbol!: Symbol;
+        _primaryExpressionBrand: any;
+        _memberExpressionBrand: any;
+        _leftHandSideExpressionBrand: any;
+        _updateExpressionBrand: any;
+        _unaryExpressionBrand: any;
+        _expressionBrand: any;
         constructor(_kind: SyntaxKind.PrivateIdentifier, pos: number, end: number) {
             super(pos, end);
         }

tests/baselines/reference/api/tsserverlibrary.d.ts

@@ -666,7 +666,7 @@ declare namespace ts {
         readonly parent: Declaration;
         readonly expression: Expression;
     }
-    export interface PrivateIdentifier extends Node {
+    export interface PrivateIdentifier extends PrimaryExpression {
         readonly kind: SyntaxKind.PrivateIdentifier;
         readonly escapedText: __String;
     }

tests/baselines/reference/api/typescript.d.ts

@@ -666,7 +666,7 @@ declare namespace ts {
         readonly parent: Declaration;
         readonly expression: Expression;
     }
-    export interface PrivateIdentifier extends Node {
+    export interface PrivateIdentifier extends PrimaryExpression {
         readonly kind: SyntaxKind.PrivateIdentifier;
         readonly escapedText: __String;
     }