Inconsistent constraint resolution for tuples.

[randolf-scholz]

Adding the following test to ConstraintsSuite fails with assert set() == {1 <: B, 1 <: A}:

 def test_wrapped_tuple_identical_results(self) -> None:
 # test inferred constraints of tuple[T, ...] <: tuple[A, B]
 # vs inferred constraints of tuple[*tuple[T, ...]] <: tuple[A, B]
 fx = self.fx
 t = Instance(fx.std_tuplei, [fx.t])
 assert set(infer_constraints(
 t,
 TupleType([self.fx.a, self.fx.b], fallback=self.fx.std_tuple),
 SUBTYPE_OF,
 )) == set(infer_constraints(
 TupleType([UnpackType(t)], fallback=self.fx.std_tuple),
 TupleType([self.fx.a, self.fx.b], fallback=self.fx.std_tuple),
 SUBTYPE_OF,
 ))

[randolf-scholz]

Here is a case where this seems to matter: https://mypy-play.net/?mypy=latest&python=3.12&gist=f30386efbc0aebb9907f30ad9eac7edf

from typing import TypeVar, Any, overload

T = TypeVar("T")
X = TypeVar("X")
Y = TypeVar("Y")

@overload
def broadcast(x: X, y: Y, /) -> tuple[X, Y]: ...
@overload
def broadcast(*args: T) -> tuple[T, ...]: ...
def broadcast(*args: object) -> tuple[object, ...]:
 return args

def test(x: int, y: Any) -> None:
 a, b = broadcast(x, y)
 reveal_type(a) # N: Revealed type is "builtins.int"
 reveal_type(b) # N: Revealed type is "Any"

If we patch infer_constraints to give {1 <: B, 1 <: A} in both cases, this breaks during multiple rvalue check

mypy/mypy/checker.py

Line 4202 in dce8e1c

assert isinstance(reinferred_rvalue_type, TupleType)

because now, with the added context [int, Any], the overload resolution is deemed ambiguous, resulting in reinferred_rvalue_type = tuple[Any, ...] here.

What is the intended result in this example?

1. (int, Any) (current master)
2. (int, int) (pyright)
3. (Any, Any) which we should get if we use the reinferred_rvalue_type properly.

For example, one could end up with (3) by adding a branch

if isinstance(reinferred_rvalue_type, Instance) and reinferred_rvalue_type.type.fullname == "builtins.tuple":
 # the type can change into variadic tuple if the added context picks a different overload
 # see testOverloadWithOverlappingItemsAndAnyArgument17 as an example
 generic_type = reinferred_rvalue_type.args[0]
 for lv in lvalues:
 if (
 isinstance(lv, NameExpr)
 and isinstance(lv.node, Var)
 and lv.node.type is None
 ):
 lv.node.type = generic_type
 elif isinstance(lv, StarExpr):
 if (
 isinstance(lv.expr, NameExpr)
 and isinstance(lv.expr.node, Var)
 and lv.expr.node.type is None
 ):
 lv.expr.node.type = self.named_generic_type(
 "builtins.list", [generic_type]
 )
 return
assert isinstance(reinferred_rvalue_type, TupleType)