@zzzen/pyright-internal 1.2.0-dev.20250202 → 1.2.0-dev.20250216

package/dist/analyzer/typeEvaluator.js

@@ -61,6 +61,7 @@ const constraintSolver_1 = require("./constraintSolver");
 const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
+const declaration_1 = require("./declaration");
 const declarationUtils_1 = require("./declarationUtils");
 const decorators_1 = require("./decorators");
 const enums_1 = require("./enums");
@@ -149,7 +150,10 @@ const maxDeclarationsToUseForInference = 64;
 const maxEffectiveTypeEvaluationAttempts = 16;
 // Maximum number of combinatoric argument type expansions allowed
 // when resolving an overload.
-const maxOverloadArgTypeExpansionCount = 64;
+const maxTotalOverloadArgTypeExpansionCount = 256;
+// Maximum size of an enum that will be expanded during overload
+// argument type expansion.
+const maxSingleOverloadArgTypeExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
@@ -1469,7 +1473,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             !types_1.ClassType.isBuiltIn(metaclass, 'type') &&
             !types_1.ClassType.isSameGenericClass(metaclass, objectType)) {
             const descMemberInfo = getTypeOfClassMemberName(errorNode, metaclass, memberName, usage, 
-            /* diag */ undefined, flags | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */, objectType, recursionCount);
+            /* diag */ undefined, flags | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */ | 4096 /* MemberAccessFlags.SkipTypedDictEntries */, objectType, recursionCount);
             if (descMemberInfo) {
                 const isProperty = (0, types_1.isClassInstance)(descMemberInfo.type) && types_1.ClassType.isPropertyClass(descMemberInfo.type);
                 if ((0, typeUtils_1.isDescriptorInstance)(descMemberInfo.type, /* requireSetter */ true) || isProperty) {
@@ -1479,7 +1483,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let subDiag;
         if (!skipObjectTypeLookup) {
-            let effectiveFlags = flags;
+            let effectiveFlags = flags | 4096 /* MemberAccessFlags.SkipTypedDictEntries */;
             if (objectTypeIsInstantiable) {
                 effectiveFlags |=
                     16 /* MemberAccessFlags.SkipInstanceMembers */ |
@@ -2550,6 +2554,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.
@@ -2936,12 +2944,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 break;
             }
             case 56 /* ParseNodeType.Unpack */: {
-                if (target.d.expr.nodeType === 38 /* ParseNodeType.Name */) {
-                    assignTypeToNameNode(target.d.expr, {
-                        type: getBuiltInObject(target.d.expr, 'list', [typeResult.type]),
-                        isIncomplete: typeResult.isIncomplete,
-                    }, ignoreEmptyContainers, srcExpr);
-                }
+                assignTypeToExpression(target.d.expr, {
+                    type: getBuiltInObject(target.d.expr, 'list', [typeResult.type]),
+                    isIncomplete: typeResult.isIncomplete,
+                }, srcExpr, ignoreEmptyContainers, allowAssignmentToFinalVar, expectedTypeDiagAddendum);
                 break;
             }
             case 0 /* ParseNodeType.Error */: {
@@ -6733,7 +6739,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             expandedArgTypes = expandArgTypes(contextFreeArgTypes, expandedArgTypes);
             // Check for combinatoric explosion and break out of loop.
-            if (!expandedArgTypes || expandedArgTypes.length > maxOverloadArgTypeExpansionCount) {
+            if (!expandedArgTypes || expandedArgTypes.length > maxTotalOverloadArgTypeExpansionCount) {
                 break;
             }
         }
@@ -6802,12 +6808,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if ((0, types_1.isClassInstance)(subtype)) {
                 // Expand any bool or Enum literals.
                 const expandedLiteralTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluatorInterface, subtype);
-                if (expandedLiteralTypes) {
+                if (expandedLiteralTypes && expandedLiteralTypes.length <= maxSingleOverloadArgTypeExpansionCount) {
                     (0, collectionUtils_1.appendArray)(expandedTypes, expandedLiteralTypes);
                     return;
                 }
                 // Expand any fixed-size tuples.
-                const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxOverloadArgTypeExpansionCount);
+                const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxSingleOverloadArgTypeExpansionCount);
                 if (expandedTuples) {
                     (0, collectionUtils_1.appendArray)(expandedTypes, expandedTuples);
                     return;
@@ -7370,7 +7376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // This logic is based on PEP 3102: https://www.python.org/dev/peps/pep-3102/
     function matchArgsToParams(errorNode, argList, typeResult, overloadIndex) {
         const overload = typeResult.type;
-        const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload);
+        const paramDetails = (0, parameterUtils_1.getParamListDetails)(overload, { disallowExtraKwargsForTd: true });
         const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(overload);
         let argIndex = 0;
         let matchedUnpackedListOfUnknownLength = false;
@@ -7498,7 +7504,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.
@@ -7510,9 +7516,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             argType.priv.tupleTypeArgs.length > 0) {
                             tooManyPositionals = true;
                         }
-                        else {
-                            matchedUnpackedListOfUnknownLength = true;
-                        }
                     }
                     else {
                         tooManyPositionals = true;
@@ -7601,6 +7604,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
                     ? {
@@ -7844,8 +7850,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 const kwargsParam = paramDetails.params[paramDetails.kwargsIndex];
                                 validateArgTypeParams.push({
                                     paramCategory: 2 /* ParamCategory.KwargsDict */,
-                                    paramType: kwargsParam.declaredType,
-                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(kwargsParam.declaredType),
+                                    paramType: kwargsParam.type,
+                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(kwargsParam.type),
                                     argument: {
                                         argCategory: 2 /* ArgCategory.UnpackedDictionary */,
                                         typeResult: { type: extraItemsType },
@@ -8105,25 +8111,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),
+                            });
                         }
                     }
                 });
