Generate correct constraints for Union[...] :> t

The old code generated a conjunction, where we wanted a disjunction.
Since we can't represent or solve a disjunction of constraints, need
to approximate. Addresses part of #1241.

Author: rwbarton

mypy/constraints.py

@@ -10,6 +10,7 @@
 from mypy.maptype import map_instance_to_supertype
 from mypy import nodes
 import mypy.subtypes
+from mypy.erasetype import erase_typevars
 
 
 SUBTYPE_OF = 0  # type: int
@@ -272,10 +273,35 @@ def visit_tuple_type(self, template: TupleType) -> List[Constraint]:
             return []
 
     def visit_union_type(self, template: UnionType) -> List[Constraint]:
-        res = []  # type: List[Constraint]
-        for item in template.items:
-            res.extend(infer_constraints(item, self.actual, self.direction))
-        return res
+        if self.direction == SUBTYPE_OF:
+            # A union is a subtype of T if all the items are subtypes of T.
+            res = []  # type: List[Constraint]
+            for item in template.items:
+                res.extend(infer_constraints(item, self.actual, self.direction))
+            return res
+        else:
+            # A union is a supertype of T if some item is a supertype
+            # of T.  We would like to take the disjunction of the
+            # constraints for the items, but we can't represent
+            # that. So we need to approximate.
+
+            # First, throw away any items of the union that definitely
+            # can't be a supertype of T. (Note that using
+            # erase_typevars here is slightly conservative--it loses
+            # information about repeated instances of a single type
+            # variable.)
+            candidates = [item for item in template.items
+                          if mypy.subtypes.is_subtype(self.actual, erase_typevars(item))]
+            # If there's just one item left, then use it.
+            if len(candidates) == 1:
+                return infer_constraints(candidates[0], self.actual, self.direction)
+
+            # Otherwise, give up and don't deduce any constraints.
+            # TODO: If there are multiple candidates, but they all require
+            # the same constraint on the same variable, we could return
+            # that constraint. Or more generally, combine bounds for a given
+            # variable and direction with meet/join.
+            return []
 
     def infer_against_any(self, types: List[Type]) -> List[Constraint]:
         res = []  # type: List[Constraint]

mypy/test/data/check-inference.test

@@ -690,6 +690,60 @@ l = lb # E: Incompatible types in assignment (expression has type List[bool], va
 [builtins fixtures/for.py]
 
 
+-- Generic function inference with unions
+-- --------------------------------------
+
+
+[case testUnionInference]
+from typing import TypeVar, Union, List
+T = TypeVar('T')
+U = TypeVar('U')
+def f(x: Union[T, int], y: T) -> T: pass
+f(1, 'a')() # E: "str" not callable
+f('a', 1)() # E: "object" not callable
+
+def g(x: Union[T, List[T]]) -> List[T]: pass
+def h(x: List[str]) -> None: pass
+g('a')() # E: List[str] not callable
+g(['a']) # E: Argument 1 to "g" has incompatible type List[str]; expected "Union[None, List[None]]"
+h(g(['a']))
+
+def i(x: Union[List[T], List[U]], y: List[T], z: List[U]) -> None: pass
+a = [1]
+b = ['b']
+i(a, a, b)
+i(b, a, b)
+i(a, b, b) # E: Argument 1 to "i" has incompatible type List[int]; expected "Union[List[str], List[str]]"
+[builtins fixtures/list.py]
+
+
+[case testUnionInferenceWithTypeVarValues]
+from typing import TypeVar, Union
+AnyStr = TypeVar('AnyStr', bytes, str)
+def f(x: Union[AnyStr, int], *a: AnyStr) -> None: pass
+f('foo')
+f('foo', 'bar')
+f('foo', b'bar') # E: Type argument 1 of "f" has incompatible value "object"
+f(1)
+f(1, 'foo')
+f(1, 'foo', b'bar') # E: Type argument 1 of "f" has incompatible value "object"
+[builtins fixtures/primitives.py]
+
+
+[case testUnionTwoPassInference-skip]
+from typing import TypeVar, Union
+T = TypeVar('T')
+U = TypeVar('U')
+def j(x: Union[List[T], List[U]], y: List[T]) -> List[U]: pass
+
+a = [1]
+b = ['b']
+# We could infer: Since List[str] <: List[T], we must have T = str.
+# Then since List[int] <: Union[List[str], List[U]], and List[int] is
+# not a subtype of List[str], we must have U = int.
+j(a, b)
+
+
 -- Literal expressions
 -- -------------------