@zzzen/pyright-internal 1.2.0-dev.20261004 → 1.2.0-dev.20261018

package/dist/analyzer/typeEvaluator.js

@@ -80,6 +80,7 @@ const namedTuples_1 = require("./namedTuples");
 const operations_1 = require("./operations");
 const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
+const parseTreeWalker_1 = require("./parseTreeWalker");
 const patternMatching_1 = require("./patternMatching");
 const properties_1 = require("./properties");
 const protocols_1 = require("./protocols");
@@ -203,8 +204,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let functionRecursionMap = new Map();
     let codeFlowAnalyzerCache = new Map();
     let typeCache = new Map();
+    let contextualLambdaTypeCache;
     let typeFormTypeCache = new Map();
     let effectiveTypeCache = new Map();
+    let exceptionTargetSymbolCache = new Map();
     let expectedTypeCache = new Map();
     let asymmetricAccessorAssignmentCache = new Set();
     let deferredClassCompletions = [];
@@ -272,6 +275,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         typeCache = new Map();
         typeFormTypeCache = new Map();
         effectiveTypeCache = new Map();
+        exceptionTargetSymbolCache = new Map();
         expectedTypeCache = new Map();
         asymmetricAccessorAssignmentCache = new Set();
     }
@@ -397,6 +401,55 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     function setTypeResultForNode(node, typeResult, flags = 0 /* EvalFlags.None */) {
         writeTypeCache(node, typeResult, flags);
     }
+    function captureContextualLambdaTypes(node, typeResult) {
+        const cache = contextualLambdaTypeCache;
+        if (!cache || !cache.lambdaNodes.some((root) => ParseTreeUtils.isNodeContainedWithin(node, root))) {
+            return;
+        }
+        captureLambdaTypeCacheEntries(node, cache, typeResult);
+    }
+    function captureLambdaTypeCacheEntries(node, cache, typeResult) {
+        checkForCancellation();
+        const entry = typeResult ? { typeResult, flags: 0 /* EvalFlags.None */, incompleteGenCount } : readTypeCacheEntry(node);
+        if (entry && !entry.typeResult.isIncomplete) {
+            captureLambdaTypeCacheEntry(node, cache, entry);
+        }
+        if (typeResult) {
+            return;
+        }
+        for (const child of (0, parseTreeWalker_1.getChildNodes)(node)) {
+            // Nested lambdas capture their own contextual types before any
+            // non-contextual fallback can replace them.
+            if (child && child.nodeType !== 33 /* ParseNodeType.Lambda */) {
+                captureLambdaTypeCacheEntries(child, cache);
+            }
+        }
+    }
+    function captureLambdaTypeCacheEntry(node, cache, entry) {
+        const nodeEntries = cache.entries.get(node) ?? new Map();
+        // Generic inference can revisit a lambda within the same callable branch.
+        nodeEntries.set(cache.branchIndex, entry);
+        cache.entries.set(node, nodeEntries);
+    }
+    function combineContextualLambdaTypes(cache) {
+        for (const [node, branchEntries] of cache.entries) {
+            checkForCancellation();
+            const nodeEntries = Array.from(branchEntries.values());
+            const lastEntry = nodeEntries[nodeEntries.length - 1];
+            writeTypeCache(node, {
+                ...lastEntry.typeResult,
+                type: (0, types_1.combineTypes)(nodeEntries.map((entry) => entry.typeResult.type)),
+                typeErrors: nodeEntries.some((entry) => entry.typeResult.typeErrors),
+            }, readTypeCacheEntry(node)?.flags ?? lastEntry.flags);
+            const parentCache = contextualLambdaTypeCache;
+            const combinedEntry = readTypeCacheEntry(node);
+            if (parentCache &&
+                combinedEntry &&
+                parentCache.lambdaNodes.some((root) => ParseTreeUtils.isNodeContainedWithin(node, root))) {
+                captureLambdaTypeCacheEntry(node, parentCache, combinedEntry);
+            }
+        }
+    }
     function getMaxCodeComplexity() {
         return maxCodeComplexity;
     }
@@ -4945,8 +4998,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // Determine if we're calling __set__ on an asymmetric descriptor or property.
         let isAsymmetricAccessor = false;
