@zzzen/pyright-internal 1.2.0-dev.20230409 → 1.2.0-dev.20230423

package/dist/analyzer/typeEvaluator.js

@@ -751,9 +751,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((flags & 1 /* ConvertEllipsisToAny */) !== 0) {
             typeResult = { type: types_1.AnyType.create(/* isEllipsis */ true) };
         }
-        else if ((flags & 512 /* ConvertEllipsisToUnknown */) !== 0) {
-            typeResult = { type: types_1.UnknownType.create() };
-        }
         else {
             const ellipsisType = getBuiltInObject(node, 'ellipsis') || types_1.AnyType.create();
             typeResult = { type: ellipsisType };
@@ -5295,7 +5292,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     }
     function getTypeOfCall(node, inferenceContext, flags) {
         var _a;
-        const baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+        let baseTypeResult;
+        // Handle immediate calls of lambdas specially.
+        if (node.leftExpression.nodeType === 30 /* Lambda */) {
+            baseTypeResult = getTypeOfLambdaForCall(node, inferenceContext);
+        }
+        else {
+            baseTypeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+        }
         const argList = node.arguments.map((arg) => {
             const functionArg = {
                 valueExpression: arg.valueExpression,
@@ -5386,6 +5390,57 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    // This function is used in cases where a lambda is defined and immediately
+    // called. In this case, we can't use normal bidirectional type inference
+    // to determine the lambda's type. It needs to be inferred from the argument
+    // types instead.
+    function getTypeOfLambdaForCall(node, inferenceContext) {
+        (0, debug_1.assert)(node.leftExpression.nodeType === 30 /* Lambda */);
+        const expectedType = types_1.FunctionType.createSynthesizedInstance('');
+        expectedType.details.declaredReturnType = inferenceContext
+            ? inferenceContext.expectedType
+            : types_1.UnknownType.create();
+        let isArgTypeIncomplete = false;
+        node.arguments.forEach((arg, index) => {
+            const argTypeResult = getTypeOfExpression(arg.valueExpression);
+            if (argTypeResult.isIncomplete) {
+                isArgTypeIncomplete = true;
+            }
+            types_1.FunctionType.addParameter(expectedType, {
+                category: 0 /* Simple */,
+                name: `p${index.toString()}`,
+                type: argTypeResult.type,
+                hasDeclaredType: true,
+            });
+        });
+        // If the lambda's param list ends with a "/" positional parameter separator,
+        // add a corresponding separator to the expected type.
+        const lambdaParams = node.leftExpression.parameters;
+        if (lambdaParams.length > 0) {
+            const lastParam = lambdaParams[lambdaParams.length - 1];
+            if (lastParam.category === 0 /* Simple */ && !lastParam.name) {
+                types_1.FunctionType.addParameter(expectedType, {
+                    category: 0 /* Simple */,
+                    name: '',
+                    type: types_1.UnknownType.create(),
+                });
+            }
+        }
+        function getLambdaType() {
+            return getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */, (0, typeUtils_1.makeInferenceContext)(expectedType));
+        }
+        // If one or more of the arguments are incomplete, use speculative mode
+        // for the lambda evaluation because it may need to be reevaluated once
+        // the arg types are complete.
+        let typeResult = isArgTypeIncomplete || speculativeTypeTracker.isSpeculative(node) || (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete)
+            ? useSpeculativeMode(node.leftExpression, getLambdaType)
+            : getLambdaType();
+        // If bidirectional type inference failed, use normal type inference instead.
+        if (typeResult.typeErrors) {
+            typeResult = getTypeOfExpression(node.leftExpression, 2 /* DoNotSpecialize */);
+        }
+        return typeResult;
+    }
     function getTypeOfAssertType(node, inferenceContext) {
         if (node.arguments.length !== 2 ||
             node.arguments[0].argumentCategory !== 0 /* Simple */ ||
@@ -5662,6 +5717,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const argTypeOverride = expandedArgTypes[expandedTypesIndex];
             const hasArgTypeOverride = argTypeOverride.some((a) => a !== undefined);
             let possibleMatchResults = [];
+            let possibleMatchInvolvesIncompleteUnknown = false;
             isDefinitiveMatchFound = false;
             for (let overloadIndex = 0; overloadIndex < argParamMatches.length; overloadIndex++) {
                 const overload = argParamMatches[overloadIndex].overload;
@@ -5709,8 +5765,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         argResults: (_b = callResult.argResults) !== null && _b !== void 0 ? _b : [],
                     };
                     matchedOverloads.push(matchedOverloadInfo);
-                    if (callResult.isArgumentAnyOrUnknown) {
+                    if (callResult.anyOrUnknownArgument) {
                         possibleMatchResults.push(matchedOverloadInfo);
+                        if ((0, typeUtils_1.isIncompleteUnknown)(callResult.anyOrUnknownArgument)) {
+                            possibleMatchInvolvesIncompleteUnknown = true;
+                        }
                     }
                     else {
                         returnTypes.push(callResult.returnType);
@@ -5752,7 +5811,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                     dedupedMatchResults = dedupedMatchResults.filter((t) => !(0, types_1.isNever)(t));
                     const combinedTypes = (0, types_1.combineTypes)(dedupedMatchResults);
-                    returnTypes.push(dedupedMatchResults.length > 1 ? types_1.UnknownType.createPossibleType(combinedTypes) : combinedTypes);
+                    returnTypes.push(dedupedMatchResults.length > 1
+                        ? types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown)
+                        : combinedTypes);
                 }
             }
             if (!matchedOverload) {
@@ -5777,7 +5838,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return {
             argumentErrors: finalCallResult.argumentErrors,
-            isArgumentAnyOrUnknown: finalCallResult.isArgumentAnyOrUnknown,
+            anyOrUnknownArgument: finalCallResult.anyOrUnknownArgument,
             returnType: (0, types_1.combineTypes)(returnTypes),
             isTypeIncomplete,
             specializedInitSelfType: finalCallResult.specializedInitSelfType,
@@ -6038,7 +6099,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (expectedCallResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
                     }
-                    overloadsUsedForCall.push(...expectedCallResult.overloadsUsedForCall);
                 }
             }
             if (!returnType) {
@@ -6134,6 +6194,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 else if (!newReturnType) {
                     newReturnType = callResult.returnType;
+                    if (overloadsUsedForCall.length === 0) {
+                        overloadsUsedForCall.push(...callResult.overloadsUsedForCall);
+                    }
                     // If the constructor returned an object whose type matches the class of
                     // the original type being constructed, use the return type in case it was
                     // specialized. If it doesn't match, we'll fall back on the assumption that
@@ -6528,7 +6591,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 return types_1.AnyType.create();
                             }
                             if ((0, types_1.isClass)(unexpandedSubtype) && (0, enums_1.isKnownEnumType)(className)) {
-                                return (_d = (0, enums_1.createEnumType)(errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create();
+                                return ((_d = (0, enums_1.createEnumType)(evaluatorInterface, errorNode, expandedSubtype, argList)) !== null && _d !== void 0 ? _d : types_1.UnknownType.create());
                             }
                             if (className === 'TypedDict') {
                                 return (0, typedDicts_1.createTypedDictType)(evaluatorInterface, errorNode, expandedSubtype, argList);
@@ -7575,7 +7638,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
-        let isArgumentAnyOrUnknown = false;
+        let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
@@ -7647,7 +7710,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // times.
                         const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
                         /* skipOverloadArg */ i === 0, 
-                        /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
+                        /* isFirstPass */ passCount > 1 && i === 0, typeCondition);
                         if (argResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
@@ -7673,7 +7736,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
             /* skipOverloadArg */ false, 
-            /* useNarrowBoundOnly */ false, typeCondition);
+            /* isFirstPass */ false, typeCondition);
             argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
@@ -7685,7 +7748,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
             }
             if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
-                isArgumentAnyOrUnknown = true;
+                anyOrUnknownArgument = anyOrUnknownArgument
+                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument)
+                    : argResult.argType;
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
@@ -7803,7 +7868,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return {
             argumentErrors,
             argResults,
-            isArgumentAnyOrUnknown,
+            anyOrUnknownArgument,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -7811,19 +7876,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             overloadsUsedForCall: argumentErrors ? [] : [type],
         };
     }
-    function adjustCallableReturnType(type) {
+    function adjustCallableReturnType(returnType) {
         // If the return type includes a generic Callable type, set the type var
         // scope to a wildcard to allow these type vars to be solved. This won't
         // work with overloads or unions of callables. It's intended for a
         // specific use case. We may need to make this more sophisticated in
         // the future.
-        if ((0, types_1.isFunction)(type) && !type.details.name) {
-            type.details = {
-                ...type.details,
-                typeVarScopeId: types_1.WildcardTypeVarScopeId,
-            };
+        if ((0, types_1.isFunction)(returnType) && !returnType.details.name) {
+            return types_1.FunctionType.cloneWithNewTypeVarScopeId(returnType, types_1.WildcardTypeVarScopeId);
         }
-        return type;
+        return returnType;
     }
     // Tries to assign the call arguments to the function parameter
     // list and reports any mismatches in types or counts. Returns the
@@ -7895,6 +7957,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const argsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 1 /* VarArgList */);
         const kwargsParam = paramSpecParams.find((paramInfo) => paramInfo.category === 2 /* VarArgDictionary */);
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        let sawUnpackedListArgument = false;
+        let sawUnpackedDictArgument = false;
         argList.forEach((arg) => {
             var _a;
             if (arg.argumentCategory === 0 /* Simple */) {
@@ -7945,15 +8009,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     /* functionType */ undefined, 
                     /* skipUnknownArgCheck */ false, 
                     /* skipOverloadArg */ false, 
-                    /* useNarrowBoundOnly */ false, conditionFilter);
+                    /* isFirstPass */ false, conditionFilter);
                     if (!argResult.isCompatible) {
                         reportedArgError = true;
                     }
                 }
             }
+            else if (arg.argumentCategory === 1 /* UnpackedList */) {
+                sawUnpackedListArgument = true;
+                // See if there is an *args parameter.
+                const argsParam = paramSpecParams.find((param) => param.category === 1 /* VarArgList */ && param.name);
+                if (argsParam && paramMap.has(argsParam.name)) {
+                    // TODO - validate args type
+                    paramMap.delete(argsParam.name);
+                }
+            }
             else {
-                // TODO - handle *args and **kwargs
-                paramMap.clear();
+                sawUnpackedDictArgument = true;
+                (0, debug_1.assert)(arg.argumentCategory === 2 /* UnpackedDictionary */);
+                // See if there is an *kwargs parameter.
+                const kwargsParam = paramSpecParams.find((param) => param.category === 2 /* VarArgDictionary */);
+                if (kwargsParam && paramMap.has(kwargsParam.name)) {
+                    // TODO - validate kwargs type
+                    paramMap.delete(kwargsParam.name);
+                }
             }
         });
         // Report any missing parameters.
@@ -7964,7 +8043,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const paramInfo = paramMap.get(name);
                 return paramInfo.category === 0 /* Simple */ && !paramInfo.hasDefault;
             });
