@zzzen/pyright-internal 1.2.0-dev.20260906 → 1.2.0-dev.20260913

package/dist/analyzer/typeEvaluator.js

@@ -4151,7 +4151,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         writeTypeCache(node.d.member, typeResult, flags);
         return typeResult;
     }
-    function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags) {
+    function getTypeOfMemberAccessWithBaseType(node, baseTypeResult, usage, flags, allowFunctionSignatureAssignment = true) {
         let baseType = (0, typeUtils_1.transformPossibleRecursiveTypeAlias)(baseTypeResult.type);
         const memberName = node.d.member.d.value;
         let diag = new diagnostic_1.DiagnosticAddendum();
@@ -4413,6 +4413,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 4 /* TypeCategory.Function */:
             case 5 /* TypeCategory.Overloaded */: {
                 const hasSelf = (0, types_1.isMethodType)(baseType);
+                const functionTypes = (0, types_1.isFunction)(baseType) ? [baseType] : types_1.OverloadedType.getOverloads(baseType);
+                const isBuiltinsFunction = functionTypes.some((functionType) => types_1.FunctionType.isBuiltIn(functionType) && functionType.shared.moduleName === 'builtins');
                 if (memberName === '__self__' && hasSelf) {
                     // Handle "__self__" specially because MethodType defines
                     // it simply as "object". We can do better here.
@@ -4430,7 +4432,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     const altType = hasSelf ? prefetched?.methodClass : prefetched?.functionClass;
-                    type = getTypeOfMemberAccessWithBaseType(node, { type: altType ? (0, typeUtils_1.convertToInstance)(altType) : types_1.UnknownType.create() }, usage, flags).type;
+                    type = getTypeOfMemberAccessWithBaseType(node, { type: altType ? (0, typeUtils_1.convertToInstance)(altType) : types_1.UnknownType.create() }, usage, flags, !hasSelf && !isBuiltinsFunction).type;
                 }
                 break;
             }
@@ -4442,7 +4444,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!type) {
             const isFunctionRule = (0, types_1.isFunctionOrOverloaded)(baseType) ||
                 ((0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, ['function', 'FunctionType']));
-            if (!baseTypeResult.isIncomplete) {
+            // These signature metadata attributes can be assigned on function objects at runtime.
+            const isFunctionSignatureAssignment = allowFunctionSignatureAssignment &&
+                usage.method === 'set' &&
+                (memberName === '__signature__' || memberName === '__text_signature__') &&
+                (0, types_1.isClassInstance)(baseType) &&
+                types_1.ClassType.isBuiltIn(baseType, ['function', 'FunctionType']);
+            if (!baseTypeResult.isIncomplete && !isFunctionSignatureAssignment) {
                 let diagMessage = localize_1.LocMessage.memberAccess();
                 if (usage.method === 'set') {
                     diagMessage = localize_1.LocMessage.memberSet();
@@ -7018,15 +7026,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const specializedInitSelfTypes = [];
         let matchedOverloads = [];
         let isTypeIncomplete = false;
-        const overloadsUsedForCall = [];
+        let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
-        let hasInitSelfMaterializationAmbiguity = false;
-        let hasEffectiveInitSelfType = false;
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         for (let expandedTypesIndex = 0; expandedTypesIndex < expandedArgTypes.length; expandedTypesIndex++) {
-            const overloadsUsedStartIndex = overloadsUsedForCall.length;
             let matchedOverload;
-            let effectiveInitSelfType;
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
             let possibleMatchResults = [];
@@ -7066,12 +7070,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         constraints: effectiveConstraints,
                         returnType: callResult.returnType,
                         argResults: callResult.argResults ?? [],
-                        specializedInitSelfType: callResult.specializedInitSelfType,
                     };
                     matchedOverloads.push(matchedOverloadInfo);
-                    if (callResult.anyOrUnknownArg ||
-                        matchResults.unpackedArgOfUnknownLength ||
-                        possibleMatchResults.length > 0) {
+                    if (callResult.anyOrUnknownArg || matchResults.unpackedArgOfUnknownLength) {
                         possibleMatchResults.push(matchedOverloadInfo);
                         if (callResult.anyOrUnknownArg) {
                             if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
@@ -7081,7 +7082,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     else {
                         returnTypes.push(callResult.returnType);
-                        effectiveInitSelfType = getEffectiveInitSelfType(matchedOverloadInfo);
+                        // Each definitive union branch needs its own constructed type;
+                        // __init__ return types alone cannot represent the specialization.
+                        const boundToType = overload.priv.boundToType;
+                        if (expandedArgTypes.length > 1 &&
+                            overload.shared.name === '__init__' &&
+                            boundToType &&
+                            (0, types_1.isClassInstance)(boundToType)) {
+                            specializedInitSelfTypes.push(callResult.specializedInitSelfType ??
+                                solveAndApplyConstraints(boundToType, effectiveConstraints, {
+                                    replaceUnsolved: {
+                                        scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(boundToType),
+                                        tupleClassType: getTupleClassType(),
+                                    },
+                                }));
+                        }
                         isDefinitiveMatchFound = true;
                         break;
                     }
@@ -7095,53 +7110,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
                 possibleMatchResults = filterOverloadMatchesForUnpackedArgs(possibleMatchResults);
                 possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
-                // Keep diagnostic bookkeeping aligned with the candidates that remain possible.
-                // This applies to both top-level gradual arguments and nested materialization,
-                // so deprecation diagnostics are reported only for retained overloads.
-                overloadsUsedForCall.splice(overloadsUsedStartIndex, overloadsUsedForCall.length - overloadsUsedStartIndex, ...possibleMatchResults.map((result) => result.overload));
                 // Did the filtering produce a single result? If so, we're done.
                 if (possibleMatchResults.length === 1) {
+                    overloadsUsedForCall = [possibleMatchResults[0].overload];
                     returnTypes.push(possibleMatchResults[0].returnType);
-                    effectiveInitSelfType = getEffectiveInitSelfType(possibleMatchResults[0]);
                     matchedOverloads = [possibleMatchResults[0]];
                 }
                 else {
-                    const firstArgParamPairs = getOverloadArgParamPairs(possibleMatchResults[0]);
-                    let ambiguousMatchIncludesNestedAny = false;
-                    let ambiguousMatchIncludesNestedUnknown = false;
-                    let ambiguousMatchIncludesTopLevelAnyOrUnknown = false;
-                    firstArgParamPairs.forEach((pair, index) => {
-                        const paramTypes = possibleMatchResults.map((match) => {
-                            const argParamPairs = getOverloadArgParamPairs(match);
-                            return index < argParamPairs.length ? argParamPairs[index].paramType : types_1.UnknownType.create();
-                        });
-                        if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
-                            if ((0, types_1.isAnyOrUnknown)(pair.argType)) {
-                                ambiguousMatchIncludesTopLevelAnyOrUnknown = true;
-                            }
-                            else {
-                                const anyOrUnknown = getAnyOrUnknownInInvariantPosition(pair.argType);
-                                if (anyOrUnknown && (0, types_1.isAny)(anyOrUnknown)) {
-                                    ambiguousMatchIncludesNestedAny = true;
-                                }
-                                else if (anyOrUnknown && (0, types_1.isUnknown)(anyOrUnknown)) {
-                                    ambiguousMatchIncludesNestedUnknown = true;
-                                }
-                            }
-                        }
-                    });
                     // Eliminate any return types that are subsumed by other return types.
                     let dedupedMatchResults = [];
                     let dedupedResultsIncludeAny = false;
-                    const isInitSelfMaterializationAmbiguity = (ambiguousMatchIncludesNestedAny || ambiguousMatchIncludesNestedUnknown) &&
-                        possibleMatchResults.some((result) => !!result.specializedInitSelfType);
                     possibleMatchResults.forEach((result) => {
-                        const resultType = isInitSelfMaterializationAmbiguity
-                            ? getEffectiveOverloadReturnType(result)
-                            : result.returnType;
                         let isSubtypeSubsumed = false;
                         for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
-                            if (assignType(dedupedMatchResults[dedupedIndex], resultType)) {
+                            if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
                                 const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex], 
                                 /* recurse */ false);
                                 if (!anyOrUnknown) {
@@ -7152,8 +7134,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 }
                                 break;
                             }
-                            else if (assignType(resultType, dedupedMatchResults[dedupedIndex])) {
-                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(resultType, /* recurse */ false);
+                            else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(result.returnType, /* recurse */ false);
                                 if (!anyOrUnknown) {
                                     dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
                                 }
@@ -7164,19 +7146,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         }
                         if (!isSubtypeSubsumed) {
-                            dedupedMatchResults.push(resultType);
+                            dedupedMatchResults.push(result.returnType);
                         }
                     });
                     dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
                     const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
                     let returnType = combinedTypes;
-                    if (ambiguousMatchIncludesNestedUnknown) {
-                        returnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
-                    }
-                    else if (ambiguousMatchIncludesNestedAny && !ambiguousMatchIncludesTopLevelAnyOrUnknown) {
-                        returnType = types_1.AnyType.create();
-                    }
-                    else if (dedupedMatchResults.length > 1) {
+                    if (dedupedMatchResults.length > 1) {
                         // If one or more of the deduped types is Any or contains Any,
                         // we will assume that the person who defined the overload really
                         // wanted Any rather than Unknown. In cases where the deduped types
@@ -7189,43 +7165,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             returnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
                         }
                     }
-                    if (isInitSelfMaterializationAmbiguity) {
-                        // Overloaded __init__ methods normally return None. Preserve that
-                        // ordinary return as a placeholder while union-expanded calls are
-                        // combined, and carry the effective constructed types separately.
-                        // validateInitMethod consumes specializedInitSelfType to reconstruct
-                        // the constructor result after call validation is complete.
-                        effectiveInitSelfType = returnType;
-                        hasInitSelfMaterializationAmbiguity = true;
-                        returnTypes.push(possibleMatchResults[0].returnType);
-                    }
-                    else {
-                        returnTypes.push(returnType);
-                    }
+                    returnTypes.push(returnType);
                 }
             }
-            if (effectiveInitSelfType) {
-                specializedInitSelfTypes.push(effectiveInitSelfType);
-                hasEffectiveInitSelfType = true;
-            }
             if (!matchedOverload) {
                 return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall };
             }
         }
-        // Union expansion requires one constructor handoff per expanded argument list.
-        // Materialization ambiguity requires a combined handoff even when there is only
-        // one argument list because multiple overload candidates contribute to its result.
-        const shouldCombineInitSelfTypes = hasInitSelfMaterializationAmbiguity || (expandedArgTypes.length > 1 && hasEffectiveInitSelfType);
         // We found a match for all of the expanded argument lists. Copy the
         // resulting type var context back into the caller's type var context.
-        // Use the type var context from the last matched overload because it
-        // includes the type var solutions for all earlier matched overloads.
+        // Constructor results for separate union branches are carried through
+        // specializedInitSelfTypes rather than the last branch's constraints.
         if (constraints && isDefinitiveMatchFound) {
             constraints.copyFromClone(matchedOverloads[matchedOverloads.length - 1].constraints);
         }
         // And run through the first expanded argument list one more time to
-        // populate the type cache.
-        const finalConstraints = shouldCombineInitSelfTypes
+        // populate the type cache, without applying a different branch's constraints.
+        const finalConstraints = expandedArgTypes.length > 1
             ? matchedOverloads[0].constraints
             : constraints ?? matchedOverloads[0].constraints;
         const finalCallResult = validateArgTypesWithContext(errorNode, matchedOverloads[0].matchResults, finalConstraints, skipUnknownArgCheck, inferenceContext);
@@ -7237,7 +7193,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             anyOrUnknownArg: finalCallResult.anyOrUnknownArg,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
-            specializedInitSelfType: specializedInitSelfTypes.length > 0 && shouldCombineInitSelfTypes
+            specializedInitSelfType: specializedInitSelfTypes.length === expandedArgTypes.length
                 ? (0, types_1.combineTypes)(specializedInitSelfTypes)
                 : finalCallResult.specializedInitSelfType,
             overloadsUsedForCall,
@@ -7257,303 +7213,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return unpackedArgsOverloads;
     }
-    // assignType cannot be used for this detection because it accepts Any and Unknown
-    // without exposing whether acceptance depends on a gradual invariant type argument.
-    function getAnyOrUnknownInInvariantPosition(type, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
-        let result;
-        const addResult = (newResult) => {
-            if (newResult) {
-                result = result ? (0, typeUtils_1.preserveUnknown)(result, newResult) : newResult;
-            }
-        };
-        if ((0, types_1.isUnion)(type)) {
-            (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
-                addResult(getAnyOrUnknownInInvariantPosition(subtype, recursionCount));
-            });
-            return result;
-        }
-        if (!(0, types_1.isClass)(type)) {
-            return undefined;
-        }
-        // Tuple entries are covariant, but they can contain an invariant type.
-        if (type.priv.tupleTypeArgs) {
-            type.priv.tupleTypeArgs.forEach((typeArg) => {
-                addResult(getAnyOrUnknownInInvariantPosition(typeArg.type, recursionCount));
-            });
-            return result;
-        }
-        if (!type.priv.typeArgs) {
-            return undefined;
-        }
-        inferVarianceForClass(type);
-        const typeParams = types_1.ClassType.getTypeParams(type);
-        type.priv.typeArgs.forEach((typeArg, index) => {
-            const typeParam = index < typeParams.length ? typeParams[index] : undefined;
-            const variance = typeParam ? types_1.TypeVarType.getVariance(typeParam) : 2 /* Variance.Invariant */;
-            if (variance === 2 /* Variance.Invariant */) {
-                addResult((0, typeUtils_1.containsAnyOrUnknown)(typeArg, /* recurse */ true));
-            }
-            else {
-                addResult(getAnyOrUnknownInInvariantPosition(typeArg, recursionCount));
-            }
-        });
-        return result;
-    }
-    function getEffectiveOverloadReturnType(match) {
-        return getEffectiveInitSelfType(match) ?? match.returnType;
-    }
-    function getEffectiveInitSelfType(match) {
-        if (match.specializedInitSelfType) {
-            return match.specializedInitSelfType;
-        }
-        const boundToType = match.overload.priv.boundToType;
-        if (match.overload.shared.name === '__init__' && boundToType && (0, types_1.isClassInstance)(boundToType)) {
-            return solveAndApplyConstraints(boundToType, match.constraints, {
-                replaceUnsolved: {
-                    scopeIds: (0, typeUtils_1.getTypeVarScopeIds)(boundToType),
-                    tupleClassType: getTupleClassType(),
-                },
-            });
-        }
-        return undefined;
-    }
-    function getOverloadArgParamPairs(match) {
-        const pairs = [];
-        // argResults and argParams share validation order: supplied arguments in caller
-        // order, followed by synthesized defaults. Preserve that order so the same index
-        // across overloads represents the same supplied argument, even for keyword calls.
-        match.argResults.forEach((argResult, index) => {
-            const argParam = index < match.matchResults.argParams.length ? match.matchResults.argParams[index] : undefined;
-            if (!argParam?.isDefaultArg) {
-                pairs.push({
-                    argType: argResult.argType,
-                    paramType: argParam?.paramType ?? types_1.UnknownType.create(),
-                });
-            }
-        });
-        if (match.overload.priv.boundToType && match.overload.priv.strippedFirstParamType) {
-            pairs.unshift({
-                argType: match.overload.priv.boundToType,
-                paramType: match.overload.priv.strippedFirstParamType,
-            });
-        }
-        return pairs;
-    }
-    function combineMaterializationCoverage(results) {
-        if (results.some((result) => result === false)) {
-            return false;
-        }
-        return results.some((result) => result === undefined) ? undefined : true;
-    }
-    function areAllMaterializationsEquivalent(destType, srcType, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
-        if (!(0, typeUtils_1.containsAnyOrUnknown)(srcType, /* recurse */ true)) {
-            return (0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true });
-        }
-        if ((0, types_1.isAnyOrUnknown)(destType)) {
-            return true;
-        }
-        if ((0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true })) {
-            return true;
-        }
-        if ((0, types_1.isTypeVar)(destType) ||
-            (0, types_1.isUnion)(destType) ||
-            (0, types_1.isFunction)(destType) ||
-            (0, types_1.isOverloaded)(destType) ||
-            ((0, types_1.isClass)(destType) && types_1.ClassType.isProtocolClass(destType))) {
-            return undefined;
-        }
-        if ((0, types_1.isAnyOrUnknown)(srcType)) {
-            return false;
-        }
-        if ((0, types_1.isUnion)(srcType) || (0, types_1.isUnion)(destType) || (0, types_1.isFunction)(srcType) || (0, types_1.isFunction)(destType)) {
-            return undefined;
-        }
-        if (!(0, types_1.isClass)(destType) || !(0, types_1.isClass)(srcType)) {
-            return false;
-        }
-        if (!types_1.ClassType.isSameGenericClass(destType, srcType)) {
-            return false;
-        }
-        if (destType.priv.tupleTypeArgs || srcType.priv.tupleTypeArgs) {
-            const destTupleTypeArgs = destType.priv.tupleTypeArgs;
-            const srcTupleTypeArgs = srcType.priv.tupleTypeArgs;
-            if (!destTupleTypeArgs ||
-                !srcTupleTypeArgs ||
-                destTupleTypeArgs.length !== srcTupleTypeArgs.length ||
-                destTupleTypeArgs.some((destTypeArg, index) => destTypeArg.isUnbounded !== srcTupleTypeArgs[index].isUnbounded)) {
-                return false;
-            }
-            return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg, index) => areAllMaterializationsEquivalent(destTupleTypeArgs[index].type, srcTypeArg.type, recursionCount)));
-        }
-        const destTypeArgs = destType.priv.typeArgs;
-        const srcTypeArgs = srcType.priv.typeArgs;
-        if (!destTypeArgs || !srcTypeArgs || destTypeArgs.length !== srcTypeArgs.length) {
-            return false;
-        }
-        return combineMaterializationCoverage(srcTypeArgs.map((srcTypeArg, index) => areAllMaterializationsEquivalent(destTypeArgs[index], srcTypeArg, recursionCount)));
-    }
-    function areAllMaterializationsAssignable(destType, srcType, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
-        if (!(0, typeUtils_1.containsAnyOrUnknown)(srcType, /* recurse */ true)) {
-            return assignType(destType, srcType);
-        }
-        if ((0, types_1.isAnyOrUnknown)(destType)) {
-            return true;
-        }
-        if ((0, types_1.isTypeSame)(destType, srcType, { treatAnySameAsUnknown: true })) {
-            return true;
-        }
-        if ((0, types_1.isTypeVar)(destType) ||
-            (0, types_1.isUnion)(destType) ||
-            (0, types_1.isFunction)(destType) ||
-            (0, types_1.isOverloaded)(destType) ||
-            ((0, types_1.isClass)(destType) && types_1.ClassType.isProtocolClass(destType))) {
-            return undefined;
-        }
-        if ((0, types_1.isAnyOrUnknown)(srcType)) {
-            return assignType(destType, getObjectType());
-        }
-        if ((0, types_1.isUnion)(srcType) ||
-            (0, types_1.isUnion)(destType) ||
-            (0, types_1.isFunction)(srcType) ||
-            (0, types_1.isFunction)(destType) ||
-            (0, types_1.isOverloaded)(srcType) ||
-            (0, types_1.isOverloaded)(destType)) {
-            return undefined;
-        }
-        if (!(0, types_1.isClass)(destType) || !(0, types_1.isClass)(srcType)) {
-            return false;
-        }
-        if ((0, typeUtils_1.isTupleClass)(destType) && (0, typeUtils_1.isTupleClass)(srcType)) {
-            const destTupleTypeArgs = destType.priv.tupleTypeArgs;
-            const srcTupleTypeArgs = srcType.priv.tupleTypeArgs;
-            if (!destTupleTypeArgs || !srcTupleTypeArgs) {
-                return undefined;
-            }
-            if (destTupleTypeArgs.length === 1 && destTupleTypeArgs[0].isUnbounded) {
-                return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg) => areAllMaterializationsAssignable(destTupleTypeArgs[0].type, srcTypeArg.type, recursionCount)));
-            }
-            if (destTupleTypeArgs.length !== srcTupleTypeArgs.length ||
-                destTupleTypeArgs.some((destTypeArg, index) => destTypeArg.isUnbounded !== srcTupleTypeArgs[index].isUnbounded)) {
-                return false;
-            }
-            return combineMaterializationCoverage(srcTupleTypeArgs.map((srcTypeArg, index) => areAllMaterializationsAssignable(destTupleTypeArgs[index].type, srcTypeArg.type, recursionCount)));
-        }
-        let specializedSrcType;
-        if (types_1.ClassType.isSameGenericClass(destType, srcType)) {
-            specializedSrcType = srcType;
-        }
-        else {
-            const instantiableDestType = (0, types_1.isClassInstance)(destType) ? types_1.ClassType.cloneAsInstantiable(destType) : destType;
-            const baseClass = srcType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(instantiableDestType, mroClass));
-            if (baseClass && (0, types_1.isClass)(baseClass)) {
-                specializedSrcType = (0, typeUtils_1.specializeForBaseClass)(srcType, baseClass);
-            }
-        }
-        if (!specializedSrcType) {
-            return types_1.ClassType.isBuiltIn(destType, 'object') ? true : undefined;
-        }
-        const typeParams = types_1.ClassType.getTypeParams(destType);
-        if (typeParams.length === 0) {
-            return true;
-        }
-        const destTypeArgs = destType.priv.typeArgs;
-        const srcTypeArgs = specializedSrcType.priv.typeArgs;
-        if (!destTypeArgs) {
-            return true;
-        }
-        if (!srcTypeArgs) {
-            return false;
-        }
-        inferVarianceForClass(destType);
-        return combineMaterializationCoverage(srcTypeArgs.map((srcTypeArg, index) => {
-            const destTypeArg = index < destTypeArgs.length ? destTypeArgs[index] : types_1.UnknownType.create();
-            const typeParam = index < typeParams.length ? typeParams[index] : undefined;
-            const variance = typeParam ? types_1.TypeVarType.getVariance(typeParam) : 2 /* Variance.Invariant */;
-            if (variance === 3 /* Variance.Covariant */) {
-                return areAllMaterializationsAssignable(destTypeArg, srcTypeArg, recursionCount);
-            }
-            if (variance === 2 /* Variance.Invariant */) {
-                return areAllMaterializationsEquivalent(destTypeArg, srcTypeArg, recursionCount);
-            }
-            return undefined;
-        }));
-    }
     // Determines whether multiple incompatible overloads match
     // due to an Any or Unknown argument type.
     function filterOverloadMatchesForAnyArgs(matches) {
         if (matches.length < 2) {
             return matches;
         }
-        let firstArgParamPairs = getOverloadArgParamPairs(matches[0]);
-        const hasInvariantAnyOrUnknownArg = firstArgParamPairs.some((pair) => getAnyOrUnknownInInvariantPosition(pair.argType));
-        // If all of the effective return types match, select the first one.
-        if ((0, typeUtils_1.areTypesSame)(matches.map((match) => hasInvariantAnyOrUnknownArg ? getEffectiveOverloadReturnType(match) : match.returnType), { treatAnySameAsUnknown: true })) {
+        // If all of the return types match, select the first one.
+        if ((0, typeUtils_1.areTypesSame)(matches.map((match) => match.returnType), { treatAnySameAsUnknown: true })) {
             return [matches[0]];
         }
-        // Apply overload step 5 to arguments that contain a gradual type in an
-        // invariant position. An overload that covers all materializations
-        // eliminates only the overloads that follow it.
-        if (hasInvariantAnyOrUnknownArg) {
-            let materializationCheckSupported = true;
-            for (let matchIndex = 0; matchIndex < matches.length; matchIndex++) {
-                const argParamPairs = getOverloadArgParamPairs(matches[matchIndex]);
-                const coverage = argParamPairs.length === firstArgParamPairs.length
-                    ? combineMaterializationCoverage(argParamPairs.map((pair, index) => {
-                        const argType = firstArgParamPairs[index].argType;
-                        return areAllMaterializationsAssignable(pair.paramType, argType);
-                    }))
-                    : false;
-                if (coverage === undefined) {
-                    materializationCheckSupported = false;
-                    break;
-                }
-                if (coverage) {
-                    matches = matches.slice(0, matchIndex + 1);
-                    break;
-                }
-            }
-            if (materializationCheckSupported) {
-                if (matches.length < 2) {
-                    return matches;
-                }
-                if ((0, typeUtils_1.areTypesSame)(matches.map((match) => getEffectiveOverloadReturnType(match)), { treatAnySameAsUnknown: true })) {
-                    return [matches[0]];
-                }
-                firstArgParamPairs = getOverloadArgParamPairs(matches[0]);
-                for (let i = 0; i < firstArgParamPairs.length; i++) {
-                    if (getAnyOrUnknownInInvariantPosition(firstArgParamPairs[i].argType)) {
-                        const paramTypes = matches.map((match) => {
-                            const argParamPairs = getOverloadArgParamPairs(match);
-                            return i < argParamPairs.length ? argParamPairs[i].paramType : types_1.UnknownType.create();
-                        });
-                        if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
-                            return matches;
-                        }
-                    }
-                }
-            }
+        const firstArgResults = matches[0].argResults;
+        if (!firstArgResults) {
+            return matches;
         }
         let foundAmbiguousAnyArg = false;
-        for (let i = 0; i < firstArgParamPairs.length; i++) {
+        for (let i = 0; i < firstArgResults.length; i++) {
             // If the arg is Any or Unknown, see if the corresponding
             // parameter types differ in any way.
-            if ((0, types_1.isAnyOrUnknown)(firstArgParamPairs[i].argType)) {
-                const paramTypes = matches.map((match) => {
-                    const argParamPairs = getOverloadArgParamPairs(match);
-                    return i < argParamPairs.length ? argParamPairs[i].paramType : types_1.UnknownType.create();
-                });
+            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
+                const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
+                    ? match.matchResults.argParams[i].paramType
+                    : types_1.UnknownType.create());
                 if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
                     foundAmbiguousAnyArg = true;
                 }
@@ -7564,8 +7245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // that one of the arguments is an unpacked iterator, and it maps to
         // an indeterminate number of parameters, which means that the overload
         // selection is ambiguous.
-        if (foundAmbiguousAnyArg ||
-            matches.some((match) => getOverloadArgParamPairs(match).length !== firstArgParamPairs.length)) {
+        if (foundAmbiguousAnyArg || matches.some((match) => match.argResults.length !== firstArgResults.length)) {
             return matches;
         }
         return [matches[0]];
@@ -9341,9 +9021,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let argumentErrors = false;
         let argumentMatchScore = 0;
         let specializedInitSelfType;
-        let anyOrUnknownArg = type.priv.boundToType
-            ? getAnyOrUnknownInInvariantPosition(type.priv.boundToType)
-            : undefined;
+        let anyOrUnknownArg;
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
@@ -9441,11 +9119,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (argResult.condition) {
                 condition = types_1.TypeCondition.combine(condition, argResult.condition) ?? [];
             }
-            const argAnyOrUnknown = (0, types_1.isAnyOrUnknown)(argResult.argType)
-                ? argResult.argType
-                : getAnyOrUnknownInInvariantPosition(argResult.argType);
-            if (argAnyOrUnknown && !argParam.isDefaultArg) {
-                anyOrUnknownArg = anyOrUnknownArg ? (0, typeUtils_1.preserveUnknown)(argAnyOrUnknown, anyOrUnknownArg) : argAnyOrUnknown;
+            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
+                anyOrUnknownArg = anyOrUnknownArg
+                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArg)
+                    : argResult.argType;
             }
             if (paramSpec) {
                 if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */) {