@zzzen/pyright-internal 1.2.0-dev.20250209 → 1.2.0-dev.20250223

package/dist/analyzer/typeEvaluator.js

@@ -86,6 +86,7 @@ const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
+const core_1 = require("../common/core");
 // This table contains the names of several built-in types that
 // are not subscriptable at runtime on older versions of Python.
 // It lists the first version of Python where subscripting is
@@ -199,12 +200,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const signatureTrackerStack = [];
     let prefetched;
     function runWithCancellationToken(token, callback) {
+        // Save the current token and restore it after the callback to support nested calls
+        const oldToken = cancellationToken;
+        let result = undefined;
         try {
             cancellationToken = token;
-            return callback();
+            result = callback();
+            if (!(0, core_1.isThenable)(result)) {
+                return result;
+            }
+            return result.finally(() => {
+                cancellationToken = oldToken;
+            });
         }
         finally {
-            cancellationToken = undefined;
+            if (!(0, core_1.isThenable)(result)) {
+                cancellationToken = oldToken;
+            }
         }
     }
     function checkForCancellation() {
@@ -590,7 +602,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Make sure the resulting type is assignable to the expected type.
                 if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
                 /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
-                    typeResult.typeErrors = true;
+                    // Set the typeErrors to true, but first make a copy of the
+                    // type result because the (non-error) version may already
+                    // be cached.
+                    typeResult = { ...typeResult, typeErrors: true };
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
                 }
@@ -2554,6 +2569,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             sourceEntryTypes.splice(unboundedIndex, 0, typeToReplicate);
                         }
                     }
+                    if (sourceEntryTypes.length > targetTypes.length) {
+                        // Remove elements to make the count match the target count.
+                        sourceEntryTypes.splice(unboundedIndex, 1);
+                    }
                 }
                 // If there's an unpack operator in the target and we have too many source elements,
                 // combine them to assign to the unpacked target.
@@ -7500,7 +7519,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 else {
                     let tooManyPositionals = false;
-                    if (foundUnpackedListArg && argList[argIndex].argCategory === 1 /* ArgCategory.UnpackedList */) {
+                    if (argList[argIndex].argCategory === 1 /* ArgCategory.UnpackedList */) {
                         // If this is an unpacked iterable, we will conservatively assume that it
                         // might have zero iterations unless we can tell from its type that it
                         // definitely has at least one iterable value.
@@ -7512,9 +7531,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             argType.priv.tupleTypeArgs.length > 0) {
                             tooManyPositionals = true;
                         }
-                        else {
-                            matchedUnpackedListOfUnknownLength = true;
-                        }
                     }
                     else {
                         tooManyPositionals = true;
@@ -7603,6 +7619,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     listElementType = getTypeOfIterator({ type: argType, isIncomplete: argTypeResult.isIncomplete }, 
                     /* isAsync */ false, errorNode, 
                     /* emitNotIterableError */ false)?.type;
+                    if (paramInfo.param.category === 1 /* ParamCategory.ArgsList */) {
+                        matchedUnpackedListOfUnknownLength = true;
+                    }
                 }
                 const funcArg = listElementType
                     ? {
@@ -8107,25 +8126,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     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 defaultArgType = paramInfo.defaultType;
-                            if (defaultArgType &&
-                                !(0, typeUtils_1.isEllipsisType)(defaultArgType) &&
-                                (0, typeUtils_1.requiresSpecialization)(paramInfo.declaredType)) {
-                                validateArgTypeParams.push({
-                                    paramCategory: param.category,
-                                    paramType: paramInfo.type,
-                                    requiresTypeVarMatching: true,
-                                    argument: {
-                                        argCategory: 0 /* ArgCategory.Simple */,
-                                        typeResult: { type: defaultArgType },
-                                    },
-                                    isDefaultArg: true,
-                                    errorNode,
-                                    paramName: param.name,
-                                    isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param),
-                                });
-                            }
+                        if (entry && entry.argsNeeded === 0 && entry.argsReceived === 0 && paramInfo.defaultType) {
+                            validateArgTypeParams.push({
+                                paramCategory: param.category,
+                                paramType: paramInfo.type,
+                                requiresTypeVarMatching: true,
+                                argument: {
+                                    argCategory: 0 /* ArgCategory.Simple */,
+                                    typeResult: { type: paramInfo.defaultType },
+                                },
+                                isDefaultArg: true,
+                                errorNode,
+                                paramName: param.name,
+                                isParamNameSynthesized: types_1.FunctionParam.isNameSynthesized(param),
+                            });
                         }
                     }
                 });
