Update error message for incompatible args (#6796)

Closes #5025

Updated the error message that is displayed when the argument types of a method in a subclass are incompatible with the arguments of the same method in the superclass.

```python
# sample.py

class A:

    def kek(self, lol: int = 0) -> None:
        print("Kek in A")


class B(A):

    def kek(self, haha: str = "") -> None:
        super().kek(1)
        print("Kek in B")
```

Output before:
```sh
mypy sample.py
sample.py:11: error: Argument 1 of "kek" incompatible with supertype "A"
```

Output now:
```
mypy sample.py
sample.py:11: error: Argument 1 of "kek" is incompatible with supertype "A"; supertype defines the argument type as "int"
```

Author: matys18

mypy/checker.py

@@ -1534,8 +1534,16 @@ def erase_override(t: Type) -> Type:
                 for i in range(len(override.arg_types)):
                     if not is_subtype(original.arg_types[i],
                                       erase_override(override.arg_types[i])):
+                        arg_type_in_super = original.arg_types[i]
                         self.msg.argument_incompatible_with_supertype(
-                            i + 1, name, type_name, name_in_super, supertype, node)
+                            i + 1,
+                            name,
+                            type_name,
+                            name_in_super,
+                            arg_type_in_super,
+                            supertype,
+                            node
+                        )
                         emitted_msg = True
 
                 if not is_subtype(erase_override(override.ret_type),

mypy/messages.py

@@ -799,10 +799,13 @@ def signature_incompatible_with_supertype(
 
     def argument_incompatible_with_supertype(
             self, arg_num: int, name: str, type_name: Optional[str],
-            name_in_supertype: str, supertype: str, context: Context) -> None:
+            name_in_supertype: str, arg_type_in_supertype: Type, supertype: str,
+            context: Context) -> None:
         target = self.override_target(name, name_in_supertype, supertype)
-        self.fail('Argument {} of "{}" incompatible with {}'
-                  .format(arg_num, name, target), context)
+        arg_type_in_supertype_f = self.format_bare(arg_type_in_supertype)
+        self.fail('Argument {} of "{}" is incompatible with {}; '
+                  'supertype defines the argument type as "{}"'
+                  .format(arg_num, name, target, arg_type_in_supertype_f), context)
 
         if name == "__eq__" and type_name:
             multiline_msg = self.comparison_method_example_msg(class_name=type_name)

test-data/unit/check-abstract.test

@@ -308,7 +308,7 @@ class A(metaclass=ABCMeta):
     def g(self, x: int) -> int: pass
 class B(A):
     def f(self, x: str) -> int: \
-            # E: Argument 1 of "f" incompatible with supertype "A"
+            # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int"
         pass
     def g(self, x: int) -> int: pass
 [out]
@@ -324,7 +324,7 @@ class J(metaclass=ABCMeta):
     def g(self, x: str) -> str: pass
 class A(I, J):
     def f(self, x: str) -> int: pass \
-        # E: Argument 1 of "f" incompatible with supertype "I"
+        # E: Argument 1 of "f" is incompatible with supertype "I"; supertype defines the argument type as "int"
     def g(self, x: str) -> int: pass \
         # E: Return type of "g" incompatible with supertype "J"
     def h(self) -> int: pass # Not related to any base class
@@ -339,7 +339,7 @@ class J(metaclass=ABCMeta):
 class I(J): pass
 class A(I):
     def f(self, x: str) -> int: pass \
-        # E: Argument 1 of "f" incompatible with supertype "J"
+        # E: Argument 1 of "f" is incompatible with supertype "J"; supertype defines the argument type as "int"
 [out]
 
 [case testInvalidOverridingAbstractMethod]
@@ -350,7 +350,7 @@ class J(metaclass=ABCMeta):
     def f(self, x: 'J') -> None: pass
 class I(J):
     @abstractmethod
-    def f(self, x: 'I') -> None: pass # E: Argument 1 of "f" incompatible with supertype "J"
+    def f(self, x: 'I') -> None: pass # E: Argument 1 of "f" is incompatible with supertype "J"; supertype defines the argument type as "J"
 [out]
 
 [case testAbstractClassCoAndContraVariance]
@@ -371,7 +371,7 @@ class A(I):
     def g(self, a: 'A') -> 'A':
         pass
 [out]
-main:11: error: Argument 1 of "h" incompatible with supertype "I"
+main:11: error: Argument 1 of "h" is incompatible with supertype "I"; supertype defines the argument type as "I"
 main:11: error: Return type of "h" incompatible with supertype "I"
 
 

test-data/unit/check-classes.test

@@ -280,15 +280,15 @@ class B(A):
   def g(self, x: A, y: A) -> A: pass
   def h(self, x: A, y: 'B') -> object: pass  # Fail
 [out]
-main:7: error: Argument 1 of "f" incompatible with supertype "A"
+main:7: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "A"
 main:9: error: Return type of "h" incompatible with supertype "A"
 
 [case testEqMethodsOverridingWithNonObjects]
 class A:
   def __eq__(self, other: A) -> bool: pass  # Fail
 [builtins fixtures/attr.pyi]
 [out]
-main:2: error: Argument 1 of "__eq__" incompatible with supertype "object"
+main:2: error: Argument 1 of "__eq__" is incompatible with supertype "object"; supertype defines the argument type as "object"
 main:2: note: It is recommended for "__eq__" to work with arbitrary objects, for example:
 main:2: note:     def __eq__(self, other: object) -> bool:
 main:2: note:         if not isinstance(other, A):
@@ -316,7 +316,7 @@ class C(B): # with gap in implementations
     def f(self, x: 'C') -> None:  # Fail
         pass
 [out]
-main:6: error: Argument 1 of "f" incompatible with supertype "A"
+main:6: error: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "B"
 
 [case testMethodOverridingAcrossDeepInheritanceHierarchy2]
 import typing
@@ -458,7 +458,7 @@ class B(A):
     @staticmethod
     def f(x: int, y: str) -> None: pass
     @staticmethod
-    def g(x: str, y: str) -> None: pass # E: Argument 1 of "g" incompatible with supertype "A"
+    def g(x: str, y: str) -> None: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int"
 [builtins fixtures/classmethod.pyi]
 
 [case testOverrideClassMethodWithClassMethod]
@@ -472,7 +472,7 @@ class B(A):
     @classmethod
     def f(cls, x: int, y: str) -> None: pass
     @classmethod
-    def g(cls, x: str, y: str) -> None: pass # E: Argument 1 of "g" incompatible with supertype "A"
+    def g(cls, x: str, y: str) -> None: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int"
 [builtins fixtures/classmethod.pyi]
 
 [case testOverrideClassMethodWithStaticMethod]
@@ -488,7 +488,7 @@ class B(A):
     @staticmethod
     def f(x: int) -> None: pass
     @staticmethod
-    def g(x: str) -> int: pass # E: Argument 1 of "g" incompatible with supertype "A"
+    def g(x: str) -> int: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "int"
     @staticmethod
     def h() -> int: pass
 [builtins fixtures/classmethod.pyi]
@@ -506,7 +506,7 @@ class B(A):
     @classmethod
     def f(cls, x: int) -> None: pass
     @classmethod
-    def g(cls, x: int) -> int: pass # E: Argument 1 of "g" incompatible with supertype "A"
+    def g(cls, x: int) -> int: pass # E: Argument 1 of "g" is incompatible with supertype "A"; supertype defines the argument type as "str"
     @classmethod
     def h(cls) -> int: pass
 [builtins fixtures/classmethod.pyi]
@@ -2452,7 +2452,7 @@ class D(A):
     def __iadd__(self, x: 'A') -> 'B': pass
 [out]
 main:6: error: Return type of "__iadd__" incompatible with "__add__" of supertype "A"
-main:8: error: Argument 1 of "__iadd__" incompatible with "__add__" of supertype "A"
+main:8: error: Argument 1 of "__iadd__" is incompatible with "__add__" of supertype "A"; supertype defines the argument type as "A"
 main:8: error: Signatures of "__iadd__" and "__add__" are incompatible
 
 [case testGetattribute]

test-data/unit/check-dynamic-typing.test

@@ -698,7 +698,7 @@ class C:
 class B(C):
     def f(self, a): pass
 class A(B):
-    def f(self, a: 'D') -> None: # E: Argument 1 of "f" incompatible with supertype "C"
+    def f(self, a: 'D') -> None: # E: Argument 1 of "f" is incompatible with supertype "C"; supertype defines the argument type as "A"
         pass
 class D: pass
 [out]

test-data/unit/check-functions.test

@@ -45,7 +45,7 @@ class A(object):
     def f(self, a: int, b: str) -> None: pass
 
 class B(A):
-    def f(self, b: str, a: int) -> None: pass # E: Argument 1 of "f" incompatible with supertype "A" # E: Argument 2 of "f" incompatible with supertype "A"
+    def f(self, b: str, a: int) -> None: pass # E: Argument 1 of "f" is incompatible with supertype "A"; supertype defines the argument type as "int" # E: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "str"
 
 class C(A):
     def f(self, foo: int, bar: str) -> None: pass

test-data/unit/check-generic-subtyping.test

@@ -186,7 +186,7 @@ class C: pass
 class D: pass
 class A(B[C]):
     def f(self, a: D) -> None: pass \
-        # E: Argument 1 of "f" incompatible with supertype "B"
+        # E: Argument 1 of "f" is incompatible with supertype "B"; supertype defines the argument type as "C"
     def g(self, a: C) -> None: pass
 [out]
 
@@ -199,7 +199,7 @@ class B:
     def g(self, a: C) -> None: pass
 class A(B, Generic[T]):
     def f(self, a: T) -> None: pass \
-        # E: Argument 1 of "f" incompatible with supertype "B"
+        # E: Argument 1 of "f" is incompatible with supertype "B"; supertype defines the argument type as "C"
     def g(self, a: 'C') -> None: pass
 [out]
 
@@ -212,7 +212,7 @@ class B(Generic[T]):
     def g(self, a: T) -> None: pass
 class A(B[S], Generic[T, S]):
     def f(self, a: T) -> None: pass \
-        # E: Argument 1 of "f" incompatible with supertype "B"
+        # E: Argument 1 of "f" is incompatible with supertype "B"; supertype defines the argument type as "S"
     def g(self, a: S) -> None: pass
 [out]
 
@@ -230,7 +230,7 @@ class C(Generic[T, U, V]):
 class B(C[D, D, T], Generic[T]): pass
 class A(B[S], Generic[T, S]):
     def f(self, a: T) -> None: pass \
-        # E: Argument 1 of "f" incompatible with supertype "C"
+        # E: Argument 1 of "f" is incompatible with supertype "C"; supertype defines the argument type as "S"
     def g(self, a: S) -> None: pass
 [out]
 
@@ -279,7 +279,7 @@ class C(A):
 class D(A):
     def f(self, x: T1, y: S) -> None: pass # TODO: This error could be more specific.
 [out]
-main:12: error: Argument 2 of "f" incompatible with supertype "A"
+main:12: error: Argument 2 of "f" is incompatible with supertype "A"; supertype defines the argument type as "S"
 main:14: error: Signature of "f" incompatible with supertype "A"
 
 
@@ -533,7 +533,7 @@ class I(Generic[T]):
     def g(self, a: T) -> None: pass
 class A(I[C]):
     def f(self, a: 'D') -> None: pass \
-        # E: Argument 1 of "f" incompatible with supertype "I"
+        # E: Argument 1 of "f" is incompatible with supertype "I"; supertype defines the argument type as "C"
     def g(self, a: 'C') -> None: pass
 class C: pass
 class D: pass
@@ -565,7 +565,7 @@ class B(I[C]):
     def g(self, a: 'C', b: Any) -> None: pass
 class A(B):
     def g(self, a: 'C', b: 'C') -> None: pass \
-        # E: Argument 2 of "g" incompatible with supertype "I"
+        # E: Argument 2 of "g" is incompatible with supertype "I"; supertype defines the argument type as "D"
     def f(self, a: 'C', b: 'C') -> None: pass
 class C: pass
 class D: pass
@@ -581,7 +581,7 @@ class B(I[C]):
     def f(self, a: 'C', b: Any) -> None: pass
 class A(B):
     def f(self, a: 'C', b: 'D') -> None: pass \
-        # E: Argument 2 of "f" incompatible with supertype "I"
+        # E: Argument 2 of "f" is incompatible with supertype "I"; supertype defines the argument type as "C"
 class C: pass
 class D: pass
 [out]

test-data/unit/check-multiple-inheritance.test

@@ -538,7 +538,7 @@ class Flag:
 class IntFlag(int, Flag):
     def __or__(self: _T, other: str) -> _T: ...
 [out]
-main:8: error: Argument 1 of "__or__" incompatible with supertype "Flag"
+main:8: error: Argument 1 of "__or__" is incompatible with supertype "Flag"; supertype defines the argument type as "IntFlag"
 
 [case testMultipleInheritance_MethodDefinitionsCompatibleNoOverride]
 from typing import TypeVar, Union