backport python#6655 and python#7446 to v0.660

1. limit the version of the test deps in test-requirements.txt by release data (i.e. Jan 16 2019, when v0.660 was released)
2. ./runtests.py and all tests pass
3. add tests from python#6655 and python#7446 and ./runtests.py and new test cases fail
4. apply changes from python#6655 and python#7446 manually
5. run tests and all pass

Author: nanshu

mypy/checker.py

@@ -3465,12 +3465,12 @@ def check_subtype(self, subtype: Type, supertype: Type, context: Context,
                     isinstance(subtype, (Instance, TupleType, TypedDictType))):
                 self.msg.report_protocol_problems(subtype, supertype, context)
             if isinstance(supertype, CallableType) and isinstance(subtype, Instance):
-                call = find_member('__call__', subtype, subtype)
+                call = find_member('__call__', subtype, subtype, is_operator=True)
                 if call:
                     self.msg.note_call(subtype, call, context)
             if isinstance(subtype, (CallableType, Overloaded)) and isinstance(supertype, Instance):
                 if supertype.type.is_protocol and supertype.type.protocol_members == ['__call__']:
-                    call = find_member('__call__', supertype, subtype)
+                    call = find_member('__call__', supertype, subtype, is_operator=True)
                     assert call is not None
                     self.msg.note_call(supertype, call, context)
             return False

mypy/checkexpr.py

