@zzzen/pyright-internal 1.2.0-dev.20261011 → 1.2.0-dev.20261101

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,6 +204,7 @@ 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();
@@ -399,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;
     }
@@ -688,6 +739,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
+        const result = getTypeOfExpressionWithCache(node, flags, inferenceContext);
+        if ((flags & 268435456 /* EvalFlags.StripTupleLiterals */) !== 0 && result.type.props?.inferredTupleLiteral) {
+            return { ...result, type: (0, types_1.getInferredTupleLiteralBase)(result.type) };
+        }
+        return result;
+    }
+    function getTypeOfExpressionWithCache(node, flags = 0 /* EvalFlags.None */, inferenceContext) {
         if (evaluatorOptions.experimentalOverloadResult?.needsActivationBoundary()) {
             return runWithOverloadActivation(() => getTypeOfExpression(node, flags, inferenceContext));
         }
@@ -1119,6 +1177,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             return getTypeOfStringListAsType(node, flags);
         }
         const isBytesNode = (node) => (node.d.token.flags & 32 /* StringTokenFlags.Bytes */) !== 0;
+        const isTemplateNode = (node) => (node.d.token.flags & 128 /* StringTokenFlags.Template */) !== 0;
+        // Check for mixing of t-string literals with str, bytes, or f-string
+        // literals. CPython reports this as a SyntaxError (PEP 750).
+        const firstTemplateIndex = node.d.strings.findIndex(isTemplateNode);
+        const firstNonTemplateIndex = node.d.strings.findIndex((str) => !isTemplateNode(str));
+        if (firstTemplateIndex >= 0 && firstNonTemplateIndex >= 0) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.mixingTemplateAndStr(), node.d.strings[Math.max(firstTemplateIndex, firstNonTemplateIndex)]);
+            return { type: types_1.UnknownType.create() };
+        }
         // Check for mixing of bytes and str, which is not allowed.
         const firstStrIndex = node.d.strings.findIndex((str) => !isBytesNode(str));
         const firstBytesIndex = node.d.strings.findIndex((str) => isBytesNode(str));
