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

package/dist/analyzer/typeEvaluator.js

@@ -651,10 +651,17 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             !(0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) &&
             !(0, types_1.isNever)(inferenceContext.expectedType)) {
             expectedTypeCache.set(node.id, inferenceContext.expectedType);
+            // If this is a generic function and there is a signature tracker,
+            // make sure the signature is unique.
+            if (inferenceContext.signatureTracker && (0, types_1.isFunction)(typeResult.type)) {
+                typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, inferenceContext.signatureTracker, node.start);
+            }
             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);
@@ -979,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.
@@ -3092,11 +3106,13 @@ 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 ((0, typeUtils_1.requiresTypeArguments)(type) && !type.typeArguments) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportMissingTypeArgument, diagnosticRules_1.DiagnosticRule.reportMissingTypeArgument, localize_1.Localizer.Diagnostic.typeArgsMissingForClass().format({
-                        name: type.aliasName || type.details.name,
-                    }), node);
+            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({
+                            name: type.aliasName || type.details.name,
+                        }), node);
+                    }
                 }
             }
             if (!type.typeArguments) {
@@ -5130,7 +5146,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         let expectedTypeDiagAddendum;
         if (effectiveExpectedType) {
-            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType));
+            const result = getTypeOfTupleWithContext(node, (0, typeUtils_1.makeInferenceContext)(effectiveExpectedType, 
+            /* isTypeIncomplete */ false, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker));
             if (result && !result.typeErrors) {
                 return result;
             }
@@ -5183,7 +5200,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         const entryTypeResults = node.expressions.map((expr, index) => getTypeOfExpression(expr, 
-        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined)));
+        /* flags */ undefined, (0, typeUtils_1.makeInferenceContext)(index < expectedTypes.length ? expectedTypes[index] : undefined, inferenceContext.isTypeIncomplete, inferenceContext.signatureTracker)));
         const isIncomplete = entryTypeResults.some((result) => result.isIncomplete);
         const type = (0, typeUtils_1.convertToInstance)((0, typeUtils_1.specializeTupleClass)(tupleClassType, buildTupleTypesList(entryTypeResults), 
         /* isTypeArgumentExplicit */ true));
@@ -5275,6 +5292,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             return functionArg;
         });
         let typeResult = { type: types_1.UnknownType.create() };
+        // If the inference context has an associated signature tracker, make sure
+        // the base type of this call is not the same as one of the tracked signatures.
+        // This is important for nested generic calls (e.g. "foo(foo(x))").
+        if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) {
+            baseTypeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(baseTypeResult.type, inferenceContext.signatureTracker, node.leftExpression.start);
+        }
         if (!(0, typeUtils_1.isTypeAliasPlaceholder)(baseTypeResult.type)) {
             if (node.leftExpression.nodeType === 38 /* Name */ && node.leftExpression.value === 'super') {
                 // Handle the built-in "super" call specially.
@@ -5537,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;
@@ -5551,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);
@@ -5594,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
@@ -5645,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
@@ -5685,7 +5707,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // (one for each argument) will be undefined. On subsequent calls, this
     // list will grow to include union expansions.
     function validateOverloadsWithExpandedTypes(errorNode, expandedArgTypes, argParamMatches, typeVarContext, skipUnknownArgCheck, inferenceContext) {
-        var _a, _b, _c;
+        var _a, _b;
         const returnTypes = [];
         const matchedOverloads = [];
         let isTypeIncomplete = false;
@@ -5812,12 +5834,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                             effectiveReturnType = types_1.AnyType.create();
                         }
                         else {
-                            // If all of the return types are the same generic class,
-                            // replace the type arguments with Unknown. Otherwise return
-                            // an Unknown type that has associated "possible types" to aid
-                            // with completion suggestions.
-                            effectiveReturnType =
-                                (_c = (0, typeUtils_1.getCommonErasedType)(dedupedMatchResults)) !== null && _c !== void 0 ? _c : types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
+                            effectiveReturnType = types_1.UnknownType.createPossibleType(combinedTypes, possibleMatchInvolvesIncompleteUnknown);
                         }
                     }
                     returnTypes.push(effectiveReturnType);
@@ -5875,24 +5892,33 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (!firstArgResults) {
             return matches;
         }
