[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)): ...
  • with statements e.g., with (item1, item2) as (x, y): ...
  • Comprehensions e.g., [_ for (x, y) in [(1, 2), (3, 4)]]
• Combine starred element types. For example, in (a, *b, c) = (1, 2, 3, 4), the Literal[2] and Literal[3] type should be combined into list[int] to be assigned to *b. (Requires generic support over list)

  ruff/crates/red_knot_python_semantic/src/types/infer.rs

  Lines 1248 to 1251 in c6b311c

  	// TODO: Combine the types into a list type. If the
  	// starred_element_types is empty, then it should be `List[Any]`.
  	// combine_types(starred_element_types);
  	element_types.push(Type::Todo);

• Additional diagnostics when the number of targets is not equal to the number of elements on the RHS

[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.