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

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");
@@ -81,6 +82,7 @@ const tuples_1 = require("./tuples");
 const typeCacheUtils_1 = require("./typeCacheUtils");
 const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
+const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
@@ -146,9 +148,12 @@ const maxDeclarationsToUseForInference = 64;
 // Maximum number of times to attempt effective type evaluation
 // of a variable that has no type declaration.
 const maxEffectiveTypeEvaluationAttempts = 16;
-// Maximum number of combinatoric union type expansions allowed
+// Maximum number of combinatoric argument type expansions allowed
 // when resolving an overload.
-const maxOverloadUnionExpansionCount = 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;
@@ -1468,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) {
@@ -1478,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 */ |
@@ -2908,7 +2913,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             case 54 /* ParseNodeType.TypeAnnotation */: {
                 let annotationType = getTypeOfAnnotation(target.d.annotation, {
                     varTypeAnnotation: true,
-                    allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(target.d.valueExpr),
+                    allowFinal: isFinalAllowedForAssignmentTarget(target.d.valueExpr),
                     allowClassVar: isClassVarAllowedForAssignmentTarget(target.d.valueExpr),
                 });
                 if (annotationType) {
@@ -2935,12 +2940,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 */: {
@@ -2960,16 +2963,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function isClassVarAllowedForAssignmentTarget(targetNode) {
+        // ClassVar is allowed only in a class body.
         const classNode = ParseTreeUtils.getEnclosingClass(targetNode, /* stopAtFunction */ true);
         if (!classNode) {
             return false;
         }
         // ClassVar is not allowed in a TypedDict or a NamedTuple class.
+        return !isInTypedDictOrNamedTuple(classNode);
+    }
+    function isFinalAllowedForAssignmentTarget(targetNode) {
+        const classNode = ParseTreeUtils.getEnclosingClass(targetNode, /* stopAtFunction */ true);
+        // Final is not allowed in the body of a TypedDict or NamedTuple class.
+        if (classNode && isInTypedDictOrNamedTuple(classNode)) {
+            return false;
+        }
+        return ParseTreeUtils.isFinalAllowedForAssignmentTarget(targetNode);
+    }
+    function isInTypedDictOrNamedTuple(classNode) {
         const classType = getTypeOfClass(classNode)?.classType;
         if (!classType) {
             return false;
         }
-        return !types_1.ClassType.isTypedDictClass(classType) && !classType.shared.namedTupleEntries;
+        return types_1.ClassType.isTypedDictClass(classType) || !!classType.shared.namedTupleEntries;
     }
     function verifyRaiseExceptionType(node, allowNone) {
         const baseExceptionType = getBuiltInType(node, 'BaseException');
@@ -6718,9 +6733,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     });
                 });
             }
-            expandedArgTypes = expandArgUnionTypes(contextFreeArgTypes, expandedArgTypes);
+            expandedArgTypes = expandArgTypes(contextFreeArgTypes, expandedArgTypes);
             // Check for combinatoric explosion and break out of loop.
-            if (!expandedArgTypes || expandedArgTypes.length > maxOverloadUnionExpansionCount) {
+            if (!expandedArgTypes || expandedArgTypes.length > maxTotalOverloadArgTypeExpansionCount) {
                 break;
             }
         }
@@ -6739,12 +6754,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         return { argumentErrors: true, isTypeIncomplete, overloadsUsedForCall: [] };
     }
     // Replaces each item in the expandedArgTypes with n items where n is
