Reconsile with CFA work

Author: weswigham

src/compiler/binder.ts

@@ -623,13 +623,13 @@ namespace ts {
                 case SyntaxKind.ExclamationEqualsToken:
                 case SyntaxKind.EqualsEqualsEqualsToken:
                 case SyntaxKind.ExclamationEqualsEqualsToken:
-                    if (isNarrowingExpression(expr.left) && (expr.right.kind === SyntaxKind.NullKeyword || expr.right.kind === SyntaxKind.Identifier)) {
+                    if (isNarrowingExpression(expr.left)) {
                         return true;
                     }
                     if (expr.left.kind === SyntaxKind.TypeOfExpression && isNarrowingExpression((<TypeOfExpression>expr.left).expression) && expr.right.kind === SyntaxKind.StringLiteral) {
                         return true;
                     }
-                    return false;
+                    return true;
                 case SyntaxKind.InstanceOfKeyword:
                     return isNarrowingExpression(expr.left);
                 case SyntaxKind.CommaToken:

src/compiler/checker.ts

@@ -7698,6 +7698,103 @@ namespace ts {
                 return isMatchingReference(expr, reference) ? getTypeWithFacts(type, assumeTrue ? TypeFacts.Truthy : TypeFacts.Falsy) : type;
             }
 
+            function narrowTypeByValueExpression(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
+                assumeTrue = (expr.operatorToken.kind === SyntaxKind.EqualsEqualsEqualsToken || expr.operatorToken.kind === SyntaxKind.EqualsEqualsToken) ? assumeTrue : !assumeTrue;
+                let lhs = expr.left;
+                // selectors is the stack of property names used to select down into a type to get the member being narrowed
+                const selectors: string[] = [];
+                while (lhs.kind !== SyntaxKind.Identifier) {
+                    switch (lhs.kind) {
+                        case SyntaxKind.ParenthesizedExpression:
+                            lhs = (lhs as ParenthesizedExpression).expression;
+                            break;
+                        case SyntaxKind.PropertyAccessExpression:
+                            const name = (lhs as PropertyAccessExpression).name.text;
+                            // If a name doesn't resolve, bail
+                            if (name === undefined) {
+                                return type;
+                            }
+                            selectors.push(name);
+                            lhs = (lhs as PropertyAccessExpression).expression;
+                            break;
+                        case SyntaxKind.Identifier:
+                            break;
+                        default:
+                            // Unhandled control flow construct, don't narrow
+                            return type;
+                    }
+                }
+
+                if (!isMatchingReference(lhs, reference)) {
+                    return type;
+                }
+                const rhsType = checkExpressionCached(expr.right);
+
+                if (assumeTrue) {
+                    return narrowIntrospectively(type);
+                }
+                return type;
+
+                /** 
+                 * Descend into the type using the selectors we accumulated above and narrow any unions along the way
+                 * If assumeTrue, we narrow by removing all types not compatible with the rhs type
+                 * If not, we narrow only if the rhsType is a Value type (ie, StringLiteral) by removing all types compatible with that type (TODO)
+                 */
+                function narrowIntrospectively(type: Type) {
+                    const propName = selectors.pop();
+                    if (propName === undefined) {
+                        // Selected all the way into the object, return the type for the property to be narrowed
+                        if (isTypeSubtypeOf(rhsType, type)) {
+                            return rhsType;
+                        }
+                        else {
+                            return type;
+                        }
+                    }
+                    if (type.flags & TypeFlags.Union) {
+                        const reducedUnion = getUnionType(
+                            filter((type as UnionType).types, t => isMemberSubtype(t, rhsType, [...selectors, propName])),
+                            /*noSubtypeReduction*/ true
+                        );
+
+                        if (reducedUnion !== emptyUnionType) {
+                            return narrowBasedOnMatchingProperty(reducedUnion, propName);
+                        }
+                        else {
+                            return type;
+                        }
+                    }
+
+                    return narrowBasedOnMatchingProperty(type, propName);
+                }
+
+                function isMemberSubtype(type: Type, check: Type, selectors: string[]): boolean {
+                    if (!selectors.length) {
+                        return isTypeSubtypeOf(type, check);
+                    }
+                    const name = selectors.pop();
+                    const childProp = getPropertyOfType(type, name);
+                    const propType = childProp && getTypeOfSymbol(childProp);
+                    return propType && isMemberSubtype(propType, check, selectors);
+                }
+
+                function narrowBasedOnMatchingProperty(type: Type, name: string): Type {
+                    const childProp = getPropertyOfType(type, name);
+                    const propType = childProp && getTypeOfSymbol(childProp);
+                    const narrowedType = propType && narrowIntrospectively(propType);
+
+                    if (narrowedType && !isTypeIdenticalTo(propType, narrowedType)) {
+                        const symbols = cloneSymbolTable(resolveStructuredTypeMembers(type as ObjectType).members);
+                        const temp = createSymbol(childProp.flags, name);
+                        getSymbolLinks(temp).type = narrowedType;
+                        symbols[name] = temp;
+                        return createAnonymousType(createSymbol(type.symbol.flags, type.symbol.name), symbols, getSignaturesOfType(type, SignatureKind.Call),
+                            getSignaturesOfType(type, SignatureKind.Construct), getIndexInfoOfType(type, IndexKind.String), getIndexInfoOfType(type, IndexKind.Number));
+                    }
+                    return type;
+                }
+            }
+
             function narrowTypeByBinaryExpression(type: Type, expr: BinaryExpression, assumeTrue: boolean): Type {
                 switch (expr.operatorToken.kind) {
                     case SyntaxKind.EqualsToken:
@@ -7712,7 +7809,7 @@ namespace ts {
                         if (expr.left.kind === SyntaxKind.TypeOfExpression && expr.right.kind === SyntaxKind.StringLiteral) {
                             return narrowTypeByTypeof(type, expr, assumeTrue);
                         }
-                        break;
+                        return narrowTypeByValueExpression(type, expr, assumeTrue);
                     case SyntaxKind.InstanceOfKeyword:
                         return narrowTypeByInstanceof(type, expr, assumeTrue);
                     case SyntaxKind.CommaToken:

tests/baselines/reference/typeGuardByEqualityCheck.symbols

@@ -3,30 +3,30 @@ interface Discriminator {
 >Discriminator : Symbol(Discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 0))
 
 	_discriminator: void;
->_discriminator : Symbol(_discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 25))
+>_discriminator : Symbol(Discriminator._discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 25))
 }
 
 interface FooDiscriminator extends Discriminator {
 >FooDiscriminator : Symbol(FooDiscriminator, Decl(typeGuardByEqualityCheck.ts, 2, 1))
 >Discriminator : Symbol(Discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 0))
 
 	_foo: void;
->_foo : Symbol(_foo, Decl(typeGuardByEqualityCheck.ts, 4, 50))
+>_foo : Symbol(FooDiscriminator._foo, Decl(typeGuardByEqualityCheck.ts, 4, 50))
 }
 
 interface BarDiscriminator extends Discriminator {
 >BarDiscriminator : Symbol(BarDiscriminator, Decl(typeGuardByEqualityCheck.ts, 6, 1))
 >Discriminator : Symbol(Discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 0))
 
 	_bar: void;
->_bar : Symbol(_bar, Decl(typeGuardByEqualityCheck.ts, 8, 50))
+>_bar : Symbol(BarDiscriminator._bar, Decl(typeGuardByEqualityCheck.ts, 8, 50))
 }
 
 interface BaseNode {
 >BaseNode : Symbol(BaseNode, Decl(typeGuardByEqualityCheck.ts, 10, 1))
 
 	kind: Discriminator;
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 12, 20))
+>kind : Symbol(BaseNode.kind, Decl(typeGuardByEqualityCheck.ts, 12, 20))
 >Discriminator : Symbol(Discriminator, Decl(typeGuardByEqualityCheck.ts, 0, 0))
 }
 
@@ -35,23 +35,23 @@ interface FooNode extends BaseNode {
 >BaseNode : Symbol(BaseNode, Decl(typeGuardByEqualityCheck.ts, 10, 1))
 
 	kind: FooDiscriminator;
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 16, 36))
+>kind : Symbol(FooNode.kind, Decl(typeGuardByEqualityCheck.ts, 16, 36))
 >FooDiscriminator : Symbol(FooDiscriminator, Decl(typeGuardByEqualityCheck.ts, 2, 1))
 
 	foo: string;
->foo : Symbol(foo, Decl(typeGuardByEqualityCheck.ts, 17, 24))
+>foo : Symbol(FooNode.foo, Decl(typeGuardByEqualityCheck.ts, 17, 24))
 }
 
 interface BarNode extends BaseNode {
 >BarNode : Symbol(BarNode, Decl(typeGuardByEqualityCheck.ts, 19, 1))
 >BaseNode : Symbol(BaseNode, Decl(typeGuardByEqualityCheck.ts, 10, 1))
 
 	kind: BarDiscriminator;
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 21, 36))
+>kind : Symbol(BarNode.kind, Decl(typeGuardByEqualityCheck.ts, 21, 36))
 >BarDiscriminator : Symbol(BarDiscriminator, Decl(typeGuardByEqualityCheck.ts, 6, 1))
 
 	bar: string;
->bar : Symbol(bar, Decl(typeGuardByEqualityCheck.ts, 22, 24))
+>bar : Symbol(BarNode.bar, Decl(typeGuardByEqualityCheck.ts, 22, 24))
 }
 
 let a: FooDiscriminator;
@@ -124,40 +124,40 @@ interface Thing {
 >Thing : Symbol(Thing, Decl(typeGuardByEqualityCheck.ts, 47, 21))
 
 	kind: string;
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 49, 17))
+>kind : Symbol(Thing.kind, Decl(typeGuardByEqualityCheck.ts, 49, 17))
 }
 interface FooThing extends Thing {
 >FooThing : Symbol(FooThing, Decl(typeGuardByEqualityCheck.ts, 51, 1))
 >Thing : Symbol(Thing, Decl(typeGuardByEqualityCheck.ts, 47, 21))
 
 	kind: "foo";
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 52, 34))
+>kind : Symbol(FooThing.kind, Decl(typeGuardByEqualityCheck.ts, 52, 34))
 
 	foo: string;
->foo : Symbol(foo, Decl(typeGuardByEqualityCheck.ts, 53, 13))
+>foo : Symbol(FooThing.foo, Decl(typeGuardByEqualityCheck.ts, 53, 13))
 }
 interface BarThing extends Thing {
 >BarThing : Symbol(BarThing, Decl(typeGuardByEqualityCheck.ts, 55, 1))
 >Thing : Symbol(Thing, Decl(typeGuardByEqualityCheck.ts, 47, 21))
 
 	kind: "bar";
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 56, 34))
+>kind : Symbol(BarThing.kind, Decl(typeGuardByEqualityCheck.ts, 56, 34))
 
 	bar: string;
->bar : Symbol(bar, Decl(typeGuardByEqualityCheck.ts, 57, 13))
+>bar : Symbol(BarThing.bar, Decl(typeGuardByEqualityCheck.ts, 57, 13))
 }
 interface FooBarThing extends Thing {
 >FooBarThing : Symbol(FooBarThing, Decl(typeGuardByEqualityCheck.ts, 59, 1))
 >Thing : Symbol(Thing, Decl(typeGuardByEqualityCheck.ts, 47, 21))
 
 	kind: "foobar";
->kind : Symbol(kind, Decl(typeGuardByEqualityCheck.ts, 60, 37))
+>kind : Symbol(FooBarThing.kind, Decl(typeGuardByEqualityCheck.ts, 60, 37))
 
 	foo: string;
->foo : Symbol(foo, Decl(typeGuardByEqualityCheck.ts, 61, 16))
+>foo : Symbol(FooBarThing.foo, Decl(typeGuardByEqualityCheck.ts, 61, 16))
 
 	bar: string;
->bar : Symbol(bar, Decl(typeGuardByEqualityCheck.ts, 62, 13))
+>bar : Symbol(FooBarThing.bar, Decl(typeGuardByEqualityCheck.ts, 62, 13))
 }
 
 let gg: FooThing | BarThing | FooBarThing;