[red-knot] Follow-up from unpacked tuple assignment work

[dhruvmanila]

As #13316 is merged, there are some follow-up work that needs to be done. The following is a list in the order of priority where the highest priority work is on the top:

• Avoiding duplicate diagnostics. Considering (a, b) = (1, 2), as the inference runs for each symbol, if there are any diagnostics that's raised during that part (like "too many values to unpack"), then there will be multiple diagnostics added to the builder one for each symbol. Refer [red-knot] Infer target types for unpacked tuple assignment #13316 (comment)
• Use the unpacking logic in other places where it's relevant like
  • for loops e.g., for (x, y) in ((1, 2), (3, 4)): ... ([red-knot] Add support for unpacking for target #15058)
  • with statements e.g., with (item1, item2) as (x, y): ...
  • Comprehensions e.g., [_ for (x, y) in [(1, 2), (3, 4)]]
• Additional diagnostics when the number of targets is not equal to the number of elements on the RHS ([red-knot] Add diagnostic for invalid unpacking #15086)

[dhruvmanila]

Regarding "Use the unpacking logic in other places where it's relevant like" task, I think the challenge here would be to implement the logic to "combine" union types into a single type. For example, in a for loop like:

for (x, y) in ((1, 2), (3, 4), (5, 6)): ...

The inferred type for the iterable would be:

tuple[Literal[1], Literal[2]] | tuple[Literal[3], Literal[4]] | tuple[Literal[5], Literal[6]]

But, we should combine it to:

tuple[int, int]
# or
tuple[Literal[1, 3, 5], Literal[2, 4, 6]]

Or, another example where the types are "mixed":

for (x, y) in ((1, 2), ("a", "b")): ...

We should combine it to:

tuple[int | str, int | str]
# or
tuple[Literal[1, "a"], Literal[2, "b"]]

Another example:

for (x, y) in ((1, 2), ("a", 3)): ...

where,

tuple[int | str, int]
# or
tuple[Literal[1, "a"], Literal[2, 3]]

[dhruvmanila]

Actually, my previous comment isn't exactly correct. We actually need to add support for union types when unpacking rather than combining the types.

For example, if the type is tuple[int, str] | list[int] and the target has two elements (a, b), then the type of a will be a union of the first tuple type (int) and the iterable type of the list (int) which should be int. And, similarly the type of b would be a union of the second tuple type (str) and the iterable type of the list (int) which would be int | str.

cc @carljm as we talked about this in our 1:1 yesterday.