WIP: Member-type based type guards

src/compiler/binder.ts

@@ -623,7 +623,7 @@ 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) {

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/equalityWithUnionTypes01.types

@@ -54,17 +54,17 @@ else if (y == z || z == y) {
 >y == z || z == y : boolean
 >y == z : boolean
 >y : I2
->z : I1
+>z : I2
 >z == y : boolean
->z : I1
+>z : I2
 >y : I2
 }
 else if (y != z || z != y) {
 >y != z || z != y : boolean
 >y != z : boolean
 >y : I2
->z : I1
+>z : I2
 >z != y : boolean
->z : I1
+>z : I2
 >y : I2
 }

tests/baselines/reference/typeGuardByEqualityCheck.js

@@ -0,0 +1,107 @@
+//// [typeGuardByEqualityCheck.ts]
+interface Discriminator {
+	_discriminator: void;
+}
+
+interface FooDiscriminator extends Discriminator {
+	_foo: void;
+}
+
+interface BarDiscriminator extends Discriminator {
+	_bar: void;
+}
+
+interface BaseNode {
+	kind: Discriminator;
+}
+
+interface FooNode extends BaseNode {
+	kind: FooDiscriminator;
+	foo: string;
+}
+
+interface BarNode extends BaseNode {
+	kind: BarDiscriminator;
+	bar: string;
+}
+
+let a: FooDiscriminator;
+let x: FooNode | BarNode;
+
+if (x.kind === a) {
+	x.foo = "yay!";
+}
+else {
+	x; // Not narrowed at present
+}
+
+let z: {
+	value: string;
+	item: FooNode | BarNode;
+}
+if (z.item.kind === a) {
+	z.item.foo = "cool!";
+	z.value = "yes";
+}
+
+let foo: "foo";
+let bar: "bar";
+let foobar: "foobar";
+
+interface Thing {
+	kind: string;
+}
+interface FooThing extends Thing {
+	kind: "foo";
+	foo: string;
+}
+interface BarThing extends Thing {
+	kind: "bar";
+	bar: string;
+}
+interface FooBarThing extends Thing {
+	kind: "foobar";
+	foo: string;
+	bar: string;
+}
+
+let gg: FooThing | BarThing | FooBarThing;
+if (gg.kind === foobar) {
+	gg.bar = "bar";
+	gg.foo = "foo";
+}
+let holder = {
+	value: gg
+};
+if (holder.value.kind === foo) {
+	holder.value.foo = "foo";
+}
+
+//// [typeGuardByEqualityCheck.js]
+var a;
+var x;
+if (x.kind === a) {
+    x.foo = "yay!";
+}
+else {
+    x; // Not narrowed at present
+}
+var z;
+if (z.item.kind === a) {
+    z.item.foo = "cool!";
+    z.value = "yes";
+}
+var foo;
+var bar;
+var foobar;
+var gg;
+if (gg.kind === foobar) {
+    gg.bar = "bar";
+    gg.foo = "foo";
+}
+var holder = {
+    value: gg
+};
+if (holder.value.kind === foo) {
+    holder.value.foo = "foo";
+}