-    // the number of subtypes in a union. The contextFreeArgTypes parameter
-    // represents the types of the arguments evaluated with no bidirectional
-    // type inference (i.e. without the help of the corresponding parameter's
-    // expected type). If the function returns undefined, that indicates that
-    // all unions have been expanded, and no more expansion is possible.
-    function expandArgUnionTypes(contextFreeArgTypes, expandedArgTypes) {
+    // the number of subtypes in a union or other expandable type.
+    // The contextFreeArgTypes parameter represents the types of the arguments
+    // evaluated with no bidirectional type inference (i.e. without the help of
+    // the corresponding parameter's expected type). If the function returns
+    // undefined, that indicates that all types have been expanded, and no
+    // more expansion is possible.
+    function expandArgTypes(contextFreeArgTypes, expandedArgTypes) {
         // Find the rightmost already-expanded argument.
         let indexToExpand = contextFreeArgTypes.length - 1;
         while (indexToExpand >= 0 && !expandedArgTypes[0][indexToExpand]) {
@@ -6755,28 +6771,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (indexToExpand >= contextFreeArgTypes.length) {
             return undefined;
         }
-        let unionToExpand;
+        let expandedTypes;
         while (indexToExpand < contextFreeArgTypes.length) {
             // Is this a union type? If so, we can expand it.
             const argType = contextFreeArgTypes[indexToExpand];
-            if ((0, types_1.isUnion)(argType)) {
-                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
-                break;
-            }
-            else if ((0, types_1.isTypeVar)(argType) && types_1.TypeVarType.hasConstraints(argType)) {
-                unionToExpand = makeTopLevelTypeVarsConcrete(argType);
+            expandedTypes = expandArgType(argType);
+            if (expandedTypes) {
                 break;
             }
             indexToExpand++;
         }
         // We have nothing left to expand.
-        if (!unionToExpand) {
+        if (!expandedTypes) {
             return undefined;
         }
         // Expand entry indexToExpand.
         const newExpandedArgTypes = [];
         expandedArgTypes.forEach((preExpandedTypes) => {
-            (0, typeUtils_1.doForEachSubtype)(unionToExpand, (subtype) => {
+            expandedTypes.forEach((subtype) => {
                 const expandedTypes = [...preExpandedTypes];
                 expandedTypes[indexToExpand] = subtype;
                 newExpandedArgTypes.push(expandedTypes);
@@ -6784,6 +6796,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         });
         return newExpandedArgTypes;
     }
+    function expandArgType(type) {
+        const expandedTypes = [];
+        // Expand any top-level type variables with constraints.
+        type = makeTopLevelTypeVarsConcrete(type);
+        (0, typeUtils_1.doForEachSubtype)(type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype)) {
+                // Expand any bool or Enum literals.
+                const expandedLiteralTypes = (0, typeGuards_1.enumerateLiteralsForType)(evaluatorInterface, subtype);
+                if (expandedLiteralTypes && expandedLiteralTypes.length <= maxSingleOverloadArgTypeExpansionCount) {
+                    (0, collectionUtils_1.appendArray)(expandedTypes, expandedLiteralTypes);
+                    return;
+                }
+                // Expand any fixed-size tuples.
+                const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxSingleOverloadArgTypeExpansionCount);
+                if (expandedTuples) {
+                    (0, collectionUtils_1.appendArray)(expandedTypes, expandedTuples);
+                    return;
+                }
+            }
+            expandedTypes.push(subtype);
+        });
+        return expandedTypes.length > 1 ? expandedTypes : undefined;
+    }
     // Validates that the arguments can be assigned to the call's parameter
     // list, specializes the call based on arg types, and returns the
     // specialized type of the return value. If it detects an error along
@@ -7337,7 +7372,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;
@@ -7811,8 +7846,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 },
@@ -10190,7 +10225,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.
@@ -12034,6 +12070,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 */) {
@@ -12216,15 +12253,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') {
@@ -12238,6 +12282,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);
@@ -13517,8 +13565,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]));
             }
@@ -13637,7 +13685,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]
@@ -14077,7 +14125,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             const annotationType = getTypeOfAnnotation(node.d.annotation, {
                 varTypeAnnotation: true,
-                allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(node.d.valueExpr),
+                allowFinal: isFinalAllowedForAssignmentTarget(node.d.valueExpr),
                 allowClassVar: isClassVarAllowedForAssignmentTarget(node.d.valueExpr),
             });
             writeTypeCache(node.d.valueExpr, { type: annotationType }, 0 /* EvalFlags.None */);
@@ -14189,7 +14237,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (annotationNode === annotationParent.d.annotationComment) {
                     getTypeOfAnnotation(annotationNode, {
                         varTypeAnnotation: true,
-                        allowFinal: ParseTreeUtils.isFinalAllowedForAssignmentTarget(annotationParent.d.leftExpr),
+                        allowFinal: isFinalAllowedForAssignmentTarget(annotationParent.d.leftExpr),
                         allowClassVar: isClassVarAllowedForAssignmentTarget(annotationParent.d.leftExpr),
                     });
                 }
@@ -15734,7 +15782,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             ? declaration.node.parent
                             : declaration.node;
                         const allowClassVar = isClassVarAllowedForAssignmentTarget(declNode);
