@zzzen/pyright-internal 1.2.0-dev.20250209 → 1.2.0-dev.20250223

package/dist/analyzer/checker.js

@@ -1382,7 +1382,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     if (isComparable) {
                         return;
                     }
-                    if (this._isTypeComparable(leftSubtype, rightSubtype)) {
+                    if (this._evaluator.isTypeComparable(leftSubtype, rightSubtype)) {
                         isComparable = true;
                     }
                     return rightSubtype;
@@ -1399,71 +1399,6 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             }
         }
     }
-    // Determines whether the two types are potentially comparable -- i.e.
-    // their types overlap in such a way that it makes sense for them to
-    // be compared with an == or != operator.
-    _isTypeComparable(leftType, rightType) {
-        if ((0, types_1.isAnyOrUnknown)(leftType) || (0, types_1.isAnyOrUnknown)(rightType)) {
-            return true;
-        }
-        if ((0, types_1.isNever)(leftType) || (0, types_1.isNever)(rightType)) {
-            return false;
-        }
-        if ((0, types_1.isModule)(leftType) || (0, types_1.isModule)(rightType)) {
-            return (0, types_1.isTypeSame)(leftType, rightType, { ignoreConditions: true });
-        }
-        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;
-        }
-        if ((0, types_1.isInstantiableClass)(leftType) || ((0, types_1.isClassInstance)(leftType) && types_1.ClassType.isBuiltIn(leftType, 'type'))) {
-            if ((0, types_1.isInstantiableClass)(rightType) ||
-                ((0, types_1.isClassInstance)(rightType) && types_1.ClassType.isBuiltIn(rightType, 'type'))) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const metaclass = leftType.shared.effectiveMetaclass;
-            if (metaclass && (0, types_1.isClass)(metaclass)) {
-                if ((0, typeUtils_1.lookUpClassMember)(metaclass, '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */)) {
-                    return true;
-                }
-            }
-            return false;
-        }
-        if ((0, types_1.isClassInstance)(leftType)) {
-            if ((0, types_1.isClass)(rightType)) {
-                const genericLeftType = types_1.ClassType.specialize(leftType, /* typeArgs */ undefined);
-                const genericRightType = types_1.ClassType.specialize(rightType, /* typeArgs */ undefined);
-                if (this._evaluator.assignType(genericLeftType, genericRightType) ||
-                    this._evaluator.assignType(genericRightType, genericLeftType)) {
-                    return true;
-                }
-                // Assume that if the types are disjoint and built-in classes that they
-                // will never be comparable.
-                if (types_1.ClassType.isBuiltIn(leftType) && types_1.ClassType.isBuiltIn(rightType) && types_1.TypeBase.isInstance(rightType)) {
-                    return false;
-                }
-            }
-            // Does the class have an operator overload for eq?
-            const eqMethod = (0, typeUtils_1.lookUpClassMember)(types_1.ClassType.cloneAsInstantiable(leftType), '__eq__', 4 /* MemberAccessFlags.SkipObjectBaseClass */);
-            if (eqMethod) {
-                // If this is a synthesized method for a dataclass, we can assume
-                // that other dataclass types will not be comparable.
-                if (types_1.ClassType.isDataClass(leftType) && eqMethod.symbol.getSynthesizedType()) {
-                    return false;
-                }
-                return true;
-            }
-            return false;
-        }
-        return true;
-    }
     // If the function is a generator, validates that its annotated return type
     // is appropriate for a generator.
     _validateGeneratorReturnType(node, functionType) {
@@ -4631,24 +4566,7 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
         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;
-            // 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.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) {
+            if (this._isFinalFunction(memberName, baseType)) {
                 const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
                 if (decl && decl.type === 5 /* DeclarationType.Function */) {
                     const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
@@ -4661,55 +4579,62 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                 }
             }
+            // Don't check certain magic functions or private symbols.
+            // 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 (this._isMethodExemptFromLsp(memberName) ||
+                SymbolNameUtils.isPrivateName(memberName) ||
+                types_1.ClassType.isTypedDictClass(childClassType)) {
+                return;
+            }
             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.
                 const enforceParamNameMatch = !SymbolNameUtils.isDunderName(memberName);
