feat(42639): allow narrowing type in 'in' operator with the identifier on the left side

Author: a-tarasyuk

src/compiler/binder.ts

@@ -917,7 +917,7 @@ namespace ts {
         }
 
         function isNarrowableInOperands(left: Expression, right: Expression) {
-            return isStringLiteralLike(left) && isNarrowingExpression(right);
+            return isNarrowingExpression(right) || (isIdentifier(left) || isStringLiteralLike(left));
         }
 
         function isNarrowingBinaryExpression(expr: BinaryExpression) {

src/compiler/checker.ts

@@ -23562,13 +23562,24 @@ namespace ts {
                 return getApplicableIndexInfoForName(type, propName) ? true : !assumeTrue;
             }
 
-            function narrowByInKeyword(type: Type, literal: LiteralExpression, assumeTrue: boolean) {
+
+            function tryGetNarrowableInOperandName(node: Node): __String | undefined {
+                if (isStringLiteralLike(node)) {
+                    return escapeLeadingUnderscores(node.text);
+                }
+                const decl = getNodeLinks(node).resolvedSymbol?.valueDeclaration;
+                if (decl && hasInitializer(decl) && decl.initializer) {
+                    return tryGetNarrowableInOperandName(decl.initializer);
+                }
+                return undefined;
+            }
+
+            function narrowByInKeyword(type: Type, name: __String, assumeTrue: boolean) {
                 if (type.flags & TypeFlags.Union
                     || type.flags & TypeFlags.Object && declaredType !== type
                     || isThisTypeParameter(type)
                     || type.flags & TypeFlags.Intersection && every((type as IntersectionType).types, t => t.symbol !== globalThisSymbol)) {
-                    const propName = escapeLeadingUnderscores(literal.text);
-                    return filterType(type, t => isTypePresencePossible(t, propName, assumeTrue));
+                    return filterType(type, t => isTypePresencePossible(t, name, assumeTrue));
                 }
                 return type;
             }
@@ -23626,13 +23637,14 @@ namespace ts {
                         return narrowTypeByInstanceof(type, expr, assumeTrue);
                     case SyntaxKind.InKeyword:
                         const target = getReferenceCandidate(expr.right);
-                        if (isStringLiteralLike(expr.left)) {
+                        const name = tryGetNarrowableInOperandName(expr.left);
+                        if (name) {
                             if (containsMissingType(type) && isAccessExpression(reference) && isMatchingReference(reference.expression, target) &&
-                                getAccessedPropertyName(reference) === escapeLeadingUnderscores(expr.left.text)) {
+                                getAccessedPropertyName(reference) === name) {
                                 return getTypeWithFacts(type, assumeTrue ? TypeFacts.NEUndefined : TypeFacts.EQUndefined);
                             }
                             if (isMatchingReference(reference, target)) {
-                                return narrowByInKeyword(type, expr.left, assumeTrue);
+                                return narrowByInKeyword(type, name, assumeTrue);
                             }
                         }
                         break;

tests/baselines/reference/controlFlowInOperator.js

@@ -0,0 +1,31 @@
+//// [controlFlowInOperator.ts]
+const a = 'a';
+const b = 'b';
+
+type A = { [a]: number; };
+type B = { [b]: string; };
+
+declare const c: A | B;
+
+if ('a' in c) {
+    c;      // A
+    c['a']; // number;
+}
+
+if (a in c) {
+    c;    // A
+    c[a]; // number;
+}
+
+
+//// [controlFlowInOperator.js]
+var a = 'a';
+var b = 'b';
+if ('a' in c) {
+    c; // A
+    c['a']; // number;
+}
+if (a in c) {
+    c; // A
+    c[a]; // number;
+}

tests/baselines/reference/controlFlowInOperator.symbols

@@ -0,0 +1,45 @@
+=== tests/cases/conformance/controlFlow/controlFlowInOperator.ts ===
+const a = 'a';
+>a : Symbol(a, Decl(controlFlowInOperator.ts, 0, 5))
+
+const b = 'b';
+>b : Symbol(b, Decl(controlFlowInOperator.ts, 1, 5))
+
+type A = { [a]: number; };
+>A : Symbol(A, Decl(controlFlowInOperator.ts, 1, 14))
+>[a] : Symbol([a], Decl(controlFlowInOperator.ts, 3, 10))
+>a : Symbol(a, Decl(controlFlowInOperator.ts, 0, 5))
+
+type B = { [b]: string; };
+>B : Symbol(B, Decl(controlFlowInOperator.ts, 3, 26))
+>[b] : Symbol([b], Decl(controlFlowInOperator.ts, 4, 10))
+>b : Symbol(b, Decl(controlFlowInOperator.ts, 1, 5))
+
+declare const c: A | B;
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+>A : Symbol(A, Decl(controlFlowInOperator.ts, 1, 14))
+>B : Symbol(B, Decl(controlFlowInOperator.ts, 3, 26))
+
+if ('a' in c) {
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+
+    c;      // A
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+
+    c['a']; // number;
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+>'a' : Symbol([a], Decl(controlFlowInOperator.ts, 3, 10))
+}
+
+if (a in c) {
+>a : Symbol(a, Decl(controlFlowInOperator.ts, 0, 5))
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+
+    c;    // A
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+
+    c[a]; // number;
+>c : Symbol(c, Decl(controlFlowInOperator.ts, 6, 13))
+>a : Symbol(a, Decl(controlFlowInOperator.ts, 0, 5))
+}
+

tests/baselines/reference/controlFlowInOperator.types

@@ -0,0 +1,50 @@
+=== tests/cases/conformance/controlFlow/controlFlowInOperator.ts ===
+const a = 'a';
+>a : "a"
+>'a' : "a"
+
+const b = 'b';
+>b : "b"
+>'b' : "b"
+
+type A = { [a]: number; };
+>A : A
+>[a] : number
+>a : "a"
+
+type B = { [b]: string; };
+>B : B
+>[b] : string
+>b : "b"
+
+declare const c: A | B;
+>c : A | B
+
+if ('a' in c) {
+>'a' in c : boolean
+>'a' : "a"
+>c : A | B
+
+    c;      // A
+>c : A
+
+    c['a']; // number;
+>c['a'] : number
+>c : A
+>'a' : "a"
+}
+
+if (a in c) {
+>a in c : boolean
+>a : "a"
+>c : A | B
+
+    c;    // A
+>c : A
+
+    c[a]; // number;
+>c[a] : number
+>c : A
+>a : "a"
+}
+

tests/cases/conformance/controlFlow/controlFlowInOperator.ts

@@ -0,0 +1,17 @@
+const a = 'a';
+const b = 'b';
+
+type A = { [a]: number; };
+type B = { [b]: string; };
+
+declare const c: A | B;
+
+if ('a' in c) {
+    c;      // A
+    c['a']; // number;
+}
+
+if (a in c) {
+    c;    // A
+    c[a]; // number;
+}