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

package/dist/analyzer/typeEvaluator.js

@@ -254,6 +254,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     let dictClassType;
     let typedDictClassType;
     let typedDictPrivateClassType;
+    let mappingType;
     let printExpressionSpaceCount = 0;
     let incompleteGenerationCount = 0;
     const returnTypeInferenceContextStack = [];
@@ -503,6 +504,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             dictClassType = getBuiltInType(node, 'dict');
             typedDictClassType = getTypingType(node, 'TypedDict');
             typedDictPrivateClassType = getTypingType(node, '_TypedDict');
+            mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
+            if (!mappingType) {
+                // Fall back on 'Mapping' if 'SupportsKeysAndGetItem' is not available.
+                mappingType = getTypingType(node, 'Mapping');
+            }
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
@@ -2272,11 +2278,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const sourceEntryTypes = tupleType.tupleTypeArguments.map((t) => (0, typeUtils_1.addConditionToType)(t.type, (0, typeUtils_1.getTypeCondition)(subtype)));
                 const unboundedIndex = tupleType.tupleTypeArguments.findIndex((t) => t.isUnbounded);
                 if (unboundedIndex >= 0) {
-                    if (sourceEntryTypes.length > targetTypes.length) {
-                        // Splice out the unbounded since it might be zero length.
-                        sourceEntryTypes.splice(unboundedIndex, 1);
-                    }
-                    else if (sourceEntryTypes.length < targetTypes.length) {
+                    if (sourceEntryTypes.length < targetTypes.length) {
                         const typeToReplicate = sourceEntryTypes.length > 0 ? sourceEntryTypes[unboundedIndex] : types_1.AnyType.create();
                         // Add elements to make the count match the target count.
                         while (sourceEntryTypes.length < targetTypes.length) {
@@ -6031,7 +6033,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // one or more analyzes with no errors, use those results.
             if (inferenceContext) {
                 const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, initMethodType);
-                if (expectedCallResult) {
+                if (expectedCallResult && !expectedCallResult.argumentErrors) {
                     returnType = expectedCallResult.returnType;
                     if (expectedCallResult.isTypeIncomplete) {
                         isTypeIncomplete = true;
@@ -6093,12 +6095,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             if (constructorMethodInfo && !skipConstructorCheck(constructorMethodInfo.type)) {
                 const constructorMethodType = constructorMethodInfo.type;
+                let newReturnType;
                 // If there is an expected type that was not applied above when
                 // handling the __init__ method, try to apply it with the __new__ method.
                 if (inferenceContext && !returnType) {
                     const expectedCallResult = validateConstructorMethodWithExpectedType(errorNode, argList, type, skipUnknownArgCheck, inferenceContext, constructorMethodType);
-                    if (expectedCallResult) {
-                        returnType = expectedCallResult.returnType;
+                    if (expectedCallResult && !expectedCallResult.argumentErrors) {
+                        newReturnType = expectedCallResult.returnType;
+                        returnType = newReturnType;
                         if (expectedCallResult.isTypeIncomplete) {
                             isTypeIncomplete = true;
                         }
@@ -6128,8 +6132,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (callResult.argumentErrors) {
                     reportedErrors = true;
                 }
-                else {
-                    let newReturnType = callResult.returnType;
+                else if (!newReturnType) {
+                    newReturnType = callResult.returnType;
                     // 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
@@ -7194,10 +7198,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                     }
                     else {
-                        let mappingType = getTypeshedType(errorNode, 'SupportsKeysAndGetItem');
-                        if (!mappingType) {
-                            mappingType = getTypingType(errorNode, 'Mapping');
-                        }
                         const strObjType = getBuiltInObject(errorNode, 'str');
                         if (mappingType &&
                             (0, types_1.isInstantiableClass)(mappingType) &&
@@ -7632,28 +7632,30 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // 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();
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
-                        if (argParam.requiresTypeVarMatching) {
-                            // Populate the typeVarContext for the argument. If the argument
-                            // is an overload function, skip it during the first pass
-                            // because the selection of the proper overload may depend
-                            // on type arguments supplied by other function arguments.
-                            // Set useNarrowBoundOnly to true the first time through
-                            // the loop if we're going to go through the loop multiple
-                            // times.
-                            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
-                            /* skipOverloadArg */ i === 0, 
-                            /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
-                            if (argResult.isTypeIncomplete) {
-                                isTypeIncomplete = true;
-                            }
-                            // If we skipped a overload arg during the first pass,
-                            // add another pass to ensure that we handle all of the
-                            // type variables.
-                            if (i === 0 && argResult.skippedOverloadArg) {
-                                passCount++;
-                            }
+                        if (!argParam.requiresTypeVarMatching) {
+                            return;
+                        }
+                        // Populate the typeVarContext for the argument. If the argument
+                        // is an overload function, skip it during the first pass
+                        // because the selection of the proper overload may depend
+                        // on type arguments supplied by other function arguments.
+                        // Set useNarrowBoundOnly to true the first time through
+                        // the loop if we're going to go through the loop multiple
+                        // times.
+                        const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
+                        /* skipOverloadArg */ i === 0, 
+                        /* useNarrowBoundOnly */ passCount > 1 && i === 0, typeCondition);
+                        if (argResult.isTypeIncomplete) {
+                            isTypeIncomplete = true;
+                        }
+                        // If we skipped a overload arg during the first pass,
+                        // add another pass to ensure that we handle all of the
+                        // type variables.
+                        if (i === 0 && argResult.skippedOverloadArg) {
+                            passCount++;
                         }
                     });
                 });
@@ -7666,9 +7668,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecKwargs = false;
         let condition = [];
         const argResults = [];
+        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         matchResults.argParams.forEach((argParam) => {
             var _a;
-            const argResult = validateArgType(argParam, typeVarContext, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
+            const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, skipUnknownArgCheck, 
             /* skipOverloadArg */ false, 
             /* useNarrowBoundOnly */ false, typeCondition);
             argResults.push(argResult);
@@ -7891,6 +7894,7 @@ 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();
         argList.forEach((arg) => {
             var _a;
             if (arg.argumentCategory === 0 /* Simple */) {
@@ -7937,7 +7941,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
-                    }, srcTypeVarContext, 
+                    }, srcTypeVarContext, signatureTracker, 
                     /* functionType */ undefined, 
                     /* skipUnknownArgCheck */ false, 
                     /* skipOverloadArg */ false, 
@@ -7973,7 +7977,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -8046,6 +8050,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
+        // If the type includes multiple instances of a generic function
+        // signature, force the type arguments for the duplicates to have
+        // unique names.
+        argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
         // If we're assigning to a var arg dictionary with a TypeVar type,
         // strip literals before performing the assignment. This is used in
         // places like a dict constructor.
@@ -9515,13 +9523,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addUnknown = false;
             }
             else if (entryNode.nodeType === 16 /* DictionaryExpandEntry */) {
-                // Verify that the type supports the `keys` and `__getitem__` methods.
-                // This protocol is defined in the _typeshed stub. If we can't find
-                // it there, fall back on typing.Mapping.
-                let mappingType = getTypeshedType(node, 'SupportsKeysAndGetItem');
-                if (!mappingType) {
-                    mappingType = getTypingType(node, 'Mapping');
-                }
                 let expectedType;
                 if (expectedKeyType && expectedValueType) {
                     if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
@@ -9553,29 +9554,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         addUnknown = false;
                     }
                 }
-                else {
-                    if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
-                        const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
-                        // Self-specialize the class.
-                        mappingType = types_1.ClassType.cloneForSpecialization(mappingType, mappingType.details.typeParameters, 
-                        /* isTypeArgumentExplicit */ true);
-                        if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
-                        /* diag */ undefined, mappingTypeVarContext, 
-                        /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
-                            const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
-                            const typeArgs = specializedMapping.typeArguments;
-                            if (typeArgs && typeArgs.length >= 2) {
-                                if (forceStrictInference || index < maxEntriesToUseForInference) {
-                                    keyTypes.push({ node: entryNode, type: typeArgs[0] });
-                                    valueTypes.push({ node: entryNode, type: typeArgs[1] });
-                                }
-                                addUnknown = false;
+                else if (mappingType && (0, types_1.isInstantiableClass)(mappingType)) {
+                    const mappingTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(mappingType));
+                    // Self-specialize the class.
+                    mappingType = types_1.ClassType.cloneForSpecialization(mappingType, mappingType.details.typeParameters, 
+                    /* isTypeArgumentExplicit */ true);
+                    if (assignType(types_1.ClassType.cloneAsInstance(mappingType), unexpandedType, 
+                    /* diag */ undefined, mappingTypeVarContext, 
+                    /* srcTypeVarContext */ undefined, 128 /* RetainLiteralsForTypeVar */)) {
+                        const specializedMapping = (0, typeUtils_1.applySolvedTypeVars)(mappingType, mappingTypeVarContext);
+                        const typeArgs = specializedMapping.typeArguments;
+                        if (typeArgs && typeArgs.length >= 2) {
+                            if (forceStrictInference || index < maxEntriesToUseForInference) {
+                                keyTypes.push({ node: entryNode, type: typeArgs[0] });
+                                valueTypes.push({ node: entryNode, type: typeArgs[1] });
                             }
+                            addUnknown = false;
                         }
-                        else {
-                            const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-                            addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictUnpackIsNotMapping(), entryNode);
-                        }
+                    }
+                    else {
+                        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
+                        addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dictUnpackIsNotMapping(), entryNode);
                     }
                 }
             }
@@ -12161,6 +12160,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         }
                         argList.forEach((arg) => {
                             var _a, _b, _c;
+                            const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
                             if (arg.argumentCategory === 0 /* Simple */ && arg.name) {
                                 const paramIndex = (_a = paramMap.get(arg.name.value)) !== null && _a !== void 0 ? _a : paramListDetails.kwargsIndex;
                                 if (paramIndex !== undefined) {
@@ -12172,7 +12172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                         argument: arg,
                                         errorNode: (_b = arg.valueExpression) !== null && _b !== void 0 ? _b : errorNode,
                                     };
-                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), { type: newMethodType }, 
+                                    validateArgType(argParam, new typeVarContext_1.TypeVarContext(), signatureTracker, { type: newMethodType }, 
                                     /* skipUnknownCheck */ true, 
                                     /* skipOverloadArg */ true, 
                                     /* useNarrowBoundOnly */ false, 
@@ -13303,9 +13303,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return getExceptionType(subType, node.typeExpression);
         });
-        // If this is an except group, wrap the exception type in an ExceptionGroup.
+        // If this is an except group, wrap the exception type in an BaseExceptionGroup.
         if (node.isExceptGroup) {
-            targetType = getBuiltInObject(node, 'ExceptionGroup', [targetType]);
+            targetType = getBuiltInObject(node, 'BaseExceptionGroup', [targetType]);
         }
         if (node.name) {
             assignTypeToExpression(node.name, targetType, /* isIncomplete */ false, node.name);
@@ -15497,33 +15497,31 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         });
+        // How many times have we already attempted to evaluate this declaration already?
+        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;
+        let resultType;
         if (typesToCombine.length > 0) {
-            // How many times have we already attempted to evaluate this declaration already?
-            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;
             // Ignore the pending evaluation flag if we've already attempted the
             // type evaluation many times because this probably means there's a
             // cyclical dependency that cannot be broken.
             isIncomplete = sawPendingEvaluation && evaluationAttempts < maxEffectiveTypeEvaluationAttempts;
-            const result = {
-                type: (0, types_1.combineTypes)(typesToCombine),
-                isIncomplete,
-                includesVariableDecl,
-                includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
-                isRecursiveDefinition: false,
-                evaluationAttempts,
-            };
-            if (!includesSpeculativeResult) {
-                addToEffectiveTypeCache(result);
-            }
-            return result;
+            resultType = (0, types_1.combineTypes)(typesToCombine);
         }
-        return {
-            type: types_1.UnboundType.create(),
+        else {
+            resultType = types_1.UnboundType.create();
+        }
+        const result = {
+            type: resultType,
             isIncomplete,
             includesVariableDecl,
             includesIllegalTypeAliasDecl: !decls.every((decl) => isPossibleTypeAliasDeclaration(decl)),
             isRecursiveDefinition: false,
+            evaluationAttempts,
         };
+        if (!includesSpeculativeResult) {
+            addToEffectiveTypeCache(result);
+        }
+        return result;
         function addToEffectiveTypeCache(result) {
             // Add the entry to the cache so we don't need to compute it next time.
             if (!cacheEntries) {
@@ -16059,7 +16057,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         });
         return isAssignable;
     }
-    function assignTupleTypeArgs(destType, srcType, diag, typeVarContext, flags, recursionCount) {
+    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 : [])];
@@ -16113,8 +16111,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (srcTypeArgs.length === destTypeArgs.length) {
             for (let argIndex = 0; argIndex < srcTypeArgs.length; argIndex++) {
                 const entryDiag = diag === null || diag === void 0 ? void 0 : diag.createAddendum();
-                if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), typeVarContext, 
-                /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                if (!assignType(destTypeArgs[argIndex].type, srcTypeArgs[argIndex].type, entryDiag === null || entryDiag === void 0 ? void 0 : entryDiag.createAddendum(), destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
                     if (entryDiag) {
                         entryDiag.addMessage(localize_1.Localizer.DiagnosticAddendum.tupleEntryTypeMismatch().format({
                             entry: argIndex + 1,
@@ -16173,7 +16170,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Handle built-in types that support arbitrary numbers
             // of type parameters like Tuple.
             if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-                return assignTupleTypeArgs(destType, curSrcType, diag, curDestTypeVarContext, flags, recursionCount);
+                return assignTupleTypeArgs(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
             }
             // If there are no type parameters on this class, we're done.
             const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
@@ -16248,6 +16245,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             destTypeArgs = destType.typeArguments;
             srcTypeArgs = srcType.typeArguments;
         }
+        let isCompatible = true;
         if (srcTypeArgs) {
             for (let srcArgIndex = 0; srcArgIndex < srcTypeArgs.length; srcArgIndex++) {
                 const srcTypeArg = srcTypeArgs[srcArgIndex];
@@ -16272,7 +16270,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 diag.addAddendum(assignmentDiag);
                             }
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
@@ -16284,7 +16282,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }));
                             childDiag.addAddendum(assignmentDiag);
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else {
@@ -16299,13 +16297,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 }));
                                 childDiag.addAddendum(assignmentDiag);
                             }
-                            return false;
+                            isCompatible = false;
                         }
                     }
                 }
             }
         }
-        return true;
+        return isCompatible;
     }
     // Determines if the source type can be assigned to the dest type.
     // If typeVarContext is provided, type variables within the destType are
@@ -16513,6 +16511,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         if ((0, types_1.isNever)(srcType)) {
+            if ((flags & 1 /* EnforceInvariance */) !== 0) {
+                return (0, types_1.isNever)(destType);
+            }
             const targetTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
             if (targetTypeVarContext) {
                 (0, typeUtils_1.setTypeArgumentsRecursive)(destType, types_1.UnknownType.create(), targetTypeVarContext, recursionCount);
@@ -16694,9 +16695,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (destCallbackType) {
                     return assignType(destCallbackType, concreteSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
-                // All functions are objects, so try to assign as an object.
-                if (objectType && (0, types_1.isClassInstance)(objectType)) {
-                    return assignType(destType, objectType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
+                // All functions are considered instances of "builtins.function".
+                if (functionObj && (0, types_1.isClassInstance)(functionObj)) {
+                    return assignType(destType, functionObj, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
                 }
             }
             else if ((0, types_1.isModule)(concreteSrcType)) {