@zzzen/pyright-internal 1.2.0-dev.20231224 → 1.2.0-dev.20240107

package/dist/analyzer/checker.js

@@ -60,6 +60,7 @@ const parameterUtils_1 = require("./parameterUtils");
 const ParseTreeUtils = __importStar(require("./parseTreeUtils"));
 const parseTreeWalker_1 = require("./parseTreeWalker");
 const patternMatching_1 = require("./patternMatching");
+const protocols_1 = require("./protocols");
 const regions_1 = require("./regions");
 const scopeUtils_1 = require("./scopeUtils");
 const sourceFile_1 = require("./sourceFile");
@@ -162,8 +163,8 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             !types_1.ClassType.isBuiltIn(baseClassType, 'Generic')) {
                             if (!types_1.ClassType.isProtocolClass(baseClassType)) {
                                 this._evaluator.addError(localize_1.Localizer.Diagnostic.protocolBaseClass().format({
-                                    classType: this._evaluator.printType(classTypeResult.classType),
-                                    baseType: this._evaluator.printType(baseClassType),
+                                    classType: classTypeResult.classType.details.name,
+                                    baseType: baseClassType.details.name,
                                 }), arg.valueExpression);
                             }
                         }
@@ -179,6 +180,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 this._validateSlotsClassVarConflict(classTypeResult.classType);
             }
             this._validateBaseClassOverrides(classTypeResult.classType);
+            this._validateOverloadDecoratorConsistency(classTypeResult.classType);
             this._validateMultipleInheritanceBaseClasses(classTypeResult.classType, node.name);
             this._validateMultipleInheritanceCompatibility(classTypeResult.classType, node.name);
             this._validateConstructorConsistency(classTypeResult.classType, node.name);
@@ -386,6 +388,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             this._validateFunctionTypeVarUsage(node, functionTypeResult);
             this._validateGeneratorReturnType(node, functionTypeResult.functionType);
             this._reportDeprecatedClassProperty(node, functionTypeResult);
+            // If this is not a method, @final is disallowed.
+            if (!containingClassNode && types_1.FunctionType.isFinal(functionTypeResult.functionType)) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.finalNonMethod().format({ name: node.name.value }), node.name);
+            }
         }
         // If we're at the module level within a stub file, report a diagnostic
         // if there is a '__getattr__' function defined when in strict mode.
