@zzzen/pyright-internal 1.2.0-dev.20250223 → 1.2.0-dev.20250309

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");
@@ -86,7 +87,6 @@ const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
-const core_1 = require("../common/core");
 // This table contains the names of several built-in types that
 // are not subscriptable at runtime on older versions of Python.
 // It lists the first version of Python where subscripting is
@@ -5778,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;
@@ -5807,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 });
             }
@@ -6892,6 +6891,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         };
     }
     function validateCallArgsForSubtype(errorNode, argList, expandedCallType, unexpandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount) {
+        function touchArgTypes() {
+            if (!isCallTypeIncomplete) {
+                argList.forEach((arg) => {
+                    if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
+                        getTypeOfArg(arg, /* inferenceContext */ undefined);
+                    }
+                });
+            }
+        }
         switch (expandedCallType.category) {
             case 3 /* TypeCategory.Never */:
             case 1 /* TypeCategory.Unknown */:
@@ -6899,13 +6907,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // Touch all of the args so they're marked accessed. Don't bother
                 // doing this if the call type is incomplete because this will need
                 // to be done again once it is complete.
-                if (!isCallTypeIncomplete) {
-                    argList.forEach((arg) => {
-                        if (arg.valueExpression && !isSpeculativeModeInUse(arg.valueExpression)) {
-                            getTypeOfArg(arg, /* inferenceContext */ undefined);
-                        }
-                    });
-                }
+                touchArgTypes();
                 return { returnType: expandedCallType };
             }
             case 4 /* TypeCategory.Function */: {
@@ -6936,6 +6938,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 return { argumentErrors: true };
             }
         }
+        touchArgTypes();
         return { argumentErrors: true };
     }
     function validateCallForFunction(errorNode, argList, type, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
@@ -7622,6 +7625,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
                     ? {
@@ -8126,20 +8134,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, { ignorePseudoGeneric: true })) {
+                                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),
+                                });
+                            }
                         }
                     }
                 });
@@ -8612,7 +8625,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     getTypeOfExpression(arg.valueExpression);
                 }
             });
+            // Use a return type of Unknown but attach a "possible type" to it
+            // so the completion provider can suggest better completions.
+            const possibleType = types_1.FunctionType.getEffectiveReturnType(typeResult.type);
             return {
+                returnType: possibleType && !(0, types_1.isAnyOrUnknown)(possibleType)
+                    ? types_1.UnknownType.createPossibleType(possibleType, /* isIncomplete */ false)
+                    : undefined,
                 argumentErrors: true,
                 activeParam: matchResults.activeParam,
                 overloadsUsedForCall: [],
@@ -9736,8 +9755,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);
@@ -10106,7 +10125,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;
             }
@@ -12610,6 +12629,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.
@@ -13353,21 +13376,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;
@@ -13576,11 +13584,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) {