@@ -8200,10 +8214,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let relevance = 0;
         if (matchedUnpackedListOfUnknownLength) {
-            // Lower the relevance if we made assumptions about the length
+            // 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--;
+            relevance++;
         }
         // Special-case the builtin isinstance and issubclass functions.
         if (types_1.FunctionType.isBuiltIn(overload, ['isinstance', 'issubclass']) && validateArgTypeParams.length === 2) {
@@ -9245,6 +9259,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeMustBeAssigned(), errorNode);
             return undefined;
         }
+        const scope = ScopeUtils.getScopeForNode(errorNode);
+        if (scope) {
+            if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeBadScope(), errorNode.parent.d.leftExpr);
+            }
+        }
         const nameNode = errorNode.parent.d.leftExpr;
         const firstArg = argList[0];
         if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
@@ -10374,7 +10394,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 : undefined, () => {
                 const returnTypeResult = getTypeOfExpression(node.d.expr, 
                 /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
-                functionType.priv.inferredReturnType = returnTypeResult.type;
+                functionType.priv.inferredReturnType = {
+                    type: returnTypeResult.type,
+                };
                 if (returnTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -12253,16 +12275,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         else if (arg.d.name.d.value === 'total' && !constArgValue) {
                             classType.shared.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
                         }
-                        else if (arg.d.name.d.value === 'closed') {
+                        else if (arg.d.name.d.value === 'closed' &&
+                            AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                             if (constArgValue) {
-                                // This is an experimental feature because PEP 728 hasn't been accepted yet.
-                                if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                                    classType.shared.flags |=
-                                        8 /* ClassTypeFlags.TypedDictMarkedClosed */ |
-                                            16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
-                                    if (classType.shared.typedDictExtraItemsExpr) {
-                                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
-                                    }
+                                classType.shared.flags |=
+                                    8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                if (classType.shared.typedDictExtraItemsExpr) {
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                                 }
                             }
                             if (sawClosedOrExtraItems) {
@@ -12271,16 +12290,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             sawClosedOrExtraItems = true;
                         }
                     }
-                    else if (arg.d.name.d.value === 'extra_items') {
-                        // This is an experimental feature because PEP 728 hasn't been accepted yet.
-                        if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                            // Record a reference to the expression but don't evaluate it yet.
-                            // It may refer to the class itself.
-                            classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
-                            classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
-                            if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
-                            }
+                    else if (arg.d.name.d.value === 'extra_items' &&
+                        AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                        // Record a reference to the expression but don't evaluate it yet.
+                        // It may refer to the class itself.
+                        classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                        classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                        if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                         }
                         if (sawClosedOrExtraItems) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.d.valueExpr);
@@ -13534,7 +13551,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
         else {
-            awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+            awaitableFunctionType.priv.inferredReturnType = {
+                type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType)),
+            };
         }
         return awaitableFunctionType;
     }
@@ -16595,8 +16614,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the return type has already been lazily evaluated,
         // don't bother computing it again.