@@ -564,7 +570,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     let diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     let returnTypeMatches = false;
                     if (this._evaluator.assignType(declaredReturnType, returnTypeResult.type, diagAddendum, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                    /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                         returnTypeMatches = true;
                     }
                     else {
@@ -587,7 +593,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 const adjustedReturnType = (0, typeUtils_1.applySolvedTypeVars)(declaredReturnType, typeVarContext);
                                 if (this._evaluator.assignType(adjustedReturnType, returnTypeResult.type, diagAddendum, 
                                 /* destTypeVarContext */ undefined, 
-                                /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
+                                /* srcTypeVarContext */ undefined, 128 /* AssignTypeFlags.AllowBoolTypeGuard */)) {
                                     returnTypeMatches = true;
                                 }
                             }
@@ -1731,7 +1737,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
     _validateOverloadConsistency(node, functionType, prevOverloads) {
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(functionType, prevOverload)) {
+            if (this._isOverlappingOverload(functionType, prevOverload, /* partialOverlap */ false)) {
                 this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overlappingOverload().format({
                     name: node.name.value,
                     obscured: prevOverloads.length + 1,
@@ -1742,14 +1748,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         for (let i = 0; i < prevOverloads.length; i++) {
             const prevOverload = prevOverloads[i];
-            if (this._isOverlappingOverload(prevOverload, functionType)) {
+            if (this._isOverlappingOverload(prevOverload, functionType, /* partialOverlap */ true)) {
                 const prevReturnType = types_1.FunctionType.getSpecializedReturnType(prevOverload);
                 const returnType = types_1.FunctionType.getSpecializedReturnType(functionType);
                 if (prevReturnType &&
                     returnType &&
                     !this._evaluator.assignType(returnType, prevReturnType, 
                     /* diag */ undefined, new typeVarContext_1.TypeVarContext(), 
-                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 512 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
+                    /* srcTypeVarContext */ undefined, 8 /* AssignTypeFlags.SkipSolveTypeVars */ | 1024 /* AssignTypeFlags.IgnoreTypeVarScope */)) {
                     const altNode = this._findNodeForOverload(node, prevOverload);
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportOverlappingOverload, diagnosticRules_1.DiagnosticRule.reportOverlappingOverload, localize_1.Localizer.Diagnostic.overloadReturnTypeMismatch().format({
                         name: node.name.value,
@@ -1779,7 +1785,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         }
         return undefined;
     }
-    _isOverlappingOverload(functionType, prevOverload) {
+    _isOverlappingOverload(functionType, prevOverload, partialOverlap) {
         // 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
@@ -1788,18 +1794,22 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (types_1.FunctionType.isInstanceMethod(functionType) && functionType.details.name === '__get__') {
             return false;
         }
+        let flags = 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */;
+        if (partialOverlap) {
+            flags |= 32 /* AssignTypeFlags.PartialOverloadOverlapCheck */;
+        }
         return this._evaluator.assignType(functionType, prevOverload, 
         /* diag */ undefined, new typeVarContext_1.TypeVarContext((0, typeUtils_1.getTypeVarScopeId)(functionType)), 
-        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ | 16 /* AssignTypeFlags.OverloadOverlapCheck */);
+        /* 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));
         // First check the parameters to see if they are assignable.
-        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
+        let isLegal = this._evaluator.assignType(overload, implementation, diag, overloadTypeVarContext, implTypeVarContext, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */ |
             2 /* AssignTypeFlags.ReverseTypeVarMatching */ |
-            256 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
+            512 /* AssignTypeFlags.SkipSelfClsTypeCheck */);
         // Now check the return types.
         const overloadReturnType = (_a = overload.details.declaredReturnType) !== null && _a !== void 0 ? _a : this._evaluator.getFunctionInferredReturnType(overload);
         const implementationReturnType = (0, typeUtils_1.applySolvedTypeVars)(implementation.details.declaredReturnType || this._evaluator.getFunctionInferredReturnType(implementation), implTypeVarContext);
@@ -2538,6 +2548,23 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     type: this._evaluator.printType(arg1Type),
                 }) + diag.getString(), node.arguments[1]);
         }
+        // If this call is an issubclass, check for the use of a "data protocol",
+        // which PEP 544 says cannot be used in issubclass.
+        if (!isInstanceCheck) {
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            (0, typeUtils_1.doForEachSubtype)(arg1Type, (arg1Subtype) => {
+                if ((0, types_1.isInstantiableClass)(arg1Subtype) &&
+                    types_1.ClassType.isProtocolClass(arg1Subtype) &&
+                    !(0, protocols_1.isMethodOnlyProtocol)(arg1Subtype)) {
+                    diag.addMessage(localize_1.Localizer.DiagnosticAddendum.dataProtocolUnsupported().format({
+                        name: arg1Subtype.details.name,
+                    }));
+                }
+            });
+            if (!diag.isEmpty()) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.dataProtocolInSubclassCheck(), node.arguments[1]);
+            }
+        }
         // If this call is within an assert statement, we won't check whether
         // it's unnecessary.
         let curNode = node;
@@ -2573,6 +2600,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             arg1IncludesSubclasses = true;
                         }
                     }
+                    if (arg0Type) {
+                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(arg1Subtype), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                    }
                 }
                 else {
                     // The isinstance and issubclass call supports a variation where the second
@@ -2585,6 +2615,9 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                     if (typeArg.type.includeSubclasses) {
                                         arg1IncludesSubclasses = true;
                                     }
+                                    if (arg0Type) {
+                                        this._validateUnsafeProtocolOverlap(node.arguments[0].valueExpression, (0, typeUtils_1.convertToInstance)(typeArg.type), isInstanceCheck ? arg0Type : (0, typeUtils_1.convertToInstance)(arg0Type));
+                                    }
                                 }
                                 else {
                                     isValidType = false;
@@ -2698,6 +2731,29 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 }), node);
         }
     }