-        if (usage.method === 'set' && (0, types_1.isClass)(methodClassType)) {
-            if (isAsymmetricDescriptorClass(methodClassType)) {
+        if (usage.method === 'set') {
+            if (isAsymmetricDescriptorClass(concreteMemberType)) {
                 isAsymmetricAccessor = true;
             }
         }
@@ -5136,14 +5189,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return classType.priv.isAsymmetricDescriptor;
         }
         let isAsymmetric = false;
-        const getterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__get__', 2 /* MemberAccessFlags.SkipBaseClasses */);
-        const setterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__set__', 2 /* MemberAccessFlags.SkipBaseClasses */);
+        // Accessors can be defined at different levels of the descriptor's MRO.
+        // Ignore instance members so an instance attribute that happens to share
+        // a dunder name doesn't shadow the descriptor protocol during this check.
+        const accessorFlags = 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */;
+        const getterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__get__', accessorFlags);
+        const setterSymbolResult = (0, typeUtils_1.lookUpClassMember)(classType, '__set__', accessorFlags);
         if (!getterSymbolResult || !setterSymbolResult) {
             isAsymmetric = false;
         }
         else {
             let getterType = getTypeOfMember(getterSymbolResult);
-            const setterType = getTypeOfMember(setterSymbolResult);
+            let setterType = getTypeOfMember(setterSymbolResult);
+            // The getter and setter can be declared on different classes. Specialize
+            // both against the concrete descriptor class so Self and inherited type
+            // variables are compared in the same context.
+            if (getterSymbolResult.classType && (0, types_1.isInstantiableClass)(getterSymbolResult.classType)) {
+                getterType = (0, typeUtils_1.partiallySpecializeType)(getterType, getterSymbolResult.classType, getTypeClassType(), classType);
+            }
+            if (setterSymbolResult.classType && (0, types_1.isInstantiableClass)(setterSymbolResult.classType)) {
+                setterType = (0, typeUtils_1.partiallySpecializeType)(setterType, setterSymbolResult.classType, getTypeClassType(), classType);
+            }
             // If this is an overload, find the appropriate overload.
             if ((0, types_1.isOverloaded)(getterType)) {
                 const getOverloads = types_1.OverloadedType.getOverloads(getterType).filter((overload) => {
@@ -6085,12 +6151,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
             }
-            else if ((0, types_1.isClassInstance)(valueType) && types_1.ClassType.isBuiltIn(valueType, 'slice')) {
+            else if (usage.method === 'get' &&
+                index0Expr.nodeType === 46 /* ParseNodeType.Slice */ &&
+                (0, types_1.isClassInstance)(valueType) &&
+                types_1.ClassType.isBuiltIn(valueType, 'slice')) {
                 const tupleType = (0, typeUtils_1.getSpecializedTupleType)(baseType);
-                if (tupleType && index0Expr.nodeType === 46 /* ParseNodeType.Slice */) {
-                    const slicedTupleType = (0, tuples_1.getSlicedTupleType)(evaluatorInterface, tupleType, index0Expr);
-                    if (slicedTupleType) {
-                        return { type: slicedTupleType };
+                if (tupleType) {
+                    // Skip this if a subclass overrides the tuple's __getitem__ method.
+                    const getItemMember = (0, typeUtils_1.lookUpObjectMember)(baseType, '__getitem__', 16 /* MemberAccessFlags.SkipInstanceMembers */);
+                    const isTupleGetItem = !getItemMember ||
+                        ((0, types_1.isInstantiableClass)(getItemMember.classType) &&
+                            types_1.ClassType.isBuiltIn(getItemMember.classType, 'tuple'));
+                    if (isTupleGetItem) {
+                        const slicedTupleType = (0, tuples_1.getSlicedTupleType)(evaluatorInterface, tupleType, index0Expr);
+                        if (slicedTupleType) {
+                            return { type: slicedTupleType };
+                        }
                     }
                 }
             }
@@ -7203,7 +7279,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     // there will be only one argument list in expandedArgTypes, and all entries
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
-    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, constraints, skipUnknownArgCheck, inferenceContext, skipFinalValidation = false) {
         const returnTypes = [];
         const specializedInitSelfTypes = [];
         let matchedOverloads = [];
@@ -7246,17 +7322,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 if (!callResult.argumentErrors && callResult.returnType) {
                     if (evaluatorOptions.experimentalOverloadResult &&
                         !callResult.isTypeIncomplete &&
-                        !overload.priv.boundToType &&
-                        !overload.shared.methodClass &&
-                        !overload.shared.declaration?.isMethod &&
                         errorNode.nodeType === 9 /* ParseNodeType.Call */ &&
-                        errorNode.d.leftExpr.nodeType === 38 /* ParseNodeType.Name */ &&
-                        errorNode.parent?.nodeType === 3 /* ParseNodeType.Assignment */ &&
-                        errorNode.parent.d.rightExpr === errorNode &&
+                        (0, overloadResultSelector_1.isAutomaticOverloadSeedSyntax)(errorNode) &&
                         expandedArgTypes.length === 1 &&
-                        !hasArgTypeOverride &&
-                        callResult.argResults) {
-                        evaluatorOptions.experimentalOverloadResult.considerActivation(errorNode, callResult.argResults);
+                        !hasArgTypeOverride) {
+                        const receiver = overload.priv.boundToType;
+                        evaluatorOptions.experimentalOverloadResult.considerActivation(errorNode, receiver && (0, types_1.isClassInstance)(receiver)
+                            ? [{ argType: receiver }, ...(callResult.argResults ?? [])]
+                            : callResult.argResults ?? []);
                     }
                     overloadsUsedForCall.push(overload);
                     matchedOverload = overload;
@@ -7375,6 +7448,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         if (constraints && isDefinitiveMatchFound) {
             constraints.copyFromClone(matchedOverloads[matchedOverloads.length - 1].constraints);
         }
+        // A speculative refinement does not need to populate the type cache;
+        // the original call has already performed the normal final validation.
+        if (skipFinalValidation) {
+            return {
+                argumentErrors: false,
+                returnType: (0, types_1.combineTypes)(returnTypes),
+                isTypeIncomplete,
+                overloadsUsedForCall,
+            };
+        }
         // And run through the first expanded argument list one more time to
         // populate the type cache, without applying a different branch's constraints.
         const finalConstraints = expandedArgTypes.length > 1
@@ -7503,10 +7586,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 name: arg.d.name,
             }));
             const sources = node.d.args.map((arg) => getTypeOfExpression(arg.d.valueExpr));
-            if (sources.some((s) => s.isIncomplete || s.typeErrors || (0, types_1.isAny)(s.type) || !(0, overloadResultSelector_1.isFixedOverloadArgumentShape)(s.type, budget))) {
+            const receiver = node.d.leftExpr.nodeType === 35 /* ParseNodeType.MemberAccess */
+                ? getTypeOfExpression(node.d.leftExpr.d.leftExpr)
+                : undefined;
+            if ([...sources, ...(receiver ? [receiver] : [])].some((s) => s.isIncomplete || s.typeErrors || (0, types_1.isAny)(s.type) || !(0, overloadResultSelector_1.isFixedOverloadArgumentShape)(s.type, budget))) {
                 return decline('unsupported-argument-shape');
             }
-            if (!sources.some((s) => (0, overloadResultSelector_1.hasNestedOverloadAny)(s.type))) {
+            if (![...sources, ...(receiver ? [receiver] : [])].some((s) => (0, overloadResultSelector_1.hasNestedOverloadAny)(s.type))) {
                 return decline('no-invariant-any');
             }
             const returns = [];
@@ -7516,10 +7602,22 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const declaration = overload.shared.declaration;
                 const declaredReturnType = overload.shared.declaredReturnType;
                 const returnType = types_1.FunctionType.getEffectiveReturnType(overload);
+                const receiverParam = overload.priv.strippedFirstParamType;
+                const supportedBinding = receiver
+                    ? declaration?.isMethod &&
+                        types_1.FunctionType.isInstanceMethod(overload) &&
+                        overload.priv.boundToType &&
+                        (0, types_1.isClassInstance)(overload.priv.boundToType) &&
+                        receiverParam &&
+                        (0, types_1.isClassInstance)(receiverParam) &&
+                        (0, types_1.isClassInstance)(receiver.type) &&
+                        types_1.ClassType.isSameGenericClass(receiver.type, receiverParam) &&
+                        overload.shared.methodClass &&
+                        types_1.ClassType.isSameGenericClass(receiver.type, types_1.ClassType.cloneAsInstance(overload.shared.methodClass)) &&
+                        (0, overloadResultSelector_1.isFixedOverloadArgumentShape)(receiverParam, budget)
+                    : !declaration?.isMethod && !overload.shared.methodClass && !overload.priv.boundToType;
                 if (!declaration ||
-                    declaration.isMethod ||
-                    overload.shared.methodClass ||
-                    overload.priv.boundToType ||
+                    !supportedBinding ||
                     overload.shared.typeParams.length ||
                     !declaredReturnType ||
                     !returnType ||
@@ -7561,6 +7659,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     continue;
                 }
                 const proof = mapping.argParams.map((p, i) => (0, overloadResultSelector_1.getFixedOverloadCoverage)(sources[i].type, p.paramType, budget));
+                if (receiver && receiverParam) {
+                    proof.unshift((0, overloadResultSelector_1.getFixedOverloadCoverage)(receiver.type, receiverParam, budget));
+                }
                 const covered = proof.includes('unsupported')
                     ? 'unsupported'
                     : proof.includes('not-covered')
@@ -7585,11 +7686,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 : decline('equivalent-or-single-return');
         });
     }
-    function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext) {
+    function validateOverloadedArgTypes(errorNode, argList, typeResult, constraints, skipUnknownArgCheck, inferenceContext, candidateOverloads) {
         const filteredMatchResults = [];
         let contextFreeArgTypes;
         let isTypeIncomplete = !!typeResult.isIncomplete;
         const type = typeResult.type;
+        const overloads = candidateOverloads ?? types_1.OverloadedType.getOverloads(type);
         const speculativeNode = getSpeculativeNodeForCall(errorNode);
         // Start by evaluating the types of the arguments without any expected
         // type. Also, filter the list of overloads based on the number of
@@ -7598,7 +7700,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         // cache or record any diagnostics at this stage.
         useSpeculativeMode(speculativeNode, () => {
             let overloadIndex = 0;
-            types_1.OverloadedType.getOverloads(type).forEach((overload) => {
+            overloads.forEach((overload) => {
                 // Consider only the functions that have the @overload decorator,
                 // not the final function that omits the overload. This is the
                 // intended behavior according to PEP 484.
@@ -7615,7 +7717,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Skip the error message if we're in speculative mode because it's very
             // expensive, and we're going to suppress the diagnostic anyway.
             if (!canSkipDiagnosticForNode(errorNode)) {
-                const overloads = types_1.OverloadedType.getOverloads(type);
                 const functionName = overloads.length > 0 && overloads[0].shared.name
                     ? overloads[0].shared.name
                     : '<anonymous function>';
@@ -7670,7 +7771,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         let expandedArgTypes = [argList.map((arg) => undefined)];
         while (true) {
-            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, constraints, skipUnknownArgCheck, inferenceContext);
+            const callResult = validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, filteredMatchResults, constraints, skipUnknownArgCheck, inferenceContext, 
+            /* skipFinalValidation */ candidateOverloads !== undefined);
             if (callResult.isTypeIncomplete) {
                 isTypeIncomplete = true;
             }
@@ -7805,24 +7907,51 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }), exprNode);
             return { returnType: types_1.UnknownType.create(), argumentErrors: true, overloadsUsedForCall };
         }
-        let returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
-            return useSpeculativeMode(isLastIteration ? undefined : getSpeculativeNodeForCall(errorNode), () => {
-                const callResult = validateCallArgsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
-                if (callResult.argumentErrors) {
-                    argumentErrors = true;
-                }
-                if (callResult.isTypeIncomplete) {
-                    isTypeIncomplete = true;
-                }
-                if (callResult.overloadsUsedForCall) {
-                    (0, collectionUtils_1.appendArray)(overloadsUsedForCall, callResult.overloadsUsedForCall);
+        const concreteCallType = makeTopLevelTypeVarsConcrete(callTypeResult.type);
+        const lambdaNodes = (0, types_1.isUnion)(concreteCallType)
+            ? argList
+                .map((arg) => arg.valueExpression)
+                .filter((node) => node?.nodeType === 33 /* ParseNodeType.Lambda */)
+            : undefined;
+        const lambdaTypeCache = lambdaNodes?.length
+            ? { lambdaNodes, entries: new Map(), branchIndex: 0 }
+            : undefined;
+        const previousCache = contextualLambdaTypeCache;
+        let returnType;
+        try {
+            if (lambdaTypeCache) {
+                contextualLambdaTypeCache = lambdaTypeCache;
+            }
+            returnType = mapSubtypesExpandTypeVars(callTypeResult.type, { sortSubtypes: true }, (expandedSubtype, unexpandedSubtype, isLastIteration) => {
+                if (lambdaTypeCache) {
+                    lambdaTypeCache.branchIndex++;
                 }
-                specializedInitSelfType = callResult.specializedInitSelfType;
-                return callResult.returnType;
-            }, {
-                allowDiagnostics: true,
+                return useSpeculativeMode(isLastIteration ? undefined : getSpeculativeNodeForCall(errorNode), () => {
+                    const callResult = validateCallArgsForSubtype(errorNode, argList, expandedSubtype, unexpandedSubtype, !!callTypeResult.isIncomplete, constraints, skipUnknownArgCheck, inferenceContext, recursionCount);
+                    if (callResult.argumentErrors) {
+                        argumentErrors = true;
+                    }
+                    if (callResult.isTypeIncomplete) {
+                        isTypeIncomplete = true;
+                    }
+                    if (callResult.overloadsUsedForCall) {
+                        (0, collectionUtils_1.appendArray)(overloadsUsedForCall, callResult.overloadsUsedForCall);
+                    }
+                    specializedInitSelfType = callResult.specializedInitSelfType;
+                    return callResult.returnType;
+                }, {
+                    allowDiagnostics: true,
+                });
             });
-        });
+        }
+        finally {
+            contextualLambdaTypeCache = previousCache;
+        }
+        // Keep branch-specific checking and return inference separate from the
+        // combined contextual types retained for subsequent queries.
+        if (!isTypeIncomplete && lambdaTypeCache && lambdaTypeCache.branchIndex > 1) {
+            (0, cancellationUtils_1.invalidateTypeCacheIfCanceled)(() => combineContextualLambdaTypes(lambdaTypeCache));
+        }
         // If we ended up with a "Never" type because all code paths returned
         // undefined due to argument errors, transform the result into an Unknown
         // to avoid subsequent false positives.
@@ -8022,6 +8151,110 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return { symbol, symbolName, classType, hasImplementation };
     }
+    // The synthesized "get" and "pop" methods for a TypedDict include a
+    // catch-all overload that accepts any str key. When the key argument is a
+    // union of str literals, that catch-all overload matches before union
+    // expansion is attempted, which produces an overly-wide return type. This
+    // function evaluates the call separately for each literal key subtype
+    // (speculatively) and, if every subtype is accepted, returns the union of
+    // the resulting return types.
+    function refineTypedDictMethodCallForUnionKey(errorNode, argList, overloadedType, isCallTypeIncomplete, constraints, inferenceContext) {
+        const overloads = types_1.OverloadedType.getOverloads(overloadedType);
+        const overload = overloads[0];
+        if (!overload || !types_1.FunctionType.isSynthesizedMethod(overload)) {
+            return undefined;
+        }
+        const methodName = overload.shared.name;
+        if (methodName !== 'get' && methodName !== 'pop') {
+            return undefined;
+        }
+        const isBound = (0, types_1.isMethodType)(overload);
+        const receiverType = isBound
+            ? overload.priv.strippedFirstParamType
+            : overload.shared.parameters.length > 0
+                ? types_1.FunctionType.getParamType(overload, 0)
+                : undefined;
+        if (!receiverType || !(0, types_1.isClassInstance)(receiverType) || !types_1.ClassType.isTypedDictClass(receiverType)) {
+            return undefined;
+        }
+        // Unbound generic methods have not specialized their field types from the
+        // receiver. Keep the normal result rather than refining it to Unknown.
+        if (!isBound &&
+            ((0, typeUtils_1.requiresSpecialization)(receiverType) || (0, typeUtils_1.containsAnyOrUnknown)(receiverType, /* recurse */ true))) {
+            return undefined;
+        }
+        // Handle only simple positional calls: (key) or (key, default).
+        const keyIndex = isBound ? 0 : 1;
+        if (argList.length <= keyIndex || argList.length > keyIndex + 2) {
+            return undefined;
+        }
+        if (!argList.every((arg) => !arg.name && arg.argCategory === 0 /* ArgCategory.Simple */)) {
+            return undefined;
+        }
+        const keyArg = argList[keyIndex];
+        const keyTypeResult = keyArg.typeResult ?? (keyArg.valueExpression ? getTypeOfExpression(keyArg.valueExpression) : undefined);
+        if (!keyTypeResult || !(0, types_1.isUnion)(keyTypeResult.type)) {
+            return undefined;
+        }
+        // Every subtype must be a str literal; otherwise keep the normal result.
+        const keySubtypes = [];
+        let allStrLiterals = true;
+        (0, typeUtils_1.doForEachSubtype)(keyTypeResult.type, (subtype) => {
+            if ((0, types_1.isClassInstance)(subtype) &&
+                types_1.ClassType.isBuiltIn(subtype, 'str') &&
+                typeof subtype.priv.literalValue === 'string') {
+                keySubtypes.push(subtype);
+            }
+            else {
+                allStrLiterals = false;
+            }
+        });
+        if (!allStrLiterals || keySubtypes.length < 2 || keySubtypes.length > maxSingleOverloadArgTypeExpansionCount) {
+            return undefined;
+        }
+        let isTypeIncomplete = !!keyTypeResult.isIncomplete;
+        const returnTypes = [];
+        const overloadsUsedForCall = new Set();
+        const succeeded = useSpeculativeMode(getSpeculativeNodeForCall(errorNode), () => {
+            for (const keySubtype of keySubtypes) {
+                // Avoid revalidating unrelated keys and their default parameters.
+                const candidates = overloads.filter((candidate) => {
+                    const paramType = types_1.FunctionType.getParamType(candidate, keyIndex);
+                    return ((0, types_1.isClassInstance)(paramType) &&
+                        types_1.ClassType.isBuiltIn(paramType, 'str') &&
+                        (paramType.priv.literalValue === undefined ||
+                            paramType.priv.literalValue === keySubtype.priv.literalValue));
+                });
+                if (candidates.length === 0) {
+                    return false;
+                }
+                const subtypeArgList = [...argList];
+                subtypeArgList[keyIndex] = {
+                    argCategory: 0 /* ArgCategory.Simple */,
+                    typeResult: { type: keySubtype, isIncomplete: keyTypeResult.isIncomplete },
+                };
+                const subtypeResult = validateOverloadedArgTypes(errorNode, subtypeArgList, { type: overloadedType, isIncomplete: isCallTypeIncomplete }, constraints?.clone(), 
+                /* skipUnknownArgCheck */ true, inferenceContext, candidates);
+                if (subtypeResult.isTypeIncomplete) {
+                    isTypeIncomplete = true;
+                }
+                if (subtypeResult.argumentErrors || !subtypeResult.returnType) {
+                    return false;
+                }
+                returnTypes.push(subtypeResult.returnType);
+                subtypeResult.overloadsUsedForCall?.forEach((matched) => overloadsUsedForCall.add(matched));
+            }
+            return true;
+        });
+        if (!succeeded) {
+            return undefined;
+        }
+        return {
+            returnType: (0, types_1.combineTypes)(returnTypes),
+            isTypeIncomplete,
+            overloadsUsedForCall: [...overloadsUsedForCall],
+        };
+    }
     function validateCallForOverloaded(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, skipUnknownArgCheck, inferenceContext) {
         const overloads = types_1.OverloadedType.getOverloads(expandedCallType);
         // Handle the 'cast' call as a special case.
@@ -8034,11 +8267,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         let returnType = callResult.returnType ?? types_1.UnknownType.create();
         let isTypeIncomplete = !!callResult.isTypeIncomplete;
         let argumentErrors = !!callResult.argumentErrors;
+        let overloadsUsedForCall = callResult.overloadsUsedForCall;
         if (!argumentErrors) {
+            const refinedResult = refineTypedDictMethodCallForUnionKey(errorNode, argList, expandedCallType, isCallTypeIncomplete, constraints, inferenceContext);
+            if (refinedResult?.isTypeIncomplete) {
+                isTypeIncomplete = true;
+            }
+            if (refinedResult) {
+                overloadsUsedForCall = refinedResult.overloadsUsedForCall;
+            }
             // Call the function transform logic to handle special-cased functions.
             const transformed = (0, functionTransform_1.applyFunctionTransform)(evaluatorInterface, errorNode, argList, expandedCallType, {
                 argumentErrors: !!callResult.argumentErrors,
-                returnType: callResult.returnType ?? types_1.UnknownType.create(isTypeIncomplete),
+                returnType: refinedResult?.returnType ?? callResult.returnType ?? types_1.UnknownType.create(isTypeIncomplete),
                 isTypeIncomplete,
             });
             returnType = transformed.returnType;
@@ -8053,7 +8294,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             returnType,
             isTypeIncomplete,
             argumentErrors,
-            overloadsUsedForCall: callResult.overloadsUsedForCall,
+            overloadsUsedForCall,
             specializedInitSelfType: callResult.specializedInitSelfType,
         };
     }
@@ -10922,7 +11163,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         const tdEntries = (0, typedDicts_1.getTypedDictMembersForClass)(evaluatorInterface, unexpandedType, 
                         /* allowNarrowed */ true);
                         tdEntries.knownItems.forEach((entry, name) => {
-                            if (entry.isRequired || entry.isProvided) {
+                            if (!expectedTypedDictEntries || entry.isRequired || entry.isProvided) {
                                 keyTypes.push({
                                     node: entryNode,
                                     type: types_1.ClassType.cloneWithLiteral(strObject, name),
@@ -10931,6 +11172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                             }
                         });
                         if (!expectedTypedDictEntries) {
+                            // Open TypedDicts can contain extra items with arbitrary value types.
                             keyTypes.push({ node: entryNode, type: types_1.ClassType.cloneAsInstance(strObject) });
                             valueTypes.push({
                                 node: entryNode,
@@ -11330,27 +11572,62 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Pre-cache the incomplete function type in case the evaluation of the
             // lambda depends on itself.
             writeTypeCache(node, { type: functionType, isIncomplete: true }, 0 /* EvalFlags.None */);
-            // We assume for simplicity that the parameter signature of the lambda is
-            // the same as the expected type. If this isn't the case, we'll use
-            // object for any lambda parameters that don't match. We could make this
-            // more sophisticated in the future, but it becomes very complex to handle
-            // all of the permutations.
+            // Match positional parameters in order, but allow keyword-only parameters
+            // to be reordered. Unmatched parameters without defaults use Unknown.
             let sawParamMismatch = false;
+            let expectedParamIndex = 0;
+            let expectedKeywordParams;
+            const positionOnlySeparatorIndex = node.d.params.findIndex((param) => param.d.category === 0 /* ParamCategory.Simple */ && !param.d.name);
             node.d.params.forEach((param, index) => {
                 let paramType;
                 if (expectedParamDetails && !sawParamMismatch) {
-                    if (index < expectedParamDetails.params.length) {
-                        const expectedParam = expectedParamDetails.params[index];
+                    const isKeywordOnlySeparator = param.d.category === 1 /* ParamCategory.ArgsList */ && !param.d.name;
+                    if (isKeywordOnlySeparator) {
+                        if (expectedParamIndex < expectedParamDetails.params.length &&
+                            expectedParamDetails.params[expectedParamIndex].kind !== parameterUtils_1.ParamKind.Keyword) {
+                            sawParamMismatch = true;
+                        }
+                    }
+                    else if (expectedParamIndex < expectedParamDetails.params.length) {
+                        let expectedParam = expectedParamDetails.params[expectedParamIndex];
+                        const isPositionOnlyParam = (positionOnlySeparatorIndex >= 0 && index < positionOnlySeparatorIndex) ||
+                            (positionOnlySeparatorIndex < 0 &&
+                                paramsArePositionOnly &&
+                                !!param.d.name &&
+                                (0, symbolNameUtils_1.isPrivateName)(param.d.name.d.value));
+                        if (expectedParam.kind === parameterUtils_1.ParamKind.Keyword &&
+                            expectedParam.param.category === 0 /* ParamCategory.Simple */ &&
+                            param.d.category === 0 /* ParamCategory.Simple */ &&
+                            param.d.name &&
+                            !isPositionOnlyParam &&
+                            param.d.name.d.value !== expectedParam.param.name) {
+                            if (!expectedKeywordParams) {
+                                expectedKeywordParams = new Map();
+                                for (const keywordParam of expectedParamDetails.params) {
+                                    if (keywordParam.kind === parameterUtils_1.ParamKind.Keyword &&
+                                        keywordParam.param.category === 0 /* ParamCategory.Simple */ &&
+                                        keywordParam.param.name) {
+                                        expectedKeywordParams.set(keywordParam.param.name, keywordParam);
+                                    }
+                                }
+                            }
+                            expectedParam = expectedKeywordParams.get(param.d.name.d.value) ?? expectedParam;
+                        }
+                        const isCompatibleKeywordParam = expectedParam.kind !== parameterUtils_1.ParamKind.Keyword ||
+                            expectedParam.param.category === 2 /* ParamCategory.KwargsDict */ ||
+                            (!isPositionOnlyParam && param.d.name?.d.value === expectedParam.param.name);
                         // If the parameter category matches and both of the parameters are
                         // either separators (/ or *) or not separators, copy the type
                         // from the expected parameter.
                         if (expectedParam.param.category === param.d.category &&
-                            !param.d.name === !expectedParam.param.name) {
+                            !param.d.name === !expectedParam.param.name &&
+                            isCompatibleKeywordParam) {
                             paramType = expectedParam.type;
                         }
                         else {
                             sawParamMismatch = true;
                         }
+                        expectedParamIndex++;
                     }
                     else if (param.d.defaultValue) {
                         // If the lambda param has a default value but there is no associated
@@ -11365,15 +11642,21 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // use the default value to infer the parameter's type.
                     paramType = inferParamTypeFromDefaultValue(param.d.defaultValue);
                 }
+                if (param.d.defaultValue) {
+                    const defaultValueResult = getTypeOfExpression(param.d.defaultValue, 1 /* EvalFlags.ConvertEllipsisToAny */, (0, typeUtils_1.makeInferenceContext)(paramType));
+                    if (defaultValueResult.isIncomplete) {
+                        isIncomplete = true;
+                    }
+                    // The lambda can also be called with its own default value.
+                    if (paramType && !assignType(paramType, defaultValueResult.type)) {
+                        paramType = (0, types_1.combineTypes)([paramType, stripLiteralValue(defaultValueResult.type)]);
+                    }
+                }
                 if (param.d.name) {
                     writeTypeCache(param.d.name, {
                         type: transformVariadicParamType(node, param.d.category, paramType ?? types_1.UnknownType.create()),
                     }, 0 /* EvalFlags.None */);
                 }
-                if (param.d.defaultValue) {
-                    // Evaluate the default value if it's present.
-                    getTypeOfExpression(param.d.defaultValue, 1 /* EvalFlags.ConvertEllipsisToAny */);
-                }
                 // Determine whether we need to insert an implied position-only parameter.
                 // This is needed when a function's parameters are named using the old-style
                 // way of specifying position-only parameters.
@@ -11439,6 +11722,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                 }
+                if (expectedType && !forceSpeculative && !isIncomplete) {
+                    captureContextualLambdaTypes(node);
+                }
             }, {
                 dependentType: inferenceContext?.expectedType,
                 allowDiagnostics: !forceSpeculative && !canSkipDiagnosticForNode(node) && !inferenceContext?.isTypeIncomplete,
@@ -11449,7 +11735,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (expectedType && !assignType(expectedType, functionType)) {
                 typeErrors = true;
             }
-            return { type: functionType, isIncomplete, typeErrors };
+            const typeResult = { type: functionType, isIncomplete, typeErrors };
+            if (expectedType && !forceSpeculative && !isIncomplete) {
+                captureContextualLambdaTypes(node, typeResult);
+            }
+            return typeResult;
         });
     }
     function getTypeOfComprehension(node, flags, inferenceContext) {
@@ -13582,6 +13872,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                 }
+                else {
+                    // Callable metaclasses can return classes with different equality semantics.
+                    classType.shared.flags |= 134217728 /* ClassTypeFlags.HasUnresolvedMetaclass */;
+                }
             }
             const effectiveMetaclass = computeEffectiveMetaclass(classType, node.d.name);
             const enumMemberSetMayBeDynamicallyModified = types_1.ClassType.isEnumClass(classType) &&
@@ -14994,9 +15288,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return getExceptionType(subType, node.d.typeExpr);
         });
-        // If this is an except group, wrap the exception type in an ExceptionGroup
-        // or BaseExceptionGroup depending on whether the target exception is
-        // a BaseException.
+        // If this is an except group, use a BaseExceptionGroup when it can contain
+        // an exception outside the Exception hierarchy.
         if (node.d.isExceptGroup) {
             targetType = getBuiltInObject(node, includesBaseException ? 'BaseExceptionGroup' : 'ExceptionGroup', [
                 targetType,
@@ -17799,8 +18092,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // This will avoid a pathological performance condition for unannotated
             // code that reassigns the same variable hundreds of times. If the symbol
             // effectively has an "Any" annotation, it won't be narrowed.
-            if (symbol.getDeclarations().length > maxDeclarationsToUseForInference) {
-                return { type: types_1.UnknownType.create() };
+            const declarations = symbol.getDeclarations();
+            if (declarations.length > maxDeclarationsToUseForInference) {
+                let isExceptionVariable = exceptionTargetSymbolCache.get(symbol.id);
+                if (isExceptionVariable === undefined) {
+                    isExceptionVariable = declarations.every((decl) => {
+                        if (decl.type !== 1 /* DeclarationType.Variable */) {
+                            return false;
+                        }
+                        const parent = decl.node.parent;
+                        return parent?.nodeType === 28 /* ParseNodeType.Except */ && parent.d.name === decl.node;
+                    });
+                    exceptionTargetSymbolCache.set(symbol.id, isExceptionVariable);
+                }
+                // Exception targets get their types from code flow. Don't let the
+                // declaration-count safeguard turn repeated targets into declared Unknown.
+                if (!isExceptionVariable) {
+                    return { type: types_1.UnknownType.create() };
+                }
             }
             // There was no declaration with a defined type.
             return { type: undefined };
@@ -18430,7 +18739,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, 
                     /* diag */ undefined, 
                     /* constraints */ undefined, 
-                    /* selfConstraints */ undefined, recursionCount)) {
+                    /* selfConstraints */ undefined, 0 /* AssignTypeFlags.Default */, recursionCount)) {
                         isAssignable = false;
                     }
                 }
@@ -20131,6 +20440,34 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return true;
         }
     }
+    // Determines whether the dest accepts every argument list the source
+    // accepts, apart from parameters that overlap only when omitted.
+    function isParamListOverlapOnlyByOmission(destType, srcType, destParamDetails, srcParamDetails, recursionCount) {
+        if (destParamDetails.params.length !== srcParamDetails.params.length) {
+            return false;
+        }
+        const destScopeIds = (0, typeUtils_1.getTypeVarScopeIds)(destType);
+        const srcScopeIds = (0, typeUtils_1.getTypeVarScopeIds)(srcType);
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        return destParamDetails.params.every((destParam, index) => {
+            const srcParam = srcParamDetails.params[index];
+            if (destParam.kind !== srcParam.kind ||
+                destParam.param.category !== srcParam.param.category ||
+                destParam.param.name !== srcParam.param.name) {
+                return false;
+            }
+            if (destParam.defaultType && srcParam.defaultType) {
+                if ((0, typeUtils_1.isOverlapOnlyByOmission)(destParam.type, destParam.defaultType, srcParam.type)) {
+                    return true;
+                }
+            }
+            else if (srcParam.defaultType) {
+                return false;
+            }
+            return assignType((0, typeUtils_1.makeTypeVarsFree)(destParam.type, destScopeIds), (0, typeUtils_1.makeTypeVarsBound)(srcParam.type, srcScopeIds), 
+            /* diag */ undefined, constraints, 0 /* AssignTypeFlags.Default */, recursionCount);
+        });
+    }
     function assignFunction(destType, srcType, diag, constraints, flags, recursionCount) {
         let canAssign = true;
         const checkReturnType = (flags & 64 /* AssignTypeFlags.SkipReturnTypeCheck */) === 0;
@@ -20151,6 +20488,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             disallowExtraKwargsForTd: (flags & 131072 /* AssignTypeFlags.DisallowExtraKwargsForTd */) !== 0,
         });
         adjustSourceParamDetailsForDestVariadic(isContra ? destParamDetails : srcParamDetails, isContra ? srcParamDetails : destParamDetails);
+        let paramListOmissionResult;
+        const checkParamListOmission = () => {
+            if (paramListOmissionResult === undefined) {
+                paramListOmissionResult = isParamListOverlapOnlyByOmission(destType, srcType, destParamDetails, srcParamDetails, recursionCount);
+            }
+            return paramListOmissionResult;
+        };
         const targetIncludesParamSpec = isContra ? !!srcParamSpec : !!destParamSpec;
         const destPositionalCount = destParamDetails.firstKeywordOnlyIndex ?? destParamDetails.params.length;
         const srcPositionalCount = srcParamDetails.firstKeywordOnlyIndex ?? srcParamDetails.params.length;
@@ -20212,6 +20556,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 // be a match.
                 if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0) {
                     if (srcParam.defaultType) {
+                        if ((0, typeUtils_1.isOverlapOnlyByOmission)(destParamType, destParam.defaultType, srcParamType) &&
+                            checkParamListOmission()) {
+                            canAssign = false;
+                        }
                         continue;
                     }
                 }
@@ -20483,6 +20831,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     // be a match.
                     if (srcParamInfo.defaultType && destParamInfo.defaultType) {
                         if ((flags & 32 /* AssignTypeFlags.PartialOverloadOverlap */) !== 0) {
+                            if ((0, typeUtils_1.isOverlapOnlyByOmission)(destParamInfo.type, destParamInfo.defaultType, srcParamType) &&
+                                checkParamListOmission()) {
+                                canAssign = false;
+                            }
                             destParamMap.delete(srcParamInfo.param.name);
                             return;
                         }