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

package/dist/analyzer/checker.js

@@ -412,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
@@ -1218,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')) {
@@ -1467,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;
         }
@@ -1737,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 &&
@@ -1770,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++;
             }
@@ -1780,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)) {
@@ -1813,8 +1835,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
                     /* diag */ undefined, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ undefined, 0 /* AssignTypeFlags.Default */)) {
+                    /* 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,
@@ -1872,43 +1893,43 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return this._evaluator.assignType(functionType, prevOverload, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, flags);
+        /* 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;
-        const implConstraints = new constraintTracker_1.ConstraintTracker();
-        const overloadConstraints = new constraintTracker_1.ConstraintTracker();
+        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, overloadConstraints, implConstraints, 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.
-        let overloadReturnType = (_a = overload.shared.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
-        let implementationReturnType = this._evaluator.solveAndApplyConstraints(implementation.shared.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implConstraints);
-        if ((_c = (_b = implementation.shared.declaration) === null || _b === void 0 ? void 0 : _b.node) === null || _c === void 0 ? void 0 : _c.parent) {
-            // Use the parent node of the implementation to determine which type variables
-            // are live. This will include any class-scoped type variables if this is an
-            // overloaded method.
-            const liveScopeIds = ParseTreeUtils.getTypeVarScopesForNode(implementation.shared.declaration.node.parent);
-            implementationReturnType = (0, typeUtils_1.makeTypeVarsBound)(implementationReturnType, liveScopeIds);
-            overloadReturnType = (0, typeUtils_1.makeTypeVarsBound)(overloadReturnType, liveScopeIds);
-        }
+        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(), implConstraints, overloadConstraints, 0 /* AssignTypeFlags.Default */)) {
+            !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;
@@ -2128,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;
             }
@@ -2147,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);
@@ -2172,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;
                         }
                     }
@@ -2186,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._validateOverloadImplementation(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);
                     }
@@ -3128,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
@@ -3136,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);
                     }
                 }
             }
@@ -3517,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);
                         }
                     }
                 }
@@ -4058,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;
             }
         }
@@ -4086,12 +4113,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
-        /* destConstraints */ undefined, 
-        /* srcConstraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
+        /* constraints */ undefined, 64 /* AssignTypeFlags.SkipReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
-            /* destConstraints */ undefined, 
-            /* srcConstraints */ 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;
@@ -4260,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, 
@@ -4333,8 +4359,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }
                 if (!this._evaluator.assignType(overriddenType, childOverrideType !== null && childOverrideType !== void 0 ? childOverrideType : overrideType, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ 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,
@@ -4448,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
@@ -4514,9 +4577,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     else if (!this._evaluator.assignType(baseExtraItemsType, entry.valueType, 
                     /* diag */ undefined, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ 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,
@@ -4533,9 +4595,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (typedDictEntries.extraItems && baseTypedDictEntries.extraItems) {
                 if (!this._evaluator.assignType(baseExtraItemsType, typedDictEntries.extraItems.valueType, 
                 /* diag */ undefined, 
-                /* destConstraints */ undefined, 
-                /* srcConstraints */ 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__',
@@ -4623,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) {
@@ -4666,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) {
@@ -4706,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;
@@ -4717,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) {
@@ -4735,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.
@@ -4846,8 +4923,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
-                    /* destConstraints */ undefined, 
-                    /* srcConstraints */ 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());
@@ -5001,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.