-            if (unassignedParams.length > 0 && !paramSpecType.details.paramSpec) {
+            if (unassignedParams.length > 0 &&
+                !paramSpecType.details.paramSpec &&
+                !sawUnpackedListArgument &&
+                !sawUnpackedDictArgument) {
                 const missingParamNames = unassignedParams.map((p) => `"${p}"`).join(', ');
                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, unassignedParams.length === 1
                     ? localize_1.Localizer.Diagnostic.argMissingForParam().format({ name: missingParamNames })
@@ -7977,7 +8059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, isFirstPass, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -7986,16 +8068,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const functionName = typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.name;
         if (argParam.argument.valueExpression) {
             // If the param type is a "bare" TypeVar, don't use it as an expected
-            // type. This causes problems for cases where the the call expression
-            // result can influence the type of the TypeVar, such as in
+            // type during the first pass. This causes problems for cases where the the
+            // call expression result can influence the type of the TypeVar, such as in
             // the expression "min(1, max(2, 0.5))". We set useNarrowBoundOnly
             // to true if this is the first pass through the parameter list because
             // a wide bound on a TypeVar (if a narrow bound has not yet been established)
             // will unnecessarily constrain the expected type.
             let expectedType;
-            if (!(0, types_1.isTypeVar)(argParam.paramType) ||
+            if (!isFirstPass ||
+                !(0, types_1.isTypeVar)(argParam.paramType) ||
                 argParam.paramType.scopeId !== (typeResult === null || typeResult === void 0 ? void 0 : typeResult.type.details.typeVarScopeId)) {
-                expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, { useNarrowBoundOnly });
+                expectedType = (0, typeUtils_1.applySolvedTypeVars)(argParam.paramType, typeVarContext, {
+                    useNarrowBoundOnly: isFirstPass,
+                });
             }
             // If the expected type is unknown, don't use an expected type. Instead,
             // use default rules for evaluating the expression type.
@@ -9923,8 +10008,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Determine the minimum number of parameters that are required to
             // satisfy the lambda.
-            const minLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */ && param.defaultValue === undefined).length;
-            const maxLambdaParamCount = node.parameters.filter((param) => param.category === 0 /* Simple */).length;
+            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) => {
@@ -11103,7 +11188,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let flags = 0 /* None */;
         if (fileInfo.isStubFile) {
             // An assignment of ellipsis means "Any" within a type stub file.
-            flags |= 512 /* ConvertEllipsisToUnknown */;
+            flags |= 1 /* ConvertEllipsisToAny */;
         }
         if (node.rightExpression.nodeType === 38 /* Name */ ||
             node.rightExpression.nodeType === 35 /* MemberAccess */) {
@@ -13166,11 +13251,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
                         const inferredYieldTypes = [];
                         let useAwaitableGenerator = false;
+                        let isYieldResultUsed = false;
                         if (functionDecl.yieldStatements) {
                             functionDecl.yieldStatements.forEach((yieldNode) => {
-                                var _a;
+                                var _a, _b;
                                 if (isNodeReachable(yieldNode)) {
                                     if (yieldNode.nodeType === 61 /* YieldFrom */) {
+                                        isYieldResultUsed = true;
                                         const iteratorTypeResult = getTypeOfExpression(yieldNode.expression);
                                         if ((0, types_1.isClassInstance)(iteratorTypeResult.type) &&
                                             types_1.ClassType.isBuiltIn(iteratorTypeResult.type, 'Coroutine')) {
@@ -13185,6 +13272,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         }
                                     }
                                     else {
+                                        // If the yield expression is not by itself in a statement list,
+                                        // assume that its result is consumed.
+                                        if (((_b = yieldNode === null || yieldNode === void 0 ? void 0 : yieldNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) !== 47 /* StatementList */) {
+                                            isYieldResultUsed = true;
+                                        }
                                         if (yieldNode.expression) {
                                             const yieldType = getTypeOfExpression(yieldNode.expression).type;
                                             inferredYieldTypes.push(yieldType !== null && yieldType !== void 0 ? yieldType : types_1.UnknownType.create());
@@ -13205,10 +13297,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const generatorType = getTypingType(node, useAwaitableGenerator ? 'AwaitableGenerator' : 'Generator');
                         if (generatorType && (0, types_1.isInstantiableClass)(generatorType)) {
                             const typeArgs = [];
+                            // The "send type" for the generator (the second type argument) is
+                            // not generally inferrable, but we can assume that it's Any
+                            // if the function never uses the value and Unknown if it does.
+                            // This eliminates any "partially unknown" errors in strict mode
+                            // in the common case.
+                            const sendType = isYieldResultUsed ? types_1.UnknownType.create() : types_1.AnyType.create();
+                            typeArgs.push(inferredYieldType, sendType, (0, types_1.isNever)(inferredReturnType) ? types_1.NoneType.createInstance() : inferredReturnType);
                             if (useAwaitableGenerator) {
                                 typeArgs.push(types_1.AnyType.create());
                             }
-                            typeArgs.push(inferredYieldType, types_1.NoneType.createInstance(), (0, types_1.isNever)(inferredReturnType) ? types_1.NoneType.createInstance() : inferredReturnType);
                             inferredReturnType = types_1.ClassType.cloneAsInstance(types_1.ClassType.cloneForSpecialization(generatorType, typeArgs, 
                             /* isTypeArgumentExplicit */ true));
                         }
@@ -13736,7 +13834,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 nodeToEvaluate = parent;
                 continue;
             }
-            // The left expression of a call or member access expression is not contextual.
+            // The left expression of a call or member access expression is not generally contextual.
             if (parent.nodeType === 9 /* Call */ || parent.nodeType === 35 /* MemberAccess */) {
                 if (nodeToEvaluate === parent.leftExpression) {
                     // Handle the special case where the LHS is a call to super().
@@ -13746,6 +13844,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         nodeToEvaluate = parent;
                         continue;
                     }
+                    // Handle the special case where the LHS is a call to a lambda.
+                    if (parent.nodeType === 9 /* Call */ && nodeToEvaluate.nodeType === 30 /* Lambda */) {
+                        nodeToEvaluate = parent;
+                        continue;
+                    }
                     flags = 2 /* DoNotSpecialize */;
                     break;
                 }
@@ -15423,8 +15526,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const resolvedDecl = (_a = resolveAliasDeclaration(decl, 
                 /* resolveLocalNames */ true, 
                 /* allowExternallyHiddenAccess */ AnalyzerNodeInfo.getFileInfo(decl.node).isStubFile)) !== null && _a !== void 0 ? _a : decl;
-                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(decl);
-                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(decl);
+                const isExplicitTypeAlias = isExplicitTypeAliasDeclaration(resolvedDecl);
+                const isTypeAlias = isExplicitTypeAlias || isPossibleTypeAliasOrTypedDict(resolvedDecl);
                 if (isExplicitTypeAlias) {
                     sawExplicitTypeAlias = true;
                 }
@@ -18608,6 +18711,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.useTypingUnpack) {
             flags |= 512 /* UseTypingUnpack */;
         }
+        if (options === null || options === void 0 ? void 0 : options.printUnknownWithAny) {
+            flags |= 1 /* PrintUnknownWithAny */;
+        }
+        if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
+            flags |= 2 /* OmitTypeArgumentsIfUnknown */;
+        }
         return TypePrinter.printType(type, flags, getFunctionEffectiveReturnType);
     }
     // Calls back into the parser to parse the contents of a string literal.