@zzzen/pyright-internal 1.2.0-dev.20250309 → 1.2.0-dev.20250323

package/dist/analyzer/typeEvaluator.js

@@ -142,6 +142,10 @@ const maxCallSiteReturnTypeCacheSize = 8;
 // when inferring the type? We need to cut it off at some point
 // to avoid excessive computation.
 const maxEntriesToUseForInference = 64;
+// How many times should attempt to infer a return type of a
+// function before giving up and assuming that it won't converge
+// due to recursion?
+const maxReturnTypeInferenceAttempts = 8;
 // How many assignments to an unannotated variable should be used
 // when inferring its type? We need to cut it off at some point
 // to avoid excessive computation.
@@ -194,7 +198,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let deferredClassCompletions = [];
     let cancellationToken;
     let printExpressionSpaceCount = 0;
-    let incompleteGenerationCount = 0;
+    let incompleteGenCount = 0;
     const returnTypeInferenceContextStack = [];
     let returnTypeInferenceTypeCache;
     const signatureTrackerStack = [];
@@ -255,7 +259,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (!cacheEntry) {
             return false;
         }
-        return (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount);
+        return !cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount;
     }
     function readTypeCache(node, flags) {
         const cacheEntry = readTypeCacheEntry(node);
@@ -290,22 +294,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             ? returnTypeInferenceTypeCache
             : typeCache;
         if (!typeResult.isIncomplete) {
-            incompleteGenerationCount++;
+            incompleteGenCount++;
         }
         else {
             const oldValue = typeCacheToUse.get(node.id);
             if (oldValue !== undefined && !(0, types_1.isTypeSame)(typeResult.type, oldValue.typeResult.type)) {
-                incompleteGenerationCount++;
+                incompleteGenCount++;
             }
         }
-        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenerationCount: incompleteGenerationCount });
+        typeCacheToUse.set(node.id, { typeResult, flags, incompleteGenCount });
         // If the entry is located within a part of the parse tree that is currently being
         // "speculatively" evaluated, track it so we delete the cached entry when we leave
         // this speculative context.
         if (isSpeculativeModeInUse(node)) {
             speculativeTypeTracker.trackEntry(typeCacheToUse, node.id);
             if (allowSpeculativeCaching) {
-                speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenerationCount, inferenceContext?.expectedType);
+                speculativeTypeTracker.addSpeculativeType(node, typeResult, incompleteGenCount, inferenceContext?.expectedType);
             }
         }
     }
