Because after you unpacked, there are three independent variables x, y, and z each with type Union[str, List[str]], mypy does not store any cross-variable constraints like if x is str then y should be also str. And I doubt it ever will.

This however works fine:

def a() -> typing.Union[typing.Tuple[str, str, str],
                        typing.Tuple[typing.List[str], typing.List[str], typing.List[str]]]:
    return '1', '1', '1'

def c() -> typing.Union[typing.Tuple[str, str, str],
                        typing.Tuple[typing.List[str], typing.List[str], typing.List[str]]]:
    x, y, z = a()[:]
    return x, y, z

This however works fine:

And this is a bug!

def c() -> typing.Union[typing.Tuple[str, str, str],
                        typing.Tuple[typing.List[str], typing.List[str], typing.List[str]]]:
    x, y, z = a()[:]
    reveal_type(x)  # Revealed type is Any
    return x, y, z

I think however this is not an independent problem, but a manifestation of a known problem of interactions between unions and overloads. @JukkaL what do you think?

Looks like there are two problems. First, the fallback of the tuple types seems to be Tuple[Any, ...], which is not right. Second, we should special case unions in type inference of indexing expressions. Currently it just falls back to calling __getitem__ which loses the special semantics for tuple types.

First, the fallback of the tuple types seems to be Tuple[Any, ...], which is not right.

There is an issue for this already, and I am going to fix it soon (I am going to go with join like for other similar cases).

Second, we should special case unions in type inference of indexing expressions. Currently it just falls back to calling __getitem__ which loses the special semantics for tuple types.

I think with the first one fixed, this seems to be not urgent.

I think with the first one fixed, this seems to be not urgent.

Yes, the first issue seems more urgent. I'll create a new issue to track second issue.

Actually we can use this issue to track the second issues. Here's a simplified example:

from typing import Union, Tuple
t: Union[Tuple[int, float], Tuple[str, bool]]
reveal_type(t[0])  # Revealed type is 'Any'
reveal_type(t[:])  # Revealed type is 'builtins.tuple[Any]'

The expected revealed types are Union[int, str] and Union[Tuple[int, float], Tuple[str, bool]]. We lose both item types and the number of items in a tuple.

@JukkaL

Actually we can use this issue to track the second issues. Here's a simplified example:

Your tuple fallback PR causes a bunch of errors internally because fallback is now builtins.tuple[builtins.object] instead of builtins.tuple[Any]. This is however probably easy to fix. Special casing indexing unions (and maybe some other special methods on unions) makes sense to me.

@JukkaL #6475 fixes the problem.