@zzzen/pyright-internal 1.2.0-dev.20230528 → 1.2.0-dev.20230604

package/dist/analyzer/typeEvaluator.js

@@ -5170,7 +5170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         else {
             const tupleTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(tupleClassType));
-            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+            if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneAsInstance(tupleClassType), inferenceContext.expectedType, tupleTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
                 return undefined;
             }
             const specializedTuple = (0, typeUtils_1.applySolvedTypeVars)(tupleClassType, tupleTypeVarContext);
@@ -5685,7 +5685,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
-        var _a, _b;
+        var _a, _b, _c;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
@@ -5774,19 +5774,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let isSubtypeSubsumed = false;
                         for (let dedupedIndex = 0; dedupedIndex < dedupedMatchResults.length; dedupedIndex++) {
                             if (assignType(dedupedMatchResults[dedupedIndex], result.returnType)) {
-                                if (!(0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(dedupedMatchResults[dedupedIndex], 
+                                /* recurse */ false);
+                                if (!anyOrUnknown) {
                                     isSubtypeSubsumed = true;
                                 }
-                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                else if ((0, types_1.isAny)(anyOrUnknown)) {
                                     dedupedResultsIncludeAny = true;
                                 }
                                 break;
                             }
                             else if (assignType(result.returnType, dedupedMatchResults[dedupedIndex])) {
-                                if (!(0, typeUtils_1.containsAnyOrUnknown)(result.returnType)) {
+                                const anyOrUnknown = (0, typeUtils_1.containsAnyOrUnknown)(result.returnType, /* recurse */ false);
+                                if (!anyOrUnknown) {
                                     dedupedMatchResults[dedupedIndex] = types_1.NeverType.createNever();
                                 }
-                                else if (!(0, typeUtils_1.containsUnknown)(dedupedMatchResults[dedupedIndex])) {
+                                else if ((0, types_1.isAny)(anyOrUnknown)) {
                                     dedupedResultsIncludeAny = true;
                                 }
                                 break;
@@ -5809,7 +5812,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveReturnType = types_1.AnyType.create();
                         }
                         else {
-                            effectiveReturnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
+                            // If all of the return types are the same generic class,
+                            // replace the type arguments with Unknown. Otherwise return
+                            // an Unknown type that has associated "possible types" to aid
+                            // with completion suggestions.
+                            effectiveReturnType =
+                                (_c = (0, typeUtils_1.getCommonErasedType)(dedupedMatchResults)) !== null && _c !== void 0 ? _c : types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
                         }
                     }
                     returnTypes.push(effectiveReturnType);
@@ -5850,6 +5858,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (matches.length < 2) {
             return matches;
         }
+        // If the relevance of some matches differs, filter out the ones that
+        // are lower relevance. This favors *args parameters in cases where
+        // a *args argument is used.
+        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
+            matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
+            if (matches.length < 2) {
+                return matches;
+            }
+        }
         // If all of the return types match, select the first one.
         if ((0, typeUtils_1.areTypesSame)(matches.map((match) => match.returnType), { treatAnySameAsUnknown: true })) {
             return [matches[0]];
@@ -5859,9 +5876,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return matches;
         }
         for (let i = 0; i < firstArgResults.length; i++) {
-            // If the arg is Any or Unknown, see if the corresponding
+            // If the arg contains Any or Unknown, see if the corresponding
             // parameter types differ in any way.
-            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
+            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(firstArgResults[i].argType, /* recurse */ true);
+            if (anyOrUnknownInArg) {
                 const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
                     ? match.matchResults.argParams[i].paramType
                     : types_1.UnknownType.create());
@@ -7319,7 +7337,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 if ((0, types_1.isClassInstance)(effectiveExpectedType) && !(0, types_1.isTypeSame)(effectiveReturnType, effectiveExpectedType)) {
                     const tempTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(effectiveReturnType));
-                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes);
+                    (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, effectiveReturnType, effectiveExpectedType, tempTypeVarContext, liveTypeVarScopes, errorNode.start);
                     const genericReturnType = types_1.ClassType.cloneForSpecialization(effectiveReturnType, 
                     /* typeArguments */ undefined, 
                     /* isTypeArgumentExplicit */ false);
@@ -7335,7 +7353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     });
                 }
             }
