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

package/dist/analyzer/typeEvaluator.js

@@ -42,6 +42,7 @@ exports.maxCodeComplexity = void 0;
 exports.createTypeEvaluator = createTypeEvaluator;
 const cancellationUtils_1 = require("../common/cancellationUtils");
 const collectionUtils_1 = require("../common/collectionUtils");
+const core_1 = require("../common/core");
 const debug_1 = require("../common/debug");
 const diagnostic_1 = require("../common/diagnostic");
 const diagnosticRules_1 = require("../common/diagnosticRules");
@@ -199,12 +200,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     const signatureTrackerStack = [];
     let prefetched;
     function runWithCancellationToken(token, callback) {
+        // Save the current token and restore it after the callback to support nested calls
+        const oldToken = cancellationToken;
+        let result = undefined;
         try {
             cancellationToken = token;
-            return callback();
+            result = callback();
+            if (!(0, core_1.isThenable)(result)) {
+                return result;
+            }
+            return result.finally(() => {
+                cancellationToken = oldToken;
+            });
         }
         finally {
-            cancellationToken = undefined;
+            if (!(0, core_1.isThenable)(result)) {
+                cancellationToken = oldToken;
+            }
         }
     }
     function checkForCancellation() {
@@ -590,7 +602,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Make sure the resulting type is assignable to the expected type.
                 if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
                 /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
-                    typeResult.typeErrors = true;
+                    // Set the typeErrors to true, but first make a copy of the
+                    // type result because the (non-error) version may already
+                    // be cached.
+                    typeResult = { ...typeResult, typeErrors: true };
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
                 }
@@ -5763,7 +5778,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return typeResult;
     }
-    function buildTupleTypesList(entryTypeResults, stripLiterals) {
+    function buildTupleTypesList(entryTypeResults, stripLiterals, convertModule) {
         const entryTypes = [];
         for (const typeResult of entryTypeResults) {
             let possibleUnpackedTuple;
@@ -5792,8 +5807,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 entryTypes.push({ type: types_1.UnknownType.create(/* isIncomplete */ true), isUnbounded: false });
             }
             else {
-                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */, 
-                /* convertModule */ true);
+                let entryType = convertSpecialFormToRuntimeValue(typeResult.type, 0 /* EvalFlags.None */, convertModule);
                 entryType = stripLiterals ? (0, typeUtils_1.stripTypeForm)(stripLiteralValue(entryType)) : entryType;
                 entryTypes.push({ type: entryType, isUnbounded: !!typeResult.unpackedType });
             }
@@ -7607,6 +7621,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (paramInfo.param.category === 1 /* ParamCategory.ArgsList */) {
                         matchedUnpackedListOfUnknownLength = true;
                     }
+                    if (isParamVariadic && listElementType) {
+                        isArgCompatibleWithVariadic = true;
+                        listElementType = (0, tuples_1.makeTupleObject)(evaluatorInterface, [{ type: listElementType, isUnbounded: true }], 
+                        /* isUnpacked */ true);
+                    }
                 }
                 const funcArg = listElementType
                     ? {
@@ -8111,20 +8130,25 @@ 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 && 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),
-                            });
+                        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),
+                                });
+                            }
                         }
                     }
                 });
@@ -9244,6 +9268,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeMustBeAssigned(), errorNode);
             return undefined;
         }
+        const scope = ScopeUtils.getScopeForNode(errorNode);
+        if (scope) {
+            if (scope.type !== 3 /* ScopeType.Class */ && scope.type !== 4 /* ScopeType.Module */ && scope.type !== 5 /* ScopeType.Builtin */) {
+                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeAliasTypeBadScope(), errorNode.parent.d.leftExpr);
+            }
+        }
         const nameNode = errorNode.parent.d.leftExpr;
         const firstArg = argList[0];
         if (firstArg.valueExpression && firstArg.valueExpression.nodeType === 48 /* ParseNodeType.StringList */) {
@@ -9715,8 +9745,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             typeErrors = true;
         }
         // Strip any literal values and TypeForm types.
