Wrong "Non-overlapping equality check" warning

[rggjan]

Running this code:

from typing import Any, Callable


class Foo:
    def __init__(self, a: int) -> None:
        print(a)


def bar(f: Callable[[Any], Any]) -> None:
    if type(f) ==Foo:
        print("The same!")

    f(3)


bar(Foo)

with mypy 0.942 and "strict_equality" enabled leads to:

error: Non-overlapping equality check (left operand type: "Type[Callable[[Any], Any]]", right operand type: "Type[Foo]")

I think this is wrong, as clearly, mypy accepts Foo as a correct argument to bar, in which case checking if f inside the function is of type Foo should also be valid...

[Akuli]

f is not of type Foo in your example though. It's literally the class Foo, not an instance of Foo, so type(f) will be the metaclass of Foo, which is confusingly type.

For the equality check to be true, you would have to create a subclass of Foo with __call__ in it, so that you would have a callable instance of Foo.

[AlexWaygood]

You do still get an erroneous non-overlapping equality check for this code though, which is more correct:

from typing import Any, Callable


class Foo:
    def __init__(self, a: int) -> None:
        print(a)


def bar(f: Callable[[Any], Any]) -> None:
    if f == Foo:  # error: Non-overlapping equality check (left operand type: "Callable[[Any], Any]", right operand type: "Type[Foo]"
        print("The same!")

    f(3)


bar(Foo)

[rggjan]

Oh, you're both right of course! Yes, I actually did have a typo in my sample code. I meant to have the check like: type(f) == type(Foo), which is very similar to your (@AlexWaygood) f == Foo conceptually.

It results in an error as well:

error: Non-overlapping equality check (left operand type: "Type[Callable[[Any], Any]]", right operand type: "Type[Type[Foo]]")