Fix handling of non-method callable attribute

mypy/checker.py

@@ -782,8 +782,9 @@ def check_reverse_op_method(self, defn: FuncItem, typ: CallableType,
             # TODO check self argument kind
 
             # Check for the issue described above.
-            arg_type = typ.arg_types[1]
             other_method = nodes.normal_from_reverse_op[method]
+            arg_type = typ.arg_types[1]
+            arg_types = [arg_type]
             if isinstance(arg_type, Instance):
                 if not arg_type.type.has_readable_member(other_method):
                     return
@@ -792,15 +793,17 @@ def check_reverse_op_method(self, defn: FuncItem, typ: CallableType,
             elif isinstance(arg_type, UnionType):
                 if not arg_type.has_readable_member(other_method):
                     return
+                arg_types = list(arg_type.iter_deep())
             else:
                 return
-
-            typ2 = self.expr_checker.analyze_external_member_access(
-                other_method, arg_type, defn)
-            self.check_overlapping_op_methods(
-                typ, method, defn.info,
-                typ2, other_method, cast(Instance, arg_type),
-                defn)
+            # We check that each method is fine when dispatched on a proper self argument
+            for arg_type in arg_types:
+                typ2 = self.expr_checker.analyze_external_member_access(
+                    other_method, arg_type, defn)
+                self.check_overlapping_op_methods(
+                    typ, method, defn.info,
+                    typ2, other_method, cast(Instance, arg_type),
+                    defn)
 
     def check_overlapping_op_methods(self,
                                      reverse_type: CallableType,

mypy/checkmember.py

@@ -286,7 +286,7 @@ def analyze_var(name: str, var: Var, itype: Instance, info: TypeInfo, node: Cont
                 # methods: the former to the instance, the latter to the
                 # class.
                 functype = t
-                check_method_type(functype, itype, var.is_classmethod, node, msg)
+                check_method_type(functype, original_type, var.is_classmethod, node, msg)
                 signature = bind_self(functype, original_type)
                 if var.is_property:
                     # A property cannot have an overloaded type => the cast
@@ -338,33 +338,23 @@ def lookup_member_var_or_accessor(info: TypeInfo, name: str,
         return None
 
 
-def check_method_type(functype: FunctionLike, itype: Instance, is_classmethod: bool,
+def check_method_type(functype: FunctionLike, original_type: Type, is_classmethod: bool,
                       context: Context, msg: MessageBuilder) -> None:
     for item in functype.items():
         if not item.arg_types or item.arg_kinds[0] not in (ARG_POS, ARG_STAR):
             # No positional first (self) argument (*args is okay).
-            msg.invalid_method_type(item, context)
-        elif not is_classmethod:
-            # Check that self argument has type 'Any' or valid instance type.
-            selfarg = item.arg_types[0]
-            # If this is a method of a tuple class, correct for the fact that
-            # we passed to typ.fallback in analyze_member_access. See #1432.
-            if isinstance(selfarg, TupleType):
-                selfarg = selfarg.fallback
-            if not subtypes.is_subtype(selfarg, itype):
-                msg.invalid_method_type(item, context)
+            msg.fail('Attribute function of type %s does not accept self argument'
+                     % msg.format(item), context)
         else:
-            # Check that cls argument has type 'Any' or valid class type.
+            # Check that self argument has type 'Any' or valid instance/class type.
+            selfarg = item.arg_types[0]
             # (This is sufficient for the current treatment of @classmethod,
             # but probably needs to be revisited when we implement Type[C]
             # or advanced variants of it like Type[<args>, C].)
-            clsarg = item.arg_types[0]
-            if isinstance(clsarg, CallableType) and clsarg.is_type_obj():
-                if not subtypes.is_equivalent(clsarg.ret_type, itype):
-                    msg.invalid_class_method_type(item, context)
-            else:
-                if not subtypes.is_equivalent(clsarg, AnyType()):
-                    msg.invalid_class_method_type(item, context)
+            if is_classmethod:
+                original_type = TypeType(original_type)
+            if not subtypes.is_subtype(original_type, erase_to_bound(selfarg)):
+                msg.invalid_method_type(original_type, item, is_classmethod, context)
 
 
 def analyze_class_attribute_access(itype: Instance,

mypy/messages.py

@@ -768,11 +768,11 @@ def cannot_determine_type(self, name: str, context: Context) -> None:
     def cannot_determine_type_in_base(self, name: str, base: str, context: Context) -> None:
         self.fail("Cannot determine type of '%s' in base class '%s'" % (name, base), context)
 
-    def invalid_method_type(self, sig: CallableType, context: Context) -> None:
-        self.fail('Invalid method type', context)
-
-    def invalid_class_method_type(self, sig: CallableType, context: Context) -> None:
-        self.fail('Invalid class method type', context)
+    def invalid_method_type(self, arg: Type, sig: CallableType, is_classmethod: bool,
+                            context: Context) -> None:
+        kind = 'class attribute function' if is_classmethod else 'attribute function'
+        self.fail('Invalid self argument %s to %s %s'
+                  % (self.format(arg), kind, self.format(sig)), context)
 
     def incompatible_conditional_function_def(self, defn: FuncDef) -> None:
         self.fail('All conditional function variants must have identical '

mypy/types.py

@@ -5,7 +5,7 @@
 from collections import OrderedDict
 from typing import (
     Any, TypeVar, Dict, List, Tuple, cast, Generic, Set, Sequence, Optional, Union, Iterable,
-    NamedTuple, Callable,
+    NamedTuple, Callable, Iterator,
 )
 
 import mypy.nodes
@@ -1062,6 +1062,13 @@ def has_readable_member(self, name: str) -> bool:
                    (isinstance(x, Instance) and x.type.has_readable_member(name))
                    for x in self.items)
 
+    def iter_deep(self) -> Iterator[Type]:
+        for x in self.items:
+            if isinstance(x, UnionType):
+                yield from x.iter_deep()
+            else:
+                yield x
+
     def serialize(self) -> JsonDict:
         return {'.class': 'UnionType',
                 'items': [t.serialize() for t in self.items],

test-data/unit/check-classes.test

@@ -1844,7 +1844,7 @@ class B:
     a = A
     bad = lambda: 42
 
-B().bad() # E: Invalid method type
+B().bad() # E: Attribute function of type Callable[[], int] does not accept self argument
 reveal_type(B.a) # E: Revealed type is 'def () -> __main__.A'
 reveal_type(B().a) # E: Revealed type is 'def () -> __main__.A'
 reveal_type(B().a()) # E: Revealed type is '__main__.A'

test-data/unit/check-functions.test

@@ -469,8 +469,8 @@ class A:
     f = x # type: Callable[[], None]
     g = x # type: Callable[[B], None]
 a = None # type: A
-a.f() # E: Invalid method type
-a.g() # E: Invalid method type
+a.f() # E: Attribute function of type Callable[[], None] does not accept self argument
+a.g() # E: Invalid self argument "A" to attribute function Callable[[B], None]
 
 [case testMethodWithDynamicallyTypedMethodAsDataAttribute]
 from typing import Any, Callable
@@ -530,7 +530,7 @@ class A(Generic[t]):
 ab = None # type: A[B]
 ac = None # type: A[C]
 ab.f()
-ac.f()   # E: Invalid method type
+ac.f()   # E: Invalid self argument A[C] to attribute function Callable[[A[B]], None]
 
 [case testPartiallyTypedSelfInMethodDataAttribute]
 from typing import Any, TypeVar, Generic, Callable

test-data/unit/check-selftype.test

@@ -342,9 +342,12 @@ class E:
 [case testSelfTypeProperty]
 from typing import TypeVar
 
-T = TypeVar('T', bound='A')
+T = TypeVar('T', bound='X')
 
-class A:
+class X:
+    pass
+
+class A(X):
     @property
     def member(self: T) -> T:
         pass