Only narrow to {} in getNarrowedType when types are completely unrelated

ahejlsberg · ahejlsberg · commit f06d3f698193 · 2016-04-22T06:52:14.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -7327,18 +7327,6 @@ namespace ts {
             return false;
         }
 
-        function typeMaybeSubtypeOf(source: Type, target: Type) {
-            if (!(source.flags & TypeFlags.Union)) {
-                return isTypeSubtypeOf(source, target);
-            }
-            for (const t of (<UnionType>source).types) {
-                if (isTypeSubtypeOf(t, target)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-
         // Remove those constituent types of declaredType to which no constituent type of assignedType is assignable.
         // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean,
         // we remove type string.
@@ -7769,28 +7757,26 @@ namespace ts {
             }
 
             function getNarrowedType(type: Type, candidate: Type, assumeTrue: boolean) {
-                if (typeMaybeSubtypeOf(type, candidate)) {
-                    // If the current type, or a constituent of the current type, is a subtype of
-                    // the candidate type then the current type contains the most specific information.
-                    // and we simply filter out constituents that aren't applicable. For example,
-                    // if the current type is string | string[] and the candidate type is any[],
-                    // we filter out string.
+                if (!assumeTrue) {
                     return type.flags & TypeFlags.Union ?
-                        getUnionType(filter((<UnionType>type).types, t => isTypeSubtypeOf(t, candidate) === assumeTrue)) :
-                        assumeTrue ? type : emptyUnionType;
-                }
-                if (assumeTrue) {
-                    // In the true branch of the remaining cases, if the candidate type is assignable
-                    // to the current type, then we narrow to the candidate type. Otherwise, we narrow
-                    // to an empty type (because we now know the types are completely unrelated). For
-                    // example, if the current type is Object and the candidate type is string[], we
-                    // narrow to string[]. But if the current type is string and the candidate is
-                    // string[], we narrow to the empty type.
-                    const targetType = type.flags & TypeFlags.TypeParameter ? getApparentType(type) : type;
-                    return isTypeAssignableTo(candidate, targetType) ? candidate : emptyUnionType;
-                }
-                // In the false branch of the remaining cases we leave the type unchanged.
-                return type;
+                        getUnionType(filter((<UnionType>type).types, t => !isTypeSubtypeOf(t, candidate))) :
+                        type;
+                }
+                // If the current type is a union type, remove all constituents that aren't assignable to
+                // the candidate type. If one or more constituents remain, return a union of those.
+                if (type.flags & TypeFlags.Union) {
+                    const assignableConstituents = filter((<UnionType>type).types, t => isTypeAssignableTo(t, candidate));
+                    if (assignableConstituents.length) {
+                        return getUnionType(assignableConstituents);
+                    }
+                }
+                // If the candidate type is assignable to the target type, narrow to the candidate type.
+                // Otherwise, if the current type is assignable to the candidate, keep the current type.
+                // Otherwise, the types are completely unrelated, so narrow to the empty type.
+                const targetType = type.flags & TypeFlags.TypeParameter ? getApparentType(type) : type;
+                return isTypeAssignableTo(candidate, targetType) ? candidate :
+                    isTypeAssignableTo(type, candidate) ? type :
+                    emptyUnionType;
             }
 
             function narrowTypeByTypePredicate(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {
