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 = getNodeLinks(privateId.parent).resolvedSymbol;
+                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.
@@ -27715,6 +27737,27 @@ namespace ts {
             }
         }
 
+        function checkPrivateIdentifierExpression(privId: PrivateIdentifier): Type {
+            // The only valid position for a PrivateIdentifier to appear as an expression is on the left side of
+            // the `#field in expr` BinaryExpression
+            const isPrivateFieldInInExpression = isBinaryExpression(privId.parent)
+                && privId.parent.left === privId
+                && privId.parent.operatorToken.kind === SyntaxKind.InKeyword;
+            let symbolResolved = false;
+            if (isPrivateFieldInInExpression) {
+                const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privId.escapedText, privId);
+                if (lexicallyScopedSymbol) {
+                    symbolResolved = true;
+                    markPropertyAsReferenced(lexicallyScopedSymbol, /* nodeForCheckWriteOnly: */ undefined, /* isThisAccess: */ false);
+                    getNodeLinks(privId.parent).resolvedSymbol = lexicallyScopedSymbol;
+                }
+            }
+            if (!symbolResolved) {
+                error(privId, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+            }
+            return anyType;
+        }
+
         function getPrivateIdentifierPropertyOfType(leftType: Type, lexicallyScopedIdentifier: Symbol): Symbol | undefined {
             return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
         }
@@ -32023,14 +32066,34 @@ namespace ts {
         }
 
         function checkInExpression(left: Expression, right: Expression, leftType: Type, rightType: Type): Type {
+            const privIdOnLeft = isPrivateIdentifier(left);
+            if (privIdOnLeft) {
+                if (languageVersion < ScriptTarget.ESNext) {
+                    checkExternalEmitHelpers(left, ExternalEmitHelpers.ClassPrivateFieldIn);
+                }
+                // Unlike in 'checkPrivateIdentifierExpression' we now have access to the RHS type
+                // which provides us with the oppotunity to emit more detailed errors
+                const symbol = getNodeLinks(left.parent).resolvedSymbol;
+                if (!symbol) {
+                    const isUncheckedJS = isUncheckedJSSuggestion(left, rightType.symbol, /*excludeClasses*/ true);
+                    reportNonexistentProperty(left, rightType, isUncheckedJS);
+                }
+            }
             if (leftType === silentNeverType || rightType === silentNeverType) {
                 return silentNeverType;
             }
-            leftType = checkNonNullType(leftType, left);
+            if (!privIdOnLeft) {
+                leftType = checkNonNullType(leftType, left);
+                // TypeScript 1.0 spec (April 2014): 4.15.5
+                // Require the left operand to be of type Any, the String primitive type, or the Number 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);
+                }
+            }
             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 +32111,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 && (
@@ -33433,6 +33492,8 @@ namespace ts {
             switch (kind) {
                 case SyntaxKind.Identifier:
                     return checkIdentifier(node as Identifier, checkMode);
+                case SyntaxKind.PrivateIdentifier:
+                    return checkPrivateIdentifierExpression(node as PrivateIdentifier);
                 case SyntaxKind.ThisKeyword:
                     return checkThisExpression(node);
                 case SyntaxKind.SuperKeyword:
@@ -40219,6 +40280,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;
+                }
+                checkPrivateIdentifierExpression(name);
+                return links.resolvedSymbol;
+            }
+
             return undefined;
         }
 
@@ -41605,6 +41675,7 @@ namespace ts {
                 case ExternalEmitHelpers.MakeTemplateObject: return "__makeTemplateObject";
                 case ExternalEmitHelpers.ClassPrivateFieldGet: return "__classPrivateFieldGet";
                 case ExternalEmitHelpers.ClassPrivateFieldSet: return "__classPrivateFieldSet";
+                case ExternalEmitHelpers.ClassPrivateFieldIn: return "__classPrivateFieldIn";
                 case ExternalEmitHelpers.CreateBinding: return "__createBinding";
                 default: return Debug.fail("Unrecognized helper");
             }

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(<weakMap/weakSet/constructor>, expression)`
+     */
+    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

@@ -4737,6 +4737,14 @@ namespace ts {
          *
          */
         function parseUnaryExpressionOrHigher(): UnaryExpression | BinaryExpression {
+            /**
+             * If we have a PrivateIdentifier, parse this unconditionally.
+             * A privateIdentifier is only valid on its own in the RelationalExpression: `#field in expr`.
+             * The checker will emit an error if this is not the case.
+             */
+            if (token() === SyntaxKind.PrivateIdentifier) {
+                return parsePrivateIdentifier();
+            }
             /**
              * ES7 UpdateExpression:
              *      1) LeftHandSideExpression[?Yield]

src/compiler/transformers/classFields.ts

@@ -266,15 +266,44 @@ namespace ts {
 
         /**
          * If we visit a private name, this means it is an undeclared private name.
-         * Replace it with an empty identifier to indicate a problem with the code.
+         * Replace it with an empty identifier to indicate a problem with the code,
+         * unless we are in a statement position - otherwise this will not trigger
+         * a SyntaxError.
          */
         function visitPrivateIdentifier(node: PrivateIdentifier) {
             if (!shouldTransformPrivateElementsOrClassStaticBlocks) {
                 return node;
             }
+            if (isStatement(node.parent)) {
+                return node;
+            }
             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);
+            Debug.assert(node.operatorToken.kind === SyntaxKind.InKeyword);
+            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 +856,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
@@ -6830,7 +6831,8 @@ namespace ts {
         MakeTemplateObject = 1 << 18,   // __makeTemplateObject (used for constructing template string array objects)
         ClassPrivateFieldGet = 1 << 19, // __classPrivateFieldGet (used by the class private field transformation)
         ClassPrivateFieldSet = 1 << 20, // __classPrivateFieldSet (used by the class private field transformation)
-        CreateBinding = 1 << 21,        // __createBinding (use by the module transform for (re)exports and namespace imports)
+        ClassPrivateFieldIn = 1 << 21,  // __classPrivateFieldIn (used by the class private field transformation)
+        CreateBinding = 1 << 22,        // __createBinding (use by the module transform for (re)exports and namespace imports)
         FirstEmitHelper = Extends,
         LastEmitHelper = CreateBinding,
 

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/fixForgottenThisPropertyAccess.ts

@@ -32,7 +32,7 @@ namespace ts.codefix {
 
     function getInfo(sourceFile: SourceFile, pos: number, diagCode: number): Info | undefined {
         const node = getTokenAtPosition(sourceFile, pos);
-        if (isIdentifier(node)) {
+        if (isIdentifier(node) || isPrivateIdentifier(node)) {
             return { node, className: diagCode === didYouMeanStaticMemberCode ? getContainingClass(node)!.name!.text : undefined };
         }
     }

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;
     }