-                // Don't check certain magic functions or private symbols.
-                // 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 (!this._isMethodExemptFromLsp(memberName) &&
-                    !SymbolNameUtils.isPrivateName(memberName) &&
-                    !types_1.ClassType.isTypedDictClass(childClassType)) {
-                    if (!this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
-                        const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
-                        if (decl) {
-                            const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
-                                name: memberName,
-                                className: baseClass.shared.name,
-                            }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
-                            const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                            if (diag && origDecl) {
-                                diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
-                            }
-                        }
-                    }
+                if (this._evaluator.validateOverrideMethod(baseType, overrideType, childClassType, diagAddendum, enforceParamNameMatch)) {
+                    return;
+                }
+                const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+                if (!decl) {
+                    return;
+                }
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.incompatibleMethodOverride().format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(decl) ?? decl.node);
+                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+                if (diag && origDecl) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                 }
+                return;
             }
-            else if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
+            if (!(0, types_1.isAnyOrUnknown)(overrideType)) {
                 // Special-case overrides of methods in '_TypedDict', since
                 // TypedDict attributes aren't manifest as attributes but rather
                 // as named keys.
-                if (!types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
-                    const decls = overrideSymbol.getDeclarations();
-                    if (decls.length > 0) {
-                        const lastDecl = decls[decls.length - 1];
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
-                            name: memberName,
-                            className: baseClass.shared.name,
-                            type: this._evaluator.printType(overrideType),
-                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                        const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                        if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
-                        }
-                    }
+                if (types_1.ClassType.isBuiltIn(baseClass, '_TypedDict')) {
+                    return;
+                }
+                const decls = overrideSymbol.getDeclarations();
+                if (decls.length === 0) {
+                    return;
+                }
+                const lastDecl = decls[decls.length - 1];
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.methodOverridden().format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                    type: this._evaluator.printType(overrideType),
+                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+                if (diag && origDecl) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenMethod(), origDecl.uri, origDecl.range);
                 }
             }
+            return;
         }
-        else if ((0, typeUtils_1.isProperty)(baseType)) {
+        if ((0, typeUtils_1.isProperty)(baseType)) {
             // Handle properties specially.
             if (!(0, typeUtils_1.isProperty)(overrideType)) {
                 const decls = overrideSymbol.getDeclarations();
@@ -4724,139 +4649,158 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
             else {
                 this._validatePropertyOverride(baseClass, childClassType, baseType, overrideType, overrideSymbol, memberName);
             }
+            return;
         }
-        else {
-            // This check can be expensive, so don't perform it if the corresponding
-            // rule is disabled.
-            if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
-                const decls = overrideSymbol.getDeclarations();
-                if (decls.length > 0) {
-                    const lastDecl = decls[decls.length - 1];
-                    const primaryDecl = decls[0];
-                    // Verify that the override type is assignable to (same or narrower than)
-                    // the declared type of the base symbol.
-                    let isInvariant = primaryDecl?.type === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
-                    // If the entry is a member of a frozen dataclass, it is immutable,
-                    // so it does not need to be invariant.
-                    if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
-                        const dataclassEntry = baseClass.shared.dataClassEntries.find((entry) => entry.name === memberName);
-                        if (dataclassEntry) {
-                            isInvariant = false;
-                        }
-                    }
-                    let overriddenTDEntry;
-                    let overrideTDEntry;
-                    if (!overrideSymbol.isIgnoredForProtocolMatch()) {
-                        if (baseClass.shared.typedDictEntries) {
-                            overriddenTDEntry =
-                                baseClass.shared.typedDictEntries.knownItems.get(memberName) ??
-                                    baseClass.shared.typedDictEntries.extraItems ??
-                                    (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
-                            if (overriddenTDEntry?.isReadOnly) {
-                                isInvariant = false;
-                            }
-                        }
-                        if (childClassType.shared.typedDictEntries) {
-                            overrideTDEntry =
-                                childClassType.shared.typedDictEntries.knownItems.get(memberName) ??
-                                    childClassType.shared.typedDictEntries.extraItems ??
-                                    (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
-                        }
-                    }
-                    let diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                    if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
-                    /* constraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.Invariant */ : 0 /* AssignTypeFlags.Default */)) {
-                        if (isInvariant) {
-                            diagAddendum = new diagnostic_1.DiagnosticAddendum();
-                            diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
-                            diagAddendum.createAddendum().addMessage(localize_1.LocAddendum.overrideInvariantMismatch().format({
-                                overrideType: this._evaluator.printType(overrideType),
-                                baseType: this._evaluator.printType(baseType),
-                            }));
-                        }
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
-                            name: memberName,
-                            className: baseClass.shared.name,
-                        }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                        const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                        if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
-                        }
-                    }
-                    else if (overriddenTDEntry && overrideTDEntry) {
-                        // Make sure the required/not-required attribute is compatible.
-                        let isRequiredCompatible = true;
-                        if (overriddenTDEntry.isReadOnly) {
-                            // If the read-only flag is set, a not-required field can be overridden
-                            // by a required field, but not vice versa.
-                            isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
-                        }
-                        else {
-                            isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
-                        }
-                        if (!isRequiredCompatible) {
-                            const message = overrideTDEntry.isRequired
-                                ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
-                                : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
-                            this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? 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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
-                                name: memberName,
-                            }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                        }
-                    }
-                    // Verify that there is not a Final mismatch.
-                    const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
-                    const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
-                    if (!isBaseVarFinal && overrideFinalVarDecl) {
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
-                            name: memberName,
-                            className: baseClass.shared.name,
-                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                        if (diag) {
-                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
-                        }
-                    }
-                    // Verify that a class variable isn't overriding an instance
-                    // variable or vice versa.
-                    const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
-                    let isClassVar = overrideSymbol.isClassVar();
-                    if (isBaseClassVar && !isClassVar) {
-                        // If the subclass doesn't redeclare the type but simply assigns
-                        // it without declaring its type, we won't consider it an instance
-                        // variable.
-                        if (!overrideSymbol.hasTypedDeclarations()) {
-                            isClassVar = true;
-                        }
-                        // If the subclass is declaring an inner class, we'll consider that
-                        // to be a ClassVar.
-                        if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 6 /* DeclarationType.Class */)) {
-                            isClassVar = true;
-                        }
-                    }
-                    // Allow TypedDict members to have the same name as class variables in the
-                    // base class because TypedDict members are not really instance members.
-                    const ignoreTypedDictOverride = types_1.ClassType.isTypedDictClass(childClassType) && !isClassVar;
-                    if (isBaseClassVar !== isClassVar && !ignoreTypedDictOverride) {
-                        const unformattedMessage = overrideSymbol.isClassVar()
-                            ? localize_1.LocMessage.classVarOverridesInstanceVar()
-                            : localize_1.LocMessage.instanceVarOverridesClassVar();
-                        const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
-                            name: memberName,
-                            className: baseClass.shared.name,
-                        }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
-                        const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
-                        if (diag && origDecl) {
-                            diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
-                        }
+        // This check can be expensive, so don't perform it if the corresponding
+        // rule is disabled.
+        if (this._fileInfo.diagnosticRuleSet.reportIncompatibleVariableOverride !== 'none') {
+            const decls = overrideSymbol.getDeclarations();
+            if (decls.length === 0) {
+                return;
+            }
+            const lastDecl = decls[decls.length - 1];
+            const primaryDecl = decls[0];
+            // Verify that the override type is assignable to (same or narrower than)
+            // the declared type of the base symbol.
+            let isInvariant = primaryDecl?.type === 1 /* DeclarationType.Variable */ && !primaryDecl.isFinal;
+            // If the entry is a member of a frozen dataclass, it is immutable,
+            // so it does not need to be invariant.
+            if (types_1.ClassType.isDataClassFrozen(baseClass) && baseClass.shared.dataClassEntries) {
+                const dataclassEntry = baseClass.shared.dataClassEntries.find((entry) => entry.name === memberName);
+                if (dataclassEntry) {
+                    isInvariant = false;
+                }
+            }
+            let overriddenTDEntry;
+            let overrideTDEntry;
+            if (!overrideSymbol.isIgnoredForProtocolMatch()) {
+                if (baseClass.shared.typedDictEntries) {
+                    overriddenTDEntry =
+                        baseClass.shared.typedDictEntries.knownItems.get(memberName) ??
+                            baseClass.shared.typedDictEntries.extraItems ??
+                            (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, baseClass);
+                    if (overriddenTDEntry?.isReadOnly) {
+                        isInvariant = false;
                     }
                 }
+                if (childClassType.shared.typedDictEntries) {
+                    overrideTDEntry =
+                        childClassType.shared.typedDictEntries.knownItems.get(memberName) ??
+                            childClassType.shared.typedDictEntries.extraItems ??
+                            (0, typedDicts_1.getEffectiveExtraItemsEntryType)(this._evaluator, childClassType);
+                }
+            }
+            let diagAddendum = new diagnostic_1.DiagnosticAddendum();
+            if (!this._evaluator.assignType(baseType, overrideType, diagAddendum, 
+            /* constraints */ undefined, isInvariant ? 1 /* AssignTypeFlags.Invariant */ : 0 /* AssignTypeFlags.Default */)) {
+                if (isInvariant) {
+                    diagAddendum = new diagnostic_1.DiagnosticAddendum();
+                    diagAddendum.addMessage(localize_1.LocAddendum.overrideIsInvariant());
+                    diagAddendum.createAddendum().addMessage(localize_1.LocAddendum.overrideInvariantMismatch().format({
+                        overrideType: this._evaluator.printType(overrideType),
+                        baseType: this._evaluator.printType(baseType),
+                    }));
+                }
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.symbolOverridden().format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                }) + diagAddendum.getString(), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+                if (diag && origDecl) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+                }
+            }
+            else if (overriddenTDEntry && overrideTDEntry) {
+                // Make sure the required/not-required attribute is compatible.
+                let isRequiredCompatible = true;
+                if (overriddenTDEntry.isReadOnly) {
+                    // If the read-only flag is set, a not-required field can be overridden
+                    // by a required field, but not vice versa.
+                    isRequiredCompatible = overrideTDEntry.isRequired || !overriddenTDEntry.isRequired;
+                }
+                else {
+                    isRequiredCompatible = overrideTDEntry.isRequired === overriddenTDEntry.isRequired;
+                }
+                if (!isRequiredCompatible) {
+                    const message = overrideTDEntry.isRequired
+                        ? localize_1.LocMessage.typedDictFieldRequiredRedefinition
+                        : localize_1.LocMessage.typedDictFieldNotRequiredRedefinition;
+                    this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, message().format({ name: memberName }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? 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(diagnosticRules_1.DiagnosticRule.reportGeneralTypeIssues, localize_1.LocMessage.typedDictFieldReadOnlyRedefinition().format({
+                        name: memberName,
+                    }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+                }
+            }
+            // Verify that there is not a Final mismatch.
+            const isBaseVarFinal = this._evaluator.isFinalVariable(baseClassAndSymbol.symbol);
+            const overrideFinalVarDecl = decls.find((d) => this._evaluator.isFinalVariableDeclaration(d));
+            if (!isBaseVarFinal && overrideFinalVarDecl) {
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, localize_1.LocMessage.variableFinalOverride().format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+                if (diag) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), overrideFinalVarDecl.uri, overrideFinalVarDecl.range);
+                }
+            }
+            // Verify that a class variable isn't overriding an instance
+            // variable or vice versa.
+            const isBaseClassVar = baseClassAndSymbol.symbol.isClassVar();
+            let isClassVar = overrideSymbol.isClassVar();
+            if (isBaseClassVar && !isClassVar) {
+                // If the subclass doesn't redeclare the type but simply assigns
+                // it without declaring its type, we won't consider it an instance
+                // variable.
+                if (!overrideSymbol.hasTypedDeclarations()) {
+                    isClassVar = true;
+                }
+                // If the subclass is declaring an inner class, we'll consider that
+                // to be a ClassVar.
+                if (overrideSymbol.getTypedDeclarations().every((decl) => decl.type === 6 /* DeclarationType.Class */)) {
+                    isClassVar = true;
+                }
+            }
+            // Allow TypedDict members to have the same name as class variables in the
+            // base class because TypedDict members are not really instance members.
+            const ignoreTypedDictOverride = types_1.ClassType.isTypedDictClass(childClassType) && !isClassVar;
+            if (isBaseClassVar !== isClassVar && !ignoreTypedDictOverride) {
+                const unformattedMessage = overrideSymbol.isClassVar()
+                    ? localize_1.LocMessage.classVarOverridesInstanceVar()
+                    : localize_1.LocMessage.instanceVarOverridesClassVar();
+                const diag = this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleVariableOverride, unformattedMessage.format({
+                    name: memberName,
+                    className: baseClass.shared.name,
+                }), (0, declarationUtils_1.getNameNodeForDeclaration)(lastDecl) ?? lastDecl.node);
+                const origDecl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(baseClassAndSymbol.symbol);
+                if (diag && origDecl) {
+                    diag.addRelatedInfo(localize_1.LocAddendum.overriddenSymbol(), origDecl.uri, origDecl.range);
+                }
             }
         }
     }
