Argument incompatibility not detected with multiple generic base classes

[ramosbugs]

• Are you reporting a bug, or opening a feature request?

Reporting a bug

• Please insert below the code you are checking with mypy,
  or a mock-up repro if the source is private. We would appreciate
  if you try to simplify your case to a minimal repro.

Minimal repro:

from abc import ABCMeta, abstractmethod
from typing import Generic, TypeVar, Union

A = TypeVar('A')


class Base(Generic[A]):
    __metaclass__ = ABCMeta

    @abstractmethod
    def do_stuff(self, a):
        # type: (A) -> None
        pass


class Foo(Generic[A], Base[A]):
    pass


class Bar(Generic[A], Base[A]):
    pass


class Baz(Foo[str], Bar[Union[str, int]]):
    def do_stuff(self, a):
        # type: (str) -> None
        return None

• What is the actual behavior/output?

No error is reported

• What is the behavior/output you expect?

The definition of Baz.do_stuff() accepts a str, which is incompatible with Bar.do_stuff()'s abstract method definition (which accepts Union[str, int]).

This bug appears to be related to the following TODO comment:

mypy/mypy/checker.py

Line 1634 in d1c8f27

# TODO: What if some classes are generic?

Interestingly, if I reverse the order of Foo and Bar in Baz's base class list, mypy reports the error.

• What are the versions of mypy and Python you are using?
  Do you see the same issue after installing mypy from Git master?

https://github.com/python/mypy/tree/103f5f3ec3fcc8fba429edcc4ee61c1370153ff9

[ilevkivskyi]

On one hand this is quite rare false negative, but on the other hand, this should be pretty easy to fix, so setting priority to normal.

Note that something like "expand method by instance" will be also useful to finally fix generic classmethod support.

[ilevkivskyi]

Btw, thanks for reporting and a nice repro! :-)

[ilevkivskyi]

It looks like this is not because of the fact that methods are generic. I fixed the problem with generics in #6720, but this issue still persists. The cause is that multiple inheritance check verifies compatibility of different method definitions in different base classes, not compatibility between bases.

I am not even sure there is any actual unsafety in this example (i.e. something that mypy doesn't catch but can cause a runtime error), because there is only one actual method definition. Maybe I am missing something, could you please provide a more extensive example showing that there is some unsafety (using the current master)?

[ilevkivskyi]

(Mostly note to self)

I am not even sure there is any actual unsafety in this example

There is no additional check needed for the method definition, but we do need to check consistency between different paths returned by map_instance_to_supertypes() in case of diamond inheritance like above the type arguments of the mapped instance may be different for different paths, which is unsafe.

[KotlinIsland]

Another example:

from typing import Generic, TypeVar

T = TypeVar("T")

class A(Generic[T]): 
    a: T

class B(A[float], A[int])  # error

class C(A[float]):
    pass 

class D(C, A[int]):  # no error
    pass

d = D()
d.a = 1.1  # What the heck?
c: C = d  # fishy
c.a = 1.1

[Lancetnik]

I would like to fix it after #18270 merge

[sobolevn]

@Lancetnik wouldn't it be fixed by #18270?
See https://github.com/python/mypy/pull/18270/files#diff-6a712ae6fdcaa321e5fce6f0867be4ec2db8ffa014dc1c4c50720521b2ae6d61R1085 as the test example of a case similar to #6184 (comment)

[Lancetnik]

@sobolevn don't think so - the root problem of current Issue is in method signature, not attributes. #18270 fixes only attributes resolution in this branch of compatibility checker, but we should fix the another branch as well

[Lancetnik]

Well, probably, this Issue is fixing by #18270 indeed, but we should fix the another branch as well 🤔
I will try to find testcase for this checker branch

[sterliakov]

@sobolevn nope, it won't be fixed by my PR: #18270 only adjusts the checks for non-overridden methods. It changes how the bases are compared, but not how overrides are checked. The second example is not equivalent to the original issue. The OP can be reduced to

from typing import Generic, TypeVar

A = TypeVar('A')


class Base(Generic[A]):
    def do_stuff(self, a: A) -> None: ...

class Foo(Base[A]): ...
class Bar(Base[A]): ...

class Baz(Foo[str], Bar[str | int]):
    def do_stuff(self, a: str) -> None: ...

which should still pass (but should fail) on my branch - do_stuff is overridden. We can't reject such code while comparing bases as the following is safe:

class BetterBaz(Foo[str], Bar[str | int]):
    def do_stuff(self, a: str | int) -> None: ...