@zzzen/pyright-internal 1.2.0-dev.20240728 → 1.2.0-dev.20240811

package/dist/analyzer/checker.js

@@ -50,6 +50,7 @@ const localize_1 = require("../localization/localize");
 const parseNodes_1 = require("../parser/parseNodes");
 const stringTokenUtils_1 = require("../parser/stringTokenUtils");
 const AnalyzerNodeInfo = __importStar(require("./analyzerNodeInfo"));
+const constraintTracker_1 = require("./constraintTracker");
 const constructors_1 = require("./constructors");
 const dataClasses_1 = require("./dataClasses");
 const declaration_1 = require("./declaration");
@@ -69,13 +70,12 @@ const sourceMapper_1 = require("./sourceMapper");
 const staticExpressions_1 = require("./staticExpressions");
 const SymbolNameUtils = __importStar(require("./symbolNameUtils"));
 const symbolUtils_1 = require("./symbolUtils");
+const typedDicts_1 = require("./typedDicts");
 const typeEvaluator_1 = require("./typeEvaluator");
 const typeEvaluatorTypes_1 = require("./typeEvaluatorTypes");
 const typeGuards_1 = require("./typeGuards");
-const typeUtils_1 = require("./typeUtils");
-const typeVarContext_1 = require("./typeVarContext");
-const typedDicts_1 = require("./typedDicts");
 const types_1 = require("./types");
+const typeUtils_1 = require("./typeUtils");
 // When enabled, this debug flag causes the code complexity of
 // functions to be emitted.
 const isPrintCodeComplexityEnabled = false;