+        let foundAmbiguousAnyArg = false;
         for (let i = 0; i < firstArgResults.length; i++) {
-            // If the arg contains Any or Unknown, see if the corresponding
+            // If the arg is Any or Unknown, see if the corresponding
             // parameter types differ in any way.
-            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(firstArgResults[i].argType, /* recurse */ true);
-            if (anyOrUnknownInArg) {
+            if ((0, types_1.isAnyOrUnknown)(firstArgResults[i].argType)) {
                 const paramTypes = matches.map((match) => i < match.matchResults.argParams.length
                     ? 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) {
         let overloadIndex = 0;
         let matches = [];
+        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
         // Create a list of potential overload matches based on arguments.
         types_1.OverloadedFunctionType.getOverloads(typeResult.type).forEach((overload) => {
             useSpeculativeMode(errorNode, () => {
@@ -5908,7 +5934,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         matches.forEach((match, matchIndex) => {
             if (winningOverloadIndex === undefined) {
                 useSpeculativeMode(errorNode, () => {
-                    const callResult = validateFunctionArgumentTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), 
+                    const callResult = validateFunctionArgumentTypes(errorNode, match, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(match.overload)), signatureTracker, 
                     /* skipUnknownArgCheck */ true);
                     if (callResult && !callResult.argumentErrors) {
                         winningOverloadIndex = matchIndex;
@@ -5963,9 +5989,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             return { argumentErrors: true, isTypeIncomplete: false, overloadsUsedForCall: [] };
         }
-        // Create a helper lambda that evaluates the overload that matches
+        // Create a helper function that evaluates the overload that matches
         // the arg/param lists.
-        const evaluateUsingLastMatchingOverload = (skipUnknownArgCheck) => {
+        function evaluateUsingLastMatchingOverload(skipUnknownArgCheck) {
             // Find the match with the largest overload index (i.e. the last overload
             // that was in the overload list).
             const lastMatch = filteredMatchResults.reduce((previous, current) => {
@@ -5975,7 +6001,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             effectiveTypeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeIds)(lastMatch.overload));
             effectiveTypeVarContext.unlock();
             return validateFunctionArgumentTypesWithContext(errorNode, lastMatch, effectiveTypeVarContext, skipUnknownArgCheck, inferenceContext);
-        };
+        }
         // If there is only one possible arg/param match among the overloads,
         // use the normal type matching mechanism because it is faster and
         // will provide a clearer error message.
@@ -6467,7 +6493,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 const combinedArgType = (0, typeUtils_1.combineSameSizedTuples)(makeTopLevelTypeVarsConcrete(argType), tupleClassType);
                 if ((0, types_1.isClassInstance)(combinedArgType) && (0, typeUtils_1.isTupleClass)(combinedArgType)) {
                     const tupleTypeArgs = (_a = combinedArgType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [];
-                    if (tupleTypeArgs.length !== 1) {
+                    if (tupleTypeArgs.length !== 1 || !tupleTypeArgs[0].isUnbounded) {
                         for (const tupleTypeArg of tupleTypeArgs) {
                             if (tupleTypeArg.isUnbounded) {
                                 expandedArgList.push({
@@ -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
@@ -7110,7 +7148,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     if (paramIndex >= paramDetails.firstPositionOrKeywordIndex &&
                         param.category === 0 /* Simple */ &&
                         param.name &&
-                        !param.hasDefault &&
                         paramMap.has(param.name) &&
                         paramMap.get(param.name).argsReceived === 0) {
                         const paramType = paramDetails.params[paramIndex].type;
@@ -7266,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,
@@ -7284,16 +7321,18 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // types of each argument expression and validates that the resulting type is
     // compatible with the declared type of the corresponding parameter.
     function validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
-        var _a;
+        var _a, _b;
         const type = matchResults.overload;
+        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        matchResults.overload = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(matchResults.overload, signatureTracker, errorNode.start);
         // Can we safely ignore the inference context (either because it's not provided
         // or will have no effect)? If so, we can eliminate a bunch of extra work.
         if (!inferenceContext ||
             (0, types_1.isAnyOrUnknown)(inferenceContext.expectedType) ||
             (0, types_1.isNever)(inferenceContext.expectedType) ||
             !type.details.declaredReturnType ||
-            !(0, typeUtils_1.requiresSpecialization)((_a = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _a !== void 0 ? _a : types_1.UnknownType.create())) {
-            return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+            !(0, typeUtils_1.requiresSpecialization)((_b = types_1.FunctionType.getSpecializedReturnType(type)) !== null && _b !== void 0 ? _b : types_1.UnknownType.create())) {
+            return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
         }
         const effectiveReturnType = getFunctionEffectiveReturnType(type);
         let effectiveExpectedType = inferenceContext.expectedType;
@@ -7310,7 +7349,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 assignType(effectiveReturnType, effectiveExpectedType, 
                 /* diag */ undefined, typeVarContextCopy, 
                 /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
-                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, skipUnknownArgCheck);
+                const speculativeResults = validateFunctionArgumentTypes(errorNode, matchResults, typeVarContextCopy, signatureTracker, skipUnknownArgCheck);
                 if (speculativeResults === null || speculativeResults === void 0 ? void 0 : speculativeResults.argumentErrors) {
                     effectiveExpectedType = undefined;
                 }
@@ -7323,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;
@@ -7358,14 +7407,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             /* diag */ undefined, typeVarContext, 
             /* srcTypeVarContext */ undefined, effectiveFlags | 1024 /* PopulatingExpectedType */);
         }
-        return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck);
+        return validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck);
     }
-    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, skipUnknownArgCheck = false) {
+    function validateFunctionArgumentTypes(errorNode, matchResults, typeVarContext, signatureTracker, skipUnknownArgCheck = false) {
         const type = matchResults.overload;
         let isTypeIncomplete = matchResults.isTypeIncomplete;
         let argumentErrors = false;
         let specializedInitSelfType;
-        let accumulatedAnyOrUnknownArg;
+        let anyOrUnknownArgument;
         const typeCondition = (0, typeUtils_1.getTypeCondition)(type);
         if (type.boundTypeVarScopeId) {
             // If the function was bound to a class or object and was a constructor, a
@@ -7422,8 +7471,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // where more than two passes are needed.
             let passCount = Math.min(typeVarMatchingCount, 2);
             for (let i = 0; i < passCount; i++) {
-                const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-                signatureTracker.addSignature(type);
                 useSpeculativeMode(errorNode, () => {
                     matchResults.argParams.forEach((argParam) => {
                         if (!argParam.requiresTypeVarMatching) {
@@ -7467,8 +7514,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let sawParamSpecKwargs = false;
         let condition = [];
         const argResults = [];
-        const signatureTracker = new typeUtils_1.UniqueSignatureTracker();
-        signatureTracker.addSignature(type);
         matchResults.argParams.forEach((argParam) => {
             var _a;
             const argResult = validateArgType(argParam, typeVarContext, signatureTracker, { type, isIncomplete: matchResults.isTypeIncomplete }, {
@@ -7485,13 +7530,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argResult.condition) {
                 condition = (_a = types_1.TypeCondition.combine(condition, argResult.condition)) !== null && _a !== void 0 ? _a : [];
             }
-            // Determine if the argument type contains an Any or Unknown. Accumulate
-            // these across all arguments.
-            const anyOrUnknownInArg = (0, typeUtils_1.containsAnyOrUnknown)(argResult.argType, /* recurs */ true);
-            if (anyOrUnknownInArg) {
-                accumulatedAnyOrUnknownArg = accumulatedAnyOrUnknownArg
-                    ? (0, typeUtils_1.preserveUnknown)(anyOrUnknownInArg, accumulatedAnyOrUnknownArg)
-                    : anyOrUnknownInArg;
+            if ((0, types_1.isAnyOrUnknown)(argResult.argType)) {
+                anyOrUnknownArgument = anyOrUnknownArgument
+                    ? (0, typeUtils_1.preserveUnknown)(argResult.argType, anyOrUnknownArgument)
+                    : argResult.argType;
             }
             if (type.details.paramSpec) {
                 if (argParam.argument.argumentCategory === 1 /* UnpackedList */) {
@@ -7602,7 +7644,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return {
             argumentErrors,
             argResults,
-            anyOrUnknownArgument: accumulatedAnyOrUnknownArg,
+            anyOrUnknownArgument,
             returnType: specializedReturnType,
             isTypeIncomplete,
             activeParam: matchResults.activeParam,
@@ -7855,17 +7897,18 @@ 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 */;
-                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete)));
+                const exprTypeResult = getTypeOfExpression(argParam.argument.valueExpression, flags, (0, typeUtils_1.makeInferenceContext)(expectedType, !!(typeResult === null || typeResult === void 0 ? void 0 : typeResult.isIncomplete), signatureTracker));
                 argType = exprTypeResult.type;
                 // If the type includes multiple instances of a generic function
                 // signature, force the type arguments for the duplicates to have
                 // unique names.
-                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker);
+                argType = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(argType, signatureTracker, argParam.argument.valueExpression.start);
                 if (exprTypeResult.isIncomplete) {
                     isTypeIncomplete = true;
                 }
@@ -7894,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 */);
@@ -8720,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;
@@ -8752,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);
@@ -8784,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.
@@ -8822,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, 
@@ -8842,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);
@@ -8877,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;
                 }
@@ -8933,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] });
@@ -9128,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) => {
@@ -9145,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;
@@ -10718,7 +10788,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
-        let isMetaclassDeferred = false;
         let exprFlags = 128 /* ExpectingType */ |
             1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
@@ -10773,7 +10842,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                                 dependency: argType,
                                 callback: () => completeClassTypeDeferred(classType, node, node.name),
                             });
-                            isMetaclassDeferred = true;
                         }
                         if (types_1.ClassType.isBuiltIn(argType, 'Protocol')) {
                             if (!fileInfo.isStubFile &&
@@ -11144,11 +11212,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         writeTypeCache(node.name, { type: classType }, 0 /* None */);
         // Update the decorated class type.
         writeTypeCache(node, { type: decoratedType }, 0 /* None */);
-        // Validate that arguments passed to `__init_subclass__` are of the correct type.
-        // Defer this if the metaclass calculation is deferred.
-        if (!isMetaclassDeferred) {
-            validateInitSubclassArgs(node, classType);
-        }
         return { classType, decoratedType };
     }
     // Determines whether the type parameters has a default that refers to another
@@ -11438,7 +11501,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // Recompute the effective metaclass.
         computeEffectiveMetaclass(type, errorNode);
-        validateInitSubclassArgs(node, type);
     }
     function validateInitSubclassArgs(node, classType) {
         // Collect arguments that will be passed to the `__init_subclass__`
@@ -12018,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);
                 }
             }
@@ -14025,7 +14097,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return undefined;
     }
     function getDeclarationsForNameNode(node, skipUnreachableCode = true) {
-        var _a;
+        var _a, _b, _c;
         if (skipUnreachableCode && AnalyzerNodeInfo.isCodeUnreachable(node)) {
             return undefined;
         }
@@ -14126,7 +14198,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // the corresponding named parameter can be determined from the context.
             const argNode = node.parent;
             const paramName = node.value;
-            if (argNode.parent && argNode.parent.nodeType === 9 /* Call */) {
+            if (((_a = argNode.parent) === null || _a === void 0 ? void 0 : _a.nodeType) === 9 /* Call */) {
                 const baseType = getType(argNode.parent.leftExpression);
                 if (baseType) {
                     if ((0, types_1.isFunction)(baseType) && baseType.details.declaration) {
@@ -14144,8 +14216,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         });
                     }
                     else if ((0, types_1.isInstantiableClass)(baseType)) {
-                        const initMethodType = (_a = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
-                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _a === void 0 ? void 0 : _a.type;
+                        const initMethodType = (_b = getTypeOfObjectMember(argNode.parent.leftExpression, types_1.ClassType.cloneAsInstance(baseType), '__init__', { method: 'get' }, 
+                        /* diag */ undefined, 4 /* SkipObjectBaseClass */)) === null || _b === void 0 ? void 0 : _b.type;
                         if (initMethodType && (0, types_1.isFunction)(initMethodType)) {
                             const paramDecl = getDeclarationFromFunctionNamedParameter(initMethodType, paramName);
                             if (paramDecl) {
@@ -14161,6 +14233,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
             }
+            else if (((_c = argNode.parent) === null || _c === void 0 ? void 0 : _c.nodeType) === 10 /* Class */) {
+                const classTypeResult = getTypeOfClass(argNode.parent);
+                // Validate the init subclass args for this class so we can properly
+                // evaluate its custom keyword parameters.
+                if (classTypeResult) {
+                    validateInitSubclassArgs(argNode.parent, classTypeResult.classType);
+                }
+            }
         }
         else {
             const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -15569,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.
@@ -15743,6 +15831,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             (transformedSrcType !== srcType && (0, types_1.isUnion)(transformedSrcType))) {
             // Use a smaller recursive limit in this case to prevent runaway recursion.
             if (recursionCount > maxRecursiveTypeAliasRecursionCount) {
+                // Add a special case for when the source is a str, which is itself
+                // a recursive type (since it derives from Sequence[str]).
+                if ((0, types_1.isClassInstance)(srcType) && types_1.ClassType.isBuiltIn(srcType, 'str') && (0, types_1.isUnion)(transformedDestType)) {
+                    return transformedDestType.subtypes.some((subtype) => (0, types_1.isClassInstance)(subtype) && types_1.ClassType.isBuiltIn(subtype, ['object', 'str']));
+                }
                 return true;
             }
         }
@@ -16626,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);
             }
         }
@@ -16636,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) {
@@ -17104,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) => {
@@ -17115,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.
@@ -17294,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)) {
@@ -17320,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 }));
@@ -17345,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);
@@ -17366,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;
@@ -17418,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)) {
@@ -17466,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({
@@ -17511,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 : '?',
@@ -17548,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) {
@@ -18028,6 +18161,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         verifyRaiseExceptionType,
         verifyDeleteExpression,
         validateOverloadedFunctionArguments,
+        validateInitSubclassArgs,
         isAfterNodeReachable,
         isNodeReachable,
         isAsymmetricDescriptorAssignment: isAsymmetricAccessorAssignment,
@@ -18075,6 +18209,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getBuiltInObject,
         getTypingType,
         verifyTypeArgumentsAssignable,
+        reportMissingTypeArguments,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,
         isFinalVariable,