@@ -8198,10 +8199,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) {
@@ -10223,7 +10224,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return generatorTypeArgs.length >= 2 ? generatorTypeArgs[2] : types_1.UnknownType.create();
             }
             // Handle old-style (pre-await) Coroutines as a special case.
-            if ((0, types_1.isClassInstance)(yieldFromSubtype) && types_1.ClassType.isBuiltIn(yieldFromSubtype, 'Coroutine')) {
+            if ((0, types_1.isClassInstance)(yieldFromSubtype) &&
+                types_1.ClassType.isBuiltIn(yieldFromSubtype, ['Coroutine', 'CoroutineType'])) {
                 return types_1.UnknownType.create();
             }
             // Handle simple iterables.
@@ -12067,6 +12069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (fileInfo.isStubFile) {
                 exprFlags |= 4 /* EvalFlags.ForwardRefs */;
             }
+            let sawClosedOrExtraItems = false;
             node.d.arguments.forEach((arg) => {
                 // Ignore unpacked arguments.
                 if (arg.d.argCategory === 2 /* ArgCategory.UnpackedDictionary */) {
@@ -12249,15 +12252,22 @@ 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' && 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);
+                        else if (arg.d.name.d.value === 'closed') {
+                            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);
+                                    }
                                 }
                             }
+                            if (sawClosedOrExtraItems) {
+                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.d.valueExpr);
+                            }
+                            sawClosedOrExtraItems = true;
                         }
                     }
                     else if (arg.d.name.d.value === 'extra_items') {
@@ -12271,6 +12281,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                 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);
+                        }
+                        sawClosedOrExtraItems = true;
                     }
                     else {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictInitsubclassParameter().format({ name: arg.d.name.d.value }), arg);
@@ -13550,8 +13564,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         if (!awaitableReturnType || !isGenerator) {
-            // Wrap in either an Awaitable or a Coroutine, which is a subclass of Awaitable.
-            const awaitableType = getTypingType(node, useCoroutine ? 'Coroutine' : 'Awaitable');
+            // Wrap in either an Awaitable or a CoroutineType, which is a subclass of Awaitable.
+            const awaitableType = useCoroutine ? getTypesType(node, 'CoroutineType') : getTypingType(node, 'Awaitable');
             if (awaitableType && (0, types_1.isInstantiableClass)(awaitableType)) {
                 awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(awaitableType, useCoroutine ? [types_1.AnyType.create(), types_1.AnyType.create(), returnType] : [returnType]));
             }