-                        const allowFinal = ParseTreeUtils.isFinalAllowedForAssignmentTarget(declNode);
+                        const allowFinal = isFinalAllowedForAssignmentTarget(declNode);
                         const allowRequired = ParseTreeUtils.isRequiredAllowedForAssignmentTarget(declNode) ||
                             !!declaration.isInInlinedTypedDict;
                         declaredType = getTypeOfAnnotation(typeAnnotationNode, {
@@ -16298,6 +16346,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;
@@ -18748,66 +18802,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.
@@ -18903,26 +18967,35 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (remainingParams.length > 0 ||
                     !effectiveSrcParamSpec ||
                     !(0, types_1.isTypeSame)(effectiveSrcParamSpec, effectiveDestParamSpec, { ignoreTypeFlags: true })) {
-                    const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.shared.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */, effectiveSrcType.shared.docString);
-                    remainingFunction.shared.deprecatedMessage = effectiveSrcType.shared.deprecatedMessage;
-                    remainingFunction.shared.typeVarScopeId = effectiveSrcType.shared.typeVarScopeId;
-                    remainingFunction.priv.constructorTypeVarScopeId = effectiveSrcType.priv.constructorTypeVarScopeId;
-                    remainingFunction.shared.methodClass = effectiveSrcType.shared.methodClass;
-                    remainingParams.forEach((param) => {
-                        types_1.FunctionType.addParam(remainingFunction, param);
-                    });
-                    if (effectiveSrcParamSpec) {
-                        types_1.FunctionType.addParamSpecVariadics(remainingFunction, (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec));
-                    }
-                    if (!assignType(effectiveDestParamSpec, remainingFunction, /* diag */ undefined, constraints, flags)) {
-                        // If we couldn't assign the function to the ParamSpec, see if we can
-                        // assign only the ParamSpec. This is possible if there were no
-                        // remaining parameters.
-                        if (remainingParams.length > 0 ||
-                            !effectiveSrcParamSpec ||
-                            !assignType((0, typeUtils_1.convertToInstance)(effectiveDestParamSpec), (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec), 
-                            /* diag */ undefined, constraints, flags)) {
-                            canAssign = false;
+                    const effectiveSrcPosCount = isContra ? destPositionalCount : srcPositionalCount;
+                    const effectiveDestPosCount = isContra ? srcPositionalCount : destPositionalCount;
+                    // If the src and dest both have ParamSpecs but the src has additional positional
+                    // parameters that have not been matched to dest positional parameters (probably due
+                    // to a Concatenate), don't attempt to assign the remaining parameters to the ParamSpec.
+                    if (!effectiveSrcParamSpec || effectiveSrcPosCount >= effectiveDestPosCount) {
+                        const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.shared.flags | 64 /* FunctionTypeFlags.SynthesizedMethod */, effectiveSrcType.shared.docString);
+                        remainingFunction.shared.deprecatedMessage = effectiveSrcType.shared.deprecatedMessage;
+                        remainingFunction.shared.typeVarScopeId = effectiveSrcType.shared.typeVarScopeId;
+                        remainingFunction.priv.constructorTypeVarScopeId =
+                            effectiveSrcType.priv.constructorTypeVarScopeId;
+                        remainingFunction.shared.methodClass = effectiveSrcType.shared.methodClass;
+                        remainingParams.forEach((param) => {
+                            types_1.FunctionType.addParam(remainingFunction, param);
+                        });
+                        if (effectiveSrcParamSpec) {
+                            types_1.FunctionType.addParamSpecVariadics(remainingFunction, (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec));
+                        }
+                        if (!assignType(effectiveDestParamSpec, remainingFunction, 
+                        /* diag */ undefined, constraints, flags)) {
+                            // If we couldn't assign the function to the ParamSpec, see if we can
+                            // assign only the ParamSpec. This is possible if there were no
+                            // remaining parameters.
+                            if (remainingParams.length > 0 ||
+                                !effectiveSrcParamSpec ||
+                                !assignType((0, typeUtils_1.convertToInstance)(effectiveDestParamSpec), (0, typeUtils_1.convertToInstance)(effectiveSrcParamSpec), 
+                                /* diag */ undefined, constraints, flags)) {
+                                canAssign = false;
+                            }
                         }
                     }
                 }