Explore using a different isArray declaration

Author: orta

src/blank.ts

@@ -0,0 +1,54 @@
+declare const MyArray: {
+    isArray<T>(arg: T | {}): arg is T extends readonly any[] ? readonly any[] : any[];
+};
+
+declare const a: readonly string[] | string;
+declare const b: string[] | string;
+declare const c: unknown;
+
+if (MyArray.isArray(a)) {
+    a;
+}
+else {
+    a;
+}
+a;
+
+if (MyArray.isArray(b)) {
+    b;
+}
+else {
+    b;
+}
+b;
+
+if (MyArray.isArray(c)) {
+    c;
+}
+
+
+function f<T>(x: T) {
+    const a: readonly T[] | string = null!;
+    const b: T[] | string = null!;
+    const c: T = null!;
+
+    if (MyArray.isArray(a)) {
+        a;
+    }
+    else {
+        a;
+    }
+    a;
+
+    if (MyArray.isArray(b)) {
+        b;
+    }
+    else {
+        b;
+    }
+    b;
+
+    if (MyArray.isArray(c)) {
+        c;
+    }
+}

src/compiler/checker.ts

@@ -21761,15 +21761,11 @@ namespace ts {
                         return assignableType;
                     }
                 }
-                // If the candidate type is a subtype of the target type, narrow to the candidate type.
-                // Otherwise, if the target type is assignable to the candidate type, keep the target type.
-                // Otherwise, if the candidate type is assignable to the target type, narrow to the candidate
-                // type. Otherwise, the types are completely unrelated, so narrow to an intersection of the
-                // two types.
-                return isTypeSubtypeOf(candidate, type) ? candidate :
-                    isTypeAssignableTo(type, candidate) ? type :
-                    isTypeAssignableTo(candidate, type) ? candidate :
-                    getIntersectionType([type, candidate]);
+
+                // If the candidate type is a subtype of the target type, narrow to the candidate type,
+                // if the target type is a subtype of the candidate type, narrow to the target type,
+                // otherwise, narrow to an intersection of the two types.
+                return isTypeSubtypeOf(candidate, type) ? candidate : isTypeSubtypeOf(type, candidate) ? type : getIntersectionType([type, candidate]);
             }
 
             function narrowTypeByCallExpression(type: Type, callExpression: CallExpression, assumeTrue: boolean): Type {