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)