Make behaviour of __hash__ = None more intuitive: can be rolled back in subclasses, only allowed to override object.__hash__

Author: sterliakov

mypy/checker.py

@@ -2215,6 +2215,10 @@ 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 name == "__hash__" and isinstance(original_type, NoneType):
+            # Allow defining `__hash__` even if parent class was explicitly made unhashable
+            return False
+
         always_allow_covariant = False
         if is_settable_property(defn) and (
             is_settable_property(original_node) or isinstance(original_node, Var)
@@ -3444,6 +3448,14 @@ def check_compatibility_all_supers(self, lvalue: RefExpr, rvalue: Expression) ->
                     lvalue_node.name == "__slots__" and base.fullname == "builtins.object"
                 ):
                     continue
+                if (
+                    lvalue_node.name == "__hash__"
+                    and base.fullname == "builtins.object"
+                    and isinstance(get_proper_type(lvalue_type), NoneType)
+                ):
+                    # allow `__hash__ = None` if the overridden `__hash__` comes from object
+                    # This isn't LSP-compliant, but too common in real code.
+                    continue
 
                 if is_private(lvalue_node.name):
                     continue

mypy/semanal.py

@@ -2030,6 +2030,15 @@ def analyze_class_body_common(self, defn: ClassDef) -> None:
             self.setup_self_type()
         defn.defs.accept(self)
         self.apply_class_plugin_hooks(defn)
+
+        if "__eq__" in defn.info.names and "__hash__" not in defn.info.names:
+            # If a class defines `__eq__` without `__hash__`, it's no longer hashable.
+            hash_none = Var("__hash__", NoneType())
+            hash_none.info = defn.info
+            hash_none.set_line(defn)
+            hash_none.is_classvar = True
+            self.add_symbol("__hash__", hash_none, defn)
+
         self.leave_class()
 
     def analyze_typeddict_classdef(self, defn: ClassDef) -> bool:

test-data/unit/check-classes.test

@@ -116,11 +116,7 @@ class Base:
     __hash__: None = None
 
 class Derived(Base):
-    def __hash__(self) -> int:  # E: Signature of "__hash__" incompatible with supertype "Base" \
-                                # N:      Superclass: \
-                                # N:          None \
-                                # N:      Subclass: \
-                                # N:          def __hash__(self) -> int
+    def __hash__(self) -> int:
         pass
 
 # Correct:
@@ -147,6 +143,29 @@ class Base:
 class Derived(Base):
     __hash__ = 1  # E: Incompatible types in assignment (expression has type "int", base class "Base" defined the type as "Callable[[], int]")
 
+[case testEqWithoutHash]
+class A:
+    def __eq__(self, other) -> bool: ...
+
+reveal_type(A.__hash__)  # N: Revealed type is "None"
+[builtins fixtures/primitives.pyi]
+
+[case testHashNoneOverride]
+class A:
+    __hash__ = None
+
+class B(A):
+    def __hash__(self) -> int: return 0
+[builtins fixtures/primitives.pyi]
+
+[case testHashNoneBadOverride]
+class A:
+    def __hash__(self) -> int: return 0
+
+class B(A):
+    __hash__ = None  # E: Incompatible types in assignment (expression has type "None", base class "A" defined the type as "Callable[[], int]")
+[builtins fixtures/primitives.pyi]
+
 [case testOverridePartialAttributeWithMethod]
 # This was crashing: https://github.com/python/mypy/issues/11686.
 class Base:

test-data/unit/fixtures/primitives.pyi

@@ -10,6 +10,7 @@ class object:
     def __str__(self) -> str: pass
     def __eq__(self, other: object) -> bool: pass
     def __ne__(self, other: object) -> bool: pass
+    def __hash__(self) -> int: ...
 
 class type:
     def __init__(self, x: object) -> None: pass