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

package/dist/analyzer/typeEvaluator.js

@@ -54,6 +54,7 @@ const constraintSolver_1 = require("./constraintSolver");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declarationUtils_1 = require("./declarationUtils");
+const decorators_1 = require("./decorators");
 const enums_1 = require("./enums");
 const functionTransform_1 = require("./functionTransform");
 const namedTuples_1 = require("./namedTuples");
@@ -211,7 +212,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return typeCache.size;
     }
     // This function should be called immediately prior to discarding
-    // the type evaluator. It forcibly replacing existing cache maps
+    // the type evaluator. It forcibly replaces existing cache maps
     // with empty equivalents. This shouldn't be necessary, but there
     // is apparently a bug in the v8 GC where it is unable to detect
     // circular references in complex data structures, so it fails
@@ -371,10 +372,27 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // context, logging any errors in the process. This may require the
     // type of surrounding statements to be evaluated.
     function getType(node) {
-        var _a;
-        return (_a = evaluateTypeForSubnode(node, () => {
+        var _a, _b;
+        let type = (_a = evaluateTypeForSubnode(node, () => {
             evaluateTypesForExpressionInContext(node);
         })) === null || _a === void 0 ? void 0 : _a.type;
+        // If this is a type parameter with a calculated variance, see if we
+        // can swap it out for a version that has a computed variance.
+        if (type && (0, types_1.isTypeVar)(type) && type.details.declaredVariance === 0 /* Auto */) {
+            const typeVarType = type;
+            const typeParamListNode = ParseTreeUtils.getParentNodeOfType(node, 76 /* TypeParameterList */);
+            if (((_b = typeParamListNode === null || typeParamListNode === void 0 ? void 0 : typeParamListNode.parent) === null || _b === void 0 ? void 0 : _b.nodeType) === 10 /* Class */) {
+                const classTypeResult = getTypeOfClass(typeParamListNode.parent);
+                if (classTypeResult) {
+                    inferTypeParameterVarianceForClass(classTypeResult.classType);
+                    const typeParam = classTypeResult.classType.details.typeParameters.find((param) => (0, types_1.isTypeSame)(param, typeVarType, { ignoreTypeFlags: true }));
+                    if (typeParam) {
+                        type = types_1.TypeBase.isInstance(type) ? types_1.TypeVarType.cloneAsInstance(typeParam) : typeParam;
+                    }
+                }
+            }
+        }
+        return type;
     }
     function getTypeResult(node) {
         return evaluateTypeForSubnode(node, () => {
@@ -446,7 +464,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
     }
     function getTypeOfExpression(node, flags = 0 /* None */, inferenceContext) {
-        var _a;
         // Is this type already cached?
         const cacheEntry = readTypeCacheEntry(node);
         if (cacheEntry &&
@@ -485,7 +502,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // at that point.
         initializedBasicTypes(node);
         let typeResult;
-        let reportExpectingTypeErrors = (flags & 128 /* ExpectingType */) !== 0;
+        let expectingInstantiable = (flags & 128 /* ExpectingInstantiableType */) !== 0;
         switch (node.nodeType) {
             case 38 /* Name */: {
                 typeResult = getTypeOfName(node, flags);
@@ -500,11 +517,11 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 9 /* Call */: {
-                typeResult = getTypeOfCall(node, inferenceContext, flags);
+                typeResult = getTypeOfCall(node, flags, inferenceContext);
                 break;
             }
             case 52 /* Tuple */: {
-                typeResult = getTypeOfTuple(node, inferenceContext, flags);
+                typeResult = getTypeOfTuple(node, flags, inferenceContext);
                 break;
             }
             case 11 /* Constant */: {
@@ -516,7 +533,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (isExpectingType) {
                     // Don't report expecting type errors again. We will have already
                     // reported them when analyzing the contents of the string.
-                    reportExpectingTypeErrors = false;
+                    expectingInstantiable = false;
                 }
                 typeResult = getTypeOfStringList(node, flags, isExpectingType);
                 break;
@@ -534,7 +551,13 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 7 /* BinaryOperation */: {
-                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, inferenceContext, flags);
+                let effectiveFlags = flags;
+                // If we're expecting an instantiable type and this isn't a union operator,
+                // don't require that the two operands are also instantiable types.
+                if (expectingInstantiable && node.operator !== 6 /* BitwiseOr */) {
+                    effectiveFlags &= ~128 /* ExpectingInstantiableType */;
+                }
+                typeResult = (0, operations_1.getTypeOfBinaryOperation)(evaluatorInterface, node, effectiveFlags, inferenceContext);
                 break;
             }
             case 5 /* AugmentedAssignment */: {
@@ -596,7 +619,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 break;
             }
             case 54 /* TypeAnnotation */: {
-                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* ExpectingType */ |
+                typeResult = getTypeOfExpression(node.typeAnnotation, 128 /* ExpectingInstantiableType */ |
                     256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
@@ -627,23 +650,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             // We shouldn't get here. If we do, report an error.
             (0, debug_1.fail)(`Unhandled expression type '${ParseTreeUtils.printExpression(node)}'`);
         }
-        if (reportExpectingTypeErrors && !typeResult.isIncomplete) {
-            if (flags & 64 /* DisallowTypeVarTuple */) {
-                if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
-                    addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
-                    typeResult.type = types_1.UnknownType.create();
-                }
-            }
-            if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
-                const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
-                    types_1.ClassType.isTupleClass(typeResult.type) &&
-                    ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
-                if (!isEmptyVariadic) {
-                    addExpectedClassDiagnostic(typeResult.type, node);
-                    typeResult.type = types_1.UnknownType.create();
-                    typeResult.typeErrors = true;
-                }
-            }
+        // Do we need to validate that the type is instantiable?
+        if (expectingInstantiable) {
+            validateTypeIsInstantiable(typeResult, flags, node);
         }
         writeTypeCache(node, typeResult, flags, inferenceContext, /* allowSpeculativeCaching */ true);
         // If there was an expected type, make sure that the result type is compatible.
@@ -659,7 +668,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);
@@ -672,6 +683,29 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
+    function validateTypeIsInstantiable(typeResult, flags, node) {
+        var _a;
+        // If the type is incomplete, don't log any diagnostics yet.
+        if (typeResult.isIncomplete) {
+            return;
+        }
+        if (flags & 64 /* DisallowTypeVarTuple */) {
+            if ((0, types_1.isVariadicTypeVar)(typeResult.type) && !typeResult.type.isVariadicInUnion) {
+                addError(localize_1.Localizer.Diagnostic.typeVarTupleContext(), node);
+                typeResult.type = types_1.UnknownType.create();
+            }
+        }
+        if (!(0, typeUtils_1.isEffectivelyInstantiable)(typeResult.type)) {
+            const isEmptyVariadic = (0, types_1.isClassInstance)(typeResult.type) &&
+                types_1.ClassType.isTupleClass(typeResult.type) &&
+                ((_a = typeResult.type.tupleTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 0;
+            if (!isEmptyVariadic) {
+                addExpectedClassDiagnostic(typeResult.type, node);
+                typeResult.type = types_1.UnknownType.create();
+                typeResult.typeErrors = true;
+            }
+        }
+    }
     function getTypeOfAwaitOperator(node, flags, inferenceContext) {
         const effectiveExpectedType = inferenceContext
             ? createAwaitableReturnType(node, inferenceContext.expectedType, /* isGenerator */ false)
@@ -748,7 +782,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfStringList(node, flags, isExpectingType) {
         let typeResult;
         if (isExpectingType) {
-            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 128 /* ExpectingType */;
+            let updatedFlags = flags | 4 /* AllowForwardReferences */ | 128 /* ExpectingInstantiableType */;
             // In most cases, annotations within a string are not parsed by the interpreter.
             // There are a few exceptions (e.g. the "bound" value for a TypeVar constructor).
             if ((flags & 4194304 /* InterpreterParsesStringLiteral */) === 0) {
@@ -911,7 +945,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return specialType;
             }
         }
-        let evaluatorFlags = 128 /* ExpectingType */ |
+        let evaluatorFlags = 128 /* ExpectingInstantiableType */ |
             256 /* ExpectingTypeAnnotation */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
@@ -975,64 +1009,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return (0, typeUtils_1.convertToInstance)(annotationType);
     }
-    function getTypeOfDecorator(node, functionOrClassType) {
-        // Evaluate the type of the decorator expression.
-        let flags = AnalyzerNodeInfo.getFileInfo(node).isStubFile
-            ? 4 /* AllowForwardReferences */
-            : 0 /* None */;
-        if (node.expression.nodeType !== 9 /* Call */) {
-            flags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorTypeResult = getTypeOfExpression(node.expression, flags);
-        // 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.
-        if ((0, types_1.isInstantiableClass)(decoratorTypeResult.type) &&
-            types_1.ClassType.isBuiltIn(decoratorTypeResult.type, 'classmethod') &&
-            (0, typeUtils_1.isProperty)(functionOrClassType)) {
-            return functionOrClassType;
-        }
-        const argList = [
-            {
-                argumentCategory: 0 /* Simple */,
-                typeResult: { type: functionOrClassType },
-            },
-        ];
-        const returnType = validateCallArguments(node.expression, argList, decoratorTypeResult, 
-        /* typeVarContext */ undefined, 
-        /* skipUnknownArgCheck */ true).returnType || types_1.UnknownType.create();
-        // If the return type is a function that has no annotations
-        // and just *args and **kwargs parameters, assume that it
-        // preserves the type of the input function.
-        if ((0, types_1.isFunction)(returnType) && !returnType.details.declaredReturnType) {
-            if (!returnType.details.parameters.some((param, index) => {
-                // Don't allow * or / separators or params with declared types.
-                if (!param.name || param.hasDeclaredType) {
-                    return true;
-                }
-                // Allow *args or **kwargs parameters.
-                if (param.category !== 0 /* Simple */) {
-                    return false;
-                }
-                // Allow inferred "self" or "cls" parameters.
-                return index !== 0 || !param.isTypeInferred;
-            })) {
-                return functionOrClassType;
-            }
-        }
-        // If the decorator is completely unannotated and the return type
-        // includes unknowns, assume that it preserves the type of the input
-        // function.
-        if ((0, typeUtils_1.isPartlyUnknown)(returnType)) {
-            if ((0, types_1.isFunction)(decoratorTypeResult.type)) {
-                if (!decoratorTypeResult.type.details.parameters.find((param) => param.typeAnnotation !== undefined) &&
-                    decoratorTypeResult.type.details.declaredReturnType === undefined) {
-                    return functionOrClassType;
-                }
-            }
-        }
-        return returnType;
-    }
     function canBeFalsy(type, recursionCount = 0) {
         type = makeTopLevelTypeVarsConcrete(type);
         if (recursionCount > types_1.maxTypeRecursionCount) {
@@ -1259,21 +1235,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             memberInfo = getTypeOfClassMemberName(errorNode, classType, 
             /* isAccessedThroughObject */ false, memberName, usage, classDiag, memberAccessFlags | 1 /* AccessClassMembersOnly */, bindToType);
         }
-        // If this is a protocol class X and we're accessing a non ClassVar,
-        // emit an error.
-        if (memberInfo &&
-            memberInfo.classType &&
-            memberInfo.symbol &&
-            (0, types_1.isClass)(memberInfo.classType) &&
-            types_1.ClassType.isProtocolClass(memberInfo.classType)) {
-            const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(memberInfo.symbol);
-            if (primaryDecl && primaryDecl.type === 1 /* Variable */ && !memberInfo.isClassVar) {
-                addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolMemberNotClassVar().format({
-                    memberName,
-                    className: memberInfo.classType.details.name,
-                }), errorNode);
-            }
-        }
         const isMemberPresentOnClass = (memberInfo === null || memberInfo === void 0 ? void 0 : memberInfo.classType) !== undefined;
         // If it wasn't found on the class, see if it's part of the metaclass.
         if (!memberInfo) {
@@ -2896,7 +2857,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if ((0, types_1.isTypeVar)(type) &&
             !type.details.isParamSpec &&
             !type.isVariadicInUnion &&
-            (flags & 128 /* ExpectingType */) === 0 &&
+            (flags & 128 /* ExpectingInstantiableType */) === 0 &&
             type.details.name === name) {
             // Handle the special case of a PEP 604 union. These can appear within
             // an implied type alias where we are not expecting a type.
@@ -2916,7 +2877,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
         }
-        if ((flags & 128 /* ExpectingType */) !== 0) {
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0) {
             if ((flags & 1024 /* AllowGenericClassType */) === 0) {
                 if ((0, types_1.isInstantiableClass)(type) && types_1.ClassType.isBuiltIn(type, 'Generic')) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.genericNotAllowed(), node);
@@ -3097,7 +3058,8 @@ 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 /* ExpectingInstantiableType */) !== 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({
@@ -3111,7 +3073,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         // Is this a generic type alias that needs to be specialized?
-        if ((flags & 128 /* ExpectingType */) !== 0 &&
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
             type.typeAliasInfo &&
             type.typeAliasInfo.typeParameters &&
             type.typeAliasInfo.typeParameters.length > 0 &&
@@ -4209,7 +4171,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // If this is meant to be a type and the base expression is a string expression,
         // emit an error because this will generate a runtime exception in Python versions
         // less than 3.10.
-        if (flags & 128 /* ExpectingType */) {
+        if (flags & 128 /* ExpectingInstantiableType */) {
             if (node.baseExpression.nodeType === 48 /* StringList */) {
                 const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
                 if (!fileInfo.isStubFile && fileInfo.executionEnvironment.pythonVersion < pythonVersion_1.PythonVersion.V3_10) {
@@ -4541,7 +4503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if ((0, types_1.isAnyOrUnknown)(concreteSubtype)) {
                 return concreteSubtype;
             }
-            if (flags & 128 /* ExpectingType */) {
+            if (flags & 128 /* ExpectingInstantiableType */) {
                 if ((0, types_1.isTypeVar)(unexpandedSubtype)) {
                     addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarNotSubscriptable().format({
                         type: printType(unexpandedSubtype),
@@ -4556,7 +4518,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 if (concreteSubtype.details.effectiveMetaclass &&
                     (0, types_1.isInstantiableClass)(concreteSubtype.details.effectiveMetaclass) &&
                     !types_1.ClassType.isBuiltIn(concreteSubtype.details.effectiveMetaclass, ['type', '_InitVarMeta']) &&
-                    (flags & 128 /* ExpectingType */) === 0) {
+                    (flags & 128 /* ExpectingInstantiableType */) === 0) {
                     const itemMethodType = getTypeOfClassMember(node, concreteSubtype, getIndexAccessMagicMethodName(usage), 
                     /* usage */ undefined, 
                     /* diag */ undefined, 64 /* SkipAttributeAccessOverride */ | 32 /* ConsiderMetaclassOnly */);
@@ -5063,7 +5025,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeArg(node, flags, supportsDictExpression) {
         let typeResult;
         let adjustedFlags = flags |
-            128 /* ExpectingType */ |
+            128 /* ExpectingInstantiableType */ |
             1 /* ConvertEllipsisToAny */ |
             8 /* EvaluateStringLiteralAsType */;
         const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
@@ -5110,8 +5072,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return typeResult;
     }
-    function getTypeOfTuple(node, inferenceContext, flags) {
-        if ((flags & 128 /* ExpectingType */) !== 0 && node.expressions.length === 0 && !inferenceContext) {
+    function getTypeOfTuple(node, flags, inferenceContext) {
+        if ((flags & 128 /* ExpectingInstantiableType */) !== 0 &&
+            node.expressions.length === 0 &&
+            !inferenceContext) {
             return { type: makeTupleObject([]), isEmptyTupleShorthand: true };
         }
         // If the expected type is a union, recursively call for each of the subtypes
@@ -5263,7 +5227,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return entryTypes;
     }
-    function getTypeOfCall(node, inferenceContext, flags) {
+    function getTypeOfCall(node, flags, inferenceContext) {
         var _a;
         let baseTypeResult;
         // Handle immediate calls of lambdas specially.
@@ -5551,9 +5515,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 +5532,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 +5573,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 +5619,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 +5830,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 +5847,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 +5856,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) {
@@ -6185,8 +6166,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         // Verify that the cast is necessary.
                         const castToType = getTypeOfArgumentExpectingType(argList[0]).type;
                         const castFromType = getTypeOfArgument(argList[1]).type;
-                        if ((0, types_1.isInstantiableClass)(castToType) && (0, types_1.isClassInstance)(castFromType)) {
-                            if ((0, types_1.isTypeSame)(castToType, types_1.ClassType.cloneAsInstantiable(castFromType), {
+                        if (types_1.TypeBase.isInstantiable(castToType) && !(0, types_1.isUnknown)(castToType)) {
+                            if ((0, types_1.isTypeSame)((0, typeUtils_1.convertToInstance)(castToType), castFromType, {
                                 ignorePseudoGeneric: true,
                             })) {
                                 addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportUnnecessaryCast, diagnosticRules_1.DiagnosticRule.reportUnnecessaryCast, localize_1.Localizer.Diagnostic.unnecessaryCast().format({
@@ -6883,7 +6864,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             while (argIndex < argList.length) {
                 if (argList[argIndex].argumentCategory === 2 /* UnpackedDictionary */) {
                     // Verify that the type used in this expression is a SupportsKeysAndGetItem[str, T].
-                    const argType = getTypeOfArgument(argList[argIndex]).type;
+                    const argType = getTypeOfArgument(argList[argIndex], (0, typeUtils_1.makeInferenceContext)(paramDetails.unpackedKwargsTypedDictType)).type;
                     if ((0, types_1.isAnyOrUnknown)(argType)) {
                         unpackedDictionaryArgType = argType;
                     }
@@ -6993,6 +6974,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 +7258,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 +7317,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;
@@ -7645,6 +7648,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     // list and reports any mismatches in types or counts. Returns the
     // specialized return type of the call.
     function validateFunctionArguments(errorNode, argList, typeResult, typeVarContext, skipUnknownArgCheck = false, inferenceContext) {
+        var _a;
+        const signatureTracker = (_a = inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.signatureTracker) !== null && _a !== void 0 ? _a : new typeUtils_1.UniqueSignatureTracker();
+        typeResult.type = (0, typeUtils_1.ensureFunctionSignaturesAreUnique)(typeResult.type, signatureTracker, errorNode.start);
         const matchResults = matchFunctionArgumentsToParameters(errorNode, argList, typeResult, 0);
         if (matchResults.argumentErrors) {
             // Evaluate types of all args. This will ensure that referenced symbols are
@@ -7660,7 +7666,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 overloadsUsedForCall: [],
             };
         }
-        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, inferenceContext);
+        return validateFunctionArgumentTypesWithContext(errorNode, matchResults, typeVarContext, skipUnknownArgCheck, (0, typeUtils_1.makeInferenceContext)(inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.expectedType, inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.isTypeIncomplete, signatureTracker));
     }
     // Determines whether the specified argument list satisfies the function
     // signature bound to the specified ParamSpec. Return value indicates success.
@@ -7849,11 +7855,12 @@ 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 */;
+                    : 2 /* DoNotSpecialize */;
                 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
@@ -7888,15 +7895,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (argParam.argType) {
                 argType = argParam.argType;
             }
-            else if (argParam.expectingType && !argParam.argument.typeResult && argParam.argument.valueExpression) {
-                const argTypeResult = getTypeOfExpression(argParam.argument.valueExpression, 8 /* EvaluateStringLiteralAsType */ |
-                    32 /* DisallowParamSpec */ |
-                    64 /* DisallowTypeVarTuple */);
-                argType = argTypeResult.type;
-                if (argTypeResult.isIncomplete) {
-                    isTypeIncomplete = true;
-                }
-            }
             else {
                 const argTypeResult = getTypeOfArgument(argParam.argument);
                 argType = argTypeResult.type;
@@ -8412,7 +8410,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             typeParameters = [];
             let isTypeParamListValid = true;
             typeParamsExpr.expressions.map((expr) => {
-                let entryType = getTypeOfExpression(expr, 128 /* ExpectingType */).type;
+                let entryType = getTypeOfExpression(expr, 128 /* ExpectingInstantiableType */).type;
                 if ((0, types_1.isTypeVar)(entryType)) {
                     if (entryType.scopeId) {
                         isTypeParamListValid = false;
@@ -8432,7 +8430,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
         return getTypeOfTypeAliasCommon(nameNode, nameNode, valueExpr, 
-        /* typeParamNodes */ undefined, () => typeParameters);
+        /* typeParamNodes */ undefined, () => typeParameters !== null && typeParameters !== void 0 ? typeParameters : []);
     }
     function getBooleanValue(node) {
         if (node.nodeType === 11 /* Constant */) {
@@ -8566,7 +8564,10 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function getTypeOfConstant(node, flags) {
         let type;
         if (node.constType === 26 /* None */) {
-            type = (flags & 128 /* ExpectingType */) !== 0 ? types_1.NoneType.createType() : types_1.NoneType.createInstance();
+            type =
+                (flags & 128 /* ExpectingInstantiableType */) !== 0
+                    ? types_1.NoneType.createType()
+                    : types_1.NoneType.createInstance();
         }
         else if (node.constType === 33 /* True */ ||
             node.constType === 15 /* False */ ||
@@ -8714,6 +8715,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 +8748,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 +8780,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 +8819,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 +8839,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 +8881,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 +8942,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 +9137,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 +9154,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;
@@ -9229,13 +9257,23 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // For now, use only the first expected type.
         const expectedFunctionType = expectedFunctionTypes.length > 0 ? expectedFunctionTypes[0] : undefined;
         let paramsArePositionOnly = true;
+        const expectedParamDetails = expectedFunctionType ? (0, parameterUtils_1.getParameterListDetails)(expectedFunctionType) : undefined;
         node.parameters.forEach((param, index) => {
-            let paramType = types_1.UnknownType.create();
-            if (expectedFunctionType && index < expectedFunctionType.details.parameters.length) {
-                paramType = types_1.FunctionType.getEffectiveParameterType(expectedFunctionType, index);
+            let paramType;
+            if (expectedParamDetails) {
+                if (index < expectedParamDetails.params.length) {
+                    paramType = expectedParamDetails.params[index].type;
+                }
+                else if (param.defaultValue) {
+                    // If the lambda param has a default value but there is no associated
+                    // parameter in the expected type, assume that the default value is
+                    // being used to explicitly capture a value from an outer scope. Infer
+                    // its type from the default value expression.
+                    paramType = getTypeOfExpression(param.defaultValue, undefined, inferenceContext).type;
+                }
             }
             if (param.name) {
-                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType) }, 0 /* None */);
+                writeTypeCache(param.name, { type: transformVariadicParamType(node, param.category, paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create()) }, 0 /* None */);
             }
             if (param.defaultValue) {
                 // Evaluate the default value if it's present.
@@ -9273,7 +9311,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 hasDefault: !!param.defaultValue,
                 defaultValueExpression: param.defaultValue,
                 hasDeclaredType: true,
-                type: paramType,
+                type: paramType !== null && paramType !== void 0 ? paramType : types_1.UnknownType.create(),
             };
             types_1.FunctionType.addParameter(functionType, functionParam);
         });
@@ -9579,11 +9617,14 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         hasDeclaredType: true,
                     });
                 });
-                types_1.FunctionType.addParameter(functionType, {
-                    category: 0 /* Simple */,
-                    isNameSynthesized: false,
-                    type: types_1.UnknownType.create(),
-                });
+                if (typeList.length > 0) {
+                    // Add a positional-only separator to the end of the parameter list.
+                    types_1.FunctionType.addParameter(functionType, {
+                        category: 0 /* Simple */,
+                        isNameSynthesized: false,
+                        type: types_1.UnknownType.create(),
+                    });
+                }
             }
             else if ((0, typeUtils_1.isEllipsisType)(typeArgs[0].type)) {
                 types_1.FunctionType.addDefaultParameters(functionType);
@@ -9842,7 +9883,8 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         const enclosingFunction = ParseTreeUtils.getEnclosingFunction(errorNode);
         if (enclosingFunction) {
-            const functionFlags = getFunctionFlagsFromDecorators(enclosingFunction, /* isInClass */ true);
+            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, enclosingFunction, 
+            /* isInClass */ true);
             const isInnerFunction = !!ParseTreeUtils.getEnclosingFunction(enclosingFunction);
             if (!isInnerFunction) {
                 // Check for static methods.
@@ -10426,7 +10468,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         if (isDeclaredTypeAlias(node.leftExpression)) {
             flags |=
-                128 /* ExpectingType */ |
+                128 /* ExpectingInstantiableType */ |
                     256 /* ExpectingTypeAnnotation */ |
                     8 /* EvaluateStringLiteralAsType */ |
                     32 /* DisallowParamSpec */ |
@@ -10712,7 +10754,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let protocolTypeParameters;
         const initSubclassArgs = [];
         let metaclassNode;
-        let exprFlags = 128 /* ExpectingType */ |
+        let exprFlags = 128 /* ExpectingInstantiableType */ |
             1024 /* AllowGenericClassType */ |
             262144 /* DisallowNakedGeneric */ |
             2048 /* DisallowTypeVarsWithScopeId */ |
@@ -11047,7 +11089,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
-            const newDecoratedType = applyClassDecorator(decoratedType, classType, decorator);
+            const newDecoratedType = (0, decorators_1.applyClassDecorator)(evaluatorInterface, decoratedType, classType, decorator);
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
@@ -11315,95 +11357,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             addDiagnostic(AnalyzerNodeInfo.getFileInfo(errorNode).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typeVarsNotInGenericOrProtocol() + diag.getString(), errorNode);
         }
     }
-    function applyClassDecorator(inputClassType, originalClassType, decoratorNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        let flags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-        if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-            flags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorType = getTypeOfExpression(decoratorNode.expression, flags).type;
-        if (decoratorNode.expression.nodeType === 9 /* Call */) {
-            const decoratorCallType = getTypeOfExpression(decoratorNode.expression.leftExpression, flags | 2 /* DoNotSpecialize */).type;
-            if ((0, types_1.isFunction)(decoratorCallType)) {
-                if (decoratorCallType.details.name === '__dataclass_transform__' ||
-                    decoratorCallType.details.builtInName === 'dataclass_transform') {
-                    originalClassType.details.classDataClassTransform = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-                }
-                else if (decoratorCallType.details.builtInName === 'deprecated') {
-                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputClassType;
-                }
-            }
-            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-                if (decoratorCallType.overloads.length > 0 &&
-                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
-                    originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputClassType;
-                }
-            }
-        }
-        if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-            const dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
-            if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, 
-                /* callNode */ undefined);
-                return inputClassType;
-            }
-            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
-                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputClassType;
-            }
-        }
-        else if ((0, types_1.isFunction)(decoratorType)) {
-            if (decoratorType.details.builtInName === 'final') {
-                originalClassType.details.flags |= 4096 /* Final */;
-                // Don't call getTypeOfDecorator for final. We'll hard-code its
-                // behavior because its function definition results in a cyclical
-                // dependency between builtins, typing and _typeshed stubs.
-                return inputClassType;
-            }
-            if (decoratorType.details.builtInName === 'deprecated') {
-                originalClassType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputClassType;
-            }
-            if (decoratorType.details.builtInName === 'runtime_checkable') {
-                originalClassType.details.flags |= 32768 /* RuntimeCheckable */;
-                // Don't call getTypeOfDecorator for runtime_checkable. It appears
-                // frequently in stubs, and it's a waste of time to validate its
-                // parameters.
-                return inputClassType;
-            }
-            // Is this a dataclass decorator?
-            let dataclassBehaviors;
-            let callNode;
-            if (decoratorNode.expression.nodeType === 9 /* Call */) {
-                callNode = decoratorNode.expression;
-                const decoratorCallType = getTypeOfExpression(callNode.leftExpression, flags | 2 /* DoNotSpecialize */).type;
-                dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorCallType);
-            }
-            else {
-                const decoratorType = getTypeOfExpression(decoratorNode.expression, flags).type;
-                dataclassBehaviors = (0, dataClasses_1.getDataclassDecoratorBehaviors)(decoratorType);
-            }
-            if (dataclassBehaviors) {
-                (0, dataClasses_1.applyDataClassDecorator)(evaluatorInterface, decoratorNode, originalClassType, dataclassBehaviors, callNode);
-                return inputClassType;
-            }
-        }
-        return getTypeOfDecorator(decoratorNode, inputClassType);
-    }
-    // Given a @typing.deprecated decorator node, returns either '' or a custom
-    // deprecation message if one is provided.
-    function getCustomDeprecationMessage(decorator) {
-        if (decorator.expression.nodeType === 9 /* Call */ &&
-            decorator.expression.arguments.length > 0 &&
-            decorator.expression.arguments[0].argumentCategory === 0 /* Simple */ &&
-            decorator.expression.arguments[0].valueExpression.nodeType === 48 /* StringList */ &&
-            decorator.expression.arguments[0].valueExpression.strings.length === 1) {
-            return decorator.expression.arguments[0].valueExpression.strings[0].value;
-        }
-        return '';
-    }
     // Runs any registered "callback hooks" that depend on the specified class type.
     // This allows us to complete any work that requires dependent classes to be
     // completed.
@@ -11550,7 +11503,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
             containingClassType = classInfo.classType;
         }
-        let functionFlags = getFunctionFlagsFromDecorators(node, !!containingClassNode);
+        let functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, node, !!containingClassNode);
         if (functionDecl === null || functionDecl === void 0 ? void 0 : functionDecl.isGenerator) {
             functionFlags |= 16 /* Generator */;
         }
@@ -11876,7 +11829,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let foundUnknown = false;
         for (let i = node.decorators.length - 1; i >= 0; i--) {
             const decorator = node.decorators[i];
-            const newDecoratedType = applyFunctionDecorator(decoratedType, functionType, decorator, node);
+            const newDecoratedType = (0, decorators_1.applyFunctionDecorator)(evaluatorInterface, decoratedType, functionType, decorator, node);
             const unknownOrAny = (0, typeUtils_1.containsAnyOrUnknown)(newDecoratedType, /* recurse */ false);
             if (unknownOrAny && (0, types_1.isUnknown)(unknownOrAny)) {
                 // Report this error only on the first unknown type.
@@ -11898,7 +11851,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     markParamAccessed(param);
                 });
             }
-            decoratedType = addOverloadsToFunctionType(node, decoratedType);
+            decoratedType = (0, decorators_1.addOverloadsToFunctionType)(evaluatorInterface, node, decoratedType);
         }
         writeTypeCache(node.name, { type: functionType }, 0 /* None */);
         writeTypeCache(node, { type: decoratedType }, 0 /* None */);
@@ -11979,6 +11932,12 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         const baseClassParamAnnotation = (_a = baseClassParam.typeAnnotation) !== null && _a !== void 0 ? _a : baseClassParam.typeAnnotationComment;
                         if (baseClassParamAnnotation) {
                             let inferredParamType = getTypeOfParameterAnnotation(baseClassParamAnnotation, functionNode.parameters[paramIndex].category);
+                            // If the parameter type is generic, specialize it in the context
+                            // of the child class.
+                            if ((0, typeUtils_1.requiresSpecialization)(inferredParamType) && (0, types_1.isClass)(baseClassMemberInfo.classType)) {
+                                const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClassMemberInfo.classType);
+                                inferredParamType = (0, typeUtils_1.applySolvedTypeVars)(inferredParamType, typeVarContext);
+                            }
                             const fileInfo = AnalyzerNodeInfo.getFileInfo(functionNode);
                             if (fileInfo.isInPyTypedPackage && !fileInfo.isStubFile) {
                                 inferredParamType = types_1.TypeBase.cloneForAmbiguousType(inferredParamType);
@@ -12004,10 +11963,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);
                 }
             }
@@ -12061,268 +12030,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    // Scans through the decorators to find a few built-in decorators
-    // that affect the function flags.
-    function getFunctionFlagsFromDecorators(node, isInClass) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(node);
-        let flags = 0 /* None */;
-        if (isInClass) {
-            // The "__new__" magic method is not an instance method.
-            // It acts as a static method instead.
-            if (node.name.value === '__new__') {
-                flags |= 1 /* ConstructorMethod */;
-            }
-            // Several magic methods are treated as class methods implicitly
-            // by the runtime. Check for these here.
-            const implicitClassMethods = ['__init_subclass__', '__class_getitem__'];
-            if (implicitClassMethods.some((name) => node.name.value === name)) {
-                flags |= 2 /* ClassMethod */;
-            }
-        }
-        for (const decoratorNode of node.decorators) {
-            // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-            let evaluatorFlags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-            if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-                evaluatorFlags |= 2 /* DoNotSpecialize */;
-            }
-            const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-            const decoratorType = decoratorTypeResult.type;
-            if ((0, types_1.isFunction)(decoratorType)) {
-                if (decoratorType.details.builtInName === 'abstractmethod') {
-                    if (isInClass) {
-                        flags |= 8 /* AbstractMethod */;
-                    }
-                }
-                else if (decoratorType.details.builtInName === 'final') {
-                    flags |= 8192 /* Final */;
-                }
-                else if (decoratorType.details.builtInName === 'override') {
-                    flags |= 262144 /* Overridden */;
-                }
-            }
-            else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-                if (types_1.ClassType.isBuiltIn(decoratorType, 'staticmethod')) {
-                    if (isInClass) {
-                        flags |= 4 /* StaticMethod */;
-                    }
-                }
-                else if (types_1.ClassType.isBuiltIn(decoratorType, 'classmethod')) {
-                    if (isInClass) {
-                        flags |= 2 /* ClassMethod */;
-                    }
-                }
-            }
-        }
-        return flags;
-    }
-    // Transforms the input function type into an output type based on the
-    // decorator function described by the decoratorNode.
-    function applyFunctionDecorator(inputFunctionType, undecoratedType, decoratorNode, functionNode) {
-        const fileInfo = AnalyzerNodeInfo.getFileInfo(decoratorNode);
-        // Some stub files (e.g. builtins.pyi) rely on forward declarations of decorators.
-        let evaluatorFlags = fileInfo.isStubFile ? 4 /* AllowForwardReferences */ : 0 /* None */;
-        if (decoratorNode.expression.nodeType !== 9 /* Call */) {
-            evaluatorFlags |= 2 /* DoNotSpecialize */;
-        }
-        const decoratorTypeResult = getTypeOfExpression(decoratorNode.expression, evaluatorFlags);
-        const decoratorType = decoratorTypeResult.type;
-        // Special-case the "overload" because it has no definition. Older versions of typeshed
-        // defined "overload" as an object, but newer versions define it as a function.
-        if (((0, types_1.isInstantiableClass)(decoratorType) && types_1.ClassType.isSpecialBuiltIn(decoratorType, 'overload')) ||
-            ((0, types_1.isFunction)(decoratorType) && decoratorType.details.builtInName === 'overload')) {
-            if ((0, types_1.isFunction)(inputFunctionType)) {
-                inputFunctionType.details.flags |= 256 /* Overloaded */;
-                undecoratedType.details.flags |= 256 /* Overloaded */;
-                return inputFunctionType;
-            }
-        }
-        if (decoratorNode.expression.nodeType === 9 /* Call */) {
-            const decoratorCallType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
-            if ((0, types_1.isFunction)(decoratorCallType)) {
-                if (decoratorCallType.details.name === '__dataclass_transform__' ||
-                    decoratorCallType.details.builtInName === 'dataclass_transform') {
-                    undecoratedType.details.decoratorDataClassBehaviors = (0, dataClasses_1.validateDataClassTransformDecorator)(evaluatorInterface, decoratorNode.expression);
-                    return inputFunctionType;
-                }
-                if (decoratorCallType.details.builtInName === 'deprecated') {
-                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputFunctionType;
-                }
-            }
-            if ((0, types_1.isOverloadedFunction)(decoratorCallType)) {
-                if (decoratorCallType.overloads.length > 0 &&
-                    decoratorCallType.overloads[0].details.builtInName === 'deprecated') {
-                    undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                    return inputFunctionType;
-                }
-            }
-        }
-        let returnType = getTypeOfDecorator(decoratorNode, inputFunctionType);
-        // Check for some built-in decorator types with known semantics.
-        if ((0, types_1.isFunction)(decoratorType)) {
-            if (decoratorType.details.builtInName === 'abstractmethod') {
-                return inputFunctionType;
-            }
-            if (decoratorType.details.builtInName === 'deprecated') {
-                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputFunctionType;
-            }
-            // Handle property setters and deleters.
-            if (decoratorNode.expression.nodeType === 35 /* MemberAccess */) {
-                const baseType = getTypeOfExpression(decoratorNode.expression.leftExpression, evaluatorFlags | 2 /* DoNotSpecialize */).type;
-                if ((0, typeUtils_1.isProperty)(baseType)) {
-                    const memberName = decoratorNode.expression.memberName.value;
-                    if (memberName === 'setter') {
-                        if ((0, types_1.isFunction)(inputFunctionType)) {
-                            (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                            return (0, properties_1.clonePropertyWithSetter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                        }
-                        else {
-                            return inputFunctionType;
-                        }
-                    }
-                    else if (memberName === 'deleter') {
-                        if ((0, types_1.isFunction)(inputFunctionType)) {
-                            (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                            return (0, properties_1.clonePropertyWithDeleter)(evaluatorInterface, baseType, inputFunctionType, functionNode);
-                        }
-                        else {
-                            return inputFunctionType;
-                        }
-                    }
-                }
-            }
-        }
-        else if ((0, types_1.isOverloadedFunction)(decoratorType)) {
-            if (decoratorType.overloads.length > 0 && decoratorType.overloads[0].details.builtInName === 'deprecated') {
-                undecoratedType.details.deprecatedMessage = getCustomDeprecationMessage(decoratorNode);
-                return inputFunctionType;
-            }
-        }
-        else if ((0, types_1.isInstantiableClass)(decoratorType)) {
-            if (types_1.ClassType.isBuiltIn(decoratorType)) {
-                switch (decoratorType.details.name) {
-                    case 'classmethod':
-                    case 'staticmethod': {
-                        const requiredFlag = decoratorType.details.name === 'classmethod'
-                            ? 2 /* ClassMethod */
-                            : 4 /* StaticMethod */;
-                        // If the function isn't currently a class method or static method
-                        // (which can happen if the function was wrapped in a decorator),
-                        // add the appropriate flag.
-                        if ((0, types_1.isFunction)(inputFunctionType) && (inputFunctionType.details.flags & requiredFlag) === 0) {
-                            const newFunction = types_1.FunctionType.clone(inputFunctionType);
-                            newFunction.details.flags &= ~(1 /* ConstructorMethod */ |
-                                4 /* StaticMethod */ |
-                                2 /* ClassMethod */);
-                            newFunction.details.flags |= requiredFlag;
-                            return newFunction;
-                        }
-                        return inputFunctionType;
-                    }
-                }
-            }
-            // Handle properties and subclasses of properties specially.
-            if (types_1.ClassType.isPropertyClass(decoratorType)) {
-                if ((0, types_1.isFunction)(inputFunctionType)) {
-                    (0, properties_1.validatePropertyMethod)(evaluatorInterface, inputFunctionType, decoratorNode);
-                    return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, inputFunctionType);
-                }
-                else if ((0, types_1.isClassInstance)(inputFunctionType)) {
-                    const boundMethod = getBoundMethod(inputFunctionType, '__call__');
-                    if (boundMethod && (0, types_1.isFunction)(boundMethod)) {
-                        return (0, properties_1.createProperty)(evaluatorInterface, decoratorNode, decoratorType, boundMethod);
-                    }
-                    return types_1.UnknownType.create();
-                }
-            }
-        }
-        if ((0, types_1.isFunction)(inputFunctionType) && (0, types_1.isFunction)(returnType)) {
-            returnType = types_1.FunctionType.clone(returnType);
-            // Copy the overload flag from the input function type.
-            if (types_1.FunctionType.isOverloaded(inputFunctionType)) {
-                returnType.details.flags |= 256 /* Overloaded */;
-            }
-            // Copy the docstrings from the input function type if the
-            // decorator didn't have its own docstring.
-            if (!returnType.details.docString) {
-                returnType.details.docString = inputFunctionType.details.docString;
-            }
-        }
-        return returnType;
-    }
-    // Given a function node and the function type associated with it, this
-    // method searches for prior function nodes that are marked as @overload
-    // and creates an OverloadedFunctionType that includes this function and
-    // all previous ones.
-    function addOverloadsToFunctionType(node, type) {
-        let functionDecl;
-        const decl = AnalyzerNodeInfo.getDeclaration(node);
-        if (decl) {
-            functionDecl = decl;
-        }
-        const symbolWithScope = lookUpSymbolRecursive(node, node.name.value, /* honorCodeFlow */ false);
-        if (symbolWithScope) {
-            const decls = symbolWithScope.symbol.getDeclarations();
-            // Find this function's declaration.
-            const declIndex = decls.findIndex((decl) => decl === functionDecl);
-            if (declIndex > 0) {
-                // Evaluate all of the previous function declarations. They will
-                // be cached. We do it in this order to avoid a stack overflow due
-                // to recursion if there is a large number (1000's) of overloads.
-                for (let i = 0; i < declIndex; i++) {
-                    const decl = decls[i];
-                    if (decl.type === 5 /* Function */) {
-                        getTypeOfFunction(decl.node);
-                    }
-                }
-                let overloadedTypes = [];
-                // Look at the previous declaration's type.
-                const prevDecl = decls[declIndex - 1];
-                if (prevDecl.type === 5 /* Function */) {
-                    const prevDeclDeclTypeInfo = getTypeOfFunction(prevDecl.node);
-                    if (prevDeclDeclTypeInfo) {
-                        if ((0, types_1.isFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                            if (types_1.FunctionType.isOverloaded(prevDeclDeclTypeInfo.decoratedType)) {
-                                overloadedTypes.push(prevDeclDeclTypeInfo.decoratedType);
-                            }
-                        }
-                        else if ((0, types_1.isOverloadedFunction)(prevDeclDeclTypeInfo.decoratedType)) {
-                            // If the previous declaration was itself an overloaded function,
-                            // copy the entries from it.
-                            (0, collectionUtils_1.appendArray)(overloadedTypes, prevDeclDeclTypeInfo.decoratedType.overloads);
-                        }
-                    }
-                }
-                overloadedTypes.push(type);
-                if (overloadedTypes.length === 1) {
-                    return overloadedTypes[0];
-                }
-                // Apply the implementation's docstring to any overloads that don't
-                // have their own docstrings.
-                const implementation = overloadedTypes.find((signature) => !types_1.FunctionType.isOverloaded(signature));
-                if (implementation === null || implementation === void 0 ? void 0 : implementation.details.docString) {
-                    overloadedTypes = overloadedTypes.map((overload) => {
-                        if (types_1.FunctionType.isOverloaded(overload) && !overload.details.docString) {
-                            return types_1.FunctionType.cloneWithDocString(overload, implementation.details.docString);
-                        }
-                        return overload;
-                    });
-                }
-                // Create a new overloaded type that copies the contents of the previous
-                // one and adds a new function.
-                const newOverload = types_1.OverloadedFunctionType.create(overloadedTypes);
-                const prevOverload = overloadedTypes[overloadedTypes.length - 2];
-                const isPrevOverloadAbstract = types_1.FunctionType.isAbstractMethod(prevOverload);
-                const isCurrentOverloadAbstract = types_1.FunctionType.isAbstractMethod(type);
-                if (isPrevOverloadAbstract !== isCurrentOverloadAbstract) {
-                    addDiagnostic(AnalyzerNodeInfo.getFileInfo(node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadAbstractMismatch().format({ name: node.name.value }), node.name);
-                }
-                return newOverload;
-            }
-        }
-        return type;
-    }
     function createAsyncFunction(node, functionType) {
         // Clone the original function and replace its return type with an
         // Awaitable[<returnType>].
@@ -13228,7 +12935,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         // See if the function is a method in a child class. We may be able to
         // infer the type of the parameter from a method of the same name in
         // a parent class if it has an annotated type.
-        const functionFlags = getFunctionFlagsFromDecorators(functionNode, /* isInClass */ true);
+        const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, functionNode, /* isInClass */ true);
         const inferredParamType = inferParameterType(functionNode, functionFlags, paramIndex, classInfo === null || classInfo === void 0 ? void 0 : classInfo.classType);
         writeTypeCache(node.name, { type: transformVariadicParamType(node, node.category, inferredParamType !== null && inferredParamType !== void 0 ? inferredParamType : types_1.UnknownType.create()) }, 0 /* None */);
     }
@@ -13737,7 +13444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         const specializedClass = types_1.ClassType.cloneForSpecialization(classType, typeArgTypes, typeArgs !== undefined);
         return { type: specializedClass };
     }
-    function getTypeOfArgument(arg) {
+    function getTypeOfArgument(arg, inferenceContext) {
         if (arg.typeResult) {
             return { type: arg.typeResult.type, isIncomplete: arg.typeResult.isIncomplete };
         }
@@ -13747,7 +13454,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         // If there was no defined type provided, there should always
         // be a value expression from which we can retrieve the type.
-        return getTypeOfExpression(arg.valueExpression);
+        return getTypeOfExpression(arg.valueExpression, /* flags */ undefined, inferenceContext);
     }
     // This function is like getTypeOfArgument except that it is
     // used in cases where the argument is expected to be a type
@@ -13762,7 +13469,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         return getTypeOfExpressionExpectingType(arg.valueExpression);
     }
     function getTypeOfExpressionExpectingType(node, options) {
-        let flags = 128 /* ExpectingType */ | 8 /* EvaluateStringLiteralAsType */ | 131072 /* DisallowClassVar */;
+        let flags = 128 /* ExpectingInstantiableType */ |
+            8 /* EvaluateStringLiteralAsType */ |
+            131072 /* DisallowClassVar */;
         if (!(options === null || options === void 0 ? void 0 : options.allowTypeVarsWithoutScopeId)) {
             flags |= 4096 /* DisallowTypeVarsWithoutScopeId */;
         }
@@ -15334,34 +15043,39 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         let isAssignable = true;
         destType.details.fields.forEach((symbol, name) => {
             var _a;
-            if (isAssignable && symbol.isClassMember() && !symbol.isIgnoredForProtocolMatch()) {
-                const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
-                (0, debug_1.assert)(memberInfo !== undefined);
-                let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
-                if (destMemberType) {
-                    const srcMemberType = getTypeOfMember(memberInfo);
-                    destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
-                    // Properties require special processing.
-                    if ((0, types_1.isClassInstance)(destMemberType) &&
-                        types_1.ClassType.isPropertyClass(destMemberType) &&
-                        (0, types_1.isClassInstance)(srcMemberType) &&
-                        types_1.ClassType.isPropertyClass(srcMemberType)) {
-                        if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
-                        /* selfTypeVarContext */ undefined, recursionCount)) {
-                            isAssignable = false;
-                        }
+            if (!isAssignable || !symbol.isClassMember() || symbol.isIgnoredForProtocolMatch()) {
+                return;
+            }
+            // Constructor methods are exempt from variance calculations.
+            if (name === '__new__' || name === '__init__') {
+                return;
+            }
+            const memberInfo = (0, typeUtils_1.lookUpClassMember)(srcType, name);
+            (0, debug_1.assert)(memberInfo !== undefined);
+            let destMemberType = (_a = getDeclaredTypeOfSymbol(symbol)) === null || _a === void 0 ? void 0 : _a.type;
+            if (destMemberType) {
+                const srcMemberType = getTypeOfMember(memberInfo);
+                destMemberType = (0, typeUtils_1.partiallySpecializeType)(destMemberType, destType);
+                // Properties require special processing.
+                if ((0, types_1.isClassInstance)(destMemberType) &&
+                    types_1.ClassType.isPropertyClass(destMemberType) &&
+                    (0, types_1.isClassInstance)(srcMemberType) &&
+                    types_1.ClassType.isPropertyClass(srcMemberType)) {
+                    if (!(0, properties_1.assignProperty)(evaluatorInterface, types_1.ClassType.cloneAsInstantiable(destMemberType), types_1.ClassType.cloneAsInstantiable(srcMemberType), destType, srcType, diag, typeVarContext, 
+                    /* selfTypeVarContext */ undefined, recursionCount)) {
+                        isAssignable = false;
                     }
-                    else {
-                        const primaryDecl = symbol.getDeclarations()[0];
-                        // Class and instance variables that are mutable need to
-                        // enforce invariance.
-                        const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !isFinalVariableDeclaration(primaryDecl)
-                            ? 1 /* EnforceInvariance */
-                            : 0 /* Default */;
-                        if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
-                        /* srcTypeVarContext */ undefined, flags, recursionCount)) {
-                            isAssignable = false;
-                        }
+                }
+                else {
+                    const primaryDecl = symbol.getDeclarations()[0];
+                    // Class and instance variables that are mutable need to
+                    // enforce invariance.
+                    const flags = (primaryDecl === null || primaryDecl === void 0 ? void 0 : primaryDecl.type) === 1 /* Variable */ && !isFinalVariableDeclaration(primaryDecl)
+                        ? 1 /* EnforceInvariance */
+                        : 0 /* Default */;
+                    if (!assignType(destMemberType, srcMemberType, diag, typeVarContext, 
+                    /* srcTypeVarContext */ undefined, flags, recursionCount)) {
+                        isAssignable = false;
                     }
                 }
             }
@@ -15458,7 +15172,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             }
         }
     }
-    function assignTupleTypeArgs(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignTupleTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b;
         const destTypeArgs = [...((_a = destType.tupleTypeArguments) !== null && _a !== void 0 ? _a : [])];
         const srcTypeArgs = [...((_b = srcType.tupleTypeArguments) !== null && _b !== void 0 ? _b : [])];
@@ -15500,32 +15214,28 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
     function assignClassWithTypeArgs(destType, srcType, inheritanceChain, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         let curSrcType = srcType;
         let prevSrcType;
-        let curDestTypeVarContext = destTypeVarContext;
-        let effectiveFlags = flags;
         inferTypeParameterVarianceForClass(destType);
-        effectiveFlags |= 8 /* SkipSolveTypeVars */;
-        if (!destTypeVarContext) {
-            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType));
-            effectiveFlags &= ~8 /* SkipSolveTypeVars */;
+        // If we're enforcing invariance, literal types must match.
+        if ((flags & 1 /* EnforceInvariance */) !== 0) {
+            const srcIsLiteral = srcType.literalValue !== undefined;
+            const destIsLiteral = destType.literalValue !== undefined;
+            if (srcIsLiteral !== destIsLiteral) {
+                return false;
+            }
         }
         else {
-            // If we're using the caller's type var context, don't solve the
-            // type vars in this pass. We'll do this after we're done looping
-            // through the inheritance chain.
-            effectiveFlags |= 8 /* SkipSolveTypeVars */;
+            // If the dest is an 'object', it's assignable.
+            if (types_1.ClassType.isBuiltIn(destType, 'object')) {
+                return true;
+            }
         }
         for (let ancestorIndex = inheritanceChain.length - 1; ancestorIndex >= 0; ancestorIndex--) {
             const ancestorType = inheritanceChain[ancestorIndex];
-            const curSrcTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(curSrcType));
             // If we've hit an "unknown", all bets are off, and we need to assume
             // that the type is assignable.
             if ((0, types_1.isUnknown)(ancestorType)) {
                 return true;
             }
-            // If we've hit an 'object', it's assignable.
-            if (types_1.ClassType.isBuiltIn(ancestorType, 'object')) {
-                return true;
-            }
             // If this isn't the first time through the loop, specialize
             // for the next ancestor in the chain.
             if (ancestorIndex < inheritanceChain.length - 1) {
@@ -15540,11 +15250,6 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
                 curSrcType = (0, typeUtils_1.specializeForBaseClass)(effectiveCurSrcType, ancestorType);
             }
-            // Handle built-in types that support arbitrary numbers
-            // of type parameters like Tuple.
-            if (ancestorIndex === 0 && destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
-                return assignTupleTypeArgs(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
-            }
             // If there are no type parameters on this class, we're done.
             const ancestorTypeParams = types_1.ClassType.getTypeParameters(ancestorType);
             if (ancestorTypeParams.length === 0) {
@@ -15554,26 +15259,26 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
             if (!ancestorType.typeArguments) {
                 return true;
             }
-            // Validate that the type arguments match.
-            if (!verifyTypeArgumentsAssignable(ancestorType, curSrcType, diag, curDestTypeVarContext, curSrcTypeVarContext, effectiveFlags, recursionCount)) {
+            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;
             }
-            // Allocate a new type var map for the next time through the loop.
-            curDestTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(ancestorType));
-            effectiveFlags &= ~8 /* SkipSolveTypeVars */;
-            prevSrcType = curSrcType;
+        }
+        // Handle tuple, which supports a variable number of type arguments.
+        if (destType.tupleTypeArguments && curSrcType.tupleTypeArguments) {
+            return assignTupleTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
         }
         if (destType.typeArguments) {
             // If the dest type is specialized, make sure the specialized source
             // type arguments are assignable to the dest type arguments.
-            if (!verifyTypeArgumentsAssignable(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount)) {
-                return false;
-            }
+            return assignTypeArguments(destType, curSrcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount);
         }
-        else if (destTypeVarContext &&
-            destType.details.typeParameters.length > 0 &&
-            curSrcType.typeArguments &&
-            !destTypeVarContext.isLocked()) {
+        if (destTypeVarContext && curSrcType.typeArguments && !destTypeVarContext.isLocked()) {
             // Populate the typeVar map with type arguments of the source.
             const srcTypeArgs = curSrcType.typeArguments;
             for (let i = 0; i < destType.details.typeParameters.length; i++) {
@@ -15599,7 +15304,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         }
         return undefined;
     }
-    function verifyTypeArgumentsAssignable(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
+    function assignTypeArguments(destType, srcType, diag, destTypeVarContext, srcTypeVarContext, flags, recursionCount) {
         var _a, _b, _c;
         (0, debug_1.assert)(types_1.ClassType.isSameGenericClass(destType, srcType));
         inferTypeParameterVarianceForClass(destType);
@@ -15660,7 +15365,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                     }
                 }
                 else {
-                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 /* EnforceInvariance */, recursionCount)) {
+                    if (!assignType(destTypeArg, srcTypeArg, assignmentDiag, destTypeVarContext, srcTypeVarContext, flags | 1 /* EnforceInvariance */ | 128 /* RetainLiteralsForTypeVar */, recursionCount)) {
                         // Don't report errors with type variables in "pseudo-random"
                         // classes since these type variables are not real.
                         if (!types_1.ClassType.isPseudoGenericClass(destType)) {
@@ -16168,7 +15873,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 return true;
             }
             if ((0, types_1.isFunction)(concreteSrcType)) {
-                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(concreteSrcType)), flags, recursionCount)) {
+                if (assignFunction(destType, concreteSrcType, diag === null || diag === void 0 ? void 0 : diag.createAddendum(), destTypeVarContext !== null && destTypeVarContext !== void 0 ? destTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(destType)), srcTypeVarContext !== null && srcTypeVarContext !== void 0 ? srcTypeVarContext : new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeIds)(concreteSrcType)), flags, recursionCount)) {
                     return true;
                 }
             }
@@ -16625,9 +16330,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 +16338,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 +16804,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 +16817,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 +16987,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 +17013,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 +17050,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 +17110,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 +17162,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 +17210,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 +17255,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 +17292,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) {
@@ -17699,7 +17444,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                         let isAbstract;
                         const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
                         if (decl && decl.type === 5 /* Function */) {
-                            const functionFlags = getFunctionFlagsFromDecorators(decl.node, true);
+                            const functionFlags = (0, decorators_1.getFunctionFlagsFromDecorators)(evaluatorInterface, decl.node, true);
                             isAbstract = !!(functionFlags & 8 /* AbstractMethod */);
                         }
                         else {
@@ -17830,7 +17575,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
                 }
             }
             else if (!assignType(memberTypeFirstParamType, firstParamType, diag, typeVarContext, 
-            /* srcTypeVarContext */ undefined, 0 /* Default */, recursionCount)) {
+            /* srcTypeVarContext */ undefined, 2048 /* AllowUnspecifiedTypeArguments */, recursionCount)) {
                 if (memberTypeFirstParam.name &&
                     !memberTypeFirstParam.isNameSynthesized &&
                     memberTypeFirstParam.hasDeclaredType) {
@@ -17932,6 +17677,9 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         if (options === null || options === void 0 ? void 0 : options.printUnknownWithAny) {
             flags |= 1 /* PrintUnknownWithAny */;
         }
+        if (options === null || options === void 0 ? void 0 : options.printTypeVarVariance) {
+            flags |= 2048 /* PrintTypeVarVariance */;
+        }
         if (options === null || options === void 0 ? void 0 : options.omitTypeArgumentsIfUnknown) {
             flags |= 2 /* OmitTypeArgumentsIfUnknown */;
         }
@@ -18074,7 +17822,7 @@ function createTypeEvaluator(importLookup, evaluatorOptions) {
         getObjectType,
         getBuiltInObject,
         getTypingType,
-        verifyTypeArgumentsAssignable,
+        assignTypeArguments,
         reportMissingTypeArguments,
         inferReturnTypeIfNecessary,
         inferTypeParameterVarianceForClass,