@zzzen/pyright-internal 1.2.0-dev.20230611 → 1.2.0-dev.20230618

package/dist/analyzer/typeEvaluator.js

@@ -659,7 +659,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!typeResult.isIncomplete && !typeResult.expectedTypeDiagAddendum) {
                 const diag = new diagnostic_1.DiagnosticAddendum();
                 // Make sure the resulting type is assignable to the expected type.
-                if (!assignType(inferenceContext.expectedType, typeResult.type, diag)) {
+                if (!assignType(inferenceContext.expectedType, typeResult.type, diag, 
+                /* destTypeVarContext */ undefined, 
+                /* srcTypeVarContext */ undefined, 512 /* IgnoreTypeVarScope */)) {
                     typeResult.typeErrors = true;
                     typeResult.expectedTypeDiagAddendum = diag;
                     diag.addTextRange(node);
@@ -984,6 +986,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             flags |= 2 /* DoNotSpecialize */;
         }
         const decoratorTypeResult = getTypeOfExpression(node.expression, flags);
+        // Special-case typing.type_check_only. It's used in many stdlib
+        // functions, and pyright treats it as a no-op, so don't waste
+        // time evaluating it.
+        if ((0, types_1.isFunction)(decoratorTypeResult.type) &&
+            decoratorTypeResult.type.details.builtInName === 'type_check_only') {
+            return functionOrClassType;
+        }
         // Special-case the combination of a classmethod decorator applied
         // to a property. This is allowed in Python 3.9, but it's not reflected
         // in the builtins.pyi stub for classmethod.
@@ -3097,7 +3106,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Is this a generic class that needs to be specialized?
         if ((0, types_1.isInstantiableClass)(type)) {
-            if ((flags & 128 /* ExpectingType */) !== 0) {
+            if ((flags & 128 /* ExpectingType */) !== 0 && (flags & 512 /* AllowMissingTypeArgs */) === 0) {
                 if (!type.typeAliasInfo && (0, typeUtils_1.requiresTypeArguments)(type)) {
                     if (!type.typeArguments || !type.isTypeArgumentExplicit) {
                         addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
@@ -5551,9 +5560,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return types_1.NoneType.createInstance();
     }
     function getTypeOfSuperCall(node) {
+        var _a;
         if (node.arguments.length > 2) {
             addError(localize_1.Localizer.Diagnostic.superCallArgCount(), node.arguments[2]);
         }
+        const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
+        const enclosingClassType = enclosingClass ? (_a = getTypeOfClass(enclosingClass)) === null || _a === void 0 ? void 0 : _a.classType : undefined;
         // Determine which class the "super" call is applied to. If
         // there is no first argument, then the class is implicit.
         let targetClassType;
@@ -5565,10 +5577,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         else {
-            const enclosingClass = ParseTreeUtils.getEnclosingClass(node);
-            if (enclosingClass) {
-                const classTypeInfo = getTypeOfClass(enclosingClass);
-                targetClassType = classTypeInfo ? classTypeInfo.classType : types_1.UnknownType.create();
+            if (enclosingClassType) {
+                targetClassType = enclosingClassType !== null && enclosingClassType !== void 0 ? enclosingClassType : types_1.UnknownType.create();
             }
             else {
                 addError(localize_1.Localizer.Diagnostic.superCallZeroArgForm(), node.leftExpression);
@@ -5608,33 +5618,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 addDiagnostic(fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.superCallSecondArg().format({ type: printType(targetClassType) }), node.arguments[1].valueExpression);
             }
         }
-        else {
+        else if (enclosingClassType) {
+            bindToType = types_1.ClassType.cloneAsInstance(enclosingClassType);
+            // Get the type from the self or cls parameter if it is explicitly annotated.
+            // If it's a TypeVar, change the bindToType into a conditional type.
             const enclosingMethod = ParseTreeUtils.getEnclosingFunction(node);
             let implicitBindToType;
-            // Get the type from the self or cls parameter if it is explicitly annotated.
             if (enclosingMethod) {
                 const methodTypeInfo = getTypeOfFunction(enclosingMethod);
                 if (methodTypeInfo) {
                     const methodType = methodTypeInfo.functionType;
-                    if (types_1.FunctionType.isClassMethod(methodType)) {
+                    if (types_1.FunctionType.isClassMethod(methodType) ||
+                        types_1.FunctionType.isConstructorMethod(methodType) ||
+                        types_1.FunctionType.isInstanceMethod(methodType)) {
                         if (methodType.details.parameters.length > 0 &&
                             methodType.details.parameters[0].hasDeclaredType) {
                             implicitBindToType = makeTopLevelTypeVarsConcrete(methodType.details.parameters[0].type);
                         }
                     }
-                    else if (types_1.FunctionType.isInstanceMethod(methodType)) {
-                        if (methodType.details.parameters.length > 0 &&
-                            methodType.details.parameters[0].hasDeclaredType) {
-                            implicitBindToType = makeTopLevelTypeVarsConcrete((0, typeUtils_1.convertToInstantiable)(methodType.details.parameters[0].type));
-                        }
-                    }
                 }
             }
-            if (implicitBindToType && (0, types_1.isInstantiableClass)(implicitBindToType)) {
-                bindToType = implicitBindToType;
-            }
-            else if ((0, types_1.isInstantiableClass)(targetClassType)) {
-                bindToType = targetClassType;
+            if (bindToType && implicitBindToType) {
+                bindToType = (0, typeUtils_1.addConditionToType)(bindToType, (0, typeUtils_1.getTypeCondition)(implicitBindToType));
             }
         }
         // Determine whether super() should return an instance of the class or
@@ -5659,7 +5664,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const parentNode = node.parent;
         if (parentNode.nodeType === 35 /* MemberAccess */) {
             const memberName = parentNode.memberName.value;
-            const lookupResults = (0, typeUtils_1.lookUpClassMember)(targetClassType, memberName, 1 /* SkipOriginalClass */);
+            const effectiveTargetClass = (0, types_1.isClass)(targetClassType) ? targetClassType : undefined;
+            const lookupResults = bindToType
+                ? (0, typeUtils_1.lookUpClassMember)(bindToType, memberName, 0 /* Default */, effectiveTargetClass)
+                : undefined;
             if (lookupResults && (0, types_1.isInstantiableClass)(lookupResults.classType)) {
                 return {
                     type: resultIsInstance
@@ -5867,6 +5875,15 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (matches.length < 2) {
             return matches;
         }
+        // If the relevance of some matches differs, filter out the ones that
+        // are lower relevance. This favors *args parameters in cases where
+        // a *args argument is used.
+        if (matches[0].matchResults.relevance !== matches[matches.length - 1].matchResults.relevance) {
+            matches = matches.filter((m) => m.matchResults.relevance === matches[0].matchResults.relevance);
+            if (matches.length < 2) {
+                return matches;
+            }
+        }
         // If all of the return types match, select the first one.
         if ((0, typeUtils_1.areTypesSame)(matches.map((match) => match.returnType), { treatAnySameAsUnknown: true })) {
             return [matches[0]];
@@ -5875,6 +5892,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!firstArgResults) {
             return matches;
         }
+        let foundAmbiguousAnyArg = false;
         for (let i = 0; i < firstArgResults.length; i++) {
             // If the arg is Any or Unknown, see if the corresponding
             // parameter types differ in any way.
@@ -5883,10 +5901,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     ? match.matchResults.argParams[i].paramType
                     : types_1.UnknownType.create());
                 if (!(0, typeUtils_1.areTypesSame)(paramTypes, { treatAnySameAsUnknown: true })) {
-                    return matches;
+                    foundAmbiguousAnyArg = true;
                 }
             }
         }
+        // If the first overload has a different number of effective arguments
+        // than latter overloads, don't filter any of them. This typically means
+        // that one of the arguments is an unpacked iterator, and it maps to
+        // an indeterminate number of parameters, which means that the overload
+        // selection is ambiguous.
+        if (foundAmbiguousAnyArg || matches.some((match) => match.argResults.length !== firstArgResults.length)) {
+            return matches;
+        }
         return [matches[0]];
     }
     function getBestOverloadForArguments(errorNode, typeResult, argList) {
@@ -6993,6 +7019,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                     unpackedDictionaryArgType = types_1.UnknownType.create();
                                 }
                             }
+                            if (paramDetails.kwargsIndex !== undefined && unpackedDictionaryArgType) {
+                                const paramType = paramDetails.params[paramDetails.kwargsIndex].type;
+                                validateArgTypeParams.push({
+                                    paramCategory: 0 /* Simple */,
+                                    paramType,
+                                    requiresTypeVarMatching: (0, typeUtils_1.requiresSpecialization)(paramType),
+                                    argType: unpackedDictionaryArgType,
+                                    argument: argList[argIndex],
+                                    errorNode: argList[argIndex].valueExpression || errorNode,
+                                    paramName: paramDetails.params[paramDetails.kwargsIndex].param.name,
+                                });
+                            }
                             if (!isValidMappingType) {
                                 if (!isDiagnosticSuppressedForNode(errorNode)) {
                                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet
@@ -7265,7 +7303,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // Special-case the builtin isinstance and issubclass functions.
         if (['isinstance', 'issubclass'].some((name) => name === typeResult.type.details.builtInName) &&
             validateArgTypeParams.length === 2) {
-            validateArgTypeParams[1].expectingType = true;
+            validateArgTypeParams[1].isinstanceParam = true;
         }
         return {
             overload: typeResult.type,
@@ -7324,13 +7362,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // the expected type if possible.
             // Determine which type arguments are needed to match the expected type.
             if ((0, types_1.isClassInstance)(effectiveReturnType)) {
-                // If the return type is a class and the expected type is a union that contains
-                // that class, see if we can eliminate the other subtypes in the union.
+                // If the return type is a class and the expected type is a union
+                // that is type compatible with that class, filter the subtypes in
+                // the union to see if we can find one that is potentially compatible.
                 if ((0, types_1.isUnion)(effectiveExpectedType)) {
                     const filteredType = (0, typeUtils_1.mapSubtypes)(effectiveExpectedType, (subtype) => {
-                        return (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isSameGenericClass(effectiveReturnType, subtype)
-                            ? subtype
-                            : undefined;
+                        if (!(0, types_1.isClassInstance)(subtype) || subtype.details.typeParameters.length === 0) {
+                            return undefined;
+                        }
+                        if (types_1.ClassType.isProtocolClass(subtype) ||
+                            subtype.details.mro.some((mroClass) => {
+                                return ((0, types_1.isClassInstance)(mroClass) &&
+                                    mroClass.details.typeParameters.length > 0 &&
+                                    types_1.ClassType.isSameGenericClass(effectiveReturnType, mroClass));
+                            })) {
+                            return subtype;
+                        }
+                        return undefined;
                     });
                     if ((0, types_1.isClassInstance)(filteredType)) {
                         effectiveExpectedType = filteredType;
@@ -7849,8 +7897,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 argType = argParam.argType;
             }
             else {
-                const flags = argParam.expectingType
-                    ? 8 /* EvaluateStringLiteralAsType */ |
+                const flags = argParam.isinstanceParam
+                    ? 512 /* AllowMissingTypeArgs */ |
+                        8 /* EvaluateStringLiteralAsType */ |
                         32 /* DisallowParamSpec */ |
                         64 /* DisallowTypeVarTuple */
                     : 0 /* None */;
@@ -7888,7 +7937,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
+            else if (argParam.isinstanceParam && !argParam.argument.typeResult && argParam.argument.valueExpression) {
                 const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
                     64 /* DisallowTypeVarTuple */);
@@ -8714,6 +8763,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Infer the key and value types if possible.
             if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
             /* forceStrictInference */ true, 
+            /* isValueTypeInvariant */ true, 
             /* expectedKeyType */ undefined, 
             /* expectedValueType */ undefined, expectedTypedDictEntries, expectedDiagAddendum)) {
                 isIncomplete = true;
@@ -8746,17 +8796,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const expectedKeyType = specializedDict.typeArguments[0];
         const expectedValueType = specializedDict.typeArguments[1];
-        // Infer the key and value types if possible.
-        if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
-        /* forceStrictInference */ true, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
-            isIncomplete = true;
-        }
         // Dict and MutableMapping types have invariant value types, so they
         // cannot be narrowed further. Other super-types like Mapping, Collection,
         // and Iterable use covariant value types, so they can be narrowed.
         const isValueTypeInvariant = (0, types_1.isClassInstance)(inferenceContext.expectedType) &&
             (types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'dict') ||
                 types_1.ClassType.isBuiltIn(inferenceContext.expectedType, 'MutableMapping'));
+        // Infer the key and value types if possible.
+        if (getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, 
+        /* forceStrictInference */ true, isValueTypeInvariant, expectedKeyType, expectedValueType, undefined, expectedDiagAddendum)) {
+            isIncomplete = true;
+        }
         const specializedKeyType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedKeyType), keyTypes.map((result) => result.type), 
         /* isNarrowable */ false);
         const specializedValueType = inferTypeArgFromExpectedEntryType((0, typeUtils_1.makeInferenceContext)(expectedValueType), valueTypes.map((result) => result.type), !isValueTypeInvariant);
@@ -8778,7 +8828,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         if (getKeyAndValueTypesFromDictionary(node, keyTypeResults, valueTypeResults, 
-        /* forceStrictInference */ hasExpectedType)) {
+        /* forceStrictInference */ hasExpectedType, 
+        /* isValueTypeInvariant */ false)) {
             isIncomplete = true;
         }
         // Strip any literal values.
@@ -8816,11 +8867,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return { type, isIncomplete };
     }
-    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
+    function getKeyAndValueTypesFromDictionary(node, keyTypes, valueTypes, forceStrictInference, isValueTypeInvariant, expectedKeyType, expectedValueType, expectedTypedDictEntries, expectedDiagAddendum) {
         let isIncomplete = false;
         // Infer the key and value types if possible.
         node.entries.forEach((entryNode, index) => {
-            var _a;
+            var _a, _b, _c;
             let addUnknown = true;
             if (entryNode.nodeType === 17 /* DictionaryKeyEntry */) {
                 const keyTypeResult = getTypeOfExpression(entryNode.keyExpression, 
@@ -8836,19 +8887,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     expectedDiagAddendum.addAddendum(keyTypeResult.expectedTypeDiagAddendum);
                 }
                 let valueTypeResult;
+                let entryInferenceContext;
                 if (expectedTypedDictEntries &&
                     (0, types_1.isClassInstance)(keyType) &&
                     types_1.ClassType.isBuiltIn(keyType, 'str') &&
                     (0, typeUtils_1.isLiteralType)(keyType) &&
                     expectedTypedDictEntries.has(keyType.literalValue)) {
                     const effectiveValueType = expectedTypedDictEntries.get(keyType.literalValue).valueType;
+                    entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, entryInferenceContext);
                 }
                 else {
                     const effectiveValueType = expectedValueType !== null && expectedValueType !== void 0 ? expectedValueType : (forceStrictInference ? types_1.NeverType.createNever() : undefined);
+                    entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(effectiveValueType);
                     valueTypeResult = getTypeOfExpression(entryNode.valueExpression, 
-                    /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(effectiveValueType));
+                    /* flags */ undefined, entryInferenceContext);
+                }
+                if (entryInferenceContext && !valueTypeResult.typeErrors) {
+                    valueTypeResult.type =
+                        (_a = inferTypeArgFromExpectedEntryType(entryInferenceContext, [valueTypeResult.type], !isValueTypeInvariant)) !== null && _a !== void 0 ? _a : valueTypeResult.type;
                 }
                 if (expectedDiagAddendum && valueTypeResult.expectedTypeDiagAddendum) {
                     expectedDiagAddendum.addAddendum(valueTypeResult.expectedTypeDiagAddendum);
@@ -8871,8 +8929,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         /* isTypeArgumentExplicit */ true));
                     }
                 }
+                const entryInferenceContext = (0, typeUtils_1.makeInferenceContext)(expectedType);
                 const unexpandedTypeResult = getTypeOfExpression(entryNode.expandExpression, 
-                /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(expectedType));
+                /* flags */ undefined, entryInferenceContext);
+                if (entryInferenceContext && !unexpandedTypeResult.typeErrors) {
+                    unexpandedTypeResult.type =
+                        (_b = inferTypeArgFromExpectedEntryType(entryInferenceContext, [unexpandedTypeResult.type], !isValueTypeInvariant)) !== null && _b !== void 0 ? _b : unexpandedTypeResult.type;
+                }
                 if (unexpandedTypeResult.isIncomplete) {
                     isIncomplete = true;
                 }
@@ -8927,7 +8990,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 // The result should be a tuple.
                 if ((0, types_1.isClassInstance)(dictEntryType) && (0, typeUtils_1.isTupleClass)(dictEntryType)) {
-                    const typeArgs = (_a = dictEntryType.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.map((t) => t.type);
+                    const typeArgs = (_c = dictEntryType.tupleTypeArguments) === null || _c === void 0 ? void 0 : _c.map((t) => t.type);
                     if (typeArgs && typeArgs.length === 2) {
                         if (forceStrictInference || index < maxEntriesToUseForInference) {
                             keyTypes.push({ node: entryNode, type: typeArgs[0] });
@@ -9122,7 +9185,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isAnyOrUnknown)(inferenceContext.expectedType)) {
             return inferenceContext.expectedType;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext();
+        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(inferenceContext.expectedType));
         const expectedType = inferenceContext.expectedType;
         let isCompatible = true;
         entryTypes.forEach((entryType) => {
@@ -9139,7 +9202,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 ? combinedTypes
                 : stripLiteralValue(combinedTypes);
         }
-        return (0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext, { applyInScopePlaceholders: true });
+        return (0, typeUtils_1.mapSubtypes)((0, typeUtils_1.applySolvedTypeVars)(inferenceContext.expectedType, typeVarContext, { applyInScopePlaceholders: true }), (subtype) => {
+            if (entryTypes.length !== 1) {
+                return subtype;
+            }
+            const entryType = entryTypes[0];
+            // If the entry type is a TypedDict instance, clone it with additional information.
+            if ((0, types_1.isTypeSame)(subtype, entryType, { ignoreTypedDictNarrowEntries: true }) &&
+                (0, types_1.isClass)(subtype) &&
+                (0, types_1.isClass)(entryType) &&
+                types_1.ClassType.isTypedDictClass(entryType)) {
+                return types_1.ClassType.cloneForNarrowedTypedDictEntries(subtype, entryType.typedDictNarrowedEntries);
+            }
+            return subtype;
+        });
     }
     function getTypeOfYield(node) {
         let expectedYieldType;
@@ -12004,10 +12080,20 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 inferredParamType = (0, types_1.combineTypes)([defaultValueType, types_1.UnknownType.create()]);
             }
             else {
-                // Do not infer certain types like tuple because it's likely to be
-                // more restrictive (narrower) than intended.
-                if (!(0, types_1.isClassInstance)(defaultValueType) ||
-                    !types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
+                let skipInference = false;
+                if ((0, types_1.isFunction)(defaultValueType) || (0, types_1.isOverloadedFunction)(defaultValueType)) {
+                    // Do not infer parameter types that use a lambda or another function as a
+                    // default value. We're likely to generate false positives in this case.
+                    // It's not clear whether parameters should be positional-only or not.
+                    skipInference = true;
+                }
+                else if ((0, types_1.isClassInstance)(defaultValueType) &&
+                    types_1.ClassType.isBuiltIn(defaultValueType, ['tuple', 'list', 'set', 'dict'])) {
+                    // Do not infer certain types like tuple because it's likely to be
+                    // more restrictive (narrower) than intended.
+                    skipInference = true;
+                }
+                if (!skipInference) {
                     inferredParamType = stripLiteralValue(defaultValueType);
                 }
             }
@@ -15563,6 +15649,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             effectiveFlags &= ~8 /* SkipSolveTypeVars */;
             prevSrcType = curSrcType;
         }
+        // If we're enforcing invariance, literal types must match as well.
+        if ((flags & 1 /* EnforceInvariance */) !== 0) {
+            const srcIsLiteral = srcType.literalValue !== undefined;
+            const destIsLiteral = destType.literalValue !== undefined;
+            if (srcIsLiteral !== destIsLiteral) {
+                return false;
+            }
+        }
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
             // type arguments are assignable to the dest type arguments.
@@ -16625,9 +16719,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext, { useNarrowBoundOnly: true });
             if ((0, typeUtils_1.requiresSpecialization)(specializedDestType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
-                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |
-                    512 /* IgnoreTypeVarScope */ |
-                    128 /* RetainLiteralsForTypeVar */, recursionCount);
+                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount);
                 specializedDestType = (0, typeUtils_1.applySolvedTypeVars)(destType, destTypeVarContext);
             }
         }
@@ -16635,9 +16727,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext, { useNarrowBoundOnly: true });
             if ((0, typeUtils_1.requiresSpecialization)(specializedSrcType)) {
                 reverseMatchingFailed = !assignType(specializedSrcType, specializedDestType, 
-                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) |
-                    512 /* IgnoreTypeVarScope */ |
-                    128 /* RetainLiteralsForTypeVar */, recursionCount);
+                /* diag */ undefined, srcTypeVarContext, destTypeVarContext, (flags ^ 2 /* ReverseTypeVarMatching */) | 128 /* RetainLiteralsForTypeVar */, recursionCount);
                 specializedSrcType = (0, typeUtils_1.applySolvedTypeVars)(srcType, srcTypeVarContext);
             }
             if (reverseMatchingFailed) {
@@ -17103,9 +17193,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 });
                 const srcParamSpec = effectiveSrcType.details.paramSpec;
                 const destParamSpec = effectiveDestType.details.paramSpec;
-                const targetTypeVarContext = (flags & 2 /* ReverseTypeVarMatching */) === 0 ? destTypeVarContext : srcTypeVarContext;
-                if (targetTypeVarContext.hasSolveForScope(destParamSpec.scopeId)) {
-                    // Synthesize a function based on the remaining parameters.
+                // If there are remaining parameters and the source and dest do not contain
+                // the same ParamSpec, synthesize a function for the remaining parameters.
+                if (remainingParams.length > 0 ||
+                    !srcParamSpec ||
+                    !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true })) {
                     const remainingFunction = types_1.FunctionType.createInstance('', '', '', effectiveSrcType.details.flags | 64 /* SynthesizedMethod */, effectiveSrcType.details.docString);
                     remainingFunction.details.typeVarScopeId = effectiveSrcType.details.typeVarScopeId;
                     remainingParams.forEach((param) => {
@@ -17114,28 +17206,19 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     remainingFunction.details.paramSpec = srcParamSpec
                         ? (0, typeUtils_1.convertToInstance)(srcParamSpec)
                         : undefined;
-                    if (!(0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destParamSpec, remainingFunction, 
-                    /* diag */ undefined, targetTypeVarContext)) {
+                    if (!assignType(destParamSpec, remainingFunction, 
+                    /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                         // If we couldn't assign the function to the ParamSpec, see if we can
                         // assign only the ParamSpec. This is possible if there were no
                         // remaining parameters.
                         if (remainingParams.length > 0 ||
                             !srcParamSpec ||
-                            !(0, constraintSolver_1.assignTypeToTypeVar)(evaluatorInterface, destParamSpec, (0, typeUtils_1.convertToInstance)(srcParamSpec), 
-                            /* diag */ undefined, targetTypeVarContext)) {
+                            !assignType(destParamSpec, (0, typeUtils_1.convertToInstance)(srcParamSpec), 
+                            /* diag */ undefined, destTypeVarContext, srcTypeVarContext, flags)) {
                             canAssign = false;
                         }
                     }
                 }
-                else {
-                    // If there are any remaining parameters or the source doesn't include the
-                    // dest param spec itself, it is not assignable in this case.
-                    if (!srcParamSpec ||
-                        !(0, types_1.isTypeSame)(srcParamSpec, destParamSpec, { ignoreTypeFlags: true }) ||
-                        remainingParams.length > 0) {
-                        canAssign = false;
-                    }
-                }
             }
         }
         // Match the return parameter.
@@ -17293,7 +17376,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return narrowedType;
     }
-    function validateOverrideMethod(baseMethod, overrideMethod, diag, enforceParamNames = true) {
+    function validateOverrideMethod(baseMethod, overrideMethod, baseClass, diag, enforceParamNames = true) {
         // If we're overriding a non-method with a method, report it as an error.
         // This occurs when a non-property overrides a property.
         if (!(0, types_1.isFunction)(baseMethod) && !(0, types_1.isOverloadedFunction)(baseMethod)) {
@@ -17319,17 +17402,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For a non-overloaded method overriding an overloaded method, the
         // override must match all of the overloads.
         if ((0, types_1.isFunction)(overrideMethod)) {
-            return types_1.OverloadedFunctionType.getOverloads(baseMethod).every((overload) => validateOverrideMethodInternal(overload, overrideMethod, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), enforceParamNames));
+            return types_1.OverloadedFunctionType.getOverloads(baseMethod).every((overload) => {
+                // If the override isn't applicable for this base class, skip the check.
+                if (baseClass && !isOverrideMethodApplicable(overload, baseClass)) {
+                    return true;
+                }
+                return validateOverrideMethodInternal(overload, overrideMethod, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), enforceParamNames);
+            });
         }
         // For an overloaded method overriding an overloaded method, the overrides
         // must all match and be in the correct order. It is OK if the base method
         // has additional overloads that are not present in the override.
         let previousMatchIndex = -1;
         let overrideOverloadIndex = 0;
+        const baseOverloads = types_1.OverloadedFunctionType.getOverloads(baseMethod);
         for (const overrideOverload of types_1.OverloadedFunctionType.getOverloads(overrideMethod)) {
-            const matchIndex = types_1.OverloadedFunctionType.getOverloads(baseMethod).findIndex((baseOverload) => {
+            const matchIndex = baseOverloads.findIndex((baseOverload) => {
+                // If the override isn't applicable for this base class, skip the check.
+                if (baseClass && !isOverrideMethodApplicable(baseOverload, baseClass)) {
+                    return false;
+                }
                 return validateOverrideMethodInternal(baseOverload, overrideOverload, 
-                /* diag */ undefined, enforceParamNames);
+                /* diag */ undefined, enforceParamNames, 
+                /* exemptSelfClsParam */ false);
             });
             if (matchIndex < 0) {
                 diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideOverloadNoMatch().format({ index: overrideOverloadIndex }));
@@ -17344,7 +17439,46 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return true;
     }
-    function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames) {
+    // Determines whether a child class override is applicable to a parent
+    // class method signature. This is important in cases where the parent
+    // class defines an overload where some of the overload signatures supply
+    // explicit type annotations for the "self" or "cls" parameter and some
+    // of these do not apply to the child class.
+    function isOverrideMethodApplicable(baseMethod, childClass) {
+        if (!types_1.FunctionType.isInstanceMethod(baseMethod) &&
+            !types_1.FunctionType.isClassMethod(baseMethod) &&
+            !types_1.FunctionType.isConstructorMethod(baseMethod)) {
+            return true;
+        }
+        const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
+        if (baseParamDetails.params.length === 0) {
+            return true;
+        }
+        const baseParamType = baseParamDetails.params[0].param;
+        if (baseParamType.category !== 0 /* Simple */ || !baseParamType.hasDeclaredType) {
+            return true;
+        }
+        // If this is a self or cls parameter, determine whether the override
+        // class can be assigned to the base parameter type. If not, then this
+        // override doesn't apply. This is important for overloads where the
+        // base class contains some overload signatures that are not applicable
+        // to the child class.
+        const childSelfOrClsType = types_1.FunctionType.isInstanceMethod(baseMethod)
+            ? types_1.ClassType.cloneAsInstance(childClass)
+            : childClass;
+        return assignType(baseParamType.type, childSelfOrClsType, 
+        /* diag */ undefined, 
+        /* destTypeVarContext */ undefined, 
+        /* srcTypeVarContext */ undefined, 8 /* SkipSolveTypeVars */);
+    }
+    // Determines whether the override method is compatible with the overridden method.
+    // This is used both for parent/child overrides and implicit overrides for peer
+    // classes in a multi-inheritance case. If enforceParamNames is true, the parameter
+    // names of non-positional-only parameters are enforced. If exemptSelfClsParam
+    // is true, the "self" and "cls" parameters are exempted from type checks.
+    // This is normally the case except with overloaded method overrides where the
+    // "self" or "cls" parameter type must be honored to differentiate between overloads.
+    function validateOverrideMethodInternal(baseMethod, overrideMethod, diag, enforceParamNames, exemptSelfClsParam = true) {
         var _a, _b;
         const baseParamDetails = (0, parameterUtils_1.getParameterListDetails)(baseMethod);
         const overrideParamDetails = (0, parameterUtils_1.getParameterListDetails)(overrideMethod);
@@ -17365,7 +17499,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     canOverride = false;
                 }
             }
-            if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
+            else if (types_1.FunctionType.isInstanceMethod(baseMethod)) {
                 if (!types_1.FunctionType.isInstanceMethod(overrideMethod)) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideNotInstanceMethod());
                     canOverride = false;
@@ -17417,7 +17551,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 // If the first parameter is a "self" or "cls" parameter, skip the
                 // test because these are allowed to violate the Liskov substitution
                 // principle.
-                if (i === 0) {
+                if (i === 0 && exemptSelfClsParam) {
                     if (types_1.FunctionType.isInstanceMethod(overrideMethod) ||
                         types_1.FunctionType.isClassMethod(overrideMethod) ||
                         types_1.FunctionType.isConstructorMethod(overrideMethod)) {
@@ -17465,7 +17599,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     const overrideParamType = overrideParamDetails.params[i].type;
                     const baseIsSynthesizedTypeVar = (0, types_1.isTypeVar)(baseParamType) && baseParamType.details.isSynthesized;
                     const overrideIsSynthesizedTypeVar = (0, types_1.isTypeVar)(overrideParamType) && overrideParamType.details.isSynthesized;
-                    if (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar) {
+                    if (!exemptSelfClsParam || (!baseIsSynthesizedTypeVar && !overrideIsSynthesizedTypeVar)) {
                         if (baseParam.category !== overrideParam.category ||
                             !assignType(overrideParamType, baseParamType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overrideMethod)), new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(baseMethod)), 8 /* SkipSolveTypeVars */)) {
                             diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamType().format({
@@ -17510,11 +17644,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // Now check any keyword-only parameters.
             const baseKwOnlyParams = baseParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
                 paramInfo.param.category === 0 /* Simple */);
-            const overrideWkOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
+            const overrideKwOnlyParams = overrideParamDetails.params.filter((paramInfo) => paramInfo.source === parameterUtils_1.ParameterSource.KeywordOnly &&
                 paramInfo.param.category === 0 /* Simple */);
             baseKwOnlyParams.forEach((paramInfo) => {
                 var _a, _b, _c;
-                const overrideParamInfo = overrideWkOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
+                const overrideParamInfo = overrideKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
                 if (!overrideParamInfo && overrideParamDetails.kwargsIndex === undefined) {
                     diag === null || diag === void 0 ? void 0 : diag.addMessage(localize_1.Localizer.DiagnosticAddendum.overrideParamNameMissing().format({
                         name: (_a = paramInfo.param.name) !== null && _a !== void 0 ? _a : '?',
@@ -17547,7 +17681,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             });
             // Verify that any keyword-only parameters added by the overload are compatible
             // with the **kwargs in the base.
-            overrideWkOnlyParams.forEach((paramInfo) => {
+            overrideKwOnlyParams.forEach((paramInfo) => {
                 var _a;
                 const baseParamInfo = baseKwOnlyParams.find((pi) => paramInfo.param.name === pi.param.name);
                 if (!baseParamInfo) {