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

package/dist/analyzer/typeEvaluator.js

@@ -95,6 +95,7 @@ const typedDicts_1 = require("./typedDicts");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
 const TypePrinter = __importStar(require("./typePrinter"));
+const typeWalker_1 = require("./typeWalker");
 const types_1 = require("./types");
 const typeUtils_1 = require("./typeUtils");
 const overloadResultSelector_1 = require("./overloadResultSelector");
@@ -204,6 +205,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
     let typeCache = new Map();
     let typeFormTypeCache = new Map();
     let effectiveTypeCache = new Map();
+    let exceptionTargetSymbolCache = new Map();
     let expectedTypeCache = new Map();
     let asymmetricAccessorAssignmentCache = new Set();
     let deferredClassCompletions = [];
@@ -271,6 +273,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         typeCache = new Map();
         typeFormTypeCache = new Map();
         effectiveTypeCache = new Map();
+        exceptionTargetSymbolCache = new Map();
         expectedTypeCache = new Map();
         asymmetricAccessorAssignmentCache = new Set();
     }
@@ -1835,11 +1838,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         }
         const argList = [];
         let previousCategory = 0 /* ArgCategory.Simple */;
+        let hasFakeArg = false;
         // Empty arguments do not enter the AST as nodes, but instead are left blank.
         // Instead, we detect when we appear to be between two known arguments or at the
         // end of the argument list and insert a fake argument of an unknown type to have
         // something to match later.
         function addFakeArg() {
+            hasFakeArg = true;
             argList.push({
                 argCategory: previousCategory,
                 typeResult: { type: types_1.UnknownType.create() },
@@ -1876,7 +1881,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 /* skipUnknownArgCheck */ true, 
                 /* inferenceContext */ undefined);
             });
-            const specializedType = solveAndApplyConstraints(type, constraints);
+            let specializedType = type;
+            if (types_1.FunctionType.getParamSpecFromArgsKwargs(type)) {
+                const solution = (0, constraintSolver_1.solveConstraints)(evaluatorInterface, constraints);
+                // The fake argument is used only to identify the active parameter. Preserve
+                // type variables in that parameter while specializing the forwarded ParamSpec.
+                if (hasFakeArg && callResult?.activeParam) {
+                    const activeParamIndex = type.shared.parameters.indexOf(callResult.activeParam);
+                    if (activeParamIndex >= 0) {
+                        (0, typeUtils_1.getTypeVarArgsRecursive)(types_1.FunctionType.getParamType(type, activeParamIndex)).forEach((typeVar) => {
+                            if (!(0, types_1.isParamSpec)(typeVar)) {
+                                solution.doForEachSolutionSet((solutionSet) => {
+                                    const solvedType = solutionSet.getType(typeVar);
+                                    if (!solvedType || (0, types_1.isUnknown)(solvedType)) {
+                                        solutionSet.setType(typeVar, typeVar);
+                                    }
+                                });
+                            }
+                        });
+                    }
+                }
+                specializedType = (0, typeUtils_1.applySolvedTypeVars)(type, solution);
+            }
             const finalType = (0, types_1.isFunction)(specializedType) ? specializedType : type;
             const hasActiveArg = argList.some((arg) => arg.active);
             // If the type was specialized (e.g. ParamSpec expansion), the activeParam
@@ -2725,6 +2751,24 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                     const memberInfo = (0, typeUtils_1.lookUpClassMember)(classType.classType, nameNode.d.value, 1 /* MemberAccessFlags.SkipOriginalClass */);
                     if (memberInfo?.isTypeDeclared) {
                         declaredType = getTypeOfMember(memberInfo);
+                        if ((0, symbolNameUtils_1.isMethodExemptFromLsp)(nameValue) &&
+                            memberInfo.symbol
+                                .getTypedDeclarations()
+                                .some((decl) => decl.type === 5 /* DeclarationType.Function */) &&
+                            (0, types_1.isFunctionOrOverloaded)(typeResult.type) &&
+                            (0, types_1.isFunctionOrOverloaded)(declaredType) &&
+                            !isFinalVariable(memberInfo.symbol)) {
+                            const baseMethods = (0, types_1.isFunction)(declaredType)
+                                ? [declaredType]
+                                : [
+                                    ...types_1.OverloadedType.getOverloads(declaredType),
+                                    types_1.OverloadedType.getImplementation(declaredType),
+                                ];
+                            if (!baseMethods.some((method) => method && (0, types_1.isFunction)(method) && types_1.FunctionType.isFinal(method))) {
+                                // Apply the same override exemptions to aliases and method definitions.
+                                declaredType = undefined;
+                            }
+                        }
                     }
                 }
             }
