Fix type inference problem with overloaded functions

Fixes #496.

Author: JukkaL

mypy/constraints.py

@@ -9,6 +9,7 @@
 from mypy.expandtype import expand_caller_var_args
 from mypy.maptype import map_instance_to_supertype
 from mypy import nodes
+import mypy.subtypes
 
 
 SUBTYPE_OF = 0  # type: int
@@ -234,7 +235,7 @@ def infer_against_overloaded(self, overloaded: Overloaded,
         # the first overload item, and by only matching the return type. This
         # seems to work somewhat well, but we should really use a more
         # reliable technique.
-        item = overloaded.items()[0]
+        item = find_matching_overload_item(overloaded, template)
         return infer_constraints(template.ret_type, item.ret_type,
                                  self.direction)
 
@@ -282,3 +283,16 @@ def neg_op(op: int) -> int:
         return SUBTYPE_OF
     else:
         raise ValueError('Invalid operator {}'.format(op))
+
+
+def find_matching_overload_item(overloaded: Overloaded, template: Callable) -> Callable:
+    """Disambiguate overload item against a template."""
+    items = overloaded.items()
+    for item in items:
+        # Return type may be indeterminate in the template, so ignore it when performing a
+        # subtype check.
+        if mypy.subtypes.is_callable_subtype(item, template, ignore_return=True):
+            return item
+    # Fall back to the first item if we can't find a match. This is totally arbitrary --
+    # maybe we should just bail out at this point.
+    return items[0]

mypy/subtypes.py

@@ -160,7 +160,7 @@ def visit_overloaded(self, left: Overloaded) -> bool:
             return False
 
 
-def is_callable_subtype(left: Callable, right: Callable) -> bool:
+def is_callable_subtype(left: Callable, right: Callable, 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.
@@ -176,7 +176,7 @@ def is_callable_subtype(left: Callable, right: Callable) -> bool:
             return False
 
     # Check return types.
-    if not is_subtype(left.ret_type, right.ret_type):
+    if not ignore_return and not is_subtype(left.ret_type, right.ret_type):
         return False
 
     # Check argument types.

mypy/test/data/check-typevar-values.test

@@ -463,3 +463,25 @@ from typing import typevar, Generic
 T = typevar('T', values=(int, str))
 class C(Generic[T]):
     def f(self, x: int = None) -> None: pass
+
+[case testTypevarValuesWithOverloadedFunctionSpecialCase]
+from typing import typevar, overload, Function
+
+T = typevar('T', values=(int, str))
+def f(x: T) -> None:
+     y = m(g, x)
+     x = y
+     y = object()
+
+A = typevar('A')
+R = typevar('R')
+def m(f: Function[[A], R], it: A) -> A: pass
+
+@overload
+def g(x: int) -> int: return x
+@overload
+def g(x: str) -> str: return x
+[out]
+main: In function "f":
+main, line 7: Incompatible types in assignment (expression has type "object", variable has type "int")
+main, line 7: Incompatible types in assignment (expression has type "object", variable has type "str")