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

package/dist/analyzer/typeEvaluator.js

@@ -81,6 +81,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 +147,9 @@ 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 maxOverloadArgTypeExpansionCount = 64;
 // Maximum number of recursive function return type inference attempts
 // that can be concurrently pending before we give up.
 const maxInferFunctionReturnRecursionCount = 12;
@@ -2908,7 +2909,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) {
@@ -2960,16 +2961,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');
@@ -3265,7 +3278,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return true;
         }
         if ((0, types_1.isTypeVar)(type)) {
-            return true;
+            if (type.props?.specialForm || type.props?.typeAliasInfo) {
+                return true;
+            }
         }
         // Exempts class types that are created by calling NewType, NamedTuple, etc.
         if ((0, types_1.isClass)(type) && !type.priv.includeSubclasses && types_1.ClassType.isValidTypeAliasClass(type)) {
@@ -6610,7 +6625,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
-        // positional and named arguments that are present. We do all of this
+        // positional and keyword arguments that are present. We do all of this
         // speculatively because we don't want to record any types in the type
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(speculativeNode, () => {
@@ -6716,9 +6731,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 > maxOverloadArgTypeExpansionCount) {
                 break;
             }
         }
@@ -6737,12 +6752,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]) {
@@ -6753,28 +6769,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);
@@ -6782,6 +6794,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) {
+                    (0, collectionUtils_1.appendArray)(expandedTypes, expandedLiteralTypes);
+                    return;
+                }
+                // Expand any fixed-size tuples.
+                const expandedTuples = (0, tuples_1.expandTuple)(subtype, maxOverloadArgTypeExpansionCount);
+                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
@@ -7566,9 +7601,6 @@ 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
                     ? {
@@ -14078,7 +14110,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 */);
@@ -14190,7 +14222,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),
                     });
                 }
@@ -15735,7 +15767,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, {
@@ -18904,26 +18936,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;
+                            }
                         }
                     }
                 }