@@ -4570,6 +4614,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const isAccessedThroughObject = types_1.TypeBase.isInstance(classType);
         // Always look for a member with a declared type first.
         let memberInfo = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags | 64 /* MemberAccessFlags.DeclaredTypesOnly */);
+        // A class-level method alias retains its inferred signature, unlike an annotated variable.
+        if (usage.method === 'get' &&
+            memberInfo?.skippedUndeclaredType &&
+            memberInfo.symbol.getTypedDeclarations().some((decl) => decl.type === 5 /* DeclarationType.Function */)) {
+            const inferredMember = (0, typeUtils_1.lookUpClassMember)(classType, memberName, flags);
+            if (inferredMember?.isClassMember &&
+                !inferredMember.isInstanceMember &&
+                (0, types_1.isFunctionOrOverloaded)(getTypeOfMember(inferredMember))) {
+                memberInfo = inferredMember;
+            }
+        }
         // If we couldn't find a symbol with a declared type, use
         // a symbol with an inferred type.
         if (!memberInfo) {
@@ -4818,7 +4873,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         const subDiag = diag ? new diagnostic_1.DiagnosticAddendum() : undefined;
         const methodTypeResult = getTypeOfBoundMember(errorNode, concreteMemberType, accessMethodName, 
         /* usage */ undefined, subDiag, 16 /* MemberAccessFlags.SkipInstanceMembers */ | 512 /* MemberAccessFlags.SkipAttributeAccessOverride */);
-        if (!methodTypeResult || methodTypeResult.typeErrors) {
+        const deferredMethodType = usage.method === 'get'
+            ? getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, subDiag)
+            : undefined;
+        if ((!methodTypeResult || methodTypeResult.typeErrors) && !deferredMethodType) {
             // Provide special error messages for properties.
             if (types_1.ClassType.isPropertyClass(concreteMemberType) && usage.method !== 'get') {
                 const message = usage.method === 'set' ? localize_1.LocAddendum.propertyMissingSetter() : localize_1.LocAddendum.propertyMissingDeleter();
@@ -4830,9 +4888,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             }
             return { type: memberType };
         }
-        const methodClassType = methodTypeResult.classType;
-        let methodType = methodTypeResult.type;
-        if (methodTypeResult.typeErrors || !methodClassType) {
+        const methodClassType = methodTypeResult?.classType ?? concreteMemberType;
+        let methodType = deferredMethodType ?? methodTypeResult.type;
+        if (!methodClassType) {
             if (diag && subDiag) {
                 diag.addAddendum(subDiag);
             }
@@ -4889,8 +4947,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;
             }
         }
@@ -4993,6 +5051,65 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             memberAccessDeprecationInfo: deprecationInfo,
         };
     }