-        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, /* convertModule */ true)));
-        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, /* convertModule */ true)));
+        const keyTypes = keyTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
+        const valueTypes = valueTypeResults.map((t) => (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(stripLiteralValue(t.type), flags, !hasExpectedType)));
         if (keyTypes.length > 0) {
             if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.strictDictionaryInference || hasExpectedType) {
                 keyType = (0, types_1.combineTypes)(keyTypes);
@@ -10085,7 +10115,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             else {
                 entryTypeResult = getTypeOfExpression(entry, flags | 268435456 /* EvalFlags.StripTupleLiterals */);
             }
-            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, /* convertModule */ true));
+            entryTypeResult.type = (0, typeUtils_1.stripTypeForm)(convertSpecialFormToRuntimeValue(entryTypeResult.type, flags, !hasExpectedType));
             if (entryTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
@@ -10373,7 +10403,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 : undefined, () => {
                 const returnTypeResult = getTypeOfExpression(node.d.expr, 
                 /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
-                functionType.priv.inferredReturnType = returnTypeResult.type;
+                functionType.priv.inferredReturnType = {
+                    type: returnTypeResult.type,
+                };
                 if (returnTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -12252,16 +12284,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         else if (arg.d.name.d.value === 'total' && !constArgValue) {
                             classType.shared.flags |= 32 /* ClassTypeFlags.CanOmitDictValues */;
                         }
-                        else if (arg.d.name.d.value === 'closed') {
+                        else if (arg.d.name.d.value === 'closed' &&
+                            AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
                             if (constArgValue) {
-                                // This is an experimental feature because PEP 728 hasn't been accepted yet.
-                                if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                                    classType.shared.flags |=
-                                        8 /* ClassTypeFlags.TypedDictMarkedClosed */ |
-                                            16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
-                                    if (classType.shared.typedDictExtraItemsExpr) {
-                                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
-                                    }
+                                classType.shared.flags |=
+                                    8 /* ClassTypeFlags.TypedDictMarkedClosed */ | 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                                if (classType.shared.typedDictExtraItemsExpr) {
+                                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                                 }
                             }
                             if (sawClosedOrExtraItems) {
@@ -12270,16 +12299,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             sawClosedOrExtraItems = true;
                         }
                     }
-                    else if (arg.d.name.d.value === 'extra_items') {
-                        // This is an experimental feature because PEP 728 hasn't been accepted yet.
-                        if (AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
-                            // Record a reference to the expression but don't evaluate it yet.
-                            // It may refer to the class itself.
-                            classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
-                            classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
-                            if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
-                                addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
-                            }
+                    else if (arg.d.name.d.value === 'extra_items' &&
+                        AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.enableExperimentalFeatures) {
+                        // Record a reference to the expression but don't evaluate it yet.
+                        // It may refer to the class itself.
+                        classType.shared.typedDictExtraItemsExpr = arg.d.valueExpr;
+                        classType.shared.flags |= 16 /* ClassTypeFlags.TypedDictEffectivelyClosed */;
+                        if (types_1.ClassType.isTypedDictMarkedClosed(classType)) {
+                            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), classType.shared.typedDictExtraItemsExpr);
                         }
                         if (sawClosedOrExtraItems) {
                             addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictExtraItemsClosed(), arg.d.valueExpr);
@@ -12592,6 +12619,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             };
+            // If Any is defined using a class statement, treat it as a special form.
+            if (node.d.name.d.value === 'Any' && fileInfo.isTypingStubFile) {
+                decoratedType = types_1.AnyType.createSpecialForm();
+            }
             // Update the undecorated class type.
             writeTypeCache(node.d.name, { type: classType }, 0 /* EvalFlags.None */);
             // Update the decorated class type.
@@ -13335,21 +13366,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (functionType.shared.declaredReturnType && returnTypeAnnotationNode) {
                 (0, typeUtils_1.addTypeVarsToListIfUnique)(typeParamsSeen, (0, typeUtils_1.getTypeVarArgsRecursive)(functionType.shared.declaredReturnType), functionType.shared.typeVarScopeId);
             }
-            // If the return type is explicitly annotated as a generator, mark the
-            // function as a generator even though it may not contain a "yield" statement.
-            // This is important for generator functions declared in stub files, abstract
-            // methods or protocol definitions.
-            if (fileInfo.isStubFile || ParseTreeUtils.isSuiteEmpty(node.d.suite)) {
-                if (functionType.shared.declaredReturnType &&
-                    (0, types_1.isClassInstance)(functionType.shared.declaredReturnType) &&
-                    types_1.ClassType.isBuiltIn(functionType.shared.declaredReturnType, [
-                        'Generator',
-                        'AsyncGenerator',
-                        'AwaitableGenerator',
-                    ])) {
-                    functionType.shared.flags |= 16 /* FunctionTypeFlags.Generator */;
-                }
-            }
             // Validate the default types for all type parameters.
             functionType.shared.typeParams.forEach((typeParam, index) => {
                 let bestErrorNode = node.d.name;
@@ -13533,7 +13549,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             awaitableFunctionType.shared.declaredReturnType = createAwaitableReturnType(node, functionType.shared.declaredReturnType, types_1.FunctionType.isGenerator(functionType));
         }
         else {
-            awaitableFunctionType.priv.inferredReturnType = createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType));
+            awaitableFunctionType.priv.inferredReturnType = {
+                type: createAwaitableReturnType(node, getInferredReturnType(functionType), types_1.FunctionType.isGenerator(functionType)),
+            };
         }
         return awaitableFunctionType;
     }
@@ -13556,11 +13574,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         awaitableReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.specialize(asyncGeneratorType, typeArgs));
                     }
                 }