@@ -531,23 +535,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
-        if (cacheEntry &&
-            (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
-            if (printExpressionTypes) {
-                console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
+        if (cacheEntry) {
+            if (!cacheEntry.typeResult.isIncomplete || cacheEntry.incompleteGenCount === incompleteGenCount) {
+                if (printExpressionTypes) {
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Cached ${printType(cacheEntry.typeResult.type)} ${cacheEntry.typeResult.typeErrors ? ' Errors' : ''}`);
+                }
+                return cacheEntry.typeResult;
             }
-            return cacheEntry.typeResult;
         }
-        else {
-            // Is it cached in the speculative type cache?
-            const cacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
-            if (cacheEntry &&
-                (!cacheEntry.typeResult.isIncomplete ||
-                    cacheEntry.incompleteGenerationCount === incompleteGenerationCount)) {
+        // Is it cached in the speculative type cache?
+        const specCacheEntry = speculativeTypeTracker.getSpeculativeType(node, inferenceContext?.expectedType);
+        if (specCacheEntry) {
+            if (!specCacheEntry.typeResult.isIncomplete ||
+                specCacheEntry.incompleteGenerationCount === incompleteGenCount) {
                 if (printExpressionTypes) {
-                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(cacheEntry.typeResult.type)}`);
+                    console.log(`${getPrintExpressionTypesSpaces()}${ParseTreeUtils.printExpression(node)} (${getLineNum(node)}): Speculative ${printType(specCacheEntry.typeResult.type)}`);
                 }
-                return cacheEntry.typeResult;
+                return specCacheEntry.typeResult;
             }
         }
         if (printExpressionTypes) {
@@ -2355,7 +2359,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             else {
                 // Constrain the resulting type to match the declared type.
-                destType = narrowTypeBasedOnAssignment(nameNode, declaredType, typeResult).type;
+                destType = narrowTypeBasedOnAssignment(declaredType, typeResult).type;
             }
         }
         else {
@@ -2950,7 +2954,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             // is a enum because the annotated type in an enum doesn't reflect
                             // the type of the symbol.
                             if (!(0, types_1.isClassInstance)(typeResult.type) || !types_1.ClassType.isEnumClass(typeResult.type)) {
-                                typeResult = narrowTypeBasedOnAssignment(target, annotationType, typeResult);
+                                typeResult = narrowTypeBasedOnAssignment(annotationType, typeResult);
                             }
                         }
                     }
@@ -3958,8 +3962,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             if (isModuleGetAttrSupported) {
                                 const getAttrTypeResult = getEffectiveTypeOfSymbolForUsage(getAttrSymbol);
                                 if ((0, types_1.isFunction)(getAttrTypeResult.type)) {
-                                    type = getEffectiveReturnType(getAttrTypeResult.type);
-                                    if (getAttrTypeResult.isIncomplete) {
+                                    const returnTypeResult = getEffectiveReturnTypeResult(getAttrTypeResult.type);
+                                    type = returnTypeResult.type;
+                                    if (getAttrTypeResult.isIncomplete || returnTypeResult.isIncomplete) {
                                         isIncomplete = true;
                                     }
                                 }
@@ -4310,7 +4315,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // descriptor-based accesses.
                 narrowedTypeForSet = isDescriptorApplied
                     ? usage.setType.type
-                    : narrowTypeBasedOnAssignment(errorNode, type, usage.setType).type;
+                    : narrowTypeBasedOnAssignment(type, usage.setType).type;
             }
             // Verify that the assigned type is compatible.
             if (!assignType(type, usage.setType.type, diag?.createAddendum())) {
@@ -6399,7 +6404,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
         const returnTypes = [];
-        const matchedOverloads = [];
+        let matchedOverloads = [];
         let isTypeIncomplete = false;
         let overloadsUsedForCall = [];
         let isDefinitiveMatchFound = false;
@@ -6447,10 +6452,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         argResults: callResult.argResults ?? [],
                     };
                     matchedOverloads.push(matchedOverloadInfo);
-                    if (callResult.anyOrUnknownArg) {
+                    if (callResult.anyOrUnknownArg || matchResults.unpackedArgOfUnknownLength) {
                         possibleMatchResults.push(matchedOverloadInfo);
-                        if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
-                            possibleMatchInvolvesIncompleteUnknown = true;
+                        if (callResult.anyOrUnknownArg) {
+                            if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArg)) {
+                                possibleMatchInvolvesIncompleteUnknown = true;
+                            }
                         }
                     }
                     else {
@@ -6466,11 +6473,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Unknown, but include the "possible types" to allow for completion
             // suggestions.
             if (!isDefinitiveMatchFound && possibleMatchResults.length > 0) {
+                possibleMatchResults = filterOverloadMatchesForUnpackedArgs(possibleMatchResults);
                 possibleMatchResults = filterOverloadMatchesForAnyArgs(possibleMatchResults);
                 // 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);
+                    matchedOverloads = [possibleMatchResults[0]];
                 }
                 else {
                     // Eliminate any return types that are subsumed by other return types.
@@ -6551,21 +6560,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             overloadsUsedForCall,
         };
     }
-    // This function determines whether multiple incompatible overloads match
+    // Determines whether one or more overloads can be eliminated because they
+    // rely on an unpacked argument of unknown length when there is at least
+    // one overload that doesn't because it maps to an *args parameter.
+    function filterOverloadMatchesForUnpackedArgs(matches) {
+        if (matches.length < 2) {
+            return matches;
+        }
+        // Is there at least one overload that relies on unpacked args for a match?
+        const unpackedArgsOverloads = matches.filter((match) => match.matchResults.unpackedArgMapsToVariadic);
+        if (unpackedArgsOverloads.length === matches.length || unpackedArgsOverloads.length === 0) {
+            return matches;
+        }
+        return unpackedArgsOverloads;
+    }
+    // Determines whether multiple incompatible overloads match
     // due to an Any or Unknown argument type.
     function filterOverloadMatchesForAnyArgs(matches) {
         if (matches.length < 2) {
             return matches;
         }
-        // If the relevance of some matches differs, filter out the ones that
-        // are lower relevance. This favors *args parameters in cases where
-        // a *args argument is used.
-        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
-            matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
-            if (matches.length < 2) {
-                return matches;
-            }
-        }
         // 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]];
@@ -6599,7 +6613,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     function getBestOverloadForArgs(errorNode, typeResult, argList) {
         let overloadIndex = 0;
-        let matches = [];
+        const matches = [];
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         useSignatureTracker(errorNode, () => {
             // Create a list of potential overload matches based on arguments.
@@ -6613,7 +6627,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
             });
         });
-        matches = sortOverloadsByBestMatch(matches);
         let winningOverloadIndex;
         matches.forEach((match, matchIndex) => {
             if (winningOverloadIndex === undefined) {
@@ -6628,17 +6641,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return winningOverloadIndex === undefined ? undefined : matches[winningOverloadIndex].overload;
     }
-    // Sorts the list of overloads based first on "relevance" and second on order.
-    function sortOverloadsByBestMatch(matches) {
-        return matches.sort((a, b) => {
-            if (a.relevance !== b.relevance) {
-                return b.relevance - a.relevance;
-            }
-            return a.overloadIndex - b.overloadIndex;
-        });
-    }
     function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
-        let filteredMatchResults = [];
+        const filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         const type = typeResult.type;
@@ -6661,7 +6665,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 overloadIndex++;
             });
         });
