Use intersection of member names to find largest overlap.

Author: DanielRosenwasser

src/compiler/checker.ts

@@ -11959,29 +11959,31 @@ namespace ts {
             }
 
             function findMostOverlappyType(source: Type, unionTarget: UnionOrIntersectionType) {
-                if (!(source.flags & (TypeFlags.Object | TypeFlags.Intersection))) {
-                    return undefined;
-                }
-                const sourceProperties = getPropertiesOfType(source);
-                let bestType;
-                let count = -1;
+                let bestMatch: Type | undefined;
+                let matchingCount = 0;
                 for (const target of unionTarget.types) {
-                    if (!(target.flags & (TypeFlags.Object | TypeFlags.Intersection))) {
-                        continue;
+                    const overlap = getIntersectionType([getIndexType(source), getIndexType(target)]);
+                    if (overlap.flags & TypeFlags.Index) {
+                        // perfect overlap of keys
+                        bestMatch = target;
+                        matchingCount = Infinity;
                     }
-
-                    let currentCount = 0;
-                    for (const prop of sourceProperties) {
-                        if (getPropertyOfType(target, prop.escapedName)) {
-                            currentCount++;
+                    else if (overlap.flags & TypeFlags.Union) {
+                        // Some subset overlap if we have only string literals.
+                        // If we have a union of index types, it seems likely that we
+                        // needed to elaborate between two generic mapped types anyway.
+                        const len = length((overlap as UnionType).types);
+                        if (len >= matchingCount) {
+                            bestMatch = target;
+                            matchingCount = len;
                         }
                     }
-                    if (currentCount >= count) {
-                        count = currentCount;
-                        bestType = target;
+                    else if (!(overlap.flags & TypeFlags.Never) && 1 >= matchingCount) {
+                        bestMatch = target;
+                        matchingCount = 1;
                     }
                 }
-                return bestType;
+                return bestMatch;
             }
 
             // Keep this up-to-date with the same logic within `getApparentTypeOfContextualType`, since they should behave similarly