@zzzen/pyright-internal 1.2.0-dev.20231022 → 1.2.0-dev.20231029

package/dist/analyzer/typeEvaluator.js

@@ -1935,9 +1935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const codeFlowResult = analyzer.getTypeFromCodeFlow(flowNode, 
         /* reference */ undefined, 
         /* targetSymbolId */ undefined, 
-        /* typeAtStart */ types_1.UnboundType.create(), {
-            skipNoReturnCallAnalysis: true,
-        });
+        /* typeAtStart */ types_1.UnboundType.create());
         return codeFlowResult.type !== undefined && !(0, types_1.isNever)(codeFlowResult.type);
     }
     // Determines whether there is a code flow path from sourceNode to sinkNode.
@@ -2871,7 +2869,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getTypeOfName(node, flags) {
-        var _a;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
         const name = node.value;
         let symbol;
@@ -3019,29 +3016,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type = types_1.UnknownType.create();
             }
         }
-        if ((0, types_1.isTypeVar)(type) &&
-            !type.details.isParamSpec &&
-            !type.isVariadicInUnion &&
-            (flags & 128 /* ExpectingInstantiableType */) === 0 &&
-            type.details.name === name) {
-            // Handle the special case of a PEP 604 union. These can appear within
-            // an implied type alias where we are not expecting a type.
-            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
-                node.parent.operator === 6 /* BitwiseOr */;
-            if (!isPep604Union) {
-                // A TypeVar in contexts where we're not expecting a type is
-                // simply a TypeVar or TypeVarTuple object.
-                const typeVarType = type.details.isVariadic
-                    ? getTypingType(node, 'TypeVarTuple')
-                    : getTypingType(node, 'TypeVar');
-                if (typeVarType && (0, types_1.isInstantiableClass)(typeVarType)) {
-                    type = types_1.ClassType.cloneAsInstance(typeVarType);
-                }
-                else {
-                    type = types_1.UnknownType.create();
-                }
-            }
-        }
+        type = convertTypeVarToRuntimeInstance(node, type, flags);
         if ((flags & 256 /* ExpectingTypeAnnotation */) === 0) {
             reportUseOfTypeCheckOnly(type, node);
         }
