Allow variables in iterable-unpacking assignment to narrow together

[benblank]

Description

I don't know whether this is feasible, but it would be very convenient if variables used in the same iterable-unpacking assignment were "linked" in some way which would make it possible for narrowing the type of one to narrow the type of the other(s).

For example, if a function is typed as returning tuple[int, int] | tuple[None, None] and its return value is unpacked, narrowing one of the unpacked values to not None would ideally narrow the other, as well.

from random import random
from typing import reveal_type


def get_tuple() -> tuple[int, int] | tuple[None, None]:
    if random() < 0.5:
        return 1, 2

    return None, None


first, second = get_tuple()

if first is not None:
    reveal_type(first)   # Reveals "int".
    reveal_type(second)  # Reveals "int | None", but "int" would be better.

(playground link)

Both Pyright and Mypy currently behave in the same manner as Basedpyright, so I assume this isn't trivial. 😅

[DetachHead]

i don't think it's really feasible tbh. the tuple is being unpacked into two completely different variables that don't know about each other. this works though:

values = get_tuple()

if values[0] is not None:
    reveal_type(values[0])  # int
    reveal_type(values[1])  # int

[benblank]

That's what I suspected, yeah. I know that TypeScript is capable of handling this kind of narrowing, but their type checker clearly has some way to tie the variables together. If there isn't currently a place to store that kind of connection in Basedpyright's model, I can imagine the implementation cost being kind of high.

Still, I'll keep my fingers crossed that the tradeoff becomes worthwhile at some point. Who knows, maybe there are other use cases out there that could benefit from it.

Thanks for looking!