-        if (type.priv.inferredReturnType) {
-            returnType = type.priv.inferredReturnType;
+        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
+            returnType = type.priv.inferredReturnType.type;
         }
         else {
             // Don't bother inferring the return type of __init__ because it's
@@ -16643,9 +16662,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
             // Cache the type for next time.
-            if (!isIncomplete) {
-                type.priv.inferredReturnType = returnType;
-            }
+            type.priv.inferredReturnType = { type: returnType, isIncomplete };
         }
         // 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
@@ -16899,13 +16916,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!(0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, destType, srcType, diag, constraints, flags, recursionCount)) {
                     return false;
                 }
-                if (types_1.ClassType.isFinal(destType) !== types_1.ClassType.isFinal(srcType)) {
-                    diag?.addMessage(localize_1.LocAddendum.typedDictFinalMismatch().format({
-                        sourceType: printType((0, typeUtils_1.convertToInstance)(srcType)),
-                        destType: printType((0, typeUtils_1.convertToInstance)(destType)),
-                    }));
-                    return false;
-                }
                 // If invariance is being enforced, the two TypedDicts must be assignable to each other.
                 if ((flags & 1 /* AssignTypeFlags.Invariant */) !== 0) {
                     return (0, typedDicts_1.assignTypedDictToTypedDict)(evaluatorInterface, srcType, destType, 
@@ -17648,6 +17658,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
+            // Handle the TypeForm special form. Add a special case for
+            // type[T] to be assignable to TypeForm[T].
+            if (types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
+                const destTypeArg = destType.priv.typeArgs && destType.priv.typeArgs.length > 0
+                    ? destType.priv.typeArgs[0]
+                    : types_1.UnknownType.create();
+                let srcTypeArg;
+                if ((0, types_1.isClassInstance)(concreteSrcType) && types_1.ClassType.isBuiltIn(concreteSrcType, 'type')) {
+                    srcTypeArg = concreteSrcType;
+                }
+                else if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
+                    srcTypeArg = (0, typeUtils_1.convertToInstance)(concreteSrcType);
+                }
+                if (srcTypeArg) {
+                    return assignType(destTypeArg, srcTypeArg, diag, constraints, flags, recursionCount);
+                }
+            }
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
                 // Handle the case where the source is an unpacked tuple.
                 if (!destType.priv.isUnpacked &&
@@ -17791,7 +17818,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const typeVarSignatures = [];
                 overloads.forEach((overload) => {
                     const overloadScopeId = (0, typeUtils_1.getTypeVarScopeId)(overload) ?? '';
-                    const constraintsClone = constraints?.cloneWithSignature(overloadScopeId);
+                    const constraintsClone = constraints?.cloneWithSignature([overloadScopeId]);
                     if (assignType(destType, overload, /* diag */ undefined, constraintsClone, flags, recursionCount)) {
                         filteredOverloads.push(overload);
                         if (constraintsClone) {
@@ -17950,6 +17977,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if ((0, types_1.isTypeSame)(srcType, destType, {}, recursionCount)) {
             return true;
         }
+        if ((flags & 16 /* AssignTypeFlags.OverloadOverlap */) !== 0 &&
+            srcType.priv.subtypes.some((subtype) => (0, types_1.isAnyOrUnknown)(subtype))) {
+            return false;
+        }
         // Sort the subtypes so we have a deterministic order for unions.
         let sortedSrcTypes = (0, typeUtils_1.sortTypes)(srcType.priv.subtypes);
         let matchedSomeSubtypes = false;
@@ -18196,6 +18227,95 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             /* diag */ undefined, 
             /* constraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount));
     }
+    // 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) {
+        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
+            return true;
+        }
+        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
+            return false;
+        }
+        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
+            return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
+        }
+        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
+        if (isLeftCallable !== isRightCallable) {
+            return false;
+        }
+        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
+            if ((0, types_1.isInstantiableClass)(rightType) ||
+                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
+                if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            const metaclass = leftType.shared.effectiveMetaclass;
+            if (metaclass && (0, types_1.isClass)(metaclass)) {
+                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if ((0, types_1.isClassInstance)(leftType)) {
+            if ((0, types_1.isClass)(rightType)) {
+                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
+                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
+                if (assignType(genericLeftType, genericRightType) || assignType(genericRightType, genericLeftType)) {
+                    return true;
+                }
+                // 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)) {
+                    // We need to be careful with bool and int literals because
+                    // they are comparable under certain circumstances.
+                    let boolType;
+                    let intType;
+                    if (types_1.ClassType.isBuiltIn(leftType, 'bool') && types_1.ClassType.isBuiltIn(rightType, 'int')) {
+                        boolType = leftType;
+                        intType = rightType;
+                    }
+                    else if (types_1.ClassType.isBuiltIn(rightType, 'bool') && types_1.ClassType.isBuiltIn(leftType, 'int')) {
+                        boolType = rightType;
+                        intType = leftType;
+                    }
+                    if (boolType && intType) {
+                        const intVal = intType.priv?.literalValue;
+                        if (intVal === undefined) {
+                            return true;
+                        }
+                        if (intVal !== 0 && intVal !== 1) {
+                            return false;
+                        }
+                        const boolVal = boolType.priv?.literalValue;
+                        if (boolVal === undefined) {
+                            return true;
+                        }
+                        return boolVal === (intVal === 1);
+                    }
+                    return false;
+                }
+            }
+            // Does the class have an operator overload for eq?
+            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
+            if (eqMethod) {
+                // If this is a synthesized method for a dataclass, we can assume
+                // that other dataclass types will not be comparable.
+                if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
+                    return false;
+                }
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
     function assignToUnionType(destType, srcType, diag, constraints, flags, recursionCount) {
         // If we need to enforce invariance, the source needs to be compatible
         // with all subtypes in the dest, unless those subtypes are subclasses
@@ -18378,17 +18498,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         for (const mroClass of objType.shared.mro) {
             if ((0, types_1.isClass)(mroClass) && types_1.ClassType.isProtocolClass(mroClass)) {
                 for (const field of types_1.ClassType.getSymbolTable(mroClass)) {
-                    if (field[0] !== '__call__' && !field[1].isIgnoredForProtocolMatch()) {
-                        let fieldIsPartOfFunction = false;
-                        if (prefetched?.functionClass && (0, types_1.isClass)(prefetched.functionClass)) {
-                            if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
-                                fieldIsPartOfFunction = true;
-                            }
-                        }
-                        if (!fieldIsPartOfFunction) {
-                            return undefined;
+                    const fieldName = field[0];
+                    const fieldSymbol = field[1];
+                    // We're expecting a __call__ method. We will also ignore a
+                    // __slots__ definition, which is (by convention) ignored for
+                    // protocol matching.
+                    if (fieldName === '__call__' || fieldName === '__slots__') {
+                        continue;
+                    }
+                    if (fieldSymbol.isIgnoredForProtocolMatch()) {
+                        continue;
+                    }
+                    let fieldIsPartOfFunction = false;
+                    if (prefetched?.functionClass && (0, types_1.isClass)(prefetched.functionClass)) {
+                        if (types_1.ClassType.getSymbolTable(prefetched.functionClass).has(field[0])) {
+                            fieldIsPartOfFunction = true;
                         }
                     }
+                    if (!fieldIsPartOfFunction) {
+                        return undefined;
+                    }
                 }
             }
         }
@@ -18539,6 +18668,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const destPositionalCount = destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
         const srcPositionalCount = srcParamDetails.firstKeywordOnlyIndex ?? srcParamDetails.params.length;
         const positionalsToMatch = Math.min(destPositionalCount, srcPositionalCount);
+        const skippedPosParamIndices = [];
         // Match positional parameters.
         for (let paramIndex = 0; paramIndex < positionalsToMatch; paramIndex++) {
             if (paramIndex === 0 &&
@@ -18550,6 +18680,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             // Skip over the *args parameter since it's handled separately below.
             if (paramIndex === destParamDetails.argsIndex) {
+                if (!(0, types_1.isUnpackedTypeVarTuple)(destParamDetails.params[destParamDetails.argsIndex].type)) {
+                    skippedPosParamIndices.push(paramIndex);
+                }
                 continue;
             }
             const destParam = destParamDetails.params[paramIndex];
@@ -18642,7 +18775,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             canAssign = false;
         }
         if (destPositionalCount < srcPositionalCount && !targetIncludesParamSpec) {
+            // Add any remaining positional parameter indices to the list that
+            // need to be validated.
             for (let i = destPositionalCount; i < srcPositionalCount; i++) {
+                skippedPosParamIndices.push(i);
+            }
+            for (const i of skippedPosParamIndices) {
                 // If the dest has an *args parameter, make sure it can accept the remaining
                 // positional arguments in the source.
                 if (destParamDetails.argsIndex !== undefined) {
@@ -19747,37 +19885,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // is the type used to reference the member.
     function partiallySpecializeBoundMethod(baseType, memberType, diag, recursionCount, firstParamType, stripFirstParam = true) {
         const constraints = new constraintTracker_1.ConstraintTracker();
-        if (firstParamType && memberType.shared.parameters.length > 0) {
-            const memberTypeFirstParam = memberType.shared.parameters[0];
-            const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
-            if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
-                memberTypeFirstParamType.shared.boundType &&
-                (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) &&
-                types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
-                // Handle the protocol class specially. Some protocol classes
-                // contain references to themselves or their subclasses, so if
-                // we attempt to call assignType, we'll risk infinite recursion.
-                // Instead, we'll assume it's assignable.
-                constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
-                    ? (0, typeUtils_1.convertToInstance)(firstParamType)
-                    : firstParamType);
+        if (firstParamType) {
+            if (memberType.shared.parameters.length > 0) {
+                const memberTypeFirstParam = memberType.shared.parameters[0];
+                const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
+                if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
+                    memberTypeFirstParamType.shared.boundType &&
+                    (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) &&
+                    types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
+                    // Handle the protocol class specially. Some protocol classes
+                    // contain references to themselves or their subclasses, so if
+                    // we attempt to call assignType, we'll risk infinite recursion.
+                    // Instead, we'll assume it's assignable.
+                    constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
+                        ? (0, typeUtils_1.convertToInstance)(firstParamType)
+                        : firstParamType);
+                }
+                else {
+                    const subDiag = diag?.createAddendum();
+                    if (!assignType(memberTypeFirstParamType, firstParamType, subDiag?.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
+                        if (memberTypeFirstParam.name &&
+                            !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
+                            types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
+                            if (subDiag) {
+                                subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                                    type: printType(firstParamType),
+                                    methodName: memberType.shared.name || '<anonymous>',
+                                    paramName: memberTypeFirstParam.name,
+                                }));
+                            }
+                            return undefined;
+                        }
+                    }
+                }
             }
             else {
                 const subDiag = diag?.createAddendum();
-                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag?.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
-                    if (memberTypeFirstParam.name &&
-                        !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
-                        types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
-                        if (subDiag) {
-                            subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
-                                type: printType(firstParamType),
-                                methodName: memberType.shared.name || '<anonymous>',
-                                paramName: memberTypeFirstParam.name,
-                            }));
-                        }
-                        return undefined;
-                    }
+                if (subDiag) {
+                    subDiag.addMessage(localize_1.LocMessage.bindParamMissing().format({
+                        methodName: memberType.shared.name || '<anonymous>',
+                    }));
                 }
+                return undefined;
             }
         }
         // Get the effective return type, which will have the side effect of lazily
@@ -20104,6 +20253,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getCallSignatureInfo,
         getAbstractSymbols,
         narrowConstrainedTypeVar,
+        isTypeComparable,
         assignType,
         validateOverrideMethod,
         validateCallArgs,