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

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) {
@@ -5293,7 +5295,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,
@@ -5384,6 +5393,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 */ ||
@@ -5660,6 +5720,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;
@@ -5707,8 +5768,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);
@@ -5750,7 +5814,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) {
@@ -5775,7 +5841,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,
@@ -6031,7 +6097,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 +6159,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 +6196,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
@@ -6524,7 +6592,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);
@@ -7194,10 +7262,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) &&
@@ -7575,7 +7639,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
@@ -7632,28 +7696,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, 
+                        /* isFirstPass */ 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,11 +7732,12 @@ 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);
+            /* isFirstPass */ false, typeCondition);
             argResults.push(argResult);
             if (!argResult.isCompatible) {
                 argumentErrors = true;
@@ -7682,7 +7749,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 */) {
@@ -7800,7 +7869,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return {
             argumentErrors,
             argResults,
-            isArgumentAnyOrUnknown,
+            anyOrUnknownArgument,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -7808,19 +7877,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
@@ -7891,6 +7957,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,11 +8004,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         requiresTypeVarMatching: false,
                         argument: arg,
                         errorNode: arg.valueExpression || errorNode,
-                    }, srcTypeVarContext, 
+                    }, srcTypeVarContext, signatureTracker, 
                     /* functionType */ undefined, 
                     /* skipUnknownArgCheck */ false, 
                     /* skipOverloadArg */ false, 
-                    /* useNarrowBoundOnly */ false, conditionFilter);
+                    /* isFirstPass */ false, conditionFilter);
                     if (!argResult.isCompatible) {
                         reportedArgError = true;
                     }
@@ -7973,7 +8040,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return !reportedArgError;
     }
-    function validateArgType(argParam, typeVarContext, typeResult, skipUnknownCheck, skipOverloadArg, useNarrowBoundOnly, conditionFilter) {
+    function validateArgType(argParam, typeVarContext, signatureTracker, typeResult, skipUnknownCheck, skipOverloadArg, isFirstPass, conditionFilter) {
         var _a;
         let argType;
         let expectedTypeDiag;
@@ -7982,16 +8049,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.
@@ -8046,6 +8116,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 +9589,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 +9620,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);
                     }
                 }
             }
@@ -9924,8 +9989,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) => {
@@ -12161,6 +12226,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 +12238,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 +13369,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);
@@ -13736,7 +13802,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 +13812,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;
                 }
@@ -15497,33 +15568,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 +16128,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 +16182,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 +16241,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 +16316,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 +16341,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 diag.addAddendum(assignmentDiag);
                             }
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else if (types_1.TypeVarType.getVariance(destTypeParam) === 4 /* Contravariant */) {
@@ -16284,7 +16353,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             }));
                             childDiag.addAddendum(assignmentDiag);
                         }
-                        return false;
+                        isCompatible = false;
                     }
                 }
                 else {
@@ -16299,13 +16368,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 +16582,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 +16766,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)) {
@@ -18607,6 +18679,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.