Fix generic functions with Callable[..., T]

Author: JukkaL

mypy/constraints.py

@@ -211,11 +211,15 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
             # FIX verify argument counts
             # FIX what if one of the functions is generic
             res = []  # type: List[Constraint]
-            for i in range(len(template.arg_types)):
-                # Negate constraints due function argument type contravariance.
-                res.extend(negate_constraints(infer_constraints(
-                    template.arg_types[i], cactual.arg_types[i],
-                    self.direction)))
+
+            # We can't infer constraints from arguments if the template is Callable[..., T] (with
+            # literal '...').
+            if not template.is_ellipsis_args():
+                for i in range(len(template.arg_types)):
+                    # Negate constraints due function argument type contravariance.
+                    res.extend(negate_constraints(infer_constraints(
+                        template.arg_types[i], cactual.arg_types[i],
+                        self.direction)))
             res.extend(infer_constraints(template.ret_type, cactual.ret_type,
                                          self.direction))
             return res

mypy/messages.py

@@ -12,9 +12,7 @@
     Type, CallableType, Instance, TypeVarType, TupleType, UnionType, Void, NoneTyp, AnyType,
     Overloaded, FunctionLike
 )
-from mypy.nodes import (
-    TypeInfo, Context, op_methods, FuncDef, reverse_type_aliases, ARG_STAR, ARG_STAR2
-)
+from mypy.nodes import TypeInfo, Context, op_methods, FuncDef, reverse_type_aliases
 
 
 # Constants that represent simple type checker error message, i.e. messages
@@ -144,7 +142,7 @@ def format(self, typ: Type, verbose: bool = False) -> str:
                 return result
             elif isinstance(func, CallableType):
                 return_type = strip_quotes(self.format(func.ret_type))
-                if func.arg_kinds == [ARG_STAR, ARG_STAR2]:
+                if func.is_ellipsis_args():
                     return 'Callable[..., {}]'.format(return_type)
                 arg_types = [strip_quotes(self.format(t)) for t in func.arg_types]
                 return 'Callable[[{}], {}]'.format(", ".join(arg_types), return_type)

mypy/test/data/check-functions.test

@@ -802,3 +802,12 @@ def f(x: Callable[..., int]) -> None:
     x = 1  # E: Incompatible types in assignment (expression has type "int", variable has type Callable[..., int])
 [out]
 main: In function "f":
+
+[case testCallableWithArbitraryArgsInGenericFunction]
+from typing import Callable, TypeVar
+T = TypeVar('T')
+def f(x: Callable[..., T]) -> T: pass
+def g(*x: int) -> str: pass
+x = f(g)
+x + 1 # E: Unsupported left operand type for + ("str")
+[builtins fixtures/list.py]

mypy/types.py

@@ -313,6 +313,9 @@ def items(self) -> List['CallableType']:
     def is_generic(self) -> bool:
         return bool(self.variables)
 
+    def is_ellipsis_args(self) -> bool:
+        return self.arg_kinds == [mypy.nodes.ARG_STAR, mypy.nodes.ARG_STAR2]
+
     def type_var_ids(self) -> List[int]:
         a = []  # type: List[int]
         for tv in self.variables: