Fix joining of fixed-length tuples with mismatching lengths

For example:
Tuple[bool, int] + Tuple[bool] becomes Tuple[int, ...]

Previously Mypy simply punted and returned `object`.

The handling of fixed tuple + variadic tuple will be implemented
separately.

Author: intgr

mypy/join.py

@@ -260,14 +260,23 @@ def visit_overloaded(self, t: Overloaded) -> ProperType:
         return join_types(t.fallback, s)
 
     def visit_tuple_type(self, t: TupleType) -> ProperType:
-        if isinstance(self.s, TupleType) and self.s.length() == t.length():
-            items = []  # type: List[Type]
-            for i in range(t.length()):
-                items.append(self.join(t.items[i], self.s.items[i]))
+        # When given two fixed-length tuples:
+        # * If lengths match, join their subtypes item-wise:
+        #   Tuple[int, bool] + Tuple[bool, bool] becomes Tuple[int, bool]
+        # * If lengths do not match, return a variadic tuple:
+        #   Tuple[bool, int] + Tuple[bool] becomes Tuple[int, ...]
+        # * Fixed tuple + variadic tuple is currently not implemented.
+        if isinstance(self.s, TupleType):
             fallback = join_instances(mypy.typeops.tuple_fallback(self.s),
                                       mypy.typeops.tuple_fallback(t))
             assert isinstance(fallback, Instance)
-            return TupleType(items, fallback)
+            if self.s.length() == t.length():
+                items = []  # type: List[Type]
+                for i in range(t.length()):
+                    items.append(self.join(t.items[i], self.s.items[i]))
+                return TupleType(items, fallback)
+            else:
+                return fallback
         else:
             return self.default(self.s)
 

mypy/test/testtypes.py

@@ -504,7 +504,13 @@ def test_tuples(self) -> None:
                          self.fx.o)
         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))
+        self.assert_join(self.tuple(self.fx.b),
+                         self.tuple(self.fx.a, self.fx.c),
+                         self.var_tuple(self.fx.a))
+        self.assert_join(self.tuple(),
+                         self.tuple(self.fx.a),
+                         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 +766,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,52 @@ x, y = g(z) # E: Argument 1 to "g" has incompatible type "int"; expected "Tuple[
 [builtins fixtures/tuple.pyi]
 [out]
 
+[case testTupleJoinIrregular]
+from typing import Tuple
+
+tup1 = None  # type: Tuple[bool, int]
+tup2 = None  # type: Tuple[bool]
+
+reveal_type(tup1 if int() else tup2)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+reveal_type(tup2 if int() else tup1)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+
+reveal_type(tup1 if int() else ())  # N: Revealed type is 'builtins.tuple[builtins.int]'
+reveal_type(() if int() else tup1)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+
+reveal_type(tup2 if int() else ())  # N: Revealed type is 'builtins.tuple[builtins.bool]'
+reveal_type(() if int() else tup2)  # N: Revealed type is 'builtins.tuple[builtins.bool]'
+
+[builtins fixtures/tuple.pyi]
+[out]
+
+[case testTupleSubclassJoinIrregular]
+from typing import Tuple, NamedTuple
+
+class NTup1(NamedTuple):
+    a: bool
+
+class NTup2(NTup1):
+    b: bool
+
+class SubTuple(Tuple[bool, int, int]): ...
+
+tup1 = None  # type: NTup1
+tup2 = None  # type: NTup2
+subtup = None  # type: SubTuple
+
+# FIXME NamedTuple inheritance has some unexpected behavior
+reveal_type(tup1 if int() else tup2)  # N: Revealed type is 'Tuple[builtins.bool, fallback=__main__.NTup1]'
+reveal_type(tup2 if int() else tup1)  # N: Revealed type is 'Tuple[builtins.bool, fallback=__main__.NTup1]'
+
+reveal_type(tup1 if int() else subtup)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+reveal_type(subtup if int() else tup1)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+
+reveal_type(tup2 if int() else subtup)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+reveal_type(subtup if int() else tup2)  # N: Revealed type is 'builtins.tuple[builtins.int]'
+
+[builtins fixtures/tuple.pyi]
+[out]
+
 [case testTupleWithUndersizedContext]
 a = ([1], 'x')
 if int():