Fix subtyping of Callable[..., t] types

Author: JukkaL

mypy/constraints.py

@@ -214,7 +214,7 @@ def visit_callable_type(self, template: CallableType) -> List[Constraint]:
 
             # We can't infer constraints from arguments if the template is Callable[..., T] (with
             # literal '...').
-            if not template.is_ellipsis_args():
+            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(

mypy/messages.py

@@ -142,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.is_ellipsis_args():
+                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/subtypes.py

@@ -163,7 +163,8 @@ def visit_union_type(self, left: UnionType) -> bool:
         return all(is_subtype(item, self.right) for item in left.items)
 
 
-def is_callable_subtype(left: CallableType, right: CallableType, ignore_return: bool = False) -> bool:
+def is_callable_subtype(left: CallableType, right: CallableType,
+                        ignore_return: bool = False) -> bool:
     """Is left a subtype of right?"""
     # TODO: Support named arguments, **args, etc.
     # Non-type cannot be a subtype of type.
@@ -182,6 +183,9 @@ def is_callable_subtype(left: CallableType, right: CallableType, ignore_return:
     if not ignore_return and not is_subtype(left.ret_type, right.ret_type):
         return False
 
+    if right.is_ellipsis_args:
+        return True
+
     # Check argument types.
     if left.min_args > right.min_args:
         return False

mypy/test/data/check-functions.test

@@ -811,3 +811,26 @@ def g(*x: int) -> str: pass
 x = f(g)
 x + 1 # E: Unsupported left operand type for + ("str")
 [builtins fixtures/list.py]
+
+[case testCallableWithArbitraryArgsSubtyping]
+from typing import Callable
+def f(x: Callable[..., int]) -> None: pass
+def g1(): pass
+def g2(x, y) -> int: pass
+def g3(*, y: str) -> int: pass
+def g4(*, y: int) -> str: pass
+f(g1)
+f(g2)
+f(g3)
+f(g4) # E: Argument 1 to "f" has incompatible type Callable[..., str]; expected Callable[..., int]
+
+[case testCallableWithArbitraryArgsSubtypingWithGenericFunc]
+from typing import Callable, TypeVar
+T = TypeVar('T')
+def f(x: Callable[..., int]) -> None: pass
+def g1(x: T) -> int: pass
+def g2(*x: T) -> int: pass
+def g3(*x: T) -> T: pass
+f(g1)
+f(g2)
+f(g3)

mypy/typeanal.py

@@ -198,7 +198,8 @@ def analyze_callable_type(self, t: UnboundType) -> Type:
                                 [nodes.ARG_STAR, nodes.ARG_STAR2],
                                 [None, None],
                                 ret_type=ret_type,
-                                fallback=fallback)
+                                fallback=fallback,
+                                is_ellipsis_args=True)
         else:
             self.fail('Invalid function type', t)
             return AnyType()

mypy/types.py

@@ -246,15 +246,18 @@ class CallableType(FunctionLike):
     # Stored as tuples (id, type).
     bound_vars = None  # type: List[Tuple[int, Type]]
 
-    _is_type_obj = False  # Does this represent a type object?
+    # Is this Callable[..., t] (with literal '...')?
+    is_ellipsis_args = False
 
     def __init__(self, arg_types: List[Type],
                  arg_kinds: List[int],
                  arg_names: List[str],
                  ret_type: Type,
                  fallback: Instance,
-                 name: str = None, variables: List[TypeVarDef] = None,
+                 name: str = None,
+                 variables: List[TypeVarDef] = None,
                  bound_vars: List[Tuple[int, Type]] = None,
+                 is_ellipsis_args: bool = False,
                  line: int = -1) -> None:
         if variables is None:
             variables = []
@@ -271,6 +274,7 @@ def __init__(self, arg_types: List[Type],
         self.name = name
         self.variables = variables
         self.bound_vars = bound_vars
+        self.is_ellipsis_args = is_ellipsis_args
         super().__init__(line)
 
     def is_type_obj(self) -> bool:
@@ -313,9 +317,6 @@ 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: