Reachability check seems to consider isinstance(obj, Hashable) as always True

[haxtibal]

Running mypy --warn-unreachable (version 0.920) against the following snippet gives a false "unreachable statement" error.

from collections.abc import Hashable
from typing import List, Tuple, Union

def wrap_hash(obj: Union[Tuple[int], List[int]]):
    if isinstance(obj, Hashable):
        return hash(obj)
    return hash(id(obj))  # error: Statement is unreachable  [unreachable]

wrap_hash((0,)) # reaches 1st return
wrap_hash([0])  # reaches 2nd return

We can even exchange the Union annotation for a single unhashable type like List or Dict, and still get the same unreachable error. Looks like isinstance(obj, Hashable) is just considered True for any type.

Is this a mypy bug? Can we add some hints into the example code so that mypy would figure out correct reachability?

[sobolevn]

The problem is that __hash__ is defined on object as a real method.

reveal_type(object.__hash__)  # N: Revealed type is "def (self: builtins.object) -> builtins.int"

We had this problem and discussion several times before.
Maybe we can try to change it to None | def (self: builtins.object) -> builtins.int?
CC @JelleZijlstra

[JelleZijlstra]

We already have __hash__: None on list in typeshed. Why would object have to change?

[sobolevn]

I don't know how we can represent this idea in types, but: some object subtypes are hashable (def (self: builtins.object) -> builtins.int) and some are not (None). But, object defines that all subclasses are hashable by defining __hash__ as def (self: builtins.object) -> builtins.int.

But, on the other hand, we know that object itself is hashable. Only its subtypes can be unhashable.

[JelleZijlstra]

But mypy already correctly errors when a subclass of a class that fulfills a protocol doesn't fulfill it:

from typing import Protocol

class X(Protocol):
    def foo(self, a: int) -> str:
        pass
    
class A:
    def foo(self, a: int) -> str:
        return ""
        
class B(A):
    def foo(self) -> str:  # type: ignore[override]
        return ""
        
a: X = A()
b: X = B()  # E: Incompatible types in assignment (expression has type "B", variable has type "X")

Why is Hashable different?

[sobolevn]

Looks like we have a bug in mypy 🤔
For some reason mypy treats Hashable as plain object.

1 NameExpr(Hashable [typing.Hashable])
TypeInfo(
  Name(typing.Hashable)
  Bases(builtins.object)
  Mro(typing.Hashable, builtins.object)
  Names(
    __hash__)
  DeclaredMetaclass(abc.ABCMeta)
  MetaclassType(abc.ABCMeta))
2 def () -> builtins.object

I will look into it.

[sobolevn]

I hope that #11802 will fix it! 🙏