@@ -1339,7 +1406,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         return (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
             if ((0, types_1.isClass)(subtype)) {
-                if (subtype.priv.literalValue !== undefined) {
+                // A sentinel literal represents a stable singleton, so stripping
+                // it cannot produce a wider instance type.
+                if (subtype.priv.literalValue !== undefined && !(0, typeUtils_1.isSentinelLiteral)(subtype)) {
                     subtype = types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined);
                 }
                 if (types_1.ClassType.isBuiltIn(subtype, 'LiteralString')) {
@@ -2741,6 +2810,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const declarations = symbolWithScope.symbol.getDeclarations();
         let declaredType = getDeclaredTypeOfSymbol(symbolWithScope.symbol)?.type;
         const fileInfo = nodeInfo.getFileInfo(nameNode);
+        // Class-scope aliases need the canonical method type for binding and override checks.
+        if (declaredType === undefined && symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
+            const methodType = getMethodFromDescriptor(typeResult.type);
+            if (methodType) {
+                typeResult = { ...typeResult, type: methodType };
+            }
+        }
         // If this is a class scope and there is no type declared for this class variable,
         // see if a parent class has a type declared.
         if (declaredType === undefined && symbolWithScope.scope.type === 3 /* ScopeType.Class */) {
@@ -3237,8 +3313,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                     // This code path can often produce many duplicate subtypes. We can
                     // reduce the cost of the combineTypes call below by filtering out these
-                    // duplicates proactively.
+                    // duplicates proactively. Equal retained tuple literals can carry
+                    // different inference fallbacks, which combineTypes must reconcile.
                     if (newSubtypes.length === 0 ||
+                        transformedType.props?.inferredTupleLiteral ||
+                        newSubtypes[newSubtypes.length - 1].props?.inferredTupleLiteral ||
                         !(0, types_1.isTypeSame)(transformedType, newSubtypes[newSubtypes.length - 1])) {
                         newSubtypes.push(transformedType);
                     }
@@ -3679,8 +3758,101 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
             }
         }
+        // Bare names expose descriptors without changing the canonical types of method declarations.
+        if ((flags & 256 /* EvalFlags.TypeExpression */) === 0) {
+            type = (0, typeUtils_1.mapSubtypes)(type, (subtype) => {
+                if (!(0, types_1.isFunctionOrOverloaded)(subtype)) {
+                    return subtype;
+                }
+                const signature = (0, types_1.isFunction)(subtype) ? subtype : types_1.OverloadedType.getOverloads(subtype)[0];
+                if (!signature ||
+                    signature.priv.boundToType ||
+                    (!types_1.FunctionType.isClassMethod(signature) && !types_1.FunctionType.isStaticMethod(signature))) {
+                    return subtype;
+                }
+                const implementation = (0, types_1.isOverloaded)(subtype) ? types_1.OverloadedType.getImplementation(subtype) : undefined;
+                const declaration = implementation && (0, types_1.isFunction)(implementation)
+                    ? implementation.shared.declaration
+                    : signature.shared.declaration;
+                for (const decorator of declaration?.node.d.decorators ?? []) {
+                    const decoratedType = readTypeCache(decorator, /* flags */ undefined);
+                    if (decoratedType &&
+                        (0, types_1.isClassInstance)(decoratedType) &&
+                        types_1.ClassType.isBuiltIn(decoratedType, ['classmethod', 'staticmethod'])) {
+                        return createMethodDescriptor(decoratedType, subtype, decorator);
+                    }
+                    // Only look through outer decorators that preserve the original
+                    // callable, rather than a replacement with a similar signature.
+                    if (!decoratedType ||
+                        !(0, types_1.isFunction)(decoratedType) ||
+                        decoratedType.shared.declaration !== declaration ||
+                        types_1.FunctionType.isClassMethod(decoratedType) !== types_1.FunctionType.isClassMethod(signature) ||
+                        types_1.FunctionType.isStaticMethod(decoratedType) !== types_1.FunctionType.isStaticMethod(signature)) {
+                        break;
+                    }
+                }
+                return subtype;
+            });
+        }
         return { type, isIncomplete };
     }
+    function createMethodDescriptor(descriptor, methodType, decorator) {
+        const signature = (0, types_1.isFunction)(methodType) ? methodType : types_1.OverloadedType.getOverloads(methodType)[0];
+        const fileInfo = nodeInfo.getFileInfo(decorator);
+        const descriptorClass = types_1.ClassType.createInstantiable(descriptor.shared.name, `${signature.shared.fullName}.__descriptor__`, fileInfo.moduleName, fileInfo.fileUri, 1 /* ClassTypeFlags.BuiltIn */, ParseTreeUtils.getTypeSourceId(decorator), 
+        /* declaredMetaclass */ undefined, descriptor.shared.effectiveMetaclass ?? types_1.UnknownType.create());
+        descriptorClass.shared.baseClasses.push(types_1.ClassType.cloneAsInstantiable(descriptor));
+        (0, typeUtils_1.computeMroLinearization)(descriptorClass);
+        // ParamSpec and return-type arguments cannot represent correlated overloads.
+        // Retain the callable itself rather than reconstructing it from those arguments.
+        const functionType = (0, typeUtils_1.mapSignatures)(methodType, (overload) => types_1.FunctionType.cloneWithNewFlags(overload, overload.shared.flags & ~(2 /* FunctionTypeFlags.ClassMethod */ | 4 /* FunctionTypeFlags.StaticMethod */)));
+        const getter = types_1.FunctionType.createSynthesizedInstance('__func__');
+        types_1.FunctionType.addParam(getter, types_1.FunctionParam.create(0 /* ParamCategory.Simple */, types_1.AnyType.create(), types_1.FunctionParamFlags.TypeDeclared, 'self'));
+        getter.shared.declaredReturnType = functionType;
+        getter.shared.declaration = signature.shared.declaration;
+        const propertyType = getBuiltInType(decorator, 'property');
+        (0, debug_1.assert)((0, types_1.isInstantiableClass)(propertyType));
+        const functionProperty = (0, properties_1.createProperty)(evaluatorInterface, decorator, propertyType, getter, nodeInfo);
+        const fields = types_1.ClassType.getSymbolTable(descriptorClass);
+        fields.set('__func__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, functionProperty));
+        fields.set('__wrapped__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, functionProperty));
+        if (types_1.ClassType.isBuiltIn(descriptor, 'staticmethod')) {
+            fields.set('__call__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, methodType));
+        }
+        const getMethod = getBoundMagicMethod(descriptor, '__get__');
+        if (getMethod && (0, types_1.isFunctionOrOverloaded)(getMethod)) {
+            const boundFunction = types_1.ClassType.isBuiltIn(descriptor, 'classmethod')
+                ? (0, typeUtils_1.mapSignatures)(methodType, (overload) => types_1.FunctionType.clone(overload, /* stripFirstParam */ true))
+                : functionType;
+            const descriptorGet = (0, typeUtils_1.mapSignatures)(getMethod, (overload) => {
+                const specializedGet = types_1.FunctionType.clone(overload);
+                specializedGet.shared.declaredReturnType = boundFunction;
+                if (specializedGet.priv.specializedTypes) {
+                    specializedGet.priv.specializedTypes.returnType = boundFunction;
+                }
+                return specializedGet;
+            });
+            (0, debug_1.assert)(descriptorGet);
+            fields.set('__get__', symbol_1.Symbol.createWithType(4 /* SymbolFlags.ClassMember */, descriptorGet));
+        }
+        return types_1.ClassType.cloneAsInstance(descriptorClass);
+    }
+    function getMethodFromDescriptor(type) {
+        if (!(0, types_1.isClassInstance)(type) || !types_1.ClassType.isBuiltIn(type, ['classmethod', 'staticmethod'])) {
+            return undefined;
+        }
+        const functionProperty = type.shared.fields.get('__func__')?.getSynthesizedType()?.type;
+        const functionType = functionProperty && (0, types_1.isClassInstance)(functionProperty)
+            ? getGetterTypeFromProperty(functionProperty)
+            : undefined;
+        if (!functionType || !(0, types_1.isFunctionOrOverloaded)(functionType)) {
+            return undefined;
+        }
+        return (0, typeUtils_1.mapSignatures)(functionType, (signature) => types_1.FunctionType.cloneWithNewFlags(signature, signature.shared.flags |
+            (types_1.ClassType.isBuiltIn(type, 'classmethod')
+                ? 2 /* FunctionTypeFlags.ClassMethod */
+                : 4 /* FunctionTypeFlags.StaticMethod */)));
+    }
     const typeFormSpecialFormDiagnosticFactories = [
         ['Final', () => localize_1.LocMessage.finalContext()],
         ['Optional', () => localize_1.LocMessage.optionalExtraArgs()],
@@ -6061,19 +6233,32 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
         }
         const magicMethodName = getIndexAccessMagicMethodName(usage);
-        const itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType, node.d.leftExpr);
-        if (!itemMethodType) {
-            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
-                name: magicMethodName,
-                type: printType(baseType),
-            }), node.d.leftExpr);
-            return { type: types_1.UnknownType.create() };
-        }
+        // A full member lookup specializes tuple arguments even if a constant
+        // index can select its answer directly.
+        const nativeItemSymbol = usage.method === 'get' && !selfType && (0, types_1.isClassInstance)(baseType) && types_1.ClassType.isBuiltIn(baseType, 'tuple')
+            ? types_1.ClassType.getSymbolTable(baseType).get(magicMethodName)
+            : undefined;
+        const nativeItemType = nativeItemSymbol?.isClassMember()
+            ? getEffectiveTypeOfSymbol(nativeItemSymbol)
+            : undefined;
+        const nativeItemMethods = nativeItemType && (0, types_1.isFunctionOrOverloaded)(nativeItemType)
+            ? (0, types_1.isOverloaded)(nativeItemType)
+                ? types_1.OverloadedType.getOverloads(nativeItemType)
+                : [nativeItemType]
+            : [];
+        const canDeferBinding = nativeItemMethods.length > 0 &&
+            nativeItemMethods.every((method) => types_1.FunctionType.isInstanceMethod(method) &&
+                method.shared.parameters.length > 0 &&
+                !types_1.FunctionParam.isTypeDeclared(method.shared.parameters[0]));
+        let itemMethodType = canDeferBinding
+            ? undefined
+            : getBoundMagicMethod(baseType, magicMethodName, selfType, node.d.leftExpr);
         // Handle the special case where the object is a tuple and
         // the index is a constant number (integer) or a slice with integer
         // start and end values. In these cases, we can determine
         // the exact type by indexing into the tuple type array.
-        if (node.d.items.length === 1 &&
+        if ((canDeferBinding || itemMethodType) &&
+            node.d.items.length === 1 &&
             !node.d.trailingComma &&
             !node.d.items[0].d.name &&
             node.d.items[0].d.argCategory === 0 /* ArgCategory.Simple */ &&
@@ -6100,16 +6285,47 @@ 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 };
+                        }
                     }
                 }
             }
         }
+        if (canDeferBinding) {
+            const inferredBase = (0, types_1.getInferredTupleLiteralBase)(baseType);
+            const tupleArgs = baseType.priv.tupleTypeArgs;
+            if (inferredBase !== baseType &&
+                (0, types_1.isClassInstance)(inferredBase) &&
+                types_1.ClassType.isBuiltIn(inferredBase, 'tuple') &&
+                tupleArgs &&
+                tupleArgs.length > 1 &&
+                tupleArgs.some((arg) => (0, types_1.isUnion)(arg.type) || ((0, types_1.isClassInstance)(arg.type) && types_1.ClassType.isBuiltIn(arg.type, 'tuple')))) {
+                // Avoid structural union work for optional literals before native method binding.
+                baseType = inferredBase;
+            }
+            itemMethodType = getBoundMagicMethod(baseType, magicMethodName, selfType, node.d.leftExpr);
+        }
+        if (!itemMethodType) {
+            addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIndexIssue, localize_1.LocMessage.methodNotDefinedOnType().format({
+                name: magicMethodName,
+                type: printType(baseType),
+            }), node.d.leftExpr);
+            return { type: types_1.UnknownType.create() };
+        }
         const positionalArgs = node.d.items.filter((item) => item.d.argCategory === 0 /* ArgCategory.Simple */);
         const unpackedListArgs = node.d.items.filter((item) => item.d.argCategory === 1 /* ArgCategory.UnpackedList */);
         let positionalIndexType;