-                else if (['AsyncGenerator', 'AsyncIterator', 'AsyncIterable'].some((name) => name === returnType.shared.name)) {
-                    // If it's already an AsyncGenerator, AsyncIterator or AsyncIterable,
-                    // leave it as is.
+                else if (['AsyncIterator', 'AsyncIterable'].some((name) => name === returnType.shared.name)) {
+                    // If it's already an AsyncIterator or AsyncIterable, leave it as is.
                     awaitableReturnType = returnType;
                 }
+                else if (returnType.shared.name === 'AsyncGenerator') {
+                    // If it's already an AsyncGenerator and the function is a generator,
+                    // leave it as is.
+                    if (isGenerator) {
+                        awaitableReturnType = returnType;
+                    }
+                }
             }
         }
         if (!awaitableReturnType || !isGenerator) {
@@ -16594,8 +16618,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // If the return type has already been lazily evaluated,
         // don't bother computing it again.
-        if (type.priv.inferredReturnType) {
-            returnType = type.priv.inferredReturnType;
+        if (type.priv.inferredReturnType && !type.priv.inferredReturnType.isIncomplete) {
+            returnType = type.priv.inferredReturnType.type;
         }
         else {
             // Don't bother inferring the return type of __init__ because it's
@@ -16642,9 +16666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             returnType = (0, typeUtils_1.makeTypeVarsFree)(returnType, typeVarScopes);
             // Cache the type for next time.
-            if (!isIncomplete) {
-                type.priv.inferredReturnType = returnType;
-            }
+            type.priv.inferredReturnType = { type: returnType, isIncomplete };
         }
         // If the type is partially unknown and the function has one or more unannotated
         // params, try to analyze the function with the provided argument types and
@@ -17640,6 +17662,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
             let concreteSrcType = makeTopLevelTypeVarsConcrete(srcType);
+            // Handle the TypeForm special form. Add a special case for
+            // type[T] to be assignable to TypeForm[T].
+            if (types_1.ClassType.isBuiltIn(destType, 'TypeForm')) {
+                const destTypeArg = destType.priv.typeArgs && destType.priv.typeArgs.length > 0
+                    ? destType.priv.typeArgs[0]
+                    : types_1.UnknownType.create();
+                let srcTypeArg;
+                if ((0, types_1.isClassInstance)(concreteSrcType) && types_1.ClassType.isBuiltIn(concreteSrcType, 'type')) {
+                    srcTypeArg = concreteSrcType;
+                }
+                else if ((0, types_1.isInstantiableClass)(concreteSrcType)) {
+                    srcTypeArg = (0, typeUtils_1.convertToInstance)(concreteSrcType);
+                }
+                if (srcTypeArg) {
+                    return assignType(destTypeArg, srcTypeArg, diag, constraints, flags, recursionCount);
+                }
+            }
             if ((0, types_1.isClass)(concreteSrcType) && types_1.TypeBase.isInstance(concreteSrcType)) {
                 // Handle the case where the source is an unpacked tuple.
                 if (!destType.priv.isUnpacked &&
@@ -19850,37 +19889,48 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // is the type used to reference the member.
     function partiallySpecializeBoundMethod(baseType, memberType, diag, recursionCount, firstParamType, stripFirstParam = true) {
         const constraints = new constraintTracker_1.ConstraintTracker();
-        if (firstParamType && memberType.shared.parameters.length > 0) {
-            const memberTypeFirstParam = memberType.shared.parameters[0];
-            const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
-            if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
-                memberTypeFirstParamType.shared.boundType &&
-                (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) &&
-                types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
-                // Handle the protocol class specially. Some protocol classes
-                // contain references to themselves or their subclasses, so if
-                // we attempt to call assignType, we'll risk infinite recursion.
-                // Instead, we'll assume it's assignable.
-                constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
-                    ? (0, typeUtils_1.convertToInstance)(firstParamType)
-                    : firstParamType);
+        if (firstParamType) {
+            if (memberType.shared.parameters.length > 0) {
+                const memberTypeFirstParam = memberType.shared.parameters[0];
+                const memberTypeFirstParamType = types_1.FunctionType.getParamType(memberType, 0);
+                if ((0, types_1.isTypeVar)(memberTypeFirstParamType) &&
+                    memberTypeFirstParamType.shared.boundType &&
+                    (0, types_1.isClassInstance)(memberTypeFirstParamType.shared.boundType) &&
+                    types_1.ClassType.isProtocolClass(memberTypeFirstParamType.shared.boundType)) {
+                    // Handle the protocol class specially. Some protocol classes
+                    // contain references to themselves or their subclasses, so if
+                    // we attempt to call assignType, we'll risk infinite recursion.
+                    // Instead, we'll assume it's assignable.
+                    constraints.setBounds(memberTypeFirstParamType, types_1.TypeBase.isInstantiable(memberTypeFirstParamType)
+                        ? (0, typeUtils_1.convertToInstance)(firstParamType)
+                        : firstParamType);
+                }
+                else {
+                    const subDiag = diag?.createAddendum();
+                    if (!assignType(memberTypeFirstParamType, firstParamType, subDiag?.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
+                        if (memberTypeFirstParam.name &&
+                            !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
+                            types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
+                            if (subDiag) {
+                                subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
+                                    type: printType(firstParamType),
+                                    methodName: memberType.shared.name || '<anonymous>',
+                                    paramName: memberTypeFirstParam.name,
+                                }));
+                            }
+                            return undefined;
+                        }
+                    }
+                }
             }
             else {
                 const subDiag = diag?.createAddendum();
-                if (!assignType(memberTypeFirstParamType, firstParamType, subDiag?.createAddendum(), constraints, 8192 /* AssignTypeFlags.AllowUnspecifiedTypeArgs */, recursionCount)) {
-                    if (memberTypeFirstParam.name &&
-                        !types_1.FunctionParam.isNameSynthesized(memberTypeFirstParam) &&
-                        types_1.FunctionParam.isTypeDeclared(memberTypeFirstParam)) {
-                        if (subDiag) {
-                            subDiag.addMessage(localize_1.LocMessage.bindTypeMismatch().format({
-                                type: printType(firstParamType),
-                                methodName: memberType.shared.name || '<anonymous>',
-                                paramName: memberTypeFirstParam.name,
-                            }));
-                        }
-                        return undefined;
-                    }
+                if (subDiag) {
+                    subDiag.addMessage(localize_1.LocMessage.bindParamMissing().format({
+                        methodName: memberType.shared.name || '<anonymous>',
+                    }));
                 }
+                return undefined;
             }
         }
         // Get the effective return type, which will have the side effect of lazily