@@ -13670,7 +13684,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                         isYieldResultUsed = true;
                                         const iteratorTypeResult = getTypeOfExpression(yieldNode.d.expr);
                                         if ((0, types_1.isClassInstance)(iteratorTypeResult.type) &&
-                                            types_1.ClassType.isBuiltIn(iteratorTypeResult.type, 'Coroutine')) {
+                                            types_1.ClassType.isBuiltIn(iteratorTypeResult.type, ['Coroutine', 'CoroutineType'])) {
                                             const yieldType = iteratorTypeResult.type.priv.typeArgs &&
                                                 iteratorTypeResult.type.priv.typeArgs.length > 0
                                                 ? iteratorTypeResult.type.priv.typeArgs[0]
@@ -16331,6 +16345,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             declsToConsider.push(resolvedDecl);
         });
+        // If all of the decls come from augmented assignments, we won't be able to
+        // determine its type. At least one declaration must be a simple assignment.
+        if (declsToConsider.every((decl) => (0, declaration_1.isVariableDeclaration)(decl) &&
+            ParseTreeUtils.isNodeContainedWithinNodeType(decl.node, 5 /* ParseNodeType.AugmentedAssignment */))) {
+            declsToConsider.splice(0);
+        }
         const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
         result.includesVariableDecl = includesVariableDecl;
         result.includesIllegalTypeAliasDecl = includesIllegalTypeAliasDecl;
@@ -16878,13 +16898,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, 
@@ -17770,7 +17783,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) {
@@ -17929,6 +17942,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;
@@ -18175,6 +18192,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
@@ -18357,17 +18463,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;
+                    }
                 }
             }
         }