@@ -6973,14 +7189,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else {
             if (enclosingClassType) {
                 targetClassType = enclosingClassType ?? types_1.UnknownType.create();
+                const functionInfo = enclosingFunction
+                    ? (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
+                    /* isInClass */ true, nodeInfo)
+                    : undefined;
                 // Zero-argument forms of super are not allowed within static methods.
                 // This results in a runtime exception.
-                if (enclosingFunction) {
-                    const functionInfo = (0, decorators_1.getFunctionInfoFromDecorators)(evaluatorInterface, enclosingFunction, 
-                    /* isInClass */ true, nodeInfo);
-                    if ((functionInfo?.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
-                        addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
-                    }
+                if (functionInfo !== undefined && (functionInfo.flags & 4 /* FunctionTypeFlags.StaticMethod */) !== 0) {
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgFormStaticMethod(), node.d.leftExpr);
+                }
+                else if (!ParseTreeUtils.isZeroArgSuperCallAllowed(node, nodeInfo.getFileInfo(node).executionEnvironment.pythonVersion, nodeInfo)) {
+                    // The evaluation scope cannot supply a first positional
+                    // argument for the zero-argument form.
+                    addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.superCallZeroArgForm(), node.d.leftExpr);
                 }
             }
             else {
@@ -7218,7 +7439,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 = [];
@@ -7261,17 +7482,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;
@@ -7390,6 +7608,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
@@ -7518,10 +7746,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 = [];
@@ -7531,10 +7762,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 ||
@@ -7576,6 +7819,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')
@@ -7600,11 +7846,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
@@ -7613,7 +7860,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.
@@ -7630,7 +7877,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>';
@@ -7685,7 +7931,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;
             }
@@ -7820,24 +8067,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.
@@ -8037,6 +8311,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.
@@ -8049,11 +8427,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;
@@ -8068,7 +8454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             returnType,
             isTypeIncomplete,
             argumentErrors,
-            overloadsUsedForCall: callResult.overloadsUsedForCall,
+            overloadsUsedForCall,
             specializedInitSelfType: callResult.specializedInitSelfType,
         };
     }