+    function getDescriptorGetMethodWithDeferredSelfSpecialization(concreteMemberType, diag) {
+        const member = (0, typeUtils_1.lookUpClassMember)(concreteMemberType, '__get__');
+        if (!member || !(0, types_1.isInstantiableClass)(member.unspecializedClassType)) {
+            return undefined;
+        }
+        const unspecializedClassType = member.unspecializedClassType;
+        const declaringClassType = member.classType;
+        if (!(0, types_1.isInstantiableClass)(declaringClassType)) {
+            return undefined;
+        }
+        const declaringObjectType = types_1.ClassType.cloneAsInstance(declaringClassType);
+        const unspecializedMethodType = getEffectiveTypeOfSymbol(member.symbol);
+        if (!(0, types_1.isFunctionOrOverloaded)(unspecializedMethodType)) {
+            return undefined;
+        }
+        // A class ParamSpec used in Concatenate within the self annotation needs to be
+        // solved from the concrete descriptor, rather than specialized before self is bound.
+        const classParamSpecs = types_1.ClassType.getTypeParams(unspecializedClassType).filter(types_1.isParamSpec);
+        if (classParamSpecs.length === 0) {
+            return undefined;
+        }
+        const signatures = (0, types_1.isFunction)(unspecializedMethodType)
+            ? [unspecializedMethodType]
+            : types_1.OverloadedType.getOverloads(unspecializedMethodType);
+        const shouldDefer = signatures.some((signature) => {
+            if (signature.shared.parameters.length === 0) {
+                return false;
+            }
+            const selfParamType = types_1.FunctionType.getParamType(signature, 0);
+            if (!(0, types_1.isClassInstance)(selfParamType) || !types_1.ClassType.isSameGenericClass(selfParamType, declaringObjectType)) {
+                return false;
+            }
+            class ConcatenateParamSpecWalker extends typeWalker_1.TypeWalker {
+                constructor() {
+                    super(...arguments);
+                    this.found = false;
+                }
+                visitFunction(type) {
+                    const paramSpec = types_1.FunctionType.getParamSpecFromArgsKwargs(type);
+                    if (paramSpec &&
+                        types_1.FunctionType.cloneRemoveParamSpecArgsKwargs(type).shared.parameters.length > 0 &&
+                        classParamSpecs.some((classParamSpec) => (0, types_1.isTypeSame)(paramSpec, classParamSpec))) {
+                        this.found = true;
+                        this.cancelWalk();
+                        return;
+                    }
+                    super.visitFunction(type);
+                }
+            }
+            const walker = new ConcatenateParamSpecWalker();
+            selfParamType.priv.typeArgs?.forEach((typeArg) => walker.walk(typeArg));
+            return walker.found;
+        });
+        if (!shouldDefer) {
+            return undefined;
+        }
+        return bindFunctionToClassOrObject(declaringObjectType, unspecializedMethodType, declaringClassType, 
+        /* treatConstructorAsClassMethod */ false, concreteMemberType, diag);
+    }
     function bindMethodForMemberAccess(type, concreteType, memberInfo, classType, selfType, flags, memberName, usage, diag, recursionCount = 0) {
         // Check for an attempt to overwrite a final method.
         if (usage.method === 'set') {
@@ -5021,14 +5138,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) => {
@@ -10807,7 +10937,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),
@@ -10816,6 +10946,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,
@@ -11215,27 +11346,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
@@ -11250,15 +11416,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.
@@ -13442,6 +13614,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             // Determine the effective metaclass.
             if (metaclassNode) {
                 let metaclassType = getTypeOfExpression(metaclassNode, exprFlags).type;
+                if ((0, types_1.isAny)(metaclassType)) {
+                    metaclassType = types_1.UnknownType.create();
+                }
                 if ((0, types_1.isInstantiableClass)(metaclassType) || (0, types_1.isUnknown)(metaclassType)) {
                     if ((0, typeUtils_1.requiresSpecialization)(metaclassType, { ignorePseudoGeneric: true })) {
                         addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.metaclassIsGeneric(), metaclassNode);
@@ -13464,6 +13639,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) &&
@@ -14876,9 +15055,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,
@@ -17681,8 +17859,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 };
@@ -18312,7 +18506,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;
                     }
                 }
@@ -20013,6 +20207,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;
@@ -20033,6 +20255,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;
@@ -20094,6 +20323,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;
                     }
                 }
@@ -20365,6 +20598,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;
                         }
@@ -21198,7 +21435,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
             if (functionType.priv.strippedFirstParamType) {
                 return functionType;
             }
-            if (types_1.FunctionType.isInstanceMethod(functionType)) {
+            if (types_1.FunctionType.isInstanceMethod(functionType) && !treatConstructorAsClassMethod) {
                 // If the baseType is a metaclass, don't specialize the function.
                 if ((0, typeUtils_1.isInstantiableMetaclass)(baseType)) {
                     return functionType;
@@ -21215,8 +21452,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
                 }
                 return partiallySpecializeBoundMethod(baseType, functionType, diag, recursionCount, selfType ?? baseObj, stripFirstParam);
             }
-            if (types_1.FunctionType.isClassMethod(functionType) ||
-                (treatConstructorAsClassMethod && types_1.FunctionType.isConstructorMethod(functionType))) {
+            if (types_1.FunctionType.isClassMethod(functionType) || treatConstructorAsClassMethod) {
                 const baseClass = (0, types_1.isInstantiableClass)(baseType) ? baseType : types_1.ClassType.cloneAsInstantiable(baseType);
                 const clsType = selfType ? (0, typeUtils_1.convertToInstantiable)(selfType) : undefined;
                 return partiallySpecializeBoundMethod(baseClass, functionType, diag, recursionCount, clsType ?? baseClass, 
@@ -21580,6 +21816,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions, wrapWithLogger) {
         validateInitSubclassArgs,
         isNodeReachable,
         isAfterNodeReachable,
+        isKeyPresentInTypedDict: (node) => codeFlowEngine.isKeyPresentInTypedDict(node),
         getNodeReachability,
         getAfterNodeReachability,
         isAsymmetricAccessorAssignment,