@@ -18518,6 +18633,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 &&
@@ -18529,6 +18645,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];
@@ -18621,7 +18740,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) {
@@ -18781,66 +18905,76 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             if (srcStartOfNamed >= 0) {
                 srcParamDetails.params.forEach((srcParamInfo, index) => {
-                    if (index >= srcStartOfNamed) {
-                        if (srcParamInfo.param.name &&
-                            srcParamInfo.param.category === 0 /* ParamCategory.Simple */ &&
-                            srcParamInfo.kind !== parameterUtils_1.ParamKind.Positional) {
-                            const destParamInfo = destParamMap.get(srcParamInfo.param.name);
-                            const paramDiag = diag?.createAddendum();
-                            const srcParamType = srcParamInfo.type;
-                            if (!destParamInfo) {
-                                if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.defaultType) {
-                                    if (paramDiag) {
-                                        paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
-                                            name: srcParamInfo.param.name,
-                                        }));
-                                    }
-                                    canAssign = false;
-                                }
-                                else if (destParamDetails.kwargsIndex !== undefined) {
-                                    // Make sure we can assign the type to the Kwargs.
-                                    if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag?.createAddendum(), constraints, flags, recursionCount)) {
-                                        canAssign = false;
-                                    }
-                                }
-                                else if (srcParamInfo.defaultType) {
-                                    // Assign default arg values in case they are needed for
-                                    // populating TypeVar constraints.
-                                    const defaultArgType = srcParamInfo.defaultType ?? srcParamInfo.defaultType;
-                                    if (defaultArgType &&
-                                        !assignType(srcParamInfo.type, defaultArgType, diag?.createAddendum(), constraints, flags, recursionCount)) {
-                                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
-                                            canAssign = false;
-                                        }
-                                    }
-                                }
+                    if (index < srcStartOfNamed) {
+                        return;
+                    }
+                    if (!srcParamInfo.param.name ||
+                        srcParamInfo.param.category !== 0 /* ParamCategory.Simple */ ||
+                        srcParamInfo.kind === parameterUtils_1.ParamKind.Positional) {
+                        return;
+                    }
+                    const destParamInfo = destParamMap.get(srcParamInfo.param.name);
+                    const paramDiag = diag?.createAddendum();
+                    const srcParamType = srcParamInfo.type;
+                    if (!destParamInfo) {
+                        if (destParamDetails.kwargsIndex === undefined && !srcParamInfo.defaultType) {
+                            if (paramDiag) {
+                                paramDiag.addMessage(localize_1.LocAddendum.namedParamMissingInDest().format({
+                                    name: srcParamInfo.param.name,
+                                }));
                             }
-                            else {
-                                const destParamType = destParamInfo.type;
-                                const specializedDestParamType = constraints
-                                    ? solveAndApplyConstraints(destParamType, constraints)
-                                    : destParamType;
-                                if (!assignParam(destParamInfo.type, srcParamType, 
-                                /* paramIndex */ undefined, paramDiag?.createAddendum(), constraints, flags, recursionCount)) {
-                                    if (paramDiag) {
-                                        paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
-                                            name: srcParamInfo.param.name,
-                                            sourceType: printType(specializedDestParamType),
-                                            destType: printType(srcParamType),
-                                        }));
-                                    }
-                                    canAssign = false;
-                                }
-                                if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
-                                    diag?.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
-                                        name: srcParamInfo.param.name,
-                                    }));
+                            canAssign = false;
+                        }
+                        else if (destParamDetails.kwargsIndex !== undefined) {
+                            // Make sure we can assign the type to the Kwargs.
+                            if (!assignParam(destParamDetails.params[destParamDetails.kwargsIndex].type, srcParamType, destParamDetails.params[destParamDetails.kwargsIndex].index, diag?.createAddendum(), constraints, flags, recursionCount)) {
+                                canAssign = false;
+                            }
+                        }
+                        else if (srcParamInfo.defaultType) {
+                            // Assign default arg values in case they are needed for
+                            // populating TypeVar constraints.
+                            const defaultArgType = srcParamInfo.defaultType ?? srcParamInfo.defaultType;
+                            if (defaultArgType &&
+                                !assignType(srcParamInfo.type, defaultArgType, diag?.createAddendum(), constraints, flags, recursionCount)) {
+                                if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) === 0) {
                                     canAssign = false;
                                 }
-                                destParamMap.delete(srcParamInfo.param.name);
                             }
                         }
+                        return;
+                    }
+                    // If we're performing a partial overload match and both the source
+                    // and dest parameters provide defaults, assume that there could
+                    // be a match.
+                    if (srcParamInfo.defaultType && destParamInfo.defaultType) {
+                        if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0) {
+                            destParamMap.delete(srcParamInfo.param.name);
+                            return;
+                        }
+                    }
+                    const destParamType = destParamInfo.type;
+                    const specializedDestParamType = constraints
+                        ? solveAndApplyConstraints(destParamType, constraints)
+                        : destParamType;
+                    if (!assignParam(destParamInfo.type, srcParamType, 
+                    /* paramIndex */ undefined, paramDiag?.createAddendum(), constraints, flags, recursionCount)) {
+                        if (paramDiag) {
+                            paramDiag.addMessage(localize_1.LocAddendum.namedParamTypeMismatch().format({
+                                name: srcParamInfo.param.name,
+                                sourceType: printType(specializedDestParamType),
+                                destType: printType(srcParamType),
+                            }));
+                        }
+                        canAssign = false;
+                    }
+                    if (destParamInfo.defaultType && !srcParamInfo.defaultType) {
+                        diag?.createAddendum().addMessage(localize_1.LocAddendum.functionParamDefaultMissing().format({
+                            name: srcParamInfo.param.name,
+                        }));
+                        canAssign = false;
                     }
+                    destParamMap.delete(srcParamInfo.param.name);
                 });
             }
             // See if there are any unmatched named parameters.
@@ -20073,6 +20207,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         getCallSignatureInfo,
         getAbstractSymbols,
         narrowConstrainedTypeVar,
+        isTypeComparable,
         assignType,
         validateOverrideMethod,
         validateCallArgs,