-        filteredMatchResults = sortOverloadsByBestMatch(filteredMatchResults);
         // If there are no possible arg/param matches among the overloads,
         // emit an error that includes the argument types.
         if (filteredMatchResults.length === 0) {
@@ -6904,11 +6907,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
             case 2 /* TypeCategory.Any */: {
-                // Touch all of the args so they're marked accessed. Don't bother
-                // doing this if the call type is incomplete because this will need
-                // to be done again once it is complete.
-                touchArgTypes();
-                return { returnType: expandedCallType };
+                // Create a dummy callable that accepts all arguments and validate
+                // that the argument expressions are valid.
+                const dummyFunctionType = types_1.FunctionType.createInstance('', '', '', 0 /* FunctionTypeFlags.None */);
+                types_1.FunctionType.addDefaultParams(dummyFunctionType);
+                const dummyCallResult = validateCallForFunction(errorNode, argList, dummyFunctionType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
+                return { ...dummyCallResult, returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
                 return validateCallForFunction(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext);
@@ -6919,6 +6923,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 6 /* TypeCategory.Class */: {
                 if ((0, typeUtils_1.isNoneInstance)(expandedCallType)) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOptionalCall, localize_1.LocMessage.noneNotCallable(), errorNode);
+                    touchArgTypes();
                     return { argumentErrors: true };
                 }
                 if (types_1.TypeBase.isInstantiable(expandedCallType)) {
@@ -6935,6 +6940,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             case 7 /* TypeCategory.Module */: {
                 addDiagnostic(diagnosticRules_1.DiagnosticRule.reportCallIssue, localize_1.LocMessage.moduleNotCallable(), errorNode);
+                touchArgTypes();
                 return { argumentErrors: true };
             }
         }
@@ -7397,25 +7403,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload, { disallowExtraKwargsForTd: true });
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
         let argIndex = 0;
-        let matchedUnpackedListOfUnknownLength = false;
+        let unpackedArgOfUnknownLength = false;
+        let unpackedArgMapsToVariadic = false;
         let reportedArgError = false;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         let isTypeVarTupleFullyMatched = false;
         // Expand any unpacked tuples in the arg list.
         argList = expandArgList(argList);
-        // Build a map of parameters by name.
-        const paramMap = new Map();
-        paramDetails.params.forEach((paramInfo) => {
-            (0, debug_1.assert)(paramInfo !== undefined, 'paramInfo is undefined for param name map');
-            const param = paramInfo.param;
-            if (param.name && param.category === 0 /* ParamCategory.Simple */ && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                let argsNeeded = paramMap.get(param.name)?.argsNeeded ?? 0;
-                if (param.category === 0 /* ParamCategory.Simple */ && !paramInfo.defaultType) {
-                    argsNeeded += 1;
-                }
-                paramMap.set(param.name, { argsNeeded, argsReceived: 0 });
-            }
-        });
+        // Construct an object that racks which parameters have been assigned arguments.
+        const paramTracker = new parameterUtils_1.ParamAssignmentTracker(paramDetails.params);
         let positionalOnlyLimitIndex = paramDetails.positionOnlyParamCount;
         let positionParamLimitIndex = paramDetails.firstKeywordOnlyIndex ?? paramDetails.params.length;
         const varArgListParamIndex = paramDetails.argsIndex;
@@ -7534,6 +7530,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             argType.priv.tupleTypeArgs.length > 0) {
                             tooManyPositionals = true;
                         }
+                        else {
+                            unpackedArgOfUnknownLength = true;
+                        }
                     }
                     else {
                         tooManyPositionals = true;
@@ -7563,6 +7562,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 let isArgCompatibleWithVariadic = false;
                 const argTypeResult = getTypeOfArg(argList[argIndex], /* inferenceContext */ undefined);
                 let listElementType;
+                let enforceIterable = false;
                 let advanceToNextArg = false;
                 // Handle the case where *args is being passed to a function defined
                 // with a ParamSpec and a Concatenate operator. PEP 612 indicates that
@@ -7622,8 +7622,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     listElementType = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
                     /* emitNotIterableError */ false)?.type;
+                    if (!listElementType) {
+                        enforceIterable = true;
+                    }
+                    unpackedArgOfUnknownLength = true;
                     if (paramInfo.param.category === 1 /* ParamCategory.ArgsList */) {
-                        matchedUnpackedListOfUnknownLength = true;
+                        unpackedArgMapsToVariadic = true;
                     }
                     if (isParamVariadic && listElementType) {
                         isArgCompatibleWithVariadic = true;
@@ -7636,7 +7640,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         argCategory: 0 /* ArgCategory.Simple */,
                         typeResult: { type: listElementType, isIncomplete: argTypeResult.isIncomplete },
                     }
-                    : { ...argList[argIndex] };
+                    : { ...argList[argIndex], enforceIterable };
                 if (argTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -7667,10 +7671,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 trySetActive(argList[argIndex], paramDetails.params[paramIndex].param);
                 // Note that the parameter has received an argument.
-                if (paramName &&
-                    paramDetails.params[paramIndex].param.category === 0 /* ParamCategory.Simple */ &&
-                    paramMap.has(paramName)) {
-                    paramMap.get(paramName).argsReceived++;
+                if (paramName && paramDetails.params[paramIndex].param.category === 0 /* ParamCategory.Simple */) {
+                    paramTracker.markArgReceived(paramInfo);
                 }
                 if (advanceToNextArg || paramDetails.params[paramIndex].param.category === 1 /* ParamCategory.ArgsList */) {
                     argIndex++;
@@ -7739,9 +7741,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 });
                 trySetActive(argList[argIndex], paramInfo.param);
                 // Note that the parameter has received an argument.
-                if (paramName && paramMap.has(paramName) && paramInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                    paramMap.get(paramName).argsReceived++;
-                }
+                paramTracker.markArgReceived(paramInfo);
                 argIndex++;
                 paramIndex++;
             }