-            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes);
+            effectiveExpectedType = (0, typeUtils_1.transformExpectedType)(effectiveExpectedType, liveTypeVarScopes, errorNode.start);
             assignType(effectiveReturnType, effectiveExpectedType, 
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
@@ -7347,7 +7365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
-        let anyOrUnknownArgument;
+        let accumulatedAnyOrUnknownArg;
         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
@@ -7400,11 +7418,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // example of this is the built-in "map" method whose first parameter is
             // a lambda and second parameter indicates what type the lambda should accept.
             // In practice, we will limit the number of passes to 2 because it can get
-            // very expensive to go beyond this, and we don't see generally see cases
+            // very expensive to go beyond this, and we don't generally see cases
             // where more than two passes are needed.
             let passCount = Math.min(typeVarMatchingCount, 2);
             for (let i = 0; i < passCount; i++) {
                 const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+                signatureTracker.addSignature(type);
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
@@ -7449,6 +7468,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let condition = [];
         const argResults = [];
         const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
+        signatureTracker.addSignature(type);
         matchResults.argParams.forEach((argParam) => {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
@@ -7465,10 +7485,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argResult.condition) {
                 condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
             }
-            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
-                anyOrUnknownArgument = anyOrUnknownArgument
-                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument)
-                    : argResult.argType;
+            // Determine if the argument type contains an Any or Unknown. Accumulate
+            // these across all arguments.
+            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(argResult.argType, /* recurs */ true);
+            if (anyOrUnknownInArg) {
+                accumulatedAnyOrUnknownArg = accumulatedAnyOrUnknownArg
+                    ? (0, typeUtils_1.preserveUnknown)(anyOrUnknownInArg, accumulatedAnyOrUnknownArg)
+                    : anyOrUnknownInArg;
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
@@ -7579,7 +7602,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return {
             argumentErrors,
             argResults,
-            anyOrUnknownArgument,
+            anyOrUnknownArgument: accumulatedAnyOrUnknownArg,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -7739,7 +7762,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (paramType) {
                     const argResult = validateArgType({
                         paramCategory: 0 /* Simple */,
-                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes),
+                        paramType: (0, typeUtils_1.transformExpectedType)(paramType, liveTypeVarScopes, /* usageOffset */ undefined),
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
@@ -8017,7 +8040,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!options.skipUnknownArgCheck) {
             const simplifiedType = (0, types_1.removeUnbound)(argType);
             const fileInfo = AnalyzerNodeInfo.getFileInfo(argParam.errorNode);
-            const getDiagAddendum = () => {
+            function getDiagAddendum() {
                 const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                 if (argParam.paramName) {
                     diagAddendum.addMessage((functionName
@@ -8029,7 +8052,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         diagAddendum.getString());
                 }
                 return diagAddendum;
-            };
+            }
             // Do not check for unknown types if the expected type is "Any".
             // Don't print types if reportUnknownArgumentType is disabled for performance.
             if (fileInfo.diagnosticRuleSet.reportUnknownArgumentType !== 'none' &&
@@ -8720,7 +8743,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const dictTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInDict));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInDict, inferenceContext.expectedType, dictTypeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedDict = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInDict), dictTypeVarContext);
@@ -8982,7 +9005,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return undefined;
         }
         const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(builtInListOrSet));
-        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node))) {
+        if (!(0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, builtInListOrSet, inferenceContext.expectedType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start)) {
             return undefined;
         }
         const specializedListOrSet = (0, typeUtils_1.applySolvedTypeVars)(types_1.ClassType.cloneAsInstantiable(builtInListOrSet), typeVarContext);
@@ -9203,7 +9226,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             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));
             });
         }
@@ -9265,10 +9290,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 type: types_1.UnknownType.create(),
             });
         }
-        // Handle the case where the expected type contains a ParamSpec.
-        if (expectedFunctionType === null || expectedFunctionType === void 0 ? void 0 : expectedFunctionType.details.paramSpec) {
-            functionType.details.paramSpec = expectedFunctionType.details.paramSpec;
-        }
         const expectedReturnType = expectedFunctionType
             ? getFunctionEffectiveReturnType(expectedFunctionType)
             : undefined;