@@ -3062,6 +3037,37 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
+    // If the type is a TypeVar and we're not expecting a type, convert
+    // a TypeVar or TypeVarTuple into a runtime type. We don't currently
+    // do this for ParamSpec (although we arguably should) because it's
+    // problematic for handling P.args and P.kwargs.
+    function convertTypeVarToRuntimeInstance(node, type, flags) {
+        var _a;
+        if (node.nodeType === 38 /* Name */ &&
+            (0, types_1.isTypeVar)(type) &&
+            node.value === type.details.name &&
+            !type.isVariadicInUnion &&
+            (flags & 128 /* ExpectingInstantiableType */) === 0) {
+            if ((flags & 33554432 /* SkipConvertParamSpecToRuntimeObject */) !== 0 && type.details.isParamSpec) {
+                return type;
+            }
+            // Handle the special case of a PEP 604 union. These can appear within
+            // an implied type alias where we are not expecting a type.
+            const isPep604Union = ((_a = node.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 7 /* BinaryOperation */ &&
+                node.parent.operator === 6 /* BitwiseOr */;
+            if (!isPep604Union) {
+                // A TypeVar in contexts where we're not expecting a type is
+                // simply a runtime object.
+                if (type.details.runtimeClass) {
+                    type = types_1.ClassType.cloneAsInstance(type.details.runtimeClass);
+                }
+                else {
+                    type = types_1.UnknownType.create();
+                }
+            }
+        }
+        return type;
+    }
     // Handles the case where a variable or parameter is defined in an outer
     // scope and captured by an inner scope (either a function or a lambda).
     function getCodeFlowTypeForCapturedVariable(node, symbolWithScope, effectiveType) {
@@ -3387,15 +3393,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type, isRescoped: false, foundInterveningClass: false };
     }
     function getTypeOfMemberAccess(node, flags) {
-        const baseTypeFlags = 16777218 /* MemberAccessBaseDefaults */ |
-            (flags &
+        // Compute flags specifically for evaluating the left expression.
+        let leftExprFlags = 16777218 /* MemberAccessBaseDefaults */;
+        leftExprFlags |=
+            flags &
                 (256 /* ExpectingTypeAnnotation */ |
                     32768 /* VariableTypeAnnotation */ |
                     4 /* AllowForwardReferences */ |
                     524288 /* NotParsedByInterpreter */ |
                     2048 /* DisallowTypeVarsWithScopeId */ |
-                    8192 /* AssociateTypeVarsWithCurrentScope */));
-        const baseTypeResult = getTypeOfExpression(node.leftExpression, baseTypeFlags);
+                    8192 /* AssociateTypeVarsWithCurrentScope */);
+        // Handle special casing for ParamSpec "args" and "kwargs" accesses.
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
+            const memberName = node.memberName.value;
+            if (memberName === 'args' || memberName === 'kwargs') {
+                leftExprFlags |= 33554432 /* SkipConvertParamSpecToRuntimeObject */;
+            }
+        }
+        const baseTypeResult = getTypeOfExpression(node.leftExpression, leftExprFlags);
         if ((0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             return {
                 type: types_1.UnknownType.create(/* isIncomplete */ true),
@@ -5531,7 +5546,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             baseTypeResult = getTypeOfExpression(node.leftExpression, 16777218 /* CallBaseDefaults */ | (flags & 4 /* AllowForwardReferences */));
         }
-        const argList = node.arguments.map((arg) => {
+        const argList = ParseTreeUtils.getArgumentsByRuntimeOrder(node).map((arg) => {
             const functionArg = {
                 valueExpression: arg.valueExpression,
                 argumentCategory: arg.argumentCategory,
@@ -8455,7 +8470,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         // Parse the remaining parameters.
         const paramNameMap = new Map();
         for (let i = 1; i < argList.length; i++) {
@@ -8581,7 +8596,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.typeVarFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false);
+        const typeVar = types_1.TypeVarType.createInstantiable(typeVarName, /* isParamSpec */ false, classType);
         typeVar.details.isVariadic = true;
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
@@ -8633,7 +8648,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         else {
             addError(localize_1.Localizer.Diagnostic.paramSpecFirstArg(), firstArg.valueExpression || errorNode);
         }
-        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true);
+        const paramSpec = types_1.TypeVarType.createInstantiable(paramSpecName, /* isParamSpec */ true, classType);
         // Parse the remaining parameters.
         for (let i = 1; i < argList.length; i++) {
             const paramNameNode = argList[i].name;
@@ -9618,12 +9633,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return { type: returnedType };
     }
     function getTypeOfLambda(node, inferenceContext) {
-        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
-        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
-        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
-        // Pre-cache the incomplete function type in case the evaluation of the
-        // lambda depends on itself.
-        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         let expectedFunctionTypes = [];
         if (inferenceContext) {
             (0, typeUtils_1.mapSubtypes)(inferenceContext.expectedType, (subtype) => {
@@ -9638,25 +9647,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 return undefined;
             });
-            // Determine the minimum number of parameters that are required to
-            // satisfy the lambda.
-            const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name && param.defaultValue === undefined).length;
-            const maxLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && !!param.name).length;
-            // Remove any expected subtypes that don't satisfy the minimum
-            // parameter count requirement.
-            expectedFunctionTypes = expectedFunctionTypes.filter((functionType) => {
-                const functionParamCount = functionType.details.parameters.filter((param) => !!param.name && !param.hasDefault).length;
-                const hasVarArgs = functionType.details.parameters.some((param) => !!param.name && param.category !== 0 /* Simple */);
-                const hasParamSpec = !!functionType.details.paramSpec;
-                return (hasVarArgs ||
-                    hasParamSpec ||
-                    (functionParamCount >= minLambdaParamCount && functionParamCount <= maxLambdaParamCount));
-            });
         }
-        // For now, use only the first expected type.
-        const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined;
+        if (expectedFunctionTypes.length <= 1) {
+            return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined, inferenceContext, 
+            /* forceSpeculative */ false);
+        }
+        // Sort the expected types for deterministic results.
+        expectedFunctionTypes = (0, typeUtils_1.sortTypes)(expectedFunctionTypes);
+        // If there's more than one type, try each in turn until we find one that works.
+        for (const expectedFunctionType of expectedFunctionTypes) {
+            const result = getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+            /* forceSpeculative */ true);
+            if (!result.typeErrors) {
+                return getTypeOfLambdaWithExpectedType(node, expectedFunctionType, inferenceContext, 
+                /* forceSpeculative */ false);
+            }
+        }
+        return getTypeOfLambdaWithExpectedType(node, expectedFunctionTypes[0], inferenceContext, 
+        /* forceSpeculative */ true);
+    }
+    function getTypeOfLambdaWithExpectedType(node, expectedType, inferenceContext, forceSpeculative) {
+        let isIncomplete = !!(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete);
         let paramsArePositionOnly = true;
-        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : undefined;
+        const expectedParamDetails = expectedType ? (0, parameterUtils_1.getParameterListDetails)(expectedType) : undefined;
+        const functionType = types_1.FunctionType.createInstance('', '', '', 131072 /* PartiallyEvaluated */);
+        functionType.details.typeVarScopeId = ParseTreeUtils.getScopeIdForNode(node);
+        // Pre-cache the incomplete function type in case the evaluation of the
+        // lambda depends on itself.
+        writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* None */);
         node.parameters.forEach((param, index) => {
             let paramType;
             if (expectedParamDetails) {
@@ -9721,9 +9739,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        const expectedReturnType = expectedFunctionType
-            ? getFunctionEffectiveReturnType(expectedFunctionType)
-            : undefined;
+        const expectedReturnType = expectedType ? getFunctionEffectiveReturnType(expectedType) : undefined;
+        let typeErrors = false;
         // If we're speculatively evaluating the lambda, create another speculative
         // evaluation scope for the return expression and do not allow retention
         // of the cached types.
@@ -9731,19 +9748,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // cache the type of the lambda return expression because it depends on
         // the parameter types that we set above, and the speculative type cache
         // doesn't know about that context.
-        useSpeculativeMode(isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete) ? node.expression : undefined, () => {
+        useSpeculativeMode(forceSpeculative || isSpeculativeModeInUse(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+            ? node.expression
+            : undefined, () => {
             const returnTypeResult = getTypeOfExpression(node.expression, 
             /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedReturnType));
             functionType.inferredReturnType = returnTypeResult.type;
             if (returnTypeResult.isIncomplete) {
                 isIncomplete = true;
             }
+            if (returnTypeResult.typeErrors) {
+                typeErrors = true;
+            }
         }, {
-            dependentType: inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType,
+            dependentType: expectedType,
         });
         // Mark the function type as no longer being evaluated.
         functionType.details.flags &= ~131072 /* PartiallyEvaluated */;
-        return { type: functionType, isIncomplete };
+        // Is the resulting function compatible with the expected type?
+        if (expectedType && !assignType(expectedType, functionType)) {
+            typeErrors = true;
+        }
+        return { type: functionType, isIncomplete, typeErrors };
     }
     function getTypeOfListComprehension(node, inferenceContext) {
         var _a;
@@ -11328,8 +11354,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         metaclassNode = arg.valueExpression;
                     }
                 }
-                else if (types_1.ClassType.isTypedDictClass(classType) &&
-                    (arg.name.value === 'total' || arg.name.value === 'readonly')) {
+                else if (types_1.ClassType.isTypedDictClass(classType) && arg.name.value === 'total') {
                     // The "total" and "readonly" parameters apply only for TypedDict classes.
                     // PEP 589 specifies that the parameter must be either True or False.
                     const constArgValue = (0, staticExpressions_1.evaluateStaticBoolExpression)(arg.valueExpression, fileInfo.executionEnvironment, fileInfo.definedConstants);
@@ -11339,9 +11364,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     else if (arg.name.value === 'total' && !constArgValue) {
                         classType.details.flags |= 256 /* CanOmitDictValues */;
                     }
-                    else if (arg.name.value === 'readonly' && constArgValue) {
-                        classType.details.flags |= 512 /* DictValuesReadOnly */;
-                    }
                 }
                 else {
                     // Collect arguments that will be passed to the `__init_subclass__`
@@ -14234,6 +14256,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 .getDeclarations()
                                 .find((decl) => decl.type === 2 /* Parameter */);
                         }
+                        const parameterDetails = (0, parameterUtils_1.getParameterListDetails)(type);
+                        if (parameterDetails.unpackedKwargsTypedDictType) {
+                            const lookupResults = (0, typeUtils_1.lookUpClassMember)(parameterDetails.unpackedKwargsTypedDictType, paramName);
+                            if (lookupResults) {
+                                return lookupResults.symbol
+                                    .getDeclarations()
+                                    .find((decl) => decl.type === 1 /* Variable */);
+                            }
+                        }
                     }
                 }
             }
@@ -14574,13 +14605,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (cachedTypeVarType && (0, types_1.isTypeVar)(cachedTypeVarType)) {
             return cachedTypeVarType;
         }
-        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value);
-        typeVar.details.isTypeParamSyntax = true;
+        let runtimeClassName = 'TypeVar';
         if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
-            typeVar.details.isVariadic = true;
+            runtimeClassName = 'TypeVarTuple';
         }
         else if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec) {
-            typeVar.details.isParamSpec = true;
+            runtimeClassName = 'ParamSpec';
+        }
+        const runtimeType = getTypingType(node, runtimeClassName);
+        const runtimeClass = runtimeType && (0, types_1.isInstantiableClass)(runtimeType) ? runtimeType : undefined;
+        let typeVar = types_1.TypeVarType.createInstantiable(node.name.value, node.typeParamCategory === parseNodes_1.TypeParameterCategory.ParamSpec, runtimeClass);
+        typeVar.details.isTypeParamSyntax = true;
+        if (node.typeParamCategory === parseNodes_1.TypeParameterCategory.TypeVarTuple) {
+            typeVar.details.isVariadic = true;
         }
         // Cache the value before we evaluate the bound or the default type in
         // case it refers to itself in a circular manner.