+    _isFinalFunction(name, type) {
+        if (SymbolNameUtils.isPrivateName(name)) {
+            return false;
+        }
+        if ((0, types_1.isFunction)(type) && types_1.FunctionType.isFinal(type)) {
+            return true;
+        }
+        if ((0, types_1.isOverloaded)(type)) {
+            const overloads = types_1.OverloadedType.getOverloads(type);
+            const impl = types_1.OverloadedType.getImplementation(type);
+            if (overloads.some((overload) => types_1.FunctionType.isFinal(overload))) {
+                return true;
+            }
+            if (impl && (0, types_1.isFunction)(impl) && types_1.FunctionType.isFinal(impl)) {
+                return true;
+            }
+        }
+        return false;
+    }
     _validatePropertyOverride(baseClassType, childClassType, baseType, childType, overrideSymbol, memberName) {
         const propMethodInfo = [
             ['fget', (c) => c.priv.fgetInfo?.methodType],
@@ -4893,6 +4837,15 @@ class Checker extends parseTreeWalker_1.ParseTreeWalker {
                     }
                     return;
                 }
+                else if (this._isFinalFunction(methodName, baseClassPropMethod)) {
+                    const decl = (0, symbolUtils_1.getLastTypedDeclarationForSymbol)(overrideSymbol);
+                    if (decl && decl.type === 5 /* DeclarationType.Function */) {
+                        this._evaluator.addDiagnostic(diagnosticRules_1.DiagnosticRule.reportIncompatibleMethodOverride, localize_1.LocMessage.finalMethodOverride().format({
+                            name: memberName,
+                            className: baseClassType.shared.name,
+                        }), decl.node.d.name);
+                    }
+                }
                 const subclassMethodType = (0, typeUtils_1.partiallySpecializeType)(subclassPropMethod, childClassType, this._evaluator.getTypeClassType());
                 if (!(0, types_1.isFunction)(subclassMethodType)) {
                     return;