@@ -701,8 +701,8 @@ def check_call(self,
         elif isinstance(callee, UnionType):
             return self.check_union_call(callee, args, arg_kinds, arg_names, context, arg_messages)
         elif isinstance(callee, Instance):
-            call_function = analyze_member_access('__call__', callee, context,
-                                                  False, False, False, self.msg,
+            call_function = analyze_member_access('__call__', callee, context, is_lvalue=False,
+                                                  is_super=False, is_operator=True, msg=self.msg,
                                                   original_type=callee, chk=self.chk,
                                                   in_literal_context=self.is_literal_context())
             return self.check_call(call_function, args, arg_kinds, context, arg_names,
@@ -1264,7 +1264,8 @@ def check_arg(self, caller_type: Type, original_caller_type: Type,
                 self.msg.report_protocol_problems(original_caller_type, callee_type, context)
             if (isinstance(callee_type, CallableType) and
                     isinstance(original_caller_type, Instance)):
-                call = find_member('__call__', original_caller_type, original_caller_type)
+                call = find_member('__call__', original_caller_type, original_caller_type,
+                                   is_operator=True)
                 if call:
                     self.msg.note_call(original_caller_type, call, context)
 

mypy/checkmember.py

@@ -326,7 +326,8 @@ def analyze_member_var_access(name: str,
         return analyze_var(name, v, itype, info, mx, implicit=implicit)
     elif isinstance(v, FuncDef):
         assert False, "Did not expect a function"
-    elif not v and name not in ['__getattr__', '__setattr__', '__getattribute__']:
+    elif (not v and name not in ['__getattr__', '__setattr__', '__getattribute__'] and
+          not mx.is_operator):
         if not mx.is_lvalue:
             for method_name in ('__getattribute__', '__getattr__'):
                 method = info.get_method(method_name)

mypy/constraints.py

@@ -284,7 +284,8 @@ def visit_instance(self, template: Instance) -> List[Constraint]:
                 # Special case: a generic callback protocol
                 if not any(is_same_type(template, t) for t in template.type.inferring):
                     template.type.inferring.append(template)
-                    call = mypy.subtypes.find_member('__call__', template, actual)
+                    call = mypy.subtypes.find_member('__call__', template, actual,
+                                                     is_operator=True)
                     assert call is not None
                     if mypy.subtypes.is_subtype(actual, erase_typevars(call)):
                         subres = infer_constraints(call, actual, self.direction)
@@ -425,7 +426,8 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
         elif isinstance(self.actual, Instance):
             # Instances with __call__ method defined are considered structural
             # subtypes of Callable with a compatible signature.
-            call = mypy.subtypes.find_member('__call__', self.actual, self.actual)
+            call = mypy.subtypes.find_member('__call__', self.actual, self.actual,
+                                             is_operator=True)
             if call:
                 return infer_constraints(template, call, self.direction)
             else:

mypy/join.py

@@ -462,5 +462,5 @@ def join_type_list(types: List[Type]) -> Type:
 def unpack_callback_protocol(t: Instance) -> Optional[Type]:
     assert t.type.is_protocol
     if t.type.protocol_members == ['__call__']:
-        return find_member('__call__', t, t)
+        return find_member('__call__', t, t, is_operator=True)
     return None

mypy/subtypes.py

@@ -230,7 +230,7 @@ def visit_instance(self, left: Instance) -> bool:
                     return is_named_instance(item, 'builtins.object')
         if isinstance(right, CallableType):
             # Special case: Instance can be a subtype of Callable.
-            call = find_member('__call__', left, left)
+            call = find_member('__call__', left, left, is_operator=True)
             if call:
                 return self._is_subtype(call, right)
             return False
@@ -258,7 +258,7 @@ def visit_callable_type(self, left: CallableType) -> bool:
             if right.type.is_protocol and right.type.protocol_members == ['__call__']:
                 # OK, a callable can implement a protocol with a single `__call__` member.
                 # TODO: we should probably explicitly exclude self-types in this case.
-                call = find_member('__call__', right, left)
+                call = find_member('__call__', right, left, is_operator=True)
                 assert call is not None
                 if self._is_subtype(left, call):
                     return True
@@ -337,7 +337,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
         if isinstance(right, Instance):
             if right.type.is_protocol and right.type.protocol_members == ['__call__']:
                 # same as for CallableType
-                call = find_member('__call__', right, left)
+                call = find_member('__call__', right, left, is_operator=True)
                 assert call is not None
                 if self._is_subtype(left, call):
                     return True
@@ -512,7 +512,10 @@ def f(self) -> A: ...
     return True
 
 
-def find_member(name: str, itype: Instance, subtype: Type) -> Optional[Type]:
+def find_member(name: str,
+                itype: Instance,
+                subtype: Type,
+                is_operator: bool = False) -> Optional[Type]:
     """Find the type of member by 'name' in 'itype's TypeInfo.
 
     Fin the member type after applying type arguments from 'itype', and binding
@@ -540,7 +543,8 @@ def find_member(name: str, itype: Instance, subtype: Type) -> Optional[Type]:
             v = v.var
         if isinstance(v, Var):
             return find_node_type(v, itype, subtype)
-        if not v and name not in ['__getattr__', '__setattr__', '__getattribute__']:
+        if (not v and name not in ['__getattr__', '__setattr__', '__getattribute__'] and
+                not is_operator):
             for method_name in ('__getattribute__', '__getattr__'):
                 # Normally, mypy assumes that instances that define __getattr__ have all
                 # attributes with the corresponding return type. If this will produce
@@ -1109,7 +1113,7 @@ def check_argument(leftarg: Type, rightarg: Type, variance: int) -> bool:
                 return True
             return False
         if isinstance(right, CallableType):
-            call = find_member('__call__', left, left)
+            call = find_member('__call__', left, left, is_operator=True)
             if call:
                 return self._is_proper_subtype(call, right)
             return False

test-data/unit/check-classes.test

@@ -2493,6 +2493,44 @@ b = a.bar
 [out]
 main:9: error: Incompatible types in assignment (expression has type "A", variable has type "B")
 
+[case testGetattrWithCallable]
+from typing import Callable, Any
+
+class C:
+    def __getattr__(self, attr: str) -> C: ...
+
+def do(cd: Callable[..., Any]) -> None: ...
+
+do(C())  # E: Argument 1 to "do" has incompatible type "C"; expected "Callable[..., Any]"
+
+[case testGetattrWithCallableTypeVar]
+from typing import Callable, Any, TypeVar
+
+class C:
+    def __getattr__(self, attr: str) -> C: ...
+
+T = TypeVar('T', bound=Callable[..., Any])
+
+def do(cd: T) -> T: ...
+
+do(C())  # E: Value of type variable "T" of "do" cannot be "C"
+
+[case testGetattrWithGetitem]
+class A:
+    def __getattr__(self, x: str) -> 'A':
+        return A()
+
+a = A()
+a[0]  # E: Value of type "A" is not indexable
+
+[case testGetattrWithCall]
+class A:
+    def __getattr__(self, x: str) -> 'A':
+        return A()
+
+a = A()
+a.y()  # E: "A" not callable
+
 [case testNestedGetattr]
 def foo() -> object:
     def __getattr__() -> None:  # no error because not in a class

test-requirements.txt

@@ -1,13 +1,13 @@
-attrs>=18.0
-flake8
-flake8-bugbear; python_version >= '3.5'
-flake8-pyi; python_version >= '3.6'
+attrs>=18.0,<=18.2.0
+flake8<=3.6.0
+flake8-bugbear<=18.8.0; python_version >= '3.5'
+flake8-pyi<=18.3.1; python_version >= '3.6'
 lxml==4.2.4
 mypy_extensions==0.4.0
 psutil==5.4.0
-pytest>=3.4
-pytest-xdist>=1.22
-pytest-cov>=2.4.0
+pytest>=3.4,<=4.1.1
+pytest-xdist>=1.22,<=1.26.0
+pytest-cov>=2.4.0,<=2.6.1
 typed-ast>=1.2.0,<1.3.0
 typing>=3.5.2; python_version < '3.5'
 py>=1.5.2