@@ -248,14 +248,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 // Allow unknown and missing param types if the param is named '_'.
                 if (param.d.name && param.d.name.d.value !== '_') {
-                    const functionTypeParam = functionTypeResult.functionType.shared.parameters.find((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
-                    if (functionTypeParam) {
-                        const paramType = functionTypeParam.type;
+                    const paramIndex = functionTypeResult.functionType.shared.parameters.findIndex((p) => { var _a; return p.name === ((_a = param.d.name) === null || _a === void 0 ? void 0 : _a.d.value); });
+                    if (paramIndex >= 0) {
+                        const functionTypeParam = functionTypeResult.functionType.shared.parameters[paramIndex];
+                        const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, paramIndex);
                         if (this._fileInfo.diagnosticRuleSet.reportUnknownParameterType !== 'none') {
                             if ((0, types_1.isUnknown)(paramType) ||
                                 ((0, types_1.isTypeVar)(paramType) &&
                                     paramType.shared.isSynthesized &&
-                                    !paramType.shared.isSynthesizedSelf)) {
+                                    !types_1.TypeVarType.isSelf(paramType))) {
                                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnknownParameterType, localize_1.LocMessage.paramTypeUnknown().format({ paramName: param.d.name.d.value }), param.d.name);
                             }
                             else if ((0, typeUtils_1.isPartlyUnknown)(paramType)) {
@@ -274,7 +275,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                         else {
                             // See if this is a "self" and "cls" parameter. They are exempt from this rule.
-                            if ((0, types_1.isTypeVar)(paramType) && paramType.shared.isSynthesizedSelf) {
+                            if ((0, types_1.isTypeVar)(paramType) && types_1.TypeVarType.isSelf(paramType)) {
                                 hasAnnotation = true;
                             }
                         }
@@ -287,7 +288,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             // Verify that an unpacked TypedDict doesn't overlap any keyword parameters.
             if (paramDetails.hasUnpackedTypedDict) {
                 const kwargsIndex = functionTypeResult.functionType.shared.parameters.length - 1;
-                const kwargsType = types_1.FunctionType.getEffectiveParamType(functionTypeResult.functionType, kwargsIndex);
+                const kwargsType = types_1.FunctionType.getParamType(functionTypeResult.functionType, kwargsIndex);
                 if ((0, types_1.isClass)(kwargsType) && kwargsType.shared.typedDictEntries) {
                     const overlappingEntries = new Set();
                     kwargsType.shared.typedDictEntries.knownItems.forEach((_, name) => {
@@ -303,9 +304,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
             }
             // Check for invalid use of ParamSpec P.args and P.kwargs.
-            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param) => {
-                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(param.type) && (0, types_1.isParamSpec)(param.type)) {
-                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && param.type.priv.paramSpecAccess) {
+            const paramSpecParams = functionTypeResult.functionType.shared.parameters.filter((param, index) => {
+                const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
+                if (types_1.FunctionParam.isTypeDeclared(param) && (0, types_1.isTypeVar)(paramType) && (0, types_1.isParamSpec)(paramType)) {
+                    if (param.category !== 0 /* ParamCategory.Simple */ && param.name && paramType.priv.paramSpecAccess) {
                         return true;
                     }
                 }
@@ -343,10 +345,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (functionTypeResult) {
                 const annotationNode = param.d.annotation || param.d.annotationComment;
                 if (annotationNode && index < functionTypeResult.functionType.shared.parameters.length) {
-                    const paramType = functionTypeResult.functionType.shared.parameters[index].type;
+                    const paramType = types_1.FunctionType.getParamType(functionTypeResult.functionType, index);
                     const exemptMethods = ['__init__', '__new__'];
                     if (containingClassNode &&
                         (0, types_1.isTypeVar)(paramType) &&
+                        paramType.priv.scopeType === 0 /* TypeVarScopeType.Class */ &&
                         paramType.shared.declaredVariance === 3 /* Variance.Covariant */ &&
                         !paramType.shared.isSynthesized &&
                         !exemptMethods.some((name) => name === functionTypeResult.functionType.shared.name)) {
@@ -409,12 +412,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
         this._scopedNodes.push(node);
-        if (functionTypeResult && (0, types_1.isOverloadedFunction)(functionTypeResult.decoratedType)) {
+        if (functionTypeResult && (0, types_1.isOverloaded)(functionTypeResult.decoratedType)) {
             // If this is the implementation for the overloaded function, skip
             // overload consistency checks.
-            if (types_1.OverloadedFunctionType.getImplementation(functionTypeResult.decoratedType) !==
-                functionTypeResult.functionType) {
-                const overloads = types_1.OverloadedFunctionType.getOverloads(functionTypeResult.decoratedType);
+            if (types_1.OverloadedType.getImplementation(functionTypeResult.decoratedType) !== functionTypeResult.functionType) {
+                const overloads = types_1.OverloadedType.getOverloads(functionTypeResult.decoratedType);
                 if (overloads.length > 1) {
                     const maxOverloadConsistencyCheckLength = 100;
                     // The check is n^2 in time, so if the number of overloads
@@ -579,33 +581,31 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 else {
                     const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-                    declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
                     declaredReturnType = this._evaluator.stripTypeGuard(declaredReturnType);
+                    let adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
-                    if (this._evaluator.assignType(declaredReturnType, returnType, diagAddendum, 
-                    /* destTypeVarContext */ new typeVarContext_1.TypeVarContext())) {
+                    if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                         returnTypeMatches = true;
                     }
                     else {
                         // See if the declared return type includes one or more constrained TypeVars. If so,
                         // try to narrow these TypeVars to a single type.
                         const uniqueTypeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(declaredReturnType);
-                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => typeVar.shared.constraints.length > 0)) {
-                            const typeVarContext = new typeVarContext_1.TypeVarContext();
+                        if (uniqueTypeVars && uniqueTypeVars.some((typeVar) => types_1.TypeVarType.hasConstraints(typeVar))) {
+                            const constraints = new constraintTracker_1.ConstraintTracker();
                             for (const typeVar of uniqueTypeVars) {
-                                if (typeVar.shared.constraints.length > 0) {
-                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, typeVar);
+                                if (types_1.TypeVarType.hasConstraints(typeVar)) {
+                                    const narrowedType = this._evaluator.narrowConstrainedTypeVar(node, types_1.TypeVarType.cloneAsBound(typeVar));
                                     if (narrowedType) {
-                                        (0, typeUtils_1.setTypeVarType)(typeVarContext, typeVar, narrowedType);
-                                        typeVarContext.addSolveForScope((0, typeUtils_1.getTypeVarScopeId)(typeVar));
+                                        constraints.setBounds(typeVar, narrowedType);
                                     }
                                 }
                             }
-                            if (!typeVarContext.isEmpty()) {
-                                let adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
-                                adjustedReturnType = this._evaluator.stripTypeGuard(adjustedReturnType);
-                                if (this._evaluator.assignType(adjustedReturnType, returnType, diagAddendum)) {
+                            if (!constraints.isEmpty()) {
+                                adjReturnType = this._evaluator.solveAndApplyConstraints(declaredReturnType, constraints);
+                                adjReturnType = (0, typeUtils_1.makeTypeVarsBound)(adjReturnType, liveScopes);
+                                if (this._evaluator.assignType(adjReturnType, returnType, diagAddendum)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -763,7 +763,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return true;
     }
     visitAugmentedAssignment(node) {
-        this._evaluator.evaluateTypesForStatement(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.destExpr, typeResult);
         return true;
     }
     visitIndex(node) {
@@ -832,7 +833,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateContainmentTypes(node);
             }
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.leftExpr, typeResult);
         return true;
     }
     visitSlice(node) {
@@ -851,7 +853,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (node.d.operator === 38 /* OperatorType.Not */) {
             this._validateConditionalIsBool(node.d.expr);
         }
-        this._evaluator.getType(node);
+        const typeResult = this._evaluator.getTypeResult(node);
+        this._reportDeprecatedUseForOperation(node.d.expr, typeResult);
         return true;
     }
     visitTernary(node) {
@@ -1164,6 +1167,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isTypeBool = true;
         const diag = new diagnostic_1.DiagnosticAddendum();
         this._evaluator.mapSubtypesExpandTypeVars(operandType, /* options */ undefined, (expandedSubtype) => {
+            var _a;
             if ((0, types_1.isAnyOrUnknown)(expandedSubtype)) {
                 return undefined;
             }
@@ -1172,8 +1176,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return undefined;
             }
             // Invoke the __bool__ method on the type.
-            const boolReturnType = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
-            /* inferenceContext */ undefined);
+            const boolReturnType = (_a = this._evaluator.getTypeOfMagicMethodCall(expandedSubtype, '__bool__', [], node, 
+            /* inferenceContext */ undefined)) === null || _a === void 0 ? void 0 : _a.type;
             if (!boolReturnType || (0, types_1.isAnyOrUnknown)(boolReturnType)) {
                 return undefined;
             }
@@ -1213,7 +1217,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let isCoroutine = true;
         (0, typeUtils_1.doForEachSubtype)(exprTypeResult.type, (subtype) => {
             subtype = this._evaluator.makeTopLevelTypeVarsConcrete(subtype);
-            if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloadedFunction)(subtype)) {
+            if (!(0, types_1.isFunction)(subtype) && !(0, types_1.isOverloaded)(subtype)) {
                 isExprFunction = false;
             }
             if (!(0, types_1.isClassInstance)(subtype) || !types_1.ClassType.isBuiltIn(subtype, 'Coroutine')) {
@@ -1406,6 +1410,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         isPossiblyTrue = true;
                     }
                 });
+                (0, typeUtils_1.doForEachSubtype)(rightType, (rightSubtype) => {
+                    if (this._evaluator.assignType(leftType, rightSubtype)) {
+                        isPossiblyTrue = true;
+                    }
+                });
                 if (!isPossiblyTrue) {
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportUnnecessaryComparison, getMessage().format({
                         leftType: this._evaluator.printType(leftType, { expandTypeAlias: true }),
@@ -1457,8 +1466,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, typeUtils_1.isNoneInstance)(leftType) || (0, typeUtils_1.isNoneInstance)(rightType)) {
             return (0, types_1.isTypeSame)(leftType, rightType);
         }
-        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloadedFunction)(leftType);
-        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloadedFunction)(rightType);
+        const isLeftCallable = (0, types_1.isFunction)(leftType) || (0, types_1.isOverloaded)(leftType);
+        const isRightCallable = (0, types_1.isFunction)(rightType) || (0, types_1.isOverloaded)(rightType);
         if (isLeftCallable !== isRightCallable) {
             return false;
         }
@@ -1582,13 +1591,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             var _a, _b, _c, _d, _e, _f, _g;
             const nameType = this._evaluator.getType(nameNode);
             ``;
-            if (nameType && (0, types_1.isTypeVar)(nameType) && !nameType.shared.isSynthesizedSelf) {
+            if (nameType && (0, types_1.isTypeVar)(nameType) && !types_1.TypeVarType.isSelf(nameType)) {
                 // Does this name refer to a TypeVar that is scoped to this function?
                 if (nameType.priv.scopeId === ParseTreeUtils.getScopeIdForNode(node)) {
                     // We exempt constrained TypeVars, TypeVars that are type arguments of
                     // other types, and ParamSpecs. There are legitimate uses for singleton
                     // instances in these particular cases.
-                    let isExempt = nameType.shared.constraints.length > 0 ||
+                    let isExempt = types_1.TypeVarType.hasConstraints(nameType) ||
                         nameType.shared.isDefaultExplicit ||
                         (exemptBoundTypeVar && subscriptIndex !== undefined) ||
                         (0, types_1.isParamSpec)(nameType);
@@ -1727,7 +1736,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             // Skip this check if the function is overloaded because the TypeVar
             // will be solved in terms of the overload signatures.
-            const skipUnsolvableTypeVarCheck = (0, types_1.isOverloadedFunction)(functionTypeResult.decoratedType) &&
+            const skipUnsolvableTypeVarCheck = (0, types_1.isOverloaded)(functionTypeResult.decoratedType) &&
                 !types_1.FunctionType.isOverloaded(functionTypeResult.functionType);
             if (isUsedInReturnType &&
                 usage.paramTypeWithEllipsisUsageCount > 0 &&
@@ -1760,9 +1769,18 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Validates that overloads use @staticmethod and @classmethod consistently.
     _validateOverloadAttributeConsistency(node, functionType) {
         var _a, _b, _c, _d, _e, _f;
+        // Don't bother with the check if it's suppressed.
+        if (this._fileInfo.diagnosticRuleSet.reportInconsistentOverload === 'none') {
+            return;
+        }
         let staticMethodCount = 0;
         let classMethodCount = 0;
-        functionType.priv.overloads.forEach((overload) => {
+        const overloads = types_1.OverloadedType.getOverloads(functionType);
+        if (overloads.length === 0) {
+            return;
+        }
+        let totalMethods = overloads.length;
+        overloads.forEach((overload) => {
             if (types_1.FunctionType.isStaticMethod(overload)) {
                 staticMethodCount++;
             }
@@ -1770,19 +1788,33 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 classMethodCount++;
             }
         });
-        if (staticMethodCount > 0 && staticMethodCount < functionType.priv.overloads.length) {
+        const impl = types_1.OverloadedType.getImplementation(functionType);
+        if (impl && (0, types_1.isFunction)(impl)) {
+            totalMethods += 1;
+            if (types_1.FunctionType.isStaticMethod(impl)) {
+                staticMethodCount++;
+            }
+            if (types_1.FunctionType.isClassMethod(impl)) {
+                classMethodCount++;
+            }
+        }
+        if (staticMethodCount > 0 && staticMethodCount < totalMethods) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadStaticMethodInconsistent().format({
                 name: node.d.name.d.value,
-            }), (_c = (_b = (_a = functionType.priv.overloads[0]) === null || _a === void 0 ? void 0 : _a.shared.declaration) === null || _b === void 0 ? void 0 : _b.node.d.name) !== null && _c !== void 0 ? _c : node.d.name);
+            }), (_c = (_b = (_a = overloads[0]) === null || _a === void 0 ? void 0 : _a.shared.declaration) === null || _b === void 0 ? void 0 : _b.node.d.name) !== null && _c !== void 0 ? _c : node.d.name);
         }
-        if (classMethodCount > 0 && classMethodCount < functionType.priv.overloads.length) {
+        if (classMethodCount > 0 && classMethodCount < totalMethods) {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadClassMethodInconsistent().format({
                 name: node.d.name.d.value,
-            }), (_f = (_e = (_d = functionType.priv.overloads[0]) === null || _d === void 0 ? void 0 : _d.shared.declaration) === null || _e === void 0 ? void 0 : _e.node.d.name) !== null && _f !== void 0 ? _f : node.d.name);
+            }), (_f = (_e = (_d = overloads[0]) === null || _d === void 0 ? void 0 : _d.shared.declaration) === null || _e === void 0 ? void 0 : _e.node.d.name) !== null && _f !== void 0 ? _f : node.d.name);
         }
     }
     // Validates that overloads do not overlap with inconsistent return results.
     _validateOverloadConsistency(node, functionType, prevOverloads) {
+        // Skip the check entirely if it's disabled.
+        if (this._fileInfo.diagnosticRuleSet.reportOverlappingOverload === 'none') {
+            return;
+        }
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
             if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
@@ -1802,8 +1834,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
-                    /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    /* diag */ undefined, 
+                    /* constraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.LocMessage.overloadReturnTypeMismatch().format({
                         name: node.d.name.d.value,
@@ -1834,6 +1866,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         return undefined;
     }
     _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
+        var _a, _b, _c;
         // According to precedent, the __get__ method is special-cased and is
         // exempt from overlapping overload checks. It's not clear why this is
         // the case, but for consistency with other type checkers, we'll honor
@@ -1846,32 +1879,57 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (partialOverlap) {
             flags |= 32 /* AssignTypeFlags.PartialOverloadOverlap */;
         }
+        const functionNode = (_a = functionType.shared.declaration) === null || _a === void 0 ? void 0 : _a.node;
+        if (functionNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(functionNode);
+            functionType = (0, typeUtils_1.makeTypeVarsBound)(functionType, liveTypeVars);
+        }
+        // Use the parent node of the declaration in this case so we don't transform
+        // function-local type variables into bound type variables.
+        const prevOverloadNode = (_c = (_b = prevOverload.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent;
+        if (prevOverloadNode) {
+            const liveTypeVars = ParseTreeUtils.getTypeVarScopesForNode(prevOverloadNode);
+            prevOverload = (0, typeUtils_1.makeTypeVarsBound)(prevOverload, liveTypeVars);
+        }
         return this._evaluator.assignType(functionType, prevOverload, 
-        /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-        /* srcTypeVarContext */ undefined, flags);
-    }
-    _isLegalOverloadImplementation(overload, implementation, diag) {
-        var _a;
-        const implTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(implementation));
-        const overloadTypeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(overload));
+        /* diag */ undefined, 
+        /* constraints */ undefined, flags);
+    }
+    // Determines whether the implementation of an overload is compatible with an
+    // overload signature. To be compatible, the implementation must accept all
+    // of the same arguments as the overload and return a type that is consistent
+    // with the overload's return type.
+    _validateOverloadImplementation(overload, implementation, diag) {
+        var _a, _b, _c, _d, _e;
+        const constraints = new constraintTracker_1.ConstraintTracker();
+        let implBound = implementation;
+        let overloadBound = overload;
+        const implNode = (_b = (_a = implementation.shared.declaration) === null || _a === void 0 ? void 0 : _a.node) === null || _b === void 0 ? void 0 : _b.parent;
+        if (implNode) {
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implNode);
+            implBound = (0, typeUtils_1.makeTypeVarsBound)(implementation, liveScopeIds);
+        }
+        const overloadNode = (_c = overload.shared.declaration) === null || _c === void 0 ? void 0 : _c.node;
+        if (overloadNode) {
+            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(overloadNode);
+            overloadBound = (0, typeUtils_1.makeTypeVarsBound)(overload, liveScopeIds);
+        }
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ |
-            2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
-            512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
+        let isConsistent = this._evaluator.assignType(overloadBound, implBound, diag, constraints, 64 /* AssignTypeFlags.SkipReturnTypeCheck */ | 2 /* AssignTypeFlags.Contravariant */ | 512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
-        const overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
-        const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
+        const overloadReturnType = this._evaluator.solveAndApplyConstraints((_d = types_1.FunctionType.getEffectiveReturnType(overloadBound)) !== null && _d !== void 0 ? _d : this._evaluator.getFunctionInferredReturnType(overloadBound), constraints);
+        const implReturnType = this._evaluator.solveAndApplyConstraints((_e = types_1.FunctionType.getEffectiveReturnType(implBound)) !== null && _e !== void 0 ? _e : this._evaluator.getFunctionInferredReturnType(implBound), constraints);
         const returnDiag = new diagnostic_1.DiagnosticAddendum();
         if (!(0, types_1.isNever)(overloadReturnType) &&
-            !this._evaluator.assignType(implementationReturnType, overloadReturnType, returnDiag.createAddendum(), implTypeVarContext, overloadTypeVarContext, 8 /* AssignTypeFlags.SkipSolveTypeVars */)) {
+            !this._evaluator.assignType(implReturnType, overloadReturnType, returnDiag.createAddendum(), constraints, 0 /* AssignTypeFlags.Default */)) {
             returnDiag.addMessage(localize_1.LocAddendum.functionReturnTypeMismatch().format({
                 sourceType: this._evaluator.printType(overloadReturnType),
-                destType: this._evaluator.printType(implementationReturnType),
+                destType: this._evaluator.printType(implReturnType),
             }));
             diag === null || diag === void 0 ? void 0 : diag.addAddendum(returnDiag);
-            isLegal = false;
+            isConsistent = false;
         }
-        return isLegal;
+        return isConsistent;
     }
     _walkStatementsAndReportUnreachable(statements) {
         let reportedUnreachable = false;
@@ -2091,16 +2149,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const type = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-        const overloadedFunctions = (0, types_1.isOverloadedFunction)(type)
-            ? types_1.OverloadedFunctionType.getOverloads(type)
+        const overloads = (0, types_1.isOverloaded)(type)
+            ? types_1.OverloadedType.getOverloads(type)
             : (0, types_1.isFunction)(type) && types_1.FunctionType.isOverloaded(type)
                 ? [type]
                 : [];
         // If the implementation has no name, it was synthesized probably by a
         // decorator that used a callable with a ParamSpec that captured the
         // overloaded signature. We'll exempt it from this check.
-        if ((0, types_1.isOverloadedFunction)(type)) {
-            const overloads = types_1.OverloadedFunctionType.getOverloads(type);
+        if ((0, types_1.isOverloaded)(type)) {
+            const overloads = types_1.OverloadedType.getOverloads(type);
             if (overloads.length > 0 && overloads[0].shared.name === '') {
                 return;
             }
@@ -2110,23 +2168,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
         }
-        if (overloadedFunctions.length === 1) {
+        if (overloads.length === 1) {
             // There should never be a single overload.
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.singleOverload().format({ name }), primaryDecl.node.d.name);
         }
         // If the file is not a stub and this is the first overload,
         // verify that there is an implementation.
-        if (this._fileInfo.isStubFile || overloadedFunctions.length === 0) {
+        if (this._fileInfo.isStubFile || overloads.length === 0) {
             return;
         }
-        let implementationFunction;
-        if ((0, types_1.isOverloadedFunction)(type)) {
-            implementationFunction = types_1.OverloadedFunctionType.getImplementation(type);
+        let implementation;
+        if ((0, types_1.isOverloaded)(type)) {
+            implementation = types_1.OverloadedType.getImplementation(type);
         }
         else if ((0, types_1.isFunction)(type) && !types_1.FunctionType.isOverloaded(type)) {
-            implementationFunction = type;
+            implementation = type;
         }
-        if (!implementationFunction) {
+        if (!implementation) {
             const containingClassNode = ParseTreeUtils.getEnclosingClassOrFunction(primaryDecl.node);
             if (containingClassNode && containingClassNode.nodeType === 10 /* ParseNodeType.Class */) {
                 const classType = this._evaluator.getTypeOfClass(containingClassNode);
@@ -2135,8 +2193,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         return;
                     }
                     if (types_1.ClassType.supportsAbstractMethods(classType.classType)) {
-                        if ((0, types_1.isOverloadedFunction)(type) &&
-                            types_1.OverloadedFunctionType.getOverloads(type).every((overload) => types_1.FunctionType.isAbstractMethod(overload))) {
+                        if ((0, types_1.isOverloaded)(type) &&
+                            types_1.OverloadedType.getOverloads(type).every((overload) => types_1.FunctionType.isAbstractMethod(overload))) {
                             return;
                         }
                     }
@@ -2149,19 +2207,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }), primaryDecl.node.d.name);
             return;
         }
-        if (!(0, types_1.isOverloadedFunction)(type)) {
+        if (!(0, types_1.isOverloaded)(type)) {
+            return;
+        }
+        if (this._fileInfo.diagnosticRuleSet.reportInconsistentOverload === 'none') {
             return;
         }
         // Verify that all overload signatures are assignable to implementation signature.
-        types_1.OverloadedFunctionType.getOverloads(type).forEach((overload, index) => {
+        types_1.OverloadedType.getOverloads(type).forEach((overload, index) => {
             var _a, _b, _c, _d;
             const diag = new diagnostic_1.DiagnosticAddendum();
-            if (!this._isLegalOverloadImplementation(overload, implementationFunction, diag)) {
-                if (implementationFunction.shared.declaration) {
+            if (implementation &&
+                (0, types_1.isFunction)(implementation) &&
+                !this._validateOverloadImplementation(overload, implementation, diag)) {
+                if (implementation.shared.declaration) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadImplementationMismatch().format({
                         name,
                         index: index + 1,
-                    }) + diag.getString(), implementationFunction.shared.declaration.node.d.name);
+                    }) + diag.getString(), implementation.shared.declaration.node.d.name);
                     if (diagnostic && overload.shared.declaration) {
                         diagnostic.addRelatedInfo(localize_1.LocAddendum.overloadSignature(), (_b = (_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.uri) !== null && _b !== void 0 ? _b : primaryDecl.uri, (_d = (_c = overload.shared.declaration) === null || _c === void 0 ? void 0 : _c.range) !== null && _d !== void 0 ? _d : primaryDecl.range);
                     }
@@ -2994,6 +3057,16 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._reportDeprecatedDiagnostic(node, errorMessage, info.deprecatedMessage);
         }
     }
+    _reportDeprecatedUseForOperation(node, typeResult) {
+        const deprecationInfo = typeResult === null || typeResult === void 0 ? void 0 : typeResult.magicMethodDeprecationInfo;
+        if (!deprecationInfo) {
+            return;
+        }
+        this._reportDeprecatedDiagnostic(node, localize_1.LocMessage.deprecatedMethod().format({
+            className: deprecationInfo.className,
+            name: deprecationInfo.methodName,
+        }), deprecationInfo.deprecatedMessage);
+    }
     _reportDeprecatedUseForType(node, type, isImportFromTyping = false) {
         var _a, _b, _c;
         if (!type) {
@@ -3042,7 +3115,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = getDeprecatedMessageForFunction(overload);
                         }
-                        else if ((0, types_1.isInstantiableClass)(type) && overload.shared.name === '__init__') {
+                        else if ((0, types_1.isInstantiableClass)(type) &&
+                            ['__init__', '__new__'].includes(overload.shared.name)) {
                             deprecatedMessage = overload.shared.deprecatedMessage;
                             errorMessage = localize_1.LocMessage.deprecatedConstructor().format({
                                 name: type.shared.name,
@@ -3080,7 +3154,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            else if ((0, types_1.isOverloadedFunction)(subtype)) {
+            else if ((0, types_1.isOverloaded)(subtype)) {
                 // Determine if the node is part of a call expression. If so,
                 // we can determine which overload(s) were used to satisfy
                 // the call expression and determine whether any of them
@@ -3088,11 +3162,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 getDeprecatedMessageForOverloadedCall(this._evaluator, subtype);
                 // If there the implementation itself is deprecated, assume it
                 // is deprecated even if it's outside of a call expression.
-                const overloadImpl = types_1.OverloadedFunctionType.getImplementation(subtype);
-                if ((overloadImpl === null || overloadImpl === void 0 ? void 0 : overloadImpl.shared.deprecatedMessage) !== undefined) {
-                    if (!overloadImpl.shared.name || node.d.value === overloadImpl.shared.name) {
-                        deprecatedMessage = overloadImpl.shared.deprecatedMessage;
-                        errorMessage = getDeprecatedMessageForFunction(overloadImpl);
+                const impl = types_1.OverloadedType.getImplementation(subtype);
+                if (impl && (0, types_1.isFunction)(impl) && impl.shared.deprecatedMessage !== undefined) {
+                    if (!impl.shared.name || node.d.value === impl.shared.name) {
+                        deprecatedMessage = impl.shared.deprecatedMessage;
+                        errorMessage = getDeprecatedMessageForFunction(impl);
                     }
                 }
             }
@@ -3390,13 +3464,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typeGuardParamCount(), node.d.name);
         }
         if (isTypeIs) {
-            const typeGuardType = returnType.priv.typeArgs[0];
+            const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(functionType);
+            const typeGuardType = (0, typeUtils_1.makeTypeVarsBound)(returnType.priv.typeArgs[0], scopeIds);
             // Determine the type of the first parameter.
             const paramIndex = isMethod && !types_1.FunctionType.isStaticMethod(functionType) ? 1 : 0;
             if (paramIndex >= functionType.shared.parameters.length) {
                 return;
             }
-            const paramType = types_1.FunctionType.getEffectiveParamType(functionType, paramIndex);
+            const paramType = (0, typeUtils_1.makeTypeVarsBound)(types_1.FunctionType.getParamType(functionType, paramIndex), scopeIds);
             // Verify that the typeGuardType is a narrower type than the paramType.
             if (!this._evaluator.assignType(paramType, typeGuardType)) {
                 const returnAnnotation = node.d.returnAnnotation || ((_a = node.d.funcAnnotationComment) === null || _a === void 0 ? void 0 : _a.d.returnAnnotation);
@@ -3446,6 +3521,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (declaredReturnType) {
                 this._reportUnknownReturnResult(node, declaredReturnType);
                 this._validateReturnTypeIsNotContravariant(declaredReturnType, returnAnnotation);
+                const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
+                declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
             }
             // Wrap the declared type in a generator type if the function is a generator.
             if (types_1.FunctionType.isGenerator(functionType)) {
@@ -3466,18 +3543,19 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
                 else if (!types_1.FunctionType.isAbstractMethod(functionType)) {
+                    // If the function consists entirely of "...", assume that it's
+                    // an abstract method or a protocol method and don't require that
+                    // the return type matches. This check can also be skipped for an overload.
+                    const isEmptySuite = ParseTreeUtils.isSuiteEmpty(node.d.suite) || types_1.FunctionType.isOverloaded(functionType);
                     // Make sure that the function doesn't implicitly return None if the declared
                     // type doesn't allow it. Skip this check for abstract methods.
-                    const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    const diagAddendum = isEmptySuite ? undefined : new diagnostic_1.DiagnosticAddendum();
                     // If the declared type isn't compatible with 'None', flag an error.
                     if (!this._evaluator.assignType(declaredReturnType, this._evaluator.getNoneType(), diagAddendum)) {
-                        // If the function consists entirely of "...", assume that it's
-                        // an abstract method or a protocol method and don't require that
-                        // the return type matches. This check can also be skipped for an overload.
-                        if (!ParseTreeUtils.isSuiteEmpty(node.d.suite) && !types_1.FunctionType.isOverloaded(functionType)) {
+                        if (!isEmptySuite) {
                             this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportReturnType, localize_1.LocMessage.returnMissing().format({
                                 returnType: this._evaluator.printType(declaredReturnType),
-                            }) + diagAddendum.getString(), returnAnnotation);
+                            }) + (diagAddendum === null || diagAddendum === void 0 ? void 0 : diagAddendum.getString()), returnAnnotation);
                         }
                     }
                 }
@@ -3623,13 +3701,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     ];
                     if (newMemberTypeResult) {
                         this._evaluator.validateCallArgs(errorNode, argList, newMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
                     if (initMemberTypeResult) {
                         this._evaluator.validateCallArgs(errorNode, argList, initMemberTypeResult, 
-                        /* typeVarContext */ undefined, 
+                        /* constraints */ undefined, 
                         /* skipUnknownArgCheck */ undefined, 
                         /* inferenceContext */ undefined);
                     }
@@ -3688,7 +3766,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Verify that the parameter count matches.
-        const nonDefaultParams = paramListDetails.params.filter((paramInfo) => !paramInfo.param.defaultType);
+        const nonDefaultParams = paramListDetails.params.filter((paramInfo, index) => types_1.FunctionType.getParamDefaultType(postInitType, index) === undefined);
         // We expect to see one param for "self" plus one for each of the InitVars.
         const expectedParamCount = initOnlySymbolMap.size + 1;
         const postInitNode = postInitType.shared.declaration.node;
@@ -3707,7 +3785,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             const annotationNode = (_a = paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotation) !== null && _a !== void 0 ? _a : paramNode === null || paramNode === void 0 ? void 0 : paramNode.d.annotationComment;
             if (types_1.FunctionParam.isTypeDeclared(param) && annotationNode) {
                 const fieldType = (_b = this._evaluator.getDeclaredTypeOfSymbol(symbol)) === null || _b === void 0 ? void 0 : _b.type;
-                const paramType = types_1.FunctionType.getEffectiveParamType(postInitType, paramListDetails.params[paramIndex].index);
+                const paramType = types_1.FunctionType.getParamType(postInitType, paramListDetails.params[paramIndex].index);
                 const assignTypeDiag = new diagnostic_1.DiagnosticAddendum();
                 if (fieldType && !this._evaluator.assignType(paramType, fieldType, assignTypeDiag)) {
                     const diagnostic = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.dataClassPostInitType().format({ fieldName }) + assignTypeDiag.getString(), annotationNode);
@@ -3890,7 +3968,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         const objectObject = types_1.ClassType.cloneAsInstance(objectType);
         const dummyTypeObject = types_1.ClassType.createInstantiable('__varianceDummy', '', '', uri_1.Uri.empty(), 0, 0, undefined, undefined);
         classType.shared.typeParams.forEach((param, paramIndex) => {
-            // Skip variadics and ParamSpecs.
+            // Skip TypeVarTuples and ParamSpecs.
             if ((0, types_1.isTypeVarTuple)(param) || (0, types_1.isParamSpec)(param)) {
                 return;
             }
@@ -4007,24 +4085,24 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         let newMemberType = newMethodResult.type;
-        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloadedFunction)(newMemberType)) {
+        if (!(0, types_1.isFunction)(newMemberType) && !(0, types_1.isOverloaded)(newMemberType)) {
             return;
         }
-        if ((0, types_1.isOverloadedFunction)(newMemberType)) {
+        if ((0, types_1.isOverloaded)(newMemberType)) {
             // Find the implementation, not the overloaded signatures.
-            newMemberType = types_1.OverloadedFunctionType.getImplementation(newMemberType);
-            if (!newMemberType) {
+            newMemberType = types_1.OverloadedType.getImplementation(newMemberType);
+            if (!newMemberType || !(0, types_1.isFunction)(newMemberType)) {
                 return;
             }
         }
         let initMemberType = initMethodResult.type;
-        if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloadedFunction)(initMemberType)) {
+        if (!(0, types_1.isFunction)(initMemberType) && !(0, types_1.isOverloaded)(initMemberType)) {
             return;
         }
-        if ((0, types_1.isOverloadedFunction)(initMemberType)) {
+        if ((0, types_1.isOverloaded)(initMemberType)) {
             // Find the implementation, not the overloaded signatures.
-            initMemberType = types_1.OverloadedFunctionType.getImplementation(initMemberType);
-            if (!initMemberType) {
+            initMemberType = types_1.OverloadedType.getImplementation(initMemberType);
+            if (!initMemberType || !(0, types_1.isFunction)(initMemberType)) {
                 return;
             }
         }
@@ -4035,12 +4113,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
-        /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
+        /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
-            /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
+            /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.shared.declaration;
             const newDecl = newMemberType.shared.declaration;
@@ -4087,16 +4163,17 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const diagAddendum = new diagnostic_1.DiagnosticAddendum();
         for (const baseClass of filteredBaseClasses) {
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             for (const baseClassMroClass of baseClass.shared.mro) {
                 // There's no need to check for conflicts if this class isn't generic.
                 if ((0, types_1.isClass)(baseClassMroClass) && baseClassMroClass.shared.typeParams.length > 0) {
-                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, typeVarContext);
+                    const specializedBaseClassMroClass = (0, typeUtils_1.applySolvedTypeVars)(baseClassMroClass, solution);
                     // Find the corresponding class in the derived class's MRO list.
                     const matchingMroClass = classType.shared.mro.find((mroClass) => (0, types_1.isClass)(mroClass) && types_1.ClassType.isSameGenericClass(mroClass, specializedBaseClassMroClass));
                     if (matchingMroClass && (0, types_1.isInstantiableClass)(matchingMroClass)) {
-                        const matchingMroObject = types_1.ClassType.cloneAsInstance(matchingMroClass);
-                        const baseClassMroObject = types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass);
+                        const scopeIds = (0, typeUtils_1.getTypeVarScopeIds)(classType);
+                        const matchingMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(matchingMroClass), scopeIds);
+                        const baseClassMroObject = (0, typeUtils_1.makeTypeVarsBound)(types_1.ClassType.cloneAsInstance(specializedBaseClassMroClass), scopeIds);
                         if (!this._evaluator.assignType(matchingMroObject, baseClassMroObject)) {
                             const diag = new diagnostic_1.DiagnosticAddendum();
                             const baseClassObject = (0, typeUtils_1.convertToInstance)(baseClass);
@@ -4208,19 +4285,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         let diag;
         const overrideDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideClassAndSymbol.symbol);
         const overriddenDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overriddenClassAndSymbol.symbol);
-        if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloadedFunction)(overriddenType)) {
+        if ((0, types_1.isFunction)(overriddenType) || (0, types_1.isOverloaded)(overriddenType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             let overrideFunction;
             if ((0, types_1.isFunction)(overrideType)) {
                 overrideFunction = overrideType;
             }
-            else if ((0, types_1.isOverloadedFunction)(overrideType)) {
+            else if ((0, types_1.isOverloaded)(overrideType)) {
                 // Use the last overload.
-                overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
+                const impl = types_1.OverloadedType.getImplementation(overrideType);
                 // If the last overload isn't an implementation, skip the check for this symbol.
-                if (!overrideFunction) {
+                if (!impl || !(0, types_1.isFunction)(impl)) {
                     return;
                 }
+                overrideFunction = impl;
             }
             if (overrideFunction) {
                 if (!this._evaluator.validateOverrideMethod(overriddenType, overrideFunction, 
@@ -4281,8 +4359,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                /* constraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.Invariant */ : 0 /* AssignTypeFlags.Default */)) {
                     diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.baseClassVariableTypeIncompatible().format({
                         classType: childClassType.shared.name,
                         name: memberName,
@@ -4396,40 +4473,78 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 return;
             }
             const typeOfSymbol = this._evaluator.getEffectiveTypeOfSymbol(symbol);
-            if (!(0, types_1.isOverloadedFunction)(typeOfSymbol)) {
+            if (!(0, types_1.isOverloaded)(typeOfSymbol)) {
                 return;
             }
-            const overloads = types_1.OverloadedFunctionType.getOverloads(typeOfSymbol);
-            // If there's an implementation, it will determine whether the
-            // function is @final.
-            const implementation = types_1.OverloadedFunctionType.getImplementation(typeOfSymbol);
-            if (implementation) {
-                // If one or more of the overloads is marked @final but the
-                // implementation is not, report an error.
-                if (!types_1.FunctionType.isFinal(implementation)) {
-                    overloads.forEach((overload) => {
-                        var _a, _b;
-                        if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
-                                name: overload.shared.name,
-                            }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
-                        }
-                    });
-                }
+            const overloads = types_1.OverloadedType.getOverloads(typeOfSymbol);
+            const implementation = types_1.OverloadedType.getImplementation(typeOfSymbol);
+            this._validateOverloadFinalConsistency(overloads, implementation);
+            this._validateOverloadAbstractConsistency(overloads, implementation);
+        });
+    }
+    _validateOverloadAbstractConsistency(overloads, implementation) {
+        // If there's an implementation, it will determine whether the
+        // function is abstract.
+        if (implementation && (0, types_1.isFunction)(implementation)) {
+            const isImplAbstract = types_1.FunctionType.isAbstractMethod(implementation);
+            if (isImplAbstract) {
                 return;
             }
-            if (!types_1.FunctionType.isFinal(overloads[0])) {
-                overloads.slice(1).forEach((overload, index) => {
+            overloads.forEach((overload) => {
+                var _a;
+                const decl = overload.shared.declaration;
+                if (types_1.FunctionType.isAbstractMethod(overload) && decl) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadAbstractImplMismatch().format({
+                        name: overload.shared.name,
+                    }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
+                }
+            });
+            return;
+        }
+        if (overloads.length < 2) {
+            return;
+        }
+        // If there was no implementation, make sure all overloads are either
+        // abstract or not abstract.
+        const isFirstOverloadAbstract = types_1.FunctionType.isAbstractMethod(overloads[0]);
+        overloads.slice(1).forEach((overload, index) => {
+            var _a;
+            if (types_1.FunctionType.isAbstractMethod(overload) !== isFirstOverloadAbstract && overload.shared.declaration) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadAbstractMismatch().format({
+                    name: overload.shared.name,
+                }), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _a !== void 0 ? _a : overload.shared.declaration.node);
+            }
+        });
+    }
+    _validateOverloadFinalConsistency(overloads, implementation) {
+        // If there's an implementation, it will determine whether the
+        // function is @final.
+        if (implementation && (0, types_1.isFunction)(implementation)) {
+            // If one or more of the overloads is marked @final but the
+            // implementation is not, report an error.
+            if (!types_1.FunctionType.isFinal(implementation)) {
+                overloads.forEach((overload) => {
                     var _a, _b;
                     if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyImpl().format({
                             name: overload.shared.name,
-                            index: index + 2,
                         }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
                     }
                 });
             }
-        });
+            return;
+        }
+        if (overloads.length > 0 && !types_1.FunctionType.isFinal(overloads[0])) {
+            overloads.slice(1).forEach((overload, index) => {
+                var _a, _b;
+                if (types_1.FunctionType.isFinal(overload) && ((_a = overload.shared.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInconsistentOverload, localize_1.LocMessage.overloadFinalInconsistencyNoImpl().format({
+                        name: overload.shared.name,
+                        index: index + 2,
+                    }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.shared.declaration)) !== null && _b !== void 0 ? _b : overload.shared.declaration.node);
+                }
+            });
+        }
     }
     // For a TypedDict class that derives from another TypedDict class
     // that is closed, verify that any new keys are compatible with the
@@ -4448,9 +4563,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
             const baseTypedDictEntries = (0, typedDicts_1.getTypedDictMembersForClass)(this._evaluator, baseClass, 
             /* allowNarrowed */ false);
-            const typeVarContext = (0, typeUtils_1.buildTypeVarContextFromSpecializedClass)(baseClass);
+            const solution = (0, typeUtils_1.buildSolutionFromSpecializedClass)(baseClass);
             const baseExtraItemsType = baseTypedDictEntries.extraItems
-                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, typeVarContext)
+                ? (0, typeUtils_1.applySolvedTypeVars)(baseTypedDictEntries.extraItems.valueType, solution)
                 : types_1.UnknownType.create();
             for (const [name, entry] of typedDictEntries.knownItems) {
                 const baseEntry = baseTypedDictEntries.knownItems.get(name);
@@ -4462,9 +4577,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     else if (!this._evaluator.assignType(baseExtraItemsType, entry.valueType, 
                     /* diag */ undefined, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
-                        ? 1 /* AssignTypeFlags.EnforceInvariance */
+                    /* constraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                        ? 1 /* AssignTypeFlags.Invariant */
                         : 0 /* AssignTypeFlags.Default */)) {
                         diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
                             name,
@@ -4481,9 +4595,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (typedDictEntries.extraItems && baseTypedDictEntries.extraItems) {
                 if (!this._evaluator.assignType(baseExtraItemsType, typedDictEntries.extraItems.valueType, 
                 /* diag */ undefined, 
-                /* destTypeVarContext */ undefined, 
-                /* srcTypeVarContext */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
-                    ? 1 /* AssignTypeFlags.EnforceInvariance */
+                /* constraints */ undefined, !baseTypedDictEntries.extraItems.isReadOnly
+                    ? 1 /* AssignTypeFlags.Invariant */
                     : 0 /* AssignTypeFlags.Default */)) {
                     diag.addMessage(localize_1.LocAddendum.typedDictClosedExtraTypeMismatch().format({
                         name: '__extra_items__',
@@ -4571,8 +4684,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunction)(overrideType)) {
             overrideFunction = overrideType;
         }
-        else if ((0, types_1.isOverloadedFunction)(overrideType)) {
-            overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
+        else if ((0, types_1.isOverloaded)(overrideType)) {
+            const impl = types_1.OverloadedType.getImplementation(overrideType);
+            if (impl && (0, types_1.isFunction)(impl)) {
+                overrideFunction = impl;
+            }
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
             if (overrideType.priv.fgetInfo) {
@@ -4614,8 +4730,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if ((0, types_1.isFunction)(overrideType)) {
             overrideFunction = overrideType;
         }
-        else if ((0, types_1.isOverloadedFunction)(overrideType)) {
-            overrideFunction = types_1.OverloadedFunctionType.getImplementation(overrideType);
+        else if ((0, types_1.isOverloaded)(overrideType)) {
+            const impl = types_1.OverloadedType.getImplementation(overrideType);
+            if (impl && (0, types_1.isFunction)(impl)) {
+                overrideFunction = impl;
+            }
         }
         else if ((0, types_1.isClassInstance)(overrideType) && types_1.ClassType.isPropertyClass(overrideType)) {
             if (overrideType.priv.fgetInfo) {
@@ -4654,9 +4773,13 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         const baseClass = baseClassAndSymbol.classType;
         const childClassSelf = types_1.ClassType.cloneAsInstance((0, typeUtils_1.selfSpecializeClass)(childClassType));
-        const baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
+        let baseType = (0, typeUtils_1.partiallySpecializeType)(this._evaluator.getEffectiveTypeOfSymbol(baseClassAndSymbol.symbol), baseClass, this._evaluator.getTypeClassType(), childClassSelf);
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, this._evaluator.getTypeClassType(), childClassSelf);
-        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
+        if (childClassType.shared.typeVarScopeId) {
+            baseType = (0, typeUtils_1.makeTypeVarsBound)(baseType, [childClassType.shared.typeVarScopeId]);
+            overrideType = (0, typeUtils_1.makeTypeVarsBound)(overrideType, [childClassType.shared.typeVarScopeId]);
+        }
+        if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloaded)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
             // Determine whether this is an attempt to override a method marked @final.
             let reportFinalMethodOverride = false;
@@ -4665,9 +4788,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
                     reportFinalMethodOverride = true;
                 }
-                else if ((0, types_1.isOverloadedFunction)(baseType) &&
-                    baseType.priv.overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
-                    reportFinalMethodOverride = true;
+                else if ((0, types_1.isOverloaded)(baseType)) {
+                    const overloads = types_1.OverloadedType.getOverloads(baseType);
+                    const impl = types_1.OverloadedType.getImplementation(baseType);
+                    if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                        reportFinalMethodOverride = true;
+                    }
+                    if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
+                        reportFinalMethodOverride = true;
+                    }
                 }
             }
             if (reportFinalMethodOverride) {
@@ -4683,7 +4812,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
-            if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
+            if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloaded)(overrideType)) {
                 // Don't enforce parameter names for dundered methods. Many of them
                 // are misnamed in typeshed stubs, so this would result in many
                 // false positives.
@@ -4794,8 +4923,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
-                    /* destTypeVarContext */ undefined, 
-                    /* srcTypeVarContext */ undefined, isInvariant ? 1 /* AssignTypeFlags.EnforceInvariance */ : 0 /* AssignTypeFlags.Default */)) {
+                    /* constraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.Invariant */ : 0 /* AssignTypeFlags.Default */)) {
                         if (isInvariant) {
                             diagAddendum = new diagnostic_1.DiagnosticAddendum();
                             diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
@@ -4949,104 +5077,93 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     // Performs checks on a function that is located within a class
     // and has been determined not to be a property accessor.
     _validateMethod(node, functionType, classNode) {
-        var _a, _b;
         const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
-        const classType = classTypeInfo === null || classTypeInfo === void 0 ? void 0 : classTypeInfo.classType;
-        if (node.d.name && classType) {
-            const superCheckMethods = ['__init__', '__init_subclass__', '__enter__', '__exit__'];
-            if (superCheckMethods.some((name) => name === node.d.name.d.value)) {
-                if (!types_1.FunctionType.isAbstractMethod(functionType) &&
-                    !types_1.FunctionType.isOverloaded(functionType) &&
-                    !this._fileInfo.isStubFile) {
-                    this._validateSuperCallForMethod(node, functionType, classType);
-                }
-            }
+        if (!classTypeInfo) {
+            return;
         }
-        if (((_a = node.d.name) === null || _a === void 0 ? void 0 : _a.d.value) === '__new__') {
-            // __new__ overrides should have a "cls" parameter.
-            if (node.d.params.length === 0 ||
-                !node.d.params[0].d.name ||
-                !['cls', '_cls', '__cls', '__mcls', 'mcls', 'mcs', 'metacls'].some((name) => node.d.params[0].d.name.d.value === name)) {
-                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
-            }
-            if (classType) {
-                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
+        const classType = classTypeInfo.classType;
+        const methodName = node.d.name.d.value;
+        const isMetaclass = (0, typeUtils_1.isInstantiableMetaclass)(classType);
+        const superCheckMethods = ['__init__', '__init_subclass__', '__enter__', '__exit__'];
+        if (superCheckMethods.includes(methodName)) {
+            if (!types_1.FunctionType.isAbstractMethod(functionType) &&
+                !types_1.FunctionType.isOverloaded(functionType) &&
+                !this._fileInfo.isStubFile) {
+                this._validateSuperCallForMethod(node, functionType, classType);
             }
         }
-        else if (((_b = node.d.name) === null || _b === void 0 ? void 0 : _b.d.value) === '_generate_next_value_') {
+        const selfNames = ['self', '_self', '__self'];
+        const clsNames = ['cls', '_cls', '__cls'];
+        const clsNamesMetaclass = ['__mcls', 'mcls', 'mcs', 'metacls'];
+        if (methodName === '_generate_next_value_') {
             // Skip this check for _generate_next_value_.
+            return;
         }
-        else if (types_1.FunctionType.isStaticMethod(functionType)) {
-            // Static methods should not have "self" or "cls" parameters.
-            if (node.d.params.length > 0 && node.d.params[0].d.name) {
+        if (methodName === '__new__') {
+            // __new__ overrides should have a "cls" parameter.
+            if (node.d.params.length === 0 || !node.d.params[0].d.name) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.d.name);
+            }
+            else {
                 const paramName = node.d.params[0].d.name.d.value;
-                if (paramName === 'self' || paramName === 'cls') {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.staticClsSelfParam(), node.d.params[0].d.name);
+                if (!clsNames.includes(paramName) && !(isMetaclass && clsNamesMetaclass.includes(paramName))) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.newClsParam(), node.d.params[0]);
                 }
             }
+            this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
+            return;
+        }
+        if (types_1.FunctionType.isStaticMethod(functionType)) {
+            if (node.d.params.length === 0 || !node.d.params[0].d.name) {
+                return;
+            }
+            // Static methods should not have "self" or "cls" parameters.
+            const paramName = node.d.params[0].d.name.d.value;
+            if (paramName === 'self' || paramName === 'cls') {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.staticClsSelfParam(), node.d.params[0].d.name);
+            }
+            return;
         }
-        else if (types_1.FunctionType.isClassMethod(functionType)) {
+        if (types_1.FunctionType.isClassMethod(functionType)) {
             let paramName = '';
             if (node.d.params.length > 0 && node.d.params[0].d.name) {
                 paramName = node.d.params[0].d.name.d.value;
             }
-            // Class methods should have a "cls" parameter. We'll exempt parameter
-            // names that start with an underscore since those are used in a few
-            // cases in the stdlib pyi files.
-            if (paramName !== 'cls') {
-                if (!this._fileInfo.isStubFile || (!paramName.startsWith('_') && paramName !== 'metacls')) {
-                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.classMethodClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
-                }
-            }
-            if (classType) {
-                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
+            // Class methods should have a "cls" parameter.
+            if (!clsNames.includes(paramName) && !(isMetaclass && clsNamesMetaclass.includes(paramName))) {
+                this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.classMethodClsParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
             }
+            this._validateClsSelfParamType(node, functionType, classType, /* isCls */ true);
+            return;
         }
-        else {
-            const decoratorIsPresent = node.d.decorators.length > 0;
-            const isOverloaded = types_1.FunctionType.isOverloaded(functionType);
-            // The presence of a decorator can change the behavior, so we need
-            // to back off from this check if a decorator is present. An overload
-            // is a decorator, but we'll ignore that here.
-            if (isOverloaded || !decoratorIsPresent) {
-                let paramName = '';
-                let firstParamIsSimple = true;
-                if (node.d.params.length > 0) {
-                    if (node.d.params[0].d.name) {
-                        paramName = node.d.params[0].d.name.d.value;
-                    }
-                    if (node.d.params[0].d.category !== 0 /* ParamCategory.Simple */) {
-                        firstParamIsSimple = false;
-                    }
+        const decoratorIsPresent = node.d.decorators.length > 0;
+        const isOverloaded = types_1.FunctionType.isOverloaded(functionType);
+        // The presence of a decorator can change the behavior, so we need
+        // to back off from this check if a decorator is present. An overload
+        // is a decorator, but we'll ignore that here.
+        if (isOverloaded || !decoratorIsPresent) {
+            let paramName = '';
+            let firstParamIsSimple = true;
+            if (node.d.params.length > 0) {
+                if (node.d.params[0].d.name) {
+                    paramName = node.d.params[0].d.name.d.value;
                 }
-                // Instance methods should have a "self" parameter.
-                if (firstParamIsSimple && paramName !== 'self') {
-                    // Special-case metaclasses, which can use "cls" or several variants.
-                    let isLegalMetaclassName = false;
-                    if (['cls', 'mcls', 'mcs'].some((name) => name === paramName)) {
-                        const classTypeInfo = this._evaluator.getTypeOfClass(classNode);
-                        const typeType = this._evaluator.getBuiltInType(classNode, 'type');
-                        if (typeType &&
-                            (0, types_1.isInstantiableClass)(typeType) &&
-                            classTypeInfo &&
-                            (0, types_1.isInstantiableClass)(classTypeInfo.classType)) {
-                            if ((0, typeUtils_1.derivesFromClassRecursive)(classTypeInfo.classType, typeType, /* ignoreUnknown */ true)) {
-                                isLegalMetaclassName = true;
-                            }
-                        }
-                    }
-                    // Some typeshed stubs use a name that starts with an underscore to designate
-                    // a parameter that cannot be positional.
-                    const isPrivateName = SymbolNameUtils.isPrivateOrProtectedName(paramName);
-                    if (!isLegalMetaclassName && !isPrivateName) {
-                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.instanceMethodSelfParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
-                    }
+                if (node.d.params[0].d.category !== 0 /* ParamCategory.Simple */) {
+                    firstParamIsSimple = false;
                 }
             }
-            if (classType) {
-                this._validateClsSelfParamType(node, functionType, classType, /* isCls */ false);
+            // Instance methods should have a "self" parameter.
+            if (firstParamIsSimple && !selfNames.includes(paramName)) {
+                const isLegalMetaclassName = isMetaclass && clsNames.includes(paramName);
+                // Some typeshed stubs use a name that starts with an underscore to designate
+                // a parameter that cannot be positional.
+                const isPrivateName = SymbolNameUtils.isPrivateOrProtectedName(paramName);
+                if (!isLegalMetaclassName && !isPrivateName) {
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportSelfClsParameterName, localize_1.LocMessage.instanceMethodSelfParam(), node.d.params.length > 0 ? node.d.params[0] : node.d.name);
+                }
             }
         }
+        this._validateClsSelfParamType(node, functionType, classType, /* isCls */ false);
     }
     // Determines whether the method properly calls through to the same method in all
     // parent classes that expose a same-named method.
@@ -5111,6 +5228,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // If there is no type annotation, there's nothing to check because
         // the type will be inferred.d.typeAnnotation
         const paramInfo = functionType.shared.parameters[0];
+        const paramType = types_1.FunctionType.getParamType(functionType, 0);
         const paramAnnotation = (_a = node.d.params[0].d.annotation) !== null && _a !== void 0 ? _a : node.d.params[0].d.annotationComment;
         if (!paramAnnotation || !paramInfo.name) {
             return;
@@ -5119,11 +5237,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         // use of class-scoped TypeVars, which are not allowed in this context
         // according to the typing spec.
         if (functionType.shared.name === '__init__' && functionType.shared.methodClass) {
-            const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramInfo.type);
+            const typeVars = (0, typeUtils_1.getTypeVarArgsRecursive)(paramType);
             if (typeVars.some((typeVar) => {
                 var _a;
                 return typeVar.priv.scopeId === ((_a = functionType.shared.methodClass) === null || _a === void 0 ? void 0 : _a.shared.typeVarScopeId) &&
-                    !typeVar.shared.isSynthesizedSelf;
+                    !types_1.TypeVarType.isSelf(typeVar);
             })) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportInvalidTypeVarUse, localize_1.LocMessage.initMethodSelfParamTypeVar(), paramAnnotation);
             }
@@ -5133,20 +5251,20 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.ClassType.isProtocolClass(classType)) {
             return;
         }
-        const paramType = this._evaluator.makeTopLevelTypeVarsConcrete(paramInfo.type);
+        const concreteParamType = this._evaluator.makeTopLevelTypeVarsConcrete(paramType);
         const expectedType = isCls ? classType : (0, typeUtils_1.convertToInstance)(classType);
         // If the declared type is a protocol class or instance, skip
         // the check. This has legitimate uses for mix-in classes.
-        if ((0, types_1.isInstantiableClass)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isInstantiableClass)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
-        if ((0, types_1.isClassInstance)(paramType) && types_1.ClassType.isProtocolClass(paramType)) {
+        if ((0, types_1.isClassInstance)(concreteParamType) && types_1.ClassType.isProtocolClass(concreteParamType)) {
             return;
         }
         // If the method starts with a `*args: P.args`, skip the check.
         if (paramInfo.category === 1 /* ParamCategory.ArgsList */ &&
-            (0, types_1.isParamSpec)(paramInfo.type) &&
-            paramInfo.type.priv.paramSpecAccess === 'args') {
+            (0, types_1.isParamSpec)(paramType) &&
+            paramType.priv.paramSpecAccess === 'args') {
             return;
         }
         // Don't enforce this for an overloaded method because the "self" param
@@ -5163,8 +5281,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             types_1.ClassType.isBuiltIn(classType, 'str')) {
             return;
         }
-        const typeVarContext = new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType));
-        if (!this._evaluator.assignType(paramType, expectedType, /* diag */ undefined, typeVarContext)) {
+        if (!this._evaluator.assignType(paramType, expectedType)) {
             // We exempt Never from this check because it has a legitimate use in this case.
             if (!(0, types_1.isNever)(paramType)) {
                 this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.clsSelfParamTypeMismatch().format({
@@ -5191,7 +5308,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         const liveScopes = ParseTreeUtils.getTypeVarScopesForNode(node);
-        declaredReturnType = (0, typeUtils_1.updateTypeWithInternalTypeVars)(declaredReturnType, liveScopes);
+        declaredReturnType = (0, typeUtils_1.makeTypeVarsBound)(declaredReturnType, liveScopes);
         let generatorType;
         if (!enclosingFunctionNode.d.isAsync &&
             (0, types_1.isClassInstance)(declaredReturnType) &&