Fix joining of Sequence (e.g. variadic tuple) and fixed-length tuple (#…

…8335)

For example:

* Tuple[int] + Tuple[bool, ...] becomes Tuple[int, ...]
* List[int] + Tuple[bool, ...] becomes Sequence[int]

Previously Mypy simply punted and returned `object`.

This solves the other part of issue #4975. Fixes issue #8074.

mypy/join.py

@@ -177,6 +177,8 @@ def visit_instance(self, t: Instance) -> ProperType:
  return join_types(t, self.s)
  elif isinstance(self.s, TypedDictType):
  return join_types(t, self.s)
+ elif isinstance(self.s, TupleType):
+ return join_types(t, self.s)
  elif isinstance(self.s, LiteralType):
  return join_types(t, self.s)
  else:
@@ -260,6 +262,15 @@ def visit_overloaded(self, t: Overloaded) -> ProperType:
  return join_types(t.fallback, s)
 
  def visit_tuple_type(self, t: TupleType) -> ProperType:
+ # When given two fixed-length tuples:
+ # * If they have the same length, join their subtypes item-wise:
+ # Tuple[int, bool] + Tuple[bool, bool] becomes Tuple[int, bool]
+ #
+ # Otherwise, `t` is a fixed-length tuple but `self.s` is NOT:
+ # * Joining with a variadic tuple returns variadic tuple:
+ # Tuple[int, bool] + Tuple[bool, ...] becomes Tuple[int, ...]
+ # * Joining with any Sequence also returns a Sequence:
+ # Tuple[int, bool] + List[bool] becomes Sequence[int]
  if isinstance(self.s, TupleType) and self.s.length() == t.length():
  items = [] # type: List[Type]
  for i in range(t.length()):
@@ -269,7 +280,7 @@ def visit_tuple_type(self, t: TupleType) -> ProperType:
  assert isinstance(fallback, Instance)
  return TupleType(items, fallback)
  else:
- return self.default(self.s)
+ return join_types(self.s, mypy.typeops.tuple_fallback(t))
 
  def visit_typeddict_type(self, t: TypedDictType) -> ProperType:
  if isinstance(self.s, TypedDictType):

mypy/test/testtypes.py

@@ -501,10 +501,21 @@ def test_tuples(self) -> None:
 
  self.assert_join(self.tuple(self.fx.a, self.fx.a),
  self.fx.std_tuple,
- self.fx.o)
+ self.var_tuple(self.fx.anyt))
  self.assert_join(self.tuple(self.fx.a),
  self.tuple(self.fx.a, self.fx.a),
- self.fx.o)
+ self.var_tuple(self.fx.a))
+
+ def test_var_tuples(self) -> None:
+ self.assert_join(self.tuple(self.fx.a),
+ self.var_tuple(self.fx.a),
+ self.var_tuple(self.fx.a))
+ self.assert_join(self.var_tuple(self.fx.a),
+ self.tuple(self.fx.a),
+ self.var_tuple(self.fx.a))
+ self.assert_join(self.var_tuple(self.fx.a),
+ self.tuple(),
+ self.var_tuple(self.fx.a))
 
  def test_function_types(self) -> None:
  self.assert_join(self.callable(self.fx.a, self.fx.b),
@@ -760,6 +771,10 @@ def assert_simple_join(self, s: Type, t: Type, join: Type) -> None:
  def tuple(self, *a: Type) -> TupleType:
  return TupleType(list(a), self.fx.std_tuple)
 
+ def var_tuple(self, t: Type) -> Instance:
+ """Construct a variable-length tuple type"""
+ return Instance(self.fx.std_tuplei, [t])
+
  def callable(self, *a: Type) -> CallableType:
  """callable(a1, ..., an, r) constructs a callable with argument types
  a1, ... an and return type r.

test-data/unit/check-tuples.test

@@ -1077,6 +1077,87 @@ x, y = g(z) # E: Argument 1 to "g" has incompatible type "int"; expected "Tuple[
 [builtins fixtures/tuple.pyi]
 [out]
 
+[case testFixedTupleJoinVarTuple]
+from typing import Tuple
+
+class A: pass
+class B(A): pass
+
+fixtup = None # type: Tuple[B, B]
+
+vartup_b = None # type: Tuple[B, ...]
+reveal_type(fixtup if int() else vartup_b) # N: Revealed type is 'builtins.tuple[__main__.B]'
+reveal_type(vartup_b if int() else fixtup) # N: Revealed type is 'builtins.tuple[__main__.B]'
+
+vartup_a = None # type: Tuple[A, ...]
+reveal_type(fixtup if int() else vartup_a) # N: Revealed type is 'builtins.tuple[__main__.A]'
+reveal_type(vartup_a if int() else fixtup) # N: Revealed type is 'builtins.tuple[__main__.A]'
+
+
+[builtins fixtures/tuple.pyi]
+[out]
+
+[case testFixedTupleJoinList]
+from typing import Tuple, List
+
+class A: pass
+class B(A): pass
+
+fixtup = None # type: Tuple[B, B]
+
+lst_b = None # type: List[B]
+reveal_type(fixtup if int() else lst_b) # N: Revealed type is 'typing.Sequence[__main__.B]'
+reveal_type(lst_b if int() else fixtup) # N: Revealed type is 'typing.Sequence[__main__.B]'
+
+lst_a = None # type: List[A]
+reveal_type(fixtup if int() else lst_a) # N: Revealed type is 'typing.Sequence[__main__.A]'
+reveal_type(lst_a if int() else fixtup) # N: Revealed type is 'typing.Sequence[__main__.A]'
+
+[builtins fixtures/tuple.pyi]
+[out]
+
+[case testEmptyTupleJoin]
+from typing import Tuple, List
+
+class A: pass
+
+empty = ()
+
+fixtup = None # type: Tuple[A]
+reveal_type(fixtup if int() else empty) # N: Revealed type is 'builtins.tuple[__main__.A]'
+reveal_type(empty if int() else fixtup) # N: Revealed type is 'builtins.tuple[__main__.A]'
+
+vartup = None # type: Tuple[A, ...]
+reveal_type(empty if int() else vartup) # N: Revealed type is 'builtins.tuple[__main__.A]'
+reveal_type(vartup if int() else empty) # N: Revealed type is 'builtins.tuple[__main__.A]'
+
+lst = None # type: List[A]
+reveal_type(empty if int() else lst) # N: Revealed type is 'typing.Sequence[__main__.A*]'
+reveal_type(lst if int() else empty) # N: Revealed type is 'typing.Sequence[__main__.A*]'
+
+[builtins fixtures/tuple.pyi]
+[out]
+
+[case testTupleSubclassJoin]
+from typing import Tuple, NamedTuple
+
+class NTup(NamedTuple):
+ a: bool
+ b: bool
+
+class SubTuple(Tuple[bool]): ...
+class SubVarTuple(Tuple[int, ...]): ...
+
+ntup = None # type: NTup
+subtup = None # type: SubTuple
+vartup = None # type: SubVarTuple
+
+reveal_type(ntup if int() else vartup) # N: Revealed type is 'builtins.tuple[builtins.int]'
+reveal_type(subtup if int() else vartup) # N: Revealed type is 'builtins.tuple[builtins.int]'
+
+[builtins fixtures/tuple.pyi]
+[out]
+
 [case testTupleWithUndersizedContext]
 a = ([1], 'x')
 if int():