@@ -7815,7 +7815,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, argType);
                         const diag = new diagnostic_1.DiagnosticAddendum();
                         tdEntries.knownItems.forEach((entry, name) => {
-                            const paramEntry = paramMap.get(name);
+                            const paramEntry = paramTracker.lookupName(name);
                             if (paramEntry) {
                                 if (paramEntry.argsReceived > 0) {
                                     diag.addMessage(localize_1.LocMessage.paramAlreadyAssigned().format({ name }));
@@ -7852,10 +7852,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     paramName: name,
                                 });
                                 // Remember that this parameter has already received a value.
-                                paramMap.set(name, {
-                                    argsNeeded: 1,
-                                    argsReceived: 1,
-                                });
+                                paramTracker.addKeywordParam(name, paramDetails.params[paramDetails.kwargsIndex]);
                             }
                             else {
                                 // If the function doesn't have a **kwargs parameter, we need to emit an error.
@@ -7941,6 +7938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     unpackedDictArgType = types_1.UnknownType.create();
                                 }
                             }
+                            unpackedArgOfUnknownLength = true;
                             if (paramDetails.kwargsIndex !== undefined && unpackedDictArgType) {
                                 const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
                                 validateArgTypeParams.push({
@@ -7952,6 +7950,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     errorNode: argList[argIndex].valueExpression || errorNode,
                                     paramName: paramDetails.params[paramDetails.kwargsIndex].param.name,
                                 });
+                                unpackedArgMapsToVariadic = true;
                             }
                             if (!isValidMappingType) {
                                 if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -7972,7 +7971,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const paramName = argList[argIndex].name;
                     if (paramName) {
                         const paramNameValue = paramName.d.value;
-                        const paramEntry = paramMap.get(paramNameValue);
+                        const paramEntry = paramTracker.lookupName(paramNameValue);
                         if (paramEntry) {
                             if (paramEntry.argsReceived > 0) {
                                 if (!canSkipDiagnosticForNode(errorNode) && !isTypeIncomplete) {
@@ -8017,12 +8016,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     errorNode: argList[argIndex].valueExpression ?? errorNode,
                                     paramName: paramNameValue,
                                 });
-                                // Remember that this parameter has already received a value.
-                                paramMap.set(paramNameValue, {
-                                    argsNeeded: 1,
-                                    argsReceived: 1,
-                                });
                                 (0, debug_1.assert)(paramDetails.params[paramDetails.kwargsIndex], 'paramDetails.kwargsIndex params entry is undefined');
+                                // Remember that this parameter has already received a value.
+                                paramTracker.addKeywordParam(paramNameValue, paramDetails.params[paramDetails.kwargsIndex]);
                             }
                             trySetActive(argList[argIndex], paramDetails.params[paramDetails.kwargsIndex].param);
                         }
@@ -8083,8 +8079,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (paramIndex >= paramDetails.firstPositionOrKeywordIndex &&
                         param.category === 0 /* ParamCategory.Simple */ &&
                         param.name &&
-                        paramMap.has(param.name) &&
-                        paramMap.get(param.name).argsReceived === 0) {
+                        paramTracker.lookupDetails(paramInfo).argsReceived === 0) {
                         const paramType = paramDetails.params[paramIndex].type;
                         if (!unpackedDictKeyNames || unpackedDictKeyNames.includes(param.name)) {
                             validateArgTypeParams.push({
@@ -8100,7 +8095,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 paramName: param.name,
                                 isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param),
                             });
-                            paramMap.get(param.name).argsReceived = 1;
+                            paramTracker.markArgReceived(paramDetails.params[paramIndex]);
                         }
                     }
                 });