@@ -8109,7 +8495,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                                     return prefetched.functionClass;
                                 }
                             }
-                            return (0, typeUtils_1.convertToInstantiable)(stripLiteralValue(subtype));
+                            // stripLiteralValue retains sentinel literals, but type() of a
+                            // sentinel evaluates to its class, not the sentinel object.
+                            const classSubtype = (0, typeUtils_1.isSentinelLiteral)(subtype)
+                                ? types_1.ClassType.cloneWithLiteral(subtype, /* value */ undefined)
+                                : stripLiteralValue(subtype);
+                            return (0, typeUtils_1.convertToInstantiable)(classSubtype);
                         }
                         if (types_1.TypeBase.isInstance(subtype)) {
                             if ((0, types_1.isFunction)(subtype) || (0, types_1.isTypeVar)(subtype)) {
@@ -9909,6 +10300,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     addDiagnostic(diagnosticRules_1.DiagnosticRule.reportArgumentType, message + diag?.getString(), argParam.errorNode, diag?.getEffectiveTextRange() ?? argParam.errorNode);
                 }
             }
+            // Retain the wrapped signature for inference after an invalid descriptor
+            // argument without treating the descriptor itself as callable.
+            if ((0, typeUtils_1.requiresSpecialization)(argParam.paramType)) {
+                let methodType = getMethodFromDescriptor(argType);
+                if (methodType && (0, types_1.isOverloaded)(methodType)) {
+                    // Recover the runtime signature, not a single overload's
+                    // parameters selected when the returned decorator is called.
+                    const implementation = types_1.OverloadedType.getImplementation(methodType);
+                    if (implementation && (0, types_1.isFunction)(implementation)) {
+                        methodType = implementation;
+                    }
+                }
+                if (methodType) {
+                    const recoveryConstraints = constraints.clone();
+                    if (assignType(argParam.paramType, methodType, 
+                    /* diag */ undefined, recoveryConstraints, assignTypeFlags)) {
+                        constraints.copyFromClone(recoveryConstraints);
+                    }
+                }
+            }
             return { isCompatible: false, argType, isTypeIncomplete, skippedBareTypeVarExpectedType, condition };
         }
         if (!options.skipUnknownArgCheck) {
@@ -11496,6 +11907,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                         }
                     }
                 }
