@zzzen/pyright-internal 1.2.0-dev.20250202 → 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");
@@ -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 */ |
@@ -2936,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 */: {
@@ -6733,7 +6735,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 +6804,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 +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;
@@ -7844,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 },
@@ -10223,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.
@@ -12067,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 */) {
@@ -12249,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') {
@@ -12271,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);
@@ -13550,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]));
             }
@@ -13670,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]
@@ -16331,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;
@@ -18781,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.