@@ -8110,10 +8105,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // (i.e. an arg starting with a "**"), we will assume that all parameters
             // are matched.
             if (!unpackedDictArgType && !types_1.FunctionType.isDefaultParamCheckDisabled(overload)) {
-                const unassignedParams = Array.from(paramMap.keys()).filter((name) => {
-                    const entry = paramMap.get(name);
-                    return !entry || entry.argsReceived < entry.argsNeeded;
-                });
+                const unassignedParams = paramTracker.getUnassignedParams();
                 if (unassignedParams.length > 0) {
                     if (!canSkipDiagnosticForNode(errorNode)) {
                         const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
@@ -8133,8 +8125,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 paramDetails.params.forEach((paramInfo) => {
                     const param = paramInfo.param;
                     if (param.category === 0 /* ParamCategory.Simple */ && param.name) {
-                        const entry = paramMap.get(param.name);
-                        if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0) {
+                        const entry = paramTracker.lookupDetails(paramInfo);
+                        if (entry.argsNeeded === 0 && entry.argsReceived === 0) {
                             const defaultArgType = paramInfo.defaultType;
                             if (defaultArgType &&
                                 !(0, typeUtils_1.isEllipsisType)(defaultArgType) &&
@@ -8225,13 +8217,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        let relevance = 0;
-        if (matchedUnpackedListOfUnknownLength) {
-            // Increase the relevance if we made assumptions about the length
-            // of an unpacked argument. This will favor overloads that
-            // associate this case with a *args parameter.
-            relevance++;
-        }
         // Special-case the builtin isinstance and issubclass functions.
         if (types_1.FunctionType.isBuiltIn(overload, ['isinstance', 'issubclass']) && validateArgTypeParams.length === 2) {
             validateArgTypeParams[1].isinstanceParam = true;
@@ -8245,7 +8230,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             paramSpecTarget,
             paramSpecArgList,
             activeParam,
-            relevance,
+            unpackedArgOfUnknownLength,
+            unpackedArgMapsToVariadic,
             argumentMatchScore: 0,
         };
     }
@@ -8500,9 +8486,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         // Calculate the return type.
-        let returnType = getEffectiveReturnType(type, {
+        const returnTypeResult = getEffectiveReturnTypeResult(type, {
             callSiteInfo: { args: matchResults.argParams, errorNode },
         });
+        let returnType = returnTypeResult.type;
+        if (returnTypeResult.isIncomplete) {
+            isTypeIncomplete = true;
+        }
         if (condition.length > 0) {
             returnType = types_1.TypeBase.cloneForCondition(returnType, condition);
         }
@@ -8776,13 +8766,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     : 16 /* EvalFlags.NoFinal */ | 2 /* EvalFlags.NoSpecialize */;
                 const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!typeResult?.isIncomplete));
                 argType = exprTypeResult.type;
+                // If the argument is unpacked and we are supposed to enforce
+                // that it's an iterator, do so now.
+                if (argParam.argument.argCategory === 1 /* ArgCategory.UnpackedList */ && argParam.argument.enforceIterable) {
+                    const iteratorType = getTypeOfIterator(exprTypeResult, 
+                    /* isAsync */ false, argParam.argument.valueExpression);
+                    // Try to prevent cascading errors if it was not iterable.
+                    argType = iteratorType?.type ?? types_1.UnknownType.create();
+                }
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
-                if (exprTypeResult.typeErrors) {
-                    isCompatible = false;
-                }
-                else if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
+                if (expectedType && (0, typeUtils_1.requiresSpecialization)(expectedType)) {
                     // Assign the argument type back to the expected type to assign
                     // values to any unification variables.
                     const clonedConstraints = constraints.clone();
@@ -10413,7 +10408,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 : undefined, () => {
                 const returnTypeResult = getTypeOfExpression(node.d.expr, 
                 /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
-                functionType.priv.inferredReturnType = {
+                functionType.shared.inferredReturnType = {
                     type: returnTypeResult.type,
                 };
                 if (returnTypeResult.isIncomplete) {
@@ -13559,7 +13554,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
         else {
-            awaitableFunctionType.priv.inferredReturnType = {
+            awaitableFunctionType.shared.inferredReturnType = {
                 type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType)),
             };
         }
@@ -15737,11 +15732,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (declaration.intrinsicType === 'int') {
                         return { type: intType };
                     }
-                    if (declaration.intrinsicType === 'Iterable[str]') {
-                        const iterableType = getBuiltInType(declaration.node, 'Iterable');
-                        if ((0, types_1.isInstantiableClass)(iterableType)) {
+                    if (declaration.intrinsicType === 'MutableSequence[str]') {
+                        const sequenceType = getBuiltInType(declaration.node, 'MutableSequence');
+                        if ((0, types_1.isInstantiableClass)(sequenceType)) {
                             return {
-                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(iterableType, [strType])),
+                                type: types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(sequenceType, [strType])),
                             };
                         }
                     }
@@ -16014,18 +16009,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if (loaderActions.implicitImports) {
                 loaderActions.implicitImports.forEach((implicitImport, name) => {
+                    const existingLoaderField = moduleType.priv.loaderFields.get(name);
                     // Recursively apply loader actions.
                     let symbolType;
                     if (implicitImport.isUnresolved) {
                         symbolType = types_1.UnknownType.create();
                     }
                     else {
-                        const moduleName = moduleType.priv.moduleName ? moduleType.priv.moduleName + '.' + name : '';
-                        const importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                        let importedModuleType;
+                        const existingType = existingLoaderField?.getSynthesizedType();
+                        if (existingType?.type && (0, types_1.isModule)(existingType.type)) {
+                            importedModuleType = existingType.type;
+                        }
+                        else {
+                            const moduleName = moduleType.priv.moduleName
+                                ? moduleType.priv.moduleName + '.' + name
+                                : '';
+                            importedModuleType = types_1.ModuleType.create(moduleName, implicitImport.uri);
+                        }
                         symbolType = applyLoaderActionsToModuleType(importedModuleType, implicitImport, importLookup);
                     }
-                    const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
-                    moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+                    if (!existingLoaderField) {
+                        const importedModuleSymbol = symbol_1.Symbol.createWithType(0 /* SymbolFlags.None */, symbolType);
+                        moduleType.priv.loaderFields.set(name, importedModuleSymbol);
+                    }
                 });
             }
             return moduleType;
@@ -16034,15 +16041,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // is pointing at a module, and we need to synthesize a
         // module type.
         if (resolvedDecl.type === 8 /* DeclarationType.Alias */) {
-            // Build a module type that corresponds to the declaration and
-            // its associated loader actions.
-            const moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
-            if (resolvedDecl.symbolName && resolvedDecl.submoduleFallback) {
-                return applyLoaderActionsToModuleType(moduleType, resolvedDecl.submoduleFallback, importLookup);
+            let moduleType;
+            // See if this is an import that shares a ModuleType with another
+            // import statement. If so, used the cached type. This happens when
+            // multiple import statements start with the same module name, such
+            // as "import a.b" and "import a.c".
+            if (resolvedDecl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
+                const cachedType = readTypeCache(resolvedDecl.node.d.module, 0 /* EvalFlags.None */);
+                if (cachedType && (0, types_1.isModule)(cachedType)) {
+                    moduleType = cachedType;
+                }
             }
-            else {
-                return applyLoaderActionsToModuleType(moduleType, resolvedDecl, importLookup);
+            if (!moduleType) {
+                // Build a module type that corresponds to the declaration and
+                // its associated loader actions.
+                moduleType = types_1.ModuleType.create(resolvedDecl.moduleName, resolvedDecl.uri);
+                if (resolvedDecl.node.nodeType === 24 /* ParseNodeType.ImportAs */) {
+                    writeTypeCache(resolvedDecl.node.d.module, { type: moduleType }, 0 /* EvalFlags.None */);
+                }
             }
+            return applyLoaderActionsToModuleType(moduleType, resolvedDecl.symbolName && resolvedDecl.submoduleFallback
+                ? resolvedDecl.submoduleFallback
+                : resolvedDecl, importLookup);
         }
         const declaredType = getTypeForDeclaration(resolvedDecl);
         if (declaredType.type) {
@@ -16598,38 +16618,49 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
     }
+    function getEffectiveReturnType(type) {
+        return getEffectiveReturnTypeResult(type).type;
+    }
+    function getInferredReturnType(type) {
+        return getInferredReturnTypeResult(type).type;
+    }
     // Returns the return type of the function. If the type is explicitly provided in
     // a type annotation, that type is returned. If not, an attempt is made to infer
     // the return type. If a list of args is provided, the inference logic may take
     // into account argument types to infer the return type.
-    function getEffectiveReturnType(type, options) {
+    function getEffectiveReturnTypeResult(type, options) {
         const specializedReturnType = types_1.FunctionType.getEffectiveReturnType(type, /* includeInferred */ false);
         if (specializedReturnType && !(0, types_1.isUnknown)(specializedReturnType)) {
-            return specializedReturnType;
+            return { type: specializedReturnType };
         }
-        return getInferredReturnType(type, options?.callSiteInfo);
+        return getInferredReturnTypeResult(type, options?.callSiteInfo);
     }
-    function _getInferredReturnType(type, callSiteInfo) {
+    function _getInferredReturnTypeResult(type, callSiteInfo) {
         let returnType;
         let isIncomplete = false;
         const analyzeUnannotatedFunctions = true;
         // Don't attempt to infer the return type for a stub file.
         if (types_1.FunctionType.isStubDefinition(type)) {
-            return types_1.UnknownType.create();
+            return { type: types_1.UnknownType.create() };
         }
         // Don't infer the return type for a ParamSpec value.
         if (types_1.FunctionType.isParamSpecValue(type)) {
-            return types_1.UnknownType.create();
+            return { type: types_1.UnknownType.create() };
         }
         // Don't infer the return type for an overloaded function (unless it's synthesized,
         // which is needed for proper operation of the __get__ method in properties).
         if (types_1.FunctionType.isOverloaded(type) && !types_1.FunctionType.isSynthesizedMethod(type)) {
-            return types_1.UnknownType.create();
+            return { type: types_1.UnknownType.create() };
         }
+        const evalCount = type.shared.inferredReturnType?.evaluationCount ?? 0;
         // If the return type has already been lazily evaluated,
         // don't bother computing it again.
-        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
-            returnType = type.priv.inferredReturnType.type;
+        if (type.shared.inferredReturnType && !type.shared.inferredReturnType.isIncomplete) {
+            returnType = type.shared.inferredReturnType.type;
+        }
+        else if (evalCount > maxReturnTypeInferenceAttempts) {
+            // Detect a case where a return type won't converge because of recursion.
+            returnType = types_1.UnknownType.create();
         }
         else {
             // Don't bother inferring the return type of __init__ because it's
@@ -16676,7 +16707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
             // Cache the type for next time.
-            type.priv.inferredReturnType = { type: returnType, isIncomplete };
+            type.shared.inferredReturnType = { type: returnType, isIncomplete, evaluationCount: evalCount + 1 };
         }
         // If the type is partially unknown and the function has one or more unannotated
         // params, try to analyze the function with the provided argument types and
@@ -16713,7 +16744,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
-        return returnType;
+        return { type: returnType, isIncomplete };
     }
     function inferReturnTypeForCallSite(type, callSiteInfo) {
         const args = callSiteInfo.args;
@@ -18243,8 +18274,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     }
     // Determines whether the two types are potentially comparable -- i.e.
     // their types overlap in such a way that it makes sense for them to
-    // be compared with an == or != operator.
-    function isTypeComparable(leftType, rightType) {
+    // be compared with an == or != operator. The functional also supports
+    // a special variant that can be used for the "is" and "is not" operator.
+    // This variant can be less conservative in some cases.
+    function isTypeComparable(leftType, rightType, assumeIsOperator = false) {
         if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
             return true;
         }
@@ -18284,6 +18317,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
                     return true;
                 }
+                // Check for the "is None" or "is not None" case.
+                if (assumeIsOperator && (0, typeUtils_1.isNoneInstance)(rightType)) {
+                    if ((0, typeUtils_1.isNoneInstance)(leftType)) {
+                        return true;
+                    }
+                    // The LHS could be a protocol or 'object', in which case None is
+                    // potentially comparable to it. In other cases, None is not comparable
+                    // because the types are disjoint.
+                    return assignType(leftType, rightType);
+                }
                 // Assume that if the types are disjoint and built-in classes that they
                 // will never be comparable.
                 if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
@@ -19197,72 +19240,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return canAssign;
     }
-    // If the declaredType contains type arguments that are "Any" and
-    // the corresponding type argument in the assignedType is not "Any",
-    // replace that type argument in the assigned type. This function assumes
-    // that the caller has already verified that the assignedType is assignable
-    // to the declaredType.
-    function replaceTypeArgsWithAny(node, declaredType, assignedType, recursionCount = 0) {
-        if (recursionCount > types_1.maxTypeRecursionCount) {
-            return undefined;
-        }
-        recursionCount++;
-        if (assignedType.shared.typeParams.length > 0 &&
-            assignedType.priv.typeArgs &&
-            assignedType.priv.typeArgs.length <= assignedType.shared.typeParams.length &&
-            !assignedType.priv.tupleTypeArgs) {
-            const constraints = new constraintTracker_1.ConstraintTracker();
-            (0, constraintSolver_1.addConstraintsForExpectedType)(evaluatorInterface, types_1.ClassType.specialize(assignedType, /* typeArgs */ undefined), declaredType, constraints, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
-            let replacedTypeArg = false;
-            const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints).getMainSolutionSet();
-            const newTypeArgs = assignedType.priv.typeArgs.map((typeArg, index) => {
-                const typeParam = assignedType.shared.typeParams[index];
-                const expectedTypeArgType = solution.getType(typeParam);
-                if (expectedTypeArgType) {
-                    if ((0, types_1.isAnyOrUnknown)(expectedTypeArgType) || (0, types_1.isAnyOrUnknown)(typeArg)) {
-                        replacedTypeArg = true;
-                        return expectedTypeArgType;
-                    }
-                    if ((0, types_1.isClassInstance)(expectedTypeArgType) && (0, types_1.isClassInstance)(typeArg)) {
-                        // Recursively replace Any in the type argument.
-                        const recursiveReplacement = replaceTypeArgsWithAny(node, expectedTypeArgType, typeArg, recursionCount);
-                        if (recursiveReplacement) {
-                            replacedTypeArg = true;
-                            return recursiveReplacement;
-                        }
-                    }
-                    else if ((0, typeUtils_1.containsAnyRecursive)(expectedTypeArgType)) {
-                        // If the expected type arg contains an Any, we can replace it with
-                        // a version that doesn't contain Any if the replacement doesn't violate
-                        // the variance of the type parameter.
-                        const variance = types_1.TypeVarType.getVariance(typeParam);
-                        const isSubtype = assignType(expectedTypeArgType, typeArg);
-                        const isSupertype = assignType(typeArg, expectedTypeArgType);
-                        if ((variance === 4 /* Variance.Contravariant */ || isSubtype) &&
-                            (variance === 3 /* Variance.Covariant */ || isSupertype)) {
-                            replacedTypeArg = true;
-                            return expectedTypeArgType;
-                        }
-                    }
-                }
-                return typeArg;
-            });
-            if (replacedTypeArg) {
-                return types_1.ClassType.specialize(assignedType, newTypeArgs);
-            }
-        }
-        // If the declared and assigned types are the same generic type but the assigned type
-        // contains one or more unknowns, use the declared type instead.
-        if (types_1.ClassType.isSameGenericClass(declaredType, assignedType)) {
-            if ((0, typeUtils_1.containsAnyRecursive)(assignedType) && !(0, typeUtils_1.containsAnyRecursive)(declaredType)) {
-                return declaredType;
-            }
-        }
-        return undefined;
-    }
     // When a value is assigned to a variable with a declared type,
     // we may be able to narrow the type based on the assignment.
-    function narrowTypeBasedOnAssignment(node, declaredType, assignedTypeResult) {
+    function narrowTypeBasedOnAssignment(declaredType, assignedTypeResult) {
         // TODO: The rules for narrowing types on assignment are not defined in
         // the typing spec. Pyright's current logic is currently not even internally
         // consistent and probably not sound from a type theory perspective. It
@@ -19278,46 +19258,36 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             const narrowedSubtype = (0, typeUtils_1.mapSubtypes)(declaredType, (declaredSubtype) => {
-                // We can't narrow "Any".
-                if ((0, types_1.isAnyOrUnknown)(declaredSubtype)) {
-                    return declaredSubtype;
+                if (!assignType(declaredSubtype, assignedSubtype)) {
+                    return undefined;
                 }
-                if (assignType(declaredSubtype, assignedSubtype)) {
-                    // If the assigned subtype is Any, stick with the declared type.
-                    if ((0, types_1.isAny)(assignedSubtype)) {
-                        return declaredSubtype;
-                    }
-                    if ((0, types_1.isClass)(declaredSubtype) &&
-                        (0, types_1.isClass)(assignedSubtype) &&
-                        types_1.TypeBase.isInstance(declaredSubtype) === types_1.TypeBase.isInstance(assignedSubtype)) {
-                        const result = replaceTypeArgsWithAny(node, declaredSubtype, assignedSubtype);
-                        if (result) {
-                            assignedSubtype = result;
-                        }
+                // Retain unknowns for code flow analysis convergence and for
+                // unknown type reporting in strict mode.
+                if ((0, types_1.isUnknown)(assignedSubtype)) {
+                    return assignedSubtype;
+                }
+                // If the two types are bidirectionally assignable, they are
+                // either equivalent (in which case it doesn't matter which
+                // one we choose) or one or both include gradual types (Any, etc.),
+                // in which case we'll want to stick with the declared subtype.
+                if (assignType(assignedSubtype, declaredSubtype)) {
+                    // We need to be careful with TypedDict types that have
+                    // narrowed fields. In this case, we want to return the
+                    // assigned type.
+                    if ((0, types_1.isClass)(assignedSubtype) &&
+                        assignedSubtype.priv.typedDictNarrowedEntries &&
+                        (0, types_1.isTypeSame)(assignedSubtype, declaredSubtype, { ignoreTypedDictNarrowEntries: true })) {
                         return assignedSubtype;
                     }
-                    if (!(0, types_1.isTypeVar)(declaredSubtype) &&
-                        (0, types_1.isTypeVar)(assignedSubtype) &&
-                        !types_1.TypeVarType.isBound(assignedSubtype)) {
-                        // If the source is an unsolved TypeVar but the declared type is concrete,
-                        // use the concrete type.
-                        return declaredSubtype;
-                    }
-                    // If the declared type doesn't contain any `Any` but the assigned
-                    // type does, stick with the declared type. We don't include unknowns
-                    // in the assigned subtype check here so unknowns are preserved so
-                    // reportUnknownVariableType assignment diagnostics are reported.
-                    // TODO - this is an inconsistency because Any and Unknown should
-                    // always be treated the same for purposes of type narrowing. This
-                    // should be revisited once the narrowing-on-assignment behavior
-                    // is properly specified in the typing spec.
-                    if ((0, typeUtils_1.containsAnyRecursive)(assignedSubtype, /* includeUnknown */ false) &&
-                        !(0, typeUtils_1.containsAnyRecursive)(declaredSubtype)) {
-                        return declaredSubtype;
+                    // We also need to be careful with callback protocols.
+                    if ((0, types_1.isClassInstance)(declaredSubtype) && types_1.ClassType.isProtocolClass(declaredSubtype)) {
+                        if ((0, types_1.isFunction)(assignedSubtype) || (0, types_1.isOverloaded)(assignedSubtype)) {
+                            return assignedSubtype;
+                        }
                     }
-                    return assignedSubtype;
+                    return declaredSubtype;
                 }
-                return undefined;
+                return assignedSubtype;
             });
             // If we couldn't assign the assigned subtype any of the declared
             // subtypes, the types are incompatible. Return the unnarrowed form.
@@ -19332,12 +19302,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // with the declared type. In strict mode, this will retain the "unknown type"
         // diagnostics while still providing reasonable completion suggestions.
         if ((0, typeUtils_1.isIncompleteUnknown)(narrowedType)) {
-            return { type: narrowedType };
+            return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
         }
         else if ((0, types_1.isUnknown)(narrowedType)) {
-            return { type: (0, types_1.combineTypes)([narrowedType, declaredType]) };
+            return { type: (0, types_1.combineTypes)([narrowedType, declaredType]), isIncomplete: assignedTypeResult.isIncomplete };
         }
-        return { type: narrowedType };
+        return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
     }
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.
@@ -19860,6 +19830,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (!baseType) {
                 return types_1.FunctionType.clone(functionType, /* stripFirstParam */ true);
             }
+            // If the first parameter was already stripped, it has already been
+            // bound. Don't attempt to rebind.
+            if (functionType.priv.strippedFirstParamType) {
+                return functionType;
+            }
             if (types_1.FunctionType.isInstanceMethod(functionType)) {
                 // If the baseType is a metaclass, don't specialize the function.
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
@@ -19917,6 +19892,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     const subDiag = diag?.createAddendum();
+                    // Protect against the case where a callback protocol is being
+                    // bound to its own __call__ method but the first parameter
+                    // is annotated with its own callable type. This can lead to
+                    // infinite recursion.
+                    if ((0, types_1.isFunction)(memberTypeFirstParamType) || (0, types_1.isOverloaded)(memberTypeFirstParamType)) {
+                        if ((0, types_1.isClassInstance)(firstParamType) && types_1.ClassType.isProtocolClass(firstParamType)) {
+                            if (subDiag) {
+                                subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                                    type: printType(firstParamType),
+                                    methodName: memberType.shared.name || '<anonymous>',
+                                    paramName: memberTypeFirstParam.name || '__p0',
+                                }));
+                            }
+                            return undefined;
+                        }
+                    }
                     if (!assignType(memberTypeFirstParamType, firstParamType, subDiag?.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
                         if (memberTypeFirstParam.name &&
                             !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
@@ -20195,7 +20186,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return codeFlowEngine.printControlFlowGraph(flowNode, reference, callName, logger);
     }
     // Track these apis internal usages when logging is on. otherwise, it should be noop.
-    const getInferredReturnType = wrapWithLogger(_getInferredReturnType);
+    const getInferredReturnTypeResult = wrapWithLogger(_getInferredReturnTypeResult);
     const evaluatorInterface = {
         runWithCancellationToken,
         getType,