+    _validateUnsafeProtocolOverlap(errorNode, protocol, testType) {
+        // If this is a protocol class, check for an "unsafe overlap"
+        // with the arg0 type.
+        if (types_1.ClassType.isProtocolClass(protocol)) {
+            let isUnsafeOverlap = false;
+            const diag = new diagnostic_1.DiagnosticAddendum();
+            (0, typeUtils_1.doForEachSubtype)(testType, (testSubtype) => {
+                if ((0, types_1.isClassInstance)(testSubtype)) {
+                    if ((0, protocols_1.isProtocolUnsafeOverlap)(this._evaluator, protocol, testSubtype)) {
+                        isUnsafeOverlap = true;
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolUnsafeOverlap().format({
+                            name: testSubtype.details.name,
+                        }));
+                    }
+                }
+            });
+            if (isUnsafeOverlap) {
+                this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.protocolUnsafeOverlap().format({
+                    name: protocol.details.name,
+                }) + diag.getString(), errorNode);
+            }
+        }
+    }
     // Determines whether the specified type is allowed as the second argument
     // to an isinstance or issubclass check.
     _isTypeSupportedTypeForIsInstance(type, isInstanceCheck, diag) {
@@ -2715,6 +2771,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.noneNotAllowed());
                         isSupported = false;
                     }
+                    else if (types_1.ClassType.isTypedDictClass(subtype)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.typedDictClassNotAllowed());
+                        isSupported = false;
+                    }
                     else if (subtype.isTypeArgumentExplicit && !subtype.includeSubclasses) {
                         // If it's a class, make sure that it has not been given explicit
                         // type arguments. This will result in a TypeError exception.
@@ -2730,6 +2790,10 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         diag.addMessage(localize_1.Localizer.DiagnosticAddendum.protocolRequiresRuntimeCheckable());
                         isSupported = false;
                     }
+                    else if (types_1.ClassType.isNewTypeClass(subtype)) {
+                        diag.addMessage(localize_1.Localizer.DiagnosticAddendum.newTypeClassNotAllowed());
+                        isSupported = false;
+                    }
                     break;
                 case 4 /* TypeCategory.Function */:
                     if (!types_1.TypeBase.isInstantiable(subtype) || subtype.isCallableWithTypeArgs) {
@@ -3782,11 +3846,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         if (!this._evaluator.assignType(newMemberType, initMemberType, 
         /* diag */ undefined, 
         /* destTypeVarContext */ undefined, 
-        /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
+        /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */) ||
             !this._evaluator.assignType(initMemberType, newMemberType, 
             /* diag */ undefined, 
             /* destTypeVarContext */ undefined, 
-            /* srcTypeVarContext */ undefined, 32 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
+            /* srcTypeVarContext */ undefined, 64 /* AssignTypeFlags.SkipFunctionReturnTypeCheck */)) {
             const displayOnInit = types_1.ClassType.isSameGenericClass(initMethodResult.classType, classType);
             const initDecl = initMemberType.details.declaration;
             const newDecl = newMemberType.details.declaration;
@@ -4078,6 +4142,51 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }), overrideDecl.uri, overrideDecl.range);
         }
     }
+    // Validates that any overloaded methods are consistent in how they
+    // are decorated. For example, if the first overload is not marked @final
+    // but subsequent ones are, an error should be reported.
+    _validateOverloadDecoratorConsistency(classType) {
+        classType.details.fields.forEach((symbol, name) => {
+            const primaryDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(symbol);
+            if (!primaryDecl || primaryDecl.type !== 5 /* DeclarationType.Function */) {
+                return;
+            }
+            const typeOfSymbol = this._evaluator.getEffectiveTypeOfSymbol(symbol);
+            if (!(0, types_1.isOverloadedFunction)(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.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                            this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyImpl().format({
+                                name: overload.details.name,
+                            }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                        }
+                    });
+                }
+                return;
+            }
+            if (!types_1.FunctionType.isFinal(overloads[0])) {
+                overloads.slice(1).forEach((overload, index) => {
+                    var _a, _b;
+                    if (types_1.FunctionType.isFinal(overload) && ((_a = overload.details.declaration) === null || _a === void 0 ? void 0 : _a.node)) {
+                        this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overloadFinalInconsistencyNoImpl().format({
+                            name: overload.details.name,
+                            index: index + 2,
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(overload.details.declaration)) !== null && _b !== void 0 ? _b : overload.details.declaration.node);
+                    }
+                });
+            }
+        });
+    }
     // Validates that any overridden methods or variables contain the same
     // types as the original method. Also marks the class as abstract if one
     // or more abstract methods are not overridden.
