Optimize for discriminated unions

Author: ahejlsberg

src/compiler/checker.ts

@@ -25318,19 +25318,25 @@ namespace ts {
                 if (!assumeTrue) {
                     return filterType(type, t => !isRelated(t, candidate));
                 }
+                if (type.flags & TypeFlags.AnyOrUnknown) {
+                    return candidate;
+                }
                 // We first attempt to filter the current type, narrowing constituents as appropriate and removing
                 // constituents that are unrelated to the candidate.
-                const narrowedType = type.flags & TypeFlags.AnyOrUnknown ? candidate :
-                    mapType(candidate, c => {
-                        // For each constituent t in the current type, if t and and c are directly related, pick the most
-                        // specific of the two.
-                        const directlyRelated = mapType(type, t => isRelated(t, c) ? t : isRelated(c, t) ? c : neverType);
-                        // If no constituents are directly related, create intersections for any generic constituents that
-                        // are related by constraint.
-                        return directlyRelated.flags & TypeFlags.Never ?
-                            mapType(type, t => maybeTypeOfKind(t, TypeFlags.Instantiable) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) :
-                            directlyRelated;
-                    });
+                const keyPropertyName = type.flags & TypeFlags.Union ? getKeyPropertyName(type as UnionType) : undefined;
+                const narrowedType = mapType(candidate, c => {
+                    // If a discriminant property is available, use that to reduce the type.
+                    const discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName);
+                    const matching = discriminant && getConstituentTypeForKeyType(type as UnionType, discriminant);
+                    // For each constituent t in the current type, if t and and c are directly related, pick the most
+                    // specific of the two.
+                    const directlyRelated = mapType(matching || type, t => isRelated(t, c) ? t : isRelated(c, t) ? c : neverType);
+                    // If no constituents are directly related, create intersections for any generic constituents that
+                    // are related by constraint.
+                    return directlyRelated.flags & TypeFlags.Never ?
+                        mapType(type, t => maybeTypeOfKind(t, TypeFlags.Instantiable) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType) :
+                        directlyRelated;
+                });
                 // If filtering produced a non-empty type, return that. Otherwise, pick the most specific of the two
                 // based on assignability, or as a last resort produce an intersection.
                 return !(narrowedType.flags & TypeFlags.Never) ? narrowedType :