Assignment to next in class body of Iterator elicits error (in PY2 mode)

[gvanrossum]

Since #2380 was merged, the following example elicits an error when type-checked in Python 2 mode:

from typing import Iterator
class A: pass
class X(Iterator[A]):
  def __next__(self):
    # type: () -> A
    pass
  next = __next__

The error comes from the code added by #2380:

__tmp__.py: note: In class "X":
__tmp__.py:7: error: Incompatible types in assignment (expression has type Callable[[X], A], variable has type Callable[[Iterator[A]], A])

[JukkaL]

The type of next in the class body should likely be inferred as Callable[[X], A] (i.e., the type of self should be derived from the enclosing class).

[gvanrossum]

This is a general problem (not just for next). It prevents us from using mypy with this PR for our own "C" repo (for totally valid code). Should we roll back the PR or ask its author to come up with a fix? I'm not sure how involved the fix would be.

[TrueBrain]

Just to check if I understand the problem correctly, the following should also pass mypy not? (but it doesn't before the revert; same error as above)

T = TypeVar("T")

class B(Generic[T]):
        v = None  # type: T
        def n(self):
                # type: () -> T
                return self.v

class C(B[int]):
        def m(self):
                # type: () -> int
                return 1
        n = m

[gvanrossum]

That looks right to me, but I'll defer to @JukkaL.

[TrueBrain]

Found an even more elegant example:

class B():
        def n(self, a: int) -> None: pass
class C(B):
        def m(self, a: int) -> None: pass
        n = m

Pushed a fix, but I would love some feedback if this is an okay way to go.

Additionally, would you be able to check if with this version your repo does validate successfully?

[gvanrossum]

Yes, that example is better because it shows the problem is not due to generics.

Where's your fix? You're going to have to create a new PR.

[JukkaL]

Both examples look good.

[gvanrossum]

However here's a more complex example:

class I:
    def foo(self) -> None: pass

class A(I):
    def foo(self) -> None: pass

class B(A):
    def bar(self) -> None: pass
    foo = bar

class C(B):
    def bar(self) -> None: pass
    foo = bar

[JukkaL]

Note that this becomes relevant after #2510 is merged.