@@ -9742,7 +9763,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     let isLiteralType = true;
                     (0, typeUtils_1.doForEachSubtype)(exprType.type, (subtype) => {
                         if (!(0, types_1.isInstantiableClass)(subtype) || subtype.literalValue === undefined) {
-                            isLiteralType = false;
+                            if (!(0, types_1.isNoneTypeClass)(subtype)) {
+                                isLiteralType = false;
+                            }
                         }
                     });
                     if (isLiteralType) {
@@ -11033,7 +11056,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
             const newDecoratedType = applyClassDecorator(decoratedType, classType, decorator);
-            if ((0, typeUtils_1.containsUnknown)(newDecoratedType)) {
+            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
+            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
                 if (!foundUnknown) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedClassDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.Localizer.Diagnostic.classDecoratorTypeUnknown(), node.decorators[i].expression);
@@ -11867,7 +11891,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
             const newDecoratedType = applyFunctionDecorator(decoratedType, functionType, decorator, node);
-            if ((0, typeUtils_1.containsUnknown)(newDecoratedType)) {
+            const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
+            if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
                 if (!foundUnknown) {
                     addDiagnostic(fileInfo.diagnosticRuleSet.reportUntypedFunctionDecorator, diagnosticRules_1.DiagnosticRule.reportUntypedFunctionDecorator, localize_1.Localizer.Diagnostic.functionDecoratorTypeUnknown(), node.decorators[i].expression);
@@ -15034,6 +15059,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             types_1.FunctionType.hasUnannotatedParams(type) &&
             !types_1.FunctionType.isStubDefinition(type) &&
             !types_1.FunctionType.isPyTypedDefinition(type) &&
+            !types_1.FunctionType.isWrapReturnTypeInAwait(type) &&
             args) {
             const contextualReturnType = getFunctionInferredReturnTypeUsingArguments(type, args);
             if (contextualReturnType) {
@@ -15386,10 +15412,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isAssignable;
     }
-    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
-        var _a, _b;
-        const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
-        const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
+    // Adjusts the source type arguments list to match the length of the
+    // dest type arguments list if the dest list contains an unbounded
+    // or variadic entry.
+    function adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs) {
         const destVariadicIndex = destTypeArgs.findIndex((t) => (0, types_1.isVariadicTypeVar)(t.type));
         const destUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
         const srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
@@ -15437,6 +15463,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+    }
+    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+        var _a, _b;
+        const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
+        const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
+        let srcUnboundedIndex;
+        if (flags & 2 /* ReverseTypeVarMatching */) {
+            adjustSourceTupleTypeArgs(srcTypeArgs, destTypeArgs);
+            srcUnboundedIndex = destTypeArgs.findIndex((t) => t.isUnbounded);
+        }
+        else {
+            adjustSourceTupleTypeArgs(destTypeArgs, srcTypeArgs);
+            srcUnboundedIndex = srcTypeArgs.findIndex((t) => t.isUnbounded);
+        }
         if (srcTypeArgs.length === destTypeArgs.length) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
@@ -17170,7 +17210,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(assignedType));
             (0, constraintSolver_1.populateTypeVarContextBasedOnExpectedType)(evaluatorInterface, types_1.ClassType.cloneForSpecialization(assignedType, 
             /* typeArguments */ undefined, 
-            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node));
+            /* isTypeArgumentExplicit */ false), declaredType, typeVarContext, ParseTreeUtils.getTypeVarScopesForNode(node), node.start);
             let replacedTypeArg = false;
             const newTypeArgs = assignedType.typeArguments.map((typeArg, index) => {
                 const typeParam = assignedType.details.typeParameters[index];
@@ -17267,25 +17307,42 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames);
             }
             // For an overload overriding a base method, at least one overload
-            // must be compatible with the base method.
-            if (types_1.OverloadedFunctionType.getOverloads(overrideMethod).some((overrideOverload) => {
+            // or the implementation must be compatible with the base method.
+            if (overrideMethod.overloads.some((overrideOverload) => {
                 return validateOverrideMethodInternal(baseMethod, overrideOverload, 
                 /* diag */ undefined, enforceParamNames);
             })) {
                 return true;
             }
-            // Or the implementation must be compatible.
-            const overrideImplementation = types_1.OverloadedFunctionType.getImplementation(overrideMethod);
-            if (overrideImplementation) {
-                if (validateOverrideMethodInternal(baseMethod, overrideImplementation, 
-                /* diag */ undefined, enforceParamNames)) {
-                    return true;
-                }
-            }
             diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNoOverloadMatches());
             return false;
         }
-        // TODO - need to implement the case where the base method is overloaded
+        // For a non-overloaded method overriding an overloaded method, the
+        // override must match all of the overloads.
+        if ((0, types_1.isFunction)(overrideMethod)) {
+            return types_1.OverloadedFunctionType.getOverloads(baseMethod).every((overload) => validateOverrideMethodInternal(overload, overrideMethod, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), enforceParamNames));
+        }
+        // For an overloaded method overriding an overloaded method, the overrides
+        // must all match and be in the correct order. It is OK if the base method
+        // has additional overloads that are not present in the override.
+        let previousMatchIndex = -1;
+        let overrideOverloadIndex = 0;
+        for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
+            const matchIndex = types_1.OverloadedFunctionType.getOverloads(baseMethod).findIndex((baseOverload) => {
+                return validateOverrideMethodInternal(baseOverload, overrideOverload, 
+                /* diag */ undefined, enforceParamNames);
+            });
+            if (matchIndex < 0) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex }));
+                return false;
+            }
+            if (matchIndex < previousMatchIndex) {
+                diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadOrder());
+                return false;
+            }
+            previousMatchIndex = matchIndex;
+            overrideOverloadIndex++;
+        }
         return true;
     }
     function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {