basic type check and narrow

Signed-off-by: Ashley Claymore <[email protected]>

Author: acutmore

src/compiler/binder.ts

@@ -880,6 +880,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;
         }

src/compiler/checker.ts

@@ -22750,6 +22750,22 @@ 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 klass = lookupClassForPrivateIdentifierDeclaration(privateId);
+                if (klass === undefined) {
+                    return type;
+                }
+
+                const classTypeForPrivateField = getTypeOfSymbolAtLocation(getSymbolOfNode(klass), klass);
+                return getNarrowedType(type, classTypeForPrivateField, 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.
@@ -23164,6 +23180,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);
@@ -26265,6 +26283,17 @@ namespace ts {
             }
         }
 
+        function lookupClassForPrivateIdentifierDeclaration(id: PrivateIdentifier): ClassLikeDeclaration | undefined {
+            for (let containingClass = getContainingClass(id); !!containingClass; containingClass = getContainingClass(containingClass)) {
+                const { symbol } = containingClass;
+                const name = getSymbolNameForPrivateIdentifier(symbol, id.escapedText);
+                const prop = (symbol.members && symbol.members.get(name)) || (symbol.exports && symbol.exports.get(name));
+                if (prop) {
+                    return containingClass;
+                }
+            }
+        }
+
         function getPrivateIdentifierPropertyOfType(leftType: Type, lexicallyScopedIdentifier: Symbol): Symbol | undefined {
             return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName);
         }
@@ -30445,6 +30474,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 && (
@@ -30454,7 +30488,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 {
@@ -30691,6 +30724,26 @@ namespace ts {
             return (target.flags & TypeFlags.Nullable) !== 0 || isTypeComparableTo(source, target);
         }
 
+        function checkPrivateIdentifierInInExpression(node: PrivateIdentifierInInExpression, checkMode?: CheckMode) {
+            const privateId = node.name;
+            const lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privateId.escapedText, privateId);
+            if (lexicallyScopedSymbol === undefined) {
+                // TODO(aclaymore): use better error message - we might be in a class but with no matching privateField
+                error(privateId, Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies);
+                return anyType;
+            }
+
+            const exp = node.expression;
+            let rightType = checkExpression(exp, checkMode);
+            if (rightType === silentNeverType) {
+                return silentNeverType;
+            }
+            rightType = checkNonNullType(rightType, exp);
+            // TODO(aclaymore): Do RHS rules matching 'in' rules? (e.g. throw on null)
+            checkInExpressionRHS(exp, rightType);
+            return booleanType;
+        }
+
         const enum CheckBinaryExpressionState {
             MaybeCheckLeft,
             CheckRight,
@@ -31817,6 +31870,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:

src/compiler/parser.ts

@@ -442,6 +442,9 @@ namespace ts {
                 return visitNodes(cbNode, cbNodes, node.decorators);
             case SyntaxKind.CommaListExpression:
                 return visitNodes(cbNode, cbNodes, (<CommaListExpression>node).elements);
+            case SyntaxKind.PrivateIdentifierInInExpression:
+                return visitNode(cbNode, (<PrivateIdentifierInInExpression>node).name) ||
+                    visitNode(cbNode, (<PrivateIdentifierInInExpression>node).expression);
 
             case SyntaxKind.JsxElement:
                 return visitNode(cbNode, (<JsxElement>node).openingElement) ||
@@ -4393,8 +4396,7 @@ namespace ts {
                 return createMissingNode(SyntaxKind.InKeyword, /*reportAtCurrentPosition*/ true, Diagnostics._0_expected, tokenToString(SyntaxKind.InKeyword));
             }
             nextToken();
-            // TODO(aclaymore): LHS can be a binary expression of higher precedence
-            // const exp = parseUnaryExpressionOrHigher();
+            // TODO(aclaymore) verify precedence is correct
             const exp = parseBinaryExpressionOrHigher(OperatorPrecedence.Relational);
             return finishNode(factory.createPrivateIdentifierInInExpression(id, exp), pos);
         }

tests/baselines/reference/privateNameInInExpression.errors.txt

@@ -1,68 +1,97 @@
-tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(18,13): error TS1005: 'in' expected.
-tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(21,14): error TS2304: Cannot find name '#p1'.
-tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(21,14): error TS18016: Private identifiers are not allowed outside class bodies.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(14,26): error TS2571: Object is of type 'unknown'.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(16,19): error TS18016: Private identifiers are not allowed outside class bodies.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(18,23): error TS1005: 'in' expected.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(20,14): error TS2304: Cannot find name '#p1'.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(20,14): error TS18016: Private identifiers are not allowed outside class bodies.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(22,23): error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(34,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(34,21): error TS2361: The right-hand side of an 'in' expression must not be a primitive.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(36,14): error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
+tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts(62,12): error TS18016: Private identifiers are not allowed outside class bodies.
 
 
-==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts (3 errors) ====
+==== tests/cases/conformance/classes/members/privateNames/privateNameInInExpression.ts (10 errors) ====
     // TODO(aclaymore) split up into seperate cases
 
     class Foo {
         #p1 = 1;
-        m1(v: {}) {
-            #p1 in v; // Good
-        }
-        m2(v: any) {
-            #p1 in v.p1.p2; // Good
-        }
-        m3(v: unknown) {
-            #p1 in v; // Bad - RHS of in must be object type or any
-        }
-        m4(v: any) {
-            #p2 in v; // Bad - Invalid private id
-        }
-        m5(v: any) {
-            (#p1) in v; // Bad - private id is not an expression on it's own
-                
+        basics(v: any) {
+            const a = #p1 in v; // Good - a is boolean
+    
+            const b = #p1 in v.p1.p2; // Good - b is boolean
+    
+            const c = #p1 in (v as {}); // Good - c is boolean
+    
+            const d = #p1 in (v as Foo); // Good d is boolean (not true)
+    
+            const e = #p1 in (v as unknown); // Bad - RHS of in must be object type or any
+                             ~~~~~~~~~~~~~~
+!!! error TS2571: Object is of type 'unknown'.
+    
+            const f = #p2 in v; // Bad - Invalid privateID
+                      ~~~
+!!! error TS18016: Private identifiers are not allowed outside class bodies.
+    
+            const g = (#p1) in v; // Bad - private id is not an expression on it's own
+                          
 !!! error TS1005: 'in' expected.
-        }
-        m6(v: any) {
+    
             for (#p1 in v) { /* no-op */ } // Bad - 'in' not allowed
                  ~~~
 !!! error TS2304: Cannot find name '#p1'.
                  ~~~
 !!! error TS18016: Private identifiers are not allowed outside class bodies.
-        }
-        m7(v: any) {
-            for (let x in #p1 in v as any) { /* no-op */ } // Good - weird but valid
-        }
-        m8(v: any) {
+    
             for (let x in #p1 in v) { /* no-op */ } // Bad - rhs of in should be a object/any
+                          ~~~~~~~~
+!!! error TS2407: The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type 'boolean'.
+    
+            for (let x in #p1 in v as any) { /* no-op */ } // Good - weird but valid
+    
         }
-        m9(v: any) {
+        precedence(v: any) {
             // '==' has lower precedence than 'in'
             // '<'  has same prededence than 'in'
             // '<<' has higher prededence than 'in'
 
             v == #p1 in v == v; // Good precidence: ((v == (#p1 in v)) == v)
 
             v << #p1 in v << v; // Good precidence: (v << (#p1 in (v << v)))
+                 ~~~~~~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
+                        ~~~~~~
+!!! error TS2361: The right-hand side of an 'in' expression must not be a primitive.
 
             v << #p1 in v == v; // Good precidence: ((v << (#p1 in v)) == v)
+                 ~~~~~~~~
+!!! error TS2363: The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
 
             v == #p1 in v < v; // Good precidence: (v == ((#p1 in v) < v))
 
             #p1 in v && #p1 in v; // Good precidence: ((#p1 in v) && (#p1 in v))
         }
-        m10() {
-            class Bar {
-                m10(v: any) {
-                    #p1 in v; // Good: access parent class
+        flow(v: unknown) {
+            if (typeof v === 'object' && v !== null) {
+                if (#p1 in v) {
+                    const y1 = v; // good y1 is typeof Foo
+                } else {
+                    const y2 = v; // y2 is not typeof Foo
+                }
+            }
+    
+            class Nested {
+                m(v: any) {
+                    if (#p1 in v) {
+                       const y1 = v; // Good y1 if typeof Foo
+                    }
                 }
             }
         }
     }
 
     function error(v: Foo) {
-        return #p1 in v; // Bad: outside of class
+        return #p1 in v; // Bad - outside of class
+               ~~~
+!!! error TS18016: Private identifiers are not allowed outside class bodies.
     }