@@ -14909,7 +14946,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getEffectiveTypeOfSymbolForUsage(symbol).type;
     }
     function getEffectiveTypeOfSymbolForUsage(symbol, usageNode, useLastDecl = false) {
-        var _a, _b;
         let declaredTypeInfo;
         // If there's a declared type, it takes precedence over inferred types.
         if (symbol.hasTypedDeclarations()) {
@@ -14942,13 +14978,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let cacheEntries = effectiveTypeCache.get(symbol.id);
         const usageNodeId = usageNode ? usageNode.id : undefined;
         const effectiveTypeCacheKey = `${usageNodeId === undefined ? '.' : usageNodeId.toString()}${useLastDecl ? '*' : ''}`;
-        if (cacheEntries) {
-            const result = cacheEntries.get(effectiveTypeCacheKey);
-            if (result) {
-                if (!result.isIncomplete) {
-                    return result;
-                }
-            }
+        const cacheEntry = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey);
+        if (cacheEntry && !cacheEntry.isIncomplete) {
+            return cacheEntry;
         }
         // Infer the type.
         const decls = symbol.getDeclarations();
@@ -15037,8 +15069,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             declsToConsider.push(resolvedDecl);
         });
-        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(effectiveTypeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
-        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, evaluationAttempts);
+        const result = getTypeOfSymbolForDecls(symbol, declsToConsider, effectiveTypeCacheKey);
         // Add the result to the effective type cache if it doesn't include speculative results.
         if (!result.includesSpeculativeResult) {
             addToEffectiveTypeCache(result);
@@ -15054,7 +15085,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     // Returns the type of a symbol based on a subset of its declarations.
-    function getTypeOfSymbolForDecls(symbol, decls, evaluationAttempts) {
+    function getTypeOfSymbolForDecls(symbol, decls, typeCacheKey) {
+        var _a, _b;
         const typesToCombine = [];
         let isIncomplete = false;
         let sawPendingEvaluation = false;
@@ -15122,6 +15154,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 sawPendingEvaluation = true;
             }
         });
+        // How many times have we already attempted to evaluate this declaration already?
+        const cacheEntries = effectiveTypeCache.get(symbol.id);
+        const evaluationAttempts = ((_b = (_a = cacheEntries === null || cacheEntries === void 0 ? void 0 : cacheEntries.get(typeCacheKey)) === null || _a === void 0 ? void 0 : _a.evaluationAttempts) !== null && _b !== void 0 ? _b : 0) + 1;
         let type;
         if (typesToCombine.length > 0) {
             // Ignore the pending evaluation flag if we've already attempted the