TypeVar in generic union member gets restricted to first constraint

[JelleZijlstra]

In the below:

from typing import TypeVar, Generic, Union

AnyStr = TypeVar('AnyStr', str, bytes)

class PathLike(Generic[AnyStr]):
    def __fspath__(self) -> AnyStr: ...

def readlink(s: Union[AnyStr, PathLike[AnyStr]]) -> AnyStr:
    ...

class BP(PathLike[bytes]):
    def __fspath__(self) -> bytes:
        return b''

class SP(PathLike[str]):
    def __fspath__(self) -> str:
        return ''

reveal_type(readlink(''))
reveal_type(readlink(b''))
reveal_type(readlink(BP()))  # E: Argument 1 to "readlink" has incompatible type "BP"; expected "Union[str, PathLike[str]]"
reveal_type(readlink(SP()))

I ran mypy current master with no extra options.

The second to last line should type check and the type should be bytes, but instead mypy somehow expects Union[str, PathLike[str]]. If I switch around the order of the constraints on the TypeVar, it complains about the last line instead.

The following all make the error go away:

• Changing the argument type of readlink to Union[str, PathLike[AnyStr]]
• Changing the argument type to Union[AnyStr, PathLike]
  Changing the order of the Union doesn't make a difference.

Guido found this bug in a comment on python/typeshed#1441. I couldn't find any other reports in the tracker, but wasn't sure what to search for.

[JukkaL]

Here's is a slightly simplified repro:

from typing import TypeVar, Generic, Union

T = TypeVar('T', str, int)

class C(Generic[T]): ...

def f(s: Union[T, C[T]]) -> T:  ...

ci: C[int]
cs: C[str]

reveal_type(f(''))
reveal_type(f(1))
reveal_type(f(ci))  # Argument 1 to "f" has incompatible type C[int]; expected "Union[str, C[str]]"
reveal_type(f(cs))

[JukkaL]

This seems like another example of this issue (reported by a coworker):

from typing import Callable, TypeVar, Generic, Union

_U = TypeVar('_U')
_T = TypeVar('_T')

class Future(Generic[_T]):
    
    def __init__(self, t: _T):
        self._t = t

    def then(self, fn: Callable[[_T], Future[_U]]) -> Future[_U]:
        return fn(self._t)
    
    def then2(self, fn: Callable[[_T], _U]) -> Future[_U]:
        return Future(fn(self._t))
        
    def then3(self, fn: Union[Callable[[_T], Future[_U]], Callable[[_T], _U]]) -> Future[_U]:
        ret = fn(self._t)
        if isinstance(ret, Future):
            return ret
        else:
            return Future(ret)

def foo(t: int) -> Future[str]:
    return Future("str")

fut = Future(5)

reveal_type(fut.then(foo)) # is a Future[str], good

def foo2(t: int) -> str:
    return "str"
    
reveal_type(fut.then2(foo2)) # also is a Future[str], good

reveal_type(fut.then3(foo)) # <<==== error, Future[<nothing>]
reveal_type(fut.then3(foo2)) 

[hauntsaninja]

#14396 fixes this, but Jukka's example in this issue is something different, so I opened #14403 for it