+                if (expectedType && !forceSpeculative && !isIncomplete) {
+                    captureContextualLambdaTypes(node);
+                }
             }, {
                 dependentType: inferenceContext?.expectedType,
                 allowDiagnostics: !forceSpeculative && !canSkipDiagnosticForNode(node) && !inferenceContext?.isTypeIncomplete,
@@ -11506,7 +11920,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) {
@@ -13666,12 +14084,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             classType.shared.flags &= ~8192 /* ClassTypeFlags.PartiallyEvaluated */;
             // Now determine the decorated type of the class.
             let decoratedType = classType;
+            let isDecoratedTypeUnknown = false;
             let foundUnknown = false;
             for (let i = node.d.decorators.length - 1; i >= 0; i--) {
                 const decorator = node.d.decorators[i];
-                const newDecoratedType = useSignatureTracker(node.parent ?? node, () => (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator, nodeInfo));
+                const newDecoratedType = useSignatureTracker(node.parent ?? node, () => (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator, nodeInfo, isDecoratedTypeUnknown));
                 const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
                 if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
+                    isDecoratedTypeUnknown = true;
                     // Report this error only on the first unknown type.
                     if (!foundUnknown) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUntypedClassDecorator, localize_1.LocMessage.classDecoratorTypeUnknown(), node.d.decorators[i].d.expr);
@@ -13679,6 +14099,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     }
                 }
                 else {
+                    // Preserving the recovery type also preserves its uncertainty.
+                    isDecoratedTypeUnknown = isDecoratedTypeUnknown && (0, types_1.isTypeSame)(newDecoratedType, decoratedType);
                     // Apply the decorator only if the type is known.
                     decoratedType = newDecoratedType;
                 }
@@ -14212,6 +14634,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         // See if there are any overloads provided by previous function declarations.
         if ((0, types_1.isFunction)(decoratedType)) {
+            if ((types_1.FunctionType.isClassMethod(decoratedType) || types_1.FunctionType.isStaticMethod(decoratedType)) &&
+                decoratedType.shared.declaration !== functionType.shared.declaration) {
+                // A wrapper can replace the signature without replacing the
+                // declaration that supplies the enclosing method descriptor.
+                decoratedType = types_1.FunctionType.clone(decoratedType);
+                decoratedType.shared.declaration = functionType.shared.declaration;
+            }
             decoratedType.shared.deprecatedMessage = functionType.shared.deprecatedMessage;
             if (types_1.FunctionType.isOverloaded(decoratedType)) {
                 // Mark all the parameters as accessed.
@@ -18496,6 +18925,16 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
                 (0, debug_1.assert)(memberInfo !== undefined);
                 let destMemberType = getEffectiveTypeOfSymbol(symbol);
+                // The synthesized NamedTuple _replace method adds typed field
+                // parameters to typeshed's "**kwargs: Any" signature. Don't let
+                // them change the variance inferred from the typeshed declaration.
+                if (name === '_replace' &&
+                    types_1.ClassType.isNamedTupleClass(destType) &&
+                    symbol.getSynthesizedType() &&
+                    (0, types_1.isFunction)(destMemberType) &&
+                    types_1.FunctionType.isSynthesizedMethod(destMemberType)) {
+                    return;
+                }
                 const srcMemberType = getTypeOfMember(memberInfo);
                 destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType, getTypeClassType());
                 // Properties require special processing.
@@ -20885,7 +21324,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         else if ((0, types_1.isUnknown)(narrowedType)) {
             return { type: (0, types_1.combineTypes)([narrowedType, declaredType]), isIncomplete: assignedTypeResult.isIncomplete };
         }
-        return { type: narrowedType, isIncomplete: assignedTypeResult.isIncomplete };
+        return {
+            type: narrowedType.props?.inferredTupleLiteral &&
+                !assignType(declaredType, (0, types_1.getInferredTupleLiteralBase)(narrowedType))
+                ? (0, types_1.preserveInferredTupleLiterals)(narrowedType)
+                : narrowedType,
+            isIncomplete: assignedTypeResult.isIncomplete,
+        };
     }
     function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.