Wrong type inference for class with metaclass that acts as descriptor

[Jackenmen]

Bug Report
Descriptor protocol does not work on metaclasses - defining __get__ method in a metaclass does not make classes using that metaclass work as descriptors.

To Reproduce

1. Put this code in a py file:

from typing import Any, TYPE_CHECKING, overload

class _IntDescriptorMeta(type):
    def __get__(self, instance: Any, owner: Any) -> int:
        return 123

class IntDescriptorClass(metaclass=_IntDescriptorMeta):
    ...

class IntDescriptor:
    def __get__(self, instance: Any, owner: Any) -> int:
        return 123

class X:
    number_cls = IntDescriptorClass
    number = IntDescriptor()

print(X.number_cls)
print(X().number_cls)
print(X.number)
print(X().number)

if TYPE_CHECKING:
    reveal_type(X.number_cls)
    reveal_type(X().number_cls)
    reveal_type(X.number)
    reveal_type(X().number)

2. Run it, you should see:

123
123
123
123

3. Type check it with mypy and see the incorrect output.

Expected Behavior
I expected mypy to infer type of X.number_cls/X().number_cls correctly:

main.py:24: note: Revealed type is "builtins.int"
main.py:25: note: Revealed type is "builtins.int"
main.py:26: note: Revealed type is "builtins.int"
main.py:27: note: Revealed type is "builtins.int"

Note:
To simplify this example, __get__ returns an int no matter if instance is None or not but I assume a fix would also make it work properly with overloads as it does for instances of classes.

Actual Behavior

Mypy does not infer type of X.number_cls/X().number_cls correctly:

main.py:24: note: Revealed type is "def () -> __main__.IntDescriptorClass"
main.py:25: note: Revealed type is "def () -> __main__.IntDescriptorClass"
main.py:26: note: Revealed type is "builtins.int"
main.py:27: note: Revealed type is "builtins.int"

Your Environment

• Mypy version used: 0.910 as well as the latest (master branch)
• mypy-play.net URL: https://mypy-play.net/?mypy=latest&python=3.8&gist=de23d753f19cf0149ed9cd6919e84791

Additional notes
This works properly on pyright 1.1.161+, see the issue: microsoft/pyright#2164

[Jackenmen]

Another worthy test case checking for proper inference of types when self is annotated as Type[T]:

from typing import Any, Optional, Union, Type, TypeVar, TYPE_CHECKING, overload


T = TypeVar("T")


class _IntDescriptorMeta(type):
    @overload
    def __get__(self: Type[T], instance: None, owner: Any) -> Type[T]: ...

    @overload
    def __get__(self: Type[T], instance: object, owner: Any) -> T: ...

    def __get__(self: Type[T], instance: Optional[object], owner: Any) -> Union[Type[T], T]:
        if instance is None:
            return self
        return self()

class IntDescriptorClass(metaclass=_IntDescriptorMeta):
    ...


class X:
    number_cls = IntDescriptorClass


print(X.number_cls)
print(X().number_cls)

if TYPE_CHECKING:
    reveal_type(X.number_cls)
    reveal_type(X().number_cls)

Taken from a pyright bug that was reported after this functionality was initially implemented: microsoft/pyright#2177

[finite-state-machine]

This provides a very useful workaround to the lack of support for arbitrary class decorators; a metaclass and __get__() could accomplish almost anything a decorator could.