Inheriting overloaded signatures

[Geggles]

Say we have a class Foo:

class Foo:
    @overload
    def fun(self, s:str) -> str:
        pass

    @overload
    def fun(self, i:int) -> int:
        pass

    def fun(self, x):
        pass

If we now add a subclass Bar like this:

class Bar(Foo):
    @overload
    def fun(self, s:str) -> str:
        pass

    @overload
    def fun(self, i:int) -> int:
        pass

    def fun(self, x):
        pass
Bar().fun([])

and run mypy on it without any flags, we get the expected
error: No overload variant of "fun" of "Bar" matches argument type "List[<nothing>]".
If however we don't copy the overloaded signatures,

class Bar(Foo):
    def fun(self, x):
        pass
Bar().fun([])

then mypy does not find any errors. Is this inteded behaviour? Is it not possible to find the overloaded signatures of the base classes statically? Am I not supposed to do this sort of thing in the first place?

> python -V
Python 3.6.2
> mypy -V
mypy 0.610+dev-eb1bb064d707ce05735ff6795df82126e75ea6ea

[ilevkivskyi]

Is this inteded behaviour?

Currently yes, you are supposed to repeat type signature in subclasses even if it is unchanged, otherwise all unannotated functions are not checked and all their args are given Any type, as per PEP 484. On one hand it is a bit "boring", on other hand explicit is better than explicit. There is already a proposal to switch to use superclass signature by default instead of defaulting to all Any python/typing#269 so I am closing this one as a duplicate.

[nateyoder]

Given that python/typing#269 was closed by saying that this should be a type checker specific decision does this mean that mypy has decided not to implement this feature or could this issue be reopened for discussion?

[peturingi]

Workaround. use "if not TYPE_CHECKING" to force mypy to traverse into the base.
This only works if you are not adding new overloads, in which case you will need to copy-paste all of the overloads down into the specialization.

from typing import overload, TYPE_CHECKING


class Foo:
    @overload
    def fun(self, s:str) -> str:
        ...

    @overload
    def fun(self, i:int) -> int:
        ...

    def fun(self, x):
        pass

class Bar(Foo):
    if not TYPE_CHECKING:
        def fun(self, x):
            pass