Inconsistent constraint resolution for tuples. #19860

Activity

1. randolf-scholz

   added

   bugmypy got something wrongmypy got something wrong

   on Sep 16, 2025
2. ilevkivskyi

   added

   topic-pep-646PEP 646 (TypeVarTuple, Unpack)PEP 646 (TypeVarTuple, Unpack)

   on Sep 16, 2025
3. randolf-scholz commented on Sep 16, 2025

   

   randolf-scholz

   on Sep 16, 2025

   ContributorAuthor

   More actions

   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)