@@ -4150,7 +4259,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             return;
         }
         // Constructors are exempt.
-        if (overrideFunction.details.name === '__init__' || overrideFunction.details.name === '__new__') {
+        if (this._isMethodExemptFromLsp(overrideFunction.details.name)) {
             return;
         }
         // If the declaration for the override function is not the same as the
@@ -4164,6 +4273,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             className: this._evaluator.printType((0, typeUtils_1.convertToInstance)(baseMember.classType)),
         }), funcNode.name);
     }
+    // Determines whether the name is exempt from Liskov Substitution Principle rules.
+    _isMethodExemptFromLsp(name) {
+        const exemptMethods = ['__init__', '__new__', '__init_subclass__', '__post_init__'];
+        return exemptMethods.some((n) => n === name);
+    }
     // Determines whether the type is a function or overloaded function with an @override
     // decorator. In this case, an error is reported because no base class has declared
     // a method of the same name.
@@ -4192,7 +4306,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.overriddenMethodNotFound().format({ name: funcNode.name.value }), funcNode.name);
     }
     _validateBaseClassOverride(baseClassAndSymbol, overrideSymbol, overrideType, childClassType, memberName) {
-        var _a, _b;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         if (!(0, types_1.isInstantiableClass)(baseClassAndSymbol.classType)) {
             return;
         }
@@ -4216,8 +4330,32 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         overrideType = (0, typeUtils_1.partiallySpecializeType)(overrideType, childClassType, childClassSelf);
         if ((0, types_1.isFunction)(baseType) || (0, types_1.isOverloadedFunction)(baseType)) {
             const diagAddendum = new diagnostic_1.DiagnosticAddendum();
+            // Determine whether this is an attempt to override a method marked @final.
+            let reportFinalMethodOverride = false;
+            // Private names (starting with double underscore) are exempt from this check.
+            if (!SymbolNameUtils.isPrivateName(memberName)) {
+                if ((0, types_1.isFunction)(baseType) && types_1.FunctionType.isFinal(baseType)) {
+                    reportFinalMethodOverride = true;
+                }
+                else if ((0, types_1.isOverloadedFunction)(baseType) &&
+                    baseType.overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                    reportFinalMethodOverride = true;
+                }
+            }
+            if (reportFinalMethodOverride) {
+                const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
+                if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                    const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
+                        name: memberName,
+                        className: baseClass.details.name,
+                    }), decl.node.name);
+                    const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
+                    if (diag && origDecl) {
+                        diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
+                    }
+                }
+            }
             if ((0, types_1.isFunction)(overrideType) || (0, types_1.isOverloadedFunction)(overrideType)) {
-                const exemptMethods = ['__init__', '__new__', '__init_subclass__'];
                 // Don't enforce parameter names for dundered methods. Many of them
                 // are misnamed in typeshed stubs, so this would result in many
                 // false positives.
@@ -4226,7 +4364,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                 // Also, skip this check if the class is a TypedDict. The methods for a TypedDict
                 // are synthesized, and they can result in many overloads. We assume they
                 // are correct and will not produce any errors.
-                if (!exemptMethods.some((exempt) => exempt === memberName) &&
+                if (!this._isMethodExemptFromLsp(memberName) &&
                     !SymbolNameUtils.isPrivateName(memberName) &&
                     !types_1.ClassType.isTypedDictClass(childClassType)) {
                     if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
@@ -4237,7 +4375,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.incompatibleMethodOverride().format({
                                 name: memberName,
                                 className: baseClass.details.name,
-                            }) + diagAddendum.getString(), decl.type === 5 /* DeclarationType.Function */ ? decl.node.name : decl.node);
+                            }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(decl)) !== null && _a !== void 0 ? _a : decl.node);
                             const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                             if (diag && origDecl) {
                                 diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4245,22 +4383,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         }
                     }
                 }
