Mypy should look in metaclass for operations on class objects

[sametmax]

Mypy complains about this line:

StringWrapper >> "foo"

With:

Unsupported left operand type for >> ("StringWrapper")

However, __rshift__ is defined on StringWrapper AND on StringWrapper's metaclass.

I understand the notation seems strange, calling shift on a class, but I'm making a library in which this API makes sense. The related code works, and applying >> does call __rshift__ on the metaclass. The only problem is mypy mentioning it. I can force ignore it, but I wish that dev using my lib won't have to do so.

[gvanrossum]

Does this work as expected when the left arg is not a class? I suspect mypy is treating classes specially somehow and not looking at the metaclass.

[sametmax]

Just tried, indeed with StringWrapper() >> "foo", no more warning.

[gvanrossum]

OK, I've changed the title accordingly (I don't think it's specific to >>).

[elazarg]

Related: #2392

[TRManderson]

A large source of "errors" for me is using metaclasses for class properties, here's a minimal example:

class Meta(type):
    @property
    def prop(cls):
        return "Hi!"

class Concrete(object, metaclass=Meta):
    pass

print(Concrete.prop)

I suspect it'll apply for anything to do with metaclasses though (as Guido suggested), given the two examples here are pretty disparate.

[TRManderson]

Yep it's just metaclass stuff in general

class Meta(type):
    attr = "attr"

    def fn(cls):
        return "fn"

class Concrete(object, metaclass=Meta):
    pass

print(Concrete.fn())
print(Concrete.attr)

[ilevkivskyi]

It looks like this issue is now fixed by #2475

[JukkaL]

The property, attribute and method examples now work.

__rshift__ still doesn't seem to work:

class Meta(type):
    def __rshift__(self, x):
        return 'foo'

class Concrete(object, metaclass=Meta):
    pass

print(Concrete >> 1)  # Unsupported operand types for >> ("Concrete" and "int")

[ilevkivskyi]

@JukkaL Hm, this is very strange, I tried this:

class Meta(type):
    def __rshift__(self, x):
        ...

class Concrete(metaclass=Meta):
    pass

print(Concrete >> 'foo')

And it works (note that I use a string, like in OP example, not an integer).

[JukkaL]

I can confirm that this behaves differently for int and str operands. It may have something to do with integers also defining __rshift__ and friends.

[elazarg]

Yes, it's failing for all types but the reverse method hides it for int. Maybe the lookup in has_member should be different.

[elazarg]

(Sorry, scratch the above: more likely is that the reverse method prohibits the lookup)