Can't pass a value of type Union[str, bytes] to a generic function typed with AnyStr

[gvanrossum]

Repro:

from typing import AnyStr, Union
def g(a: AnyStr) -> AnyStr:
    pass
def f(a: Union[str, bytes]):
    g(a)

We get an error on the last line:

c.py:5: error: Type argument 1 of "g" has incompatible value "Union[str, bytes]"

I would have expected that it would just deduce that y is also a Union[str, bytes].

(UPDATE: shortened the repro.)

[JukkaL]

Yeah, it would be nice if the example would work. Generally substituting Union[str, bytes] for AnyStr would be wrong, though. Instead, the union could be decomposed into the components and these could be checked separately.

The reason why can't substitute a union is a little subtle. First, consider this example:

from typing import AnyStr, Union, Sequence

def g(a: Sequence[AnyStr]) -> Sequence[AnyStr]:
    if isinstance(a[0], str):
        for s in a:
            print(s + 'x')

def f(a: Sequence[Union[str, bytes]]):
    g(a)   # should be rejected

Now the call should be rejected, since g expects a uniform sequence and can fail on a mixed sequence.

Here is another example:

from typing import AnyStr, Union, List

def g(a: AnyStr, b: AnyStr) -> None:
    if isinstance(a, str):
        print(a + b)

def f(a: Union[str, bytes], b: Union[str, bytes]):
    g(a, b)  # should be rejected 

The latter example is similar but doesn't use generics. Here we could type check the call g(a, b) with all 4 possible argument type combinations.

Substituting a union type might be safe if AnyStr is only used once in an argument type and it's used as a bare type (not within a generic or a composite type). Not 100% about this, though.

[rwbarton]

We do already perform this kind of separate type checking of each case when type checking a method call on a union, so it does seem natural to extend that to function calls as @JukkaL described. Another place this would come up is in calls to overloaded functions.

[ilevkivskyi]

Btw note this issue is not specific to type variables with values. This example should be supported as well:

def foo[T: int | str](x: list[T]) -> T: ...
x: list[str] | list[int]
foo(x)

essentially we would need to perform union math as we do for overloads. Obviously we need to take care not to introduce false negatives as @JukkaL described above in case of multiple arguments, but we already do take care in case of overloads. The only real problem I am not sure how to deal with is performance (as union math is exponentially complex). But again, maybe we can try some ad-hoc limits similar to what we have for overloads.