-                if ((0, types_1.isFunction)(baseType)) {
-                    // Private names (starting with double underscore) are exempt from this check.
-                    if (!SymbolNameUtils.isPrivateName(memberName) && types_1.FunctionType.isFinal(baseType)) {
-                        const decl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(overrideSymbol);
-                        if (decl && decl.type === 5 /* DeclarationType.Function */) {
-                            const diag = this._evaluator.addError(localize_1.Localizer.Diagnostic.finalMethodOverride().format({
-                                name: memberName,
-                                className: baseClass.details.name,
-                            }), decl.node.name);
-                            const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
-                            if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.finalMethod(), origDecl.uri, origDecl.range);
-                            }
-                        }
-                    }
-                }
             }
             else if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
                 // Special-case overrides of methods in '_TypedDict', since
@@ -4274,7 +4396,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             name: memberName,
                             className: baseClass.details.name,
                             type: this._evaluator.printType(overrideType),
-                        }), lastDecl.node);
+                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4288,10 +4410,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             if (!(0, typeUtils_1.isProperty)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
                 if (decls.length > 0) {
+                    const lastDecl = decls[decls.length - 1];
                     this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                         name: memberName,
                         className: baseClass.details.name,
-                    }), decls[decls.length - 1].node);
+                    }), (_c = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _c !== void 0 ? _c : lastDecl.node);
                 }
             }
             else {
@@ -4302,6 +4425,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     ['fdel', (c) => { var _a; return (_a = c.fdelInfo) === null || _a === void 0 ? void 0 : _a.methodType; }],
                 ];
                 propMethodInfo.forEach((info) => {
+                    var _a;
                     const diagAddendum = new diagnostic_1.DiagnosticAddendum();
                     const [methodName, methodAccessor] = info;
                     const baseClassPropMethod = methodAccessor(baseType);
@@ -4317,10 +4441,11 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                                 }));
                                 const decls = overrideSymbol.getDeclarations();
                                 if (decls.length > 0) {
+                                    const lastDecl = decls[decls.length - 1];
                                     const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleMethodOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.Localizer.Diagnostic.propertyOverridden().format({
                                         name: memberName,
                                         className: baseClassType.details.name,
-                                    }) + diagAddendum.getString(), decls[decls.length - 1].node);
+                                    }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
                                     const origDecl = baseClassMethodType.details.declaration;
                                     if (diag && origDecl) {
                                         diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
@@ -4398,7 +4523,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.symbolOverridden().format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }) + diagAddendum.getString(), (_a = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _a !== void 0 ? _a : lastDecl.node);
+                        }) + diagAddendum.getString(), (_d = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _d !== void 0 ? _d : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
@@ -4419,14 +4544,14 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                             const message = overrideTDEntry.isRequired
                                 ? localize_1.Localizer.Diagnostic.typedDictFieldRequiredRedefinition
                                 : localize_1.Localizer.Diagnostic.typedDictFieldNotRequiredRedefinition;
-                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), lastDecl.node);
+                            this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (_e = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _e !== void 0 ? _e : lastDecl.node);
                         }
                         // Make sure that the derived class isn't marking a previously writable
                         // entry as read-only.
                         if (!overriddenTDEntry.isReadOnly && overrideTDEntry.isReadOnly) {
                             this._evaluator.addDiagnostic(AnalyzerNodeInfo.getFileInfo(lastDecl.node).diagnosticRuleSet.reportGeneralTypeIssues, diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.Localizer.Diagnostic.typedDictFieldReadOnlyRedefinition().format({
                                 name: memberName,
-                            }), lastDecl.node);
+                            }), (_f = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _f !== void 0 ? _f : lastDecl.node);
                         }
                     }
                     // Verify that there is not a Final mismatch.
@@ -4436,7 +4561,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.Localizer.Diagnostic.variableFinalOverride().format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }), lastDecl.node);
+                        }), (_g = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _g !== void 0 ? _g : lastDecl.node);
                         if (diag) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
                         }
@@ -4465,7 +4590,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                         const diag = this._evaluator.addDiagnostic(this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride, diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
                             name: memberName,
                             className: baseClass.details.name,
-                        }), (_b = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _b !== void 0 ? _b : lastDecl.node);
+                        }), (_h = (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl)) !== null && _h !== void 0 ? _h : lastDecl.node);
                         const origDecl = (0, symbolUtils_1.getLastTypedDeclaredForSymbol)(baseClassAndSymbol.symbol);
                         if (diag && origDecl) {
                             diag.addRelatedInfo(localize_1.Localizer.DiagnosticAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);