First check for strict subtypes, then check for regular subtypes

Author: ahejlsberg

src/compiler/checker.ts

@@ -27254,7 +27254,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             }
             // We first attempt to filter the current type, narrowing constituents as appropriate and removing
             // constituents that are unrelated to the candidate.
-            const isRelated = checkDerived ? isTypeDerivedFrom : isTypeStrictSubtypeOf;
+            const isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf;
             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.
@@ -27264,7 +27264,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
                 // specific of the two. When t and c are related in both directions, we prefer c for type predicates
                 // because that is the asserted type, but t for `instanceof` because generics aren't reflected in
                 // prototype object types.
-                const directlyRelated = mapType(matching || type, t => isRelated(t, c) ? t : isRelated(c, t) ? c : neverType);
+                const directlyRelated = mapType(matching || type, checkDerived ?
+                    t => isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType :
+                    t => isTypeStrictSubtypeOf(t, c) ? t : isTypeStrictSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : isTypeSubtypeOf(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 ?
@@ -27274,7 +27276,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             // 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 :
-                isTypeStrictSubtypeOf(candidate, type) ? candidate :
+                isTypeSubtypeOf(candidate, type) ? candidate :
                 isTypeAssignableTo(type, candidate) ? type :
                 isTypeAssignableTo(candidate, type) ? candidate :
                 getIntersectionType([type, candidate]);