Make None compatible with Hashable

mypy/subtypes.py

@@ -207,10 +207,15 @@ def visit_any(self, left: AnyType) -> bool:
 
     def visit_none_type(self, left: NoneType) -> bool:
         if state.strict_optional:
-            return (isinstance(self.right, NoneType) or
-                    is_named_instance(self.right, 'builtins.object') or
-                    isinstance(self.right, Instance) and self.right.type.is_protocol and
-                    not self.right.type.protocol_members)
+            if isinstance(self.right, NoneType) or is_named_instance(self.right,
+                                                                     'builtins.object'):
+                return True
+            if isinstance(self.right, Instance) and self.right.type.is_protocol:
+                members = self.right.type.protocol_members
+                # None is compatible with Hashable (and other similar protocols). This is
+                # slightly sloppy since we don't check the signature of "__hash__".
+                return not members or members == ["__hash__"]
+            return False
         else:
             return True
 

test-data/unit/check-protocols.test

@@ -2507,3 +2507,32 @@ class A(Protocol):
     __slots__ = ()
 
 [builtins fixtures/tuple.pyi]
+
+[case testNoneVsProtocol]
+# mypy: strict-optional
+from typing_extensions import Protocol
+
+class MyHashable(Protocol):
+    def __hash__(self) -> int: ...
+
+def f(h: MyHashable) -> None: pass
+f(None)
+
+class Proto(Protocol):
+    def __hash__(self) -> int: ...
+    def method(self) -> None: ...
+
+def g(h: Proto) -> None: pass
+g(None)  # E: Argument 1 to "g" has incompatible type "None"; expected "Proto"
+
+class Proto2(Protocol):
+    def hash(self) -> None: ...
+
+def h(h: Proto2) -> None: pass
+h(None)  # E: Argument 1 to "h" has incompatible type "None"; expected "Proto2"
+
+class EmptyProto(Protocol): ...
+
+def hh(h: EmptyProto) -> None: pass
+hh(None)
+[builtins fixtures/tuple.pyi]