Handle allow_incompatible_override consistenly instead

Author: sterliakov

mypy/checker.py

@@ -2216,6 +2216,9 @@ def check_method_override_for_base_with_name(
                 # Will always fail to typecheck below, since we know the node is a method
                 original_type = NoneType()
 
+        if isinstance(original_node, Var) and original_node.allow_incompatible_override:
+            return False
+
         always_allow_covariant = False
         if is_settable_property(defn) and (
             is_settable_property(original_node) or isinstance(original_node, Var)
@@ -2239,14 +2242,6 @@ def check_method_override_for_base_with_name(
         typ = get_proper_type(typ)
         original_type = get_proper_type(original_type)
 
-        if name == "__hash__" and isinstance(original_type, NoneType):
-            # Allow defining `__hash__` even if parent class was explicitly made unhashable
-            if base.fullname == "builtins.object":
-                # This is only for test stubs to avoid adding object.__hash__
-                # to all of them.
-                return True
-            return self.check_method_override_for_base_with_name(defn, name, base.mro[-1])
-
         if (
             is_property(defn)
             and isinstance(original_node, Var)
@@ -3448,13 +3443,6 @@ def check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expression) ->
                 return
 
             for base in lvalue_node.info.mro[1:]:
-                # The type of "__slots__" and some other attributes usually doesn't need to
-                # be compatible with a base class. We'll still check the type of "__slots__"
-                # against "object" as an exception.
-                if lvalue_node.allow_incompatible_override and not (
-                    lvalue_node.name == "__slots__" and base.fullname == "builtins.object"
-                ):
-                    continue
                 if (
                     lvalue_node.name == "__hash__"
                     and base.fullname == "builtins.object"
@@ -3468,6 +3456,17 @@ def check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expression) ->
                     continue
 
                 base_type, base_node = self.node_type_from_base(lvalue_node.name, base, lvalue)
+                # The type of "__slots__" and some other attributes usually doesn't need to
+                # be compatible with a base class. We'll still check the type of "__slots__"
+                # against "object" as an exception.
+                if (
+                    isinstance(base_node, Var)
+                    and base_node.allow_incompatible_override
+                    and not (
+                        lvalue_node.name == "__slots__" and base.fullname == "builtins.object"
+                    )
+                ):
+                    continue
                 custom_setter = is_custom_settable_property(base_node)
                 if isinstance(base_type, PartialType):
                     base_type = None
@@ -3497,7 +3496,7 @@ def check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expression) ->
                                 lvalue, lvalue_type, base_type, base
                             )
                             return
-                    if base is last_immediate_base and base_node.name != "__hash__":
+                    if base is last_immediate_base:
                         # At this point, the attribute was found to be compatible with all
                         # immediate parents.
                         break
@@ -3511,9 +3510,6 @@ def check_compatibility_super(
         base_node: Node,
         always_allow_covariant: bool,
     ) -> bool:
-        if base_node.name == "__hash__" and isinstance(base_type, NoneType):
-            # Allow defining `__hash__` even if parent class was explicitly made unhashable
-            return True
         # TODO: check __set__() type override for custom descriptors.
         # TODO: for descriptors check also class object access override.
         ok = self.check_subtype(

mypy/semanal.py

@@ -3257,6 +3257,22 @@ def visit_assignment_stmt(self, s: AssignmentStmt) -> None:
         self.process__all__(s)
         self.process__deletable__(s)
         self.process__slots__(s)
+        self.process__hash__(s)
+
+    def process__hash__(self, s: AssignmentStmt) -> None:
+        # Allow overriding `__hash__ = None` in subclasses.
+        if (
+            isinstance(self.type, TypeInfo)
+            and len(s.lvalues) == 1
+            and isinstance(s.lvalues[0], NameExpr)
+            and s.lvalues[0].name == "__hash__"
+            and s.lvalues[0].kind == MDEF
+            and isinstance(s.rvalue, NameExpr)
+            and s.rvalue.name == "None"
+        ):
+            var = s.lvalues[0].node
+            if isinstance(var, Var):
+                var.allow_incompatible_override = True
 
     def analyze_identity_global_assignment(self, s: AssignmentStmt) -> bool:
         """Special case 'X = X' in global scope.

test-data/unit/check-classes.test

@@ -163,10 +163,6 @@ class C(A):
 
 class D(A):
     def __hash__(self, x: int) -> str:  # E: Signature of "__hash__" incompatible with supertype "object" \
-                                        # N:      Superclass: \
-                                        # N:          def __hash__(self) -> int \
-                                        # N:      Subclass: \
-                                        # N:          def __hash__(self, x: int) -> str \
                                         # N:      Superclass: \
                                         # N:          def __hash__(self) -> int \
                                         # N:      Subclass: \
@@ -178,7 +174,6 @@ def bad_hash(x: E, y: str) -> str:
 
 class E(A):
     __hash__ = bad_hash  # E: Incompatible types in assignment (expression has type "Callable[[str], str]", base class "object" defined the type as "Callable[[], int]")
-
 [builtins fixtures/primitives.pyi]
 
 [case testHashNoneBadOverride]