Fix joining of fixed 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,28 @@ 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]))
-            fallback = join_instances(mypy.typeops.tuple_fallback(self.s),
-                                      mypy.typeops.tuple_fallback(t))
-            assert isinstance(fallback, Instance)
-            return TupleType(items, fallback)
+        # 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):
+            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]))
+                fallback = join_instances(mypy.typeops.tuple_fallback(self.s),
+                                          mypy.typeops.tuple_fallback(t))
+                assert isinstance(fallback, Instance)
+                return TupleType(items, fallback)
+            else:
+                items = self.s.items + t.items
+                # Otherwise they'd compare equal in above check.
+                assert len(items), "Both tuple items cannot be empty"
+                subtype = join_type_list(items)
+                tuple_type = self.s.partial_fallback.type  # FIXME how do I construct TypeInfo?
+                return Instance(tuple_type, [subtype])
         else:
             return self.default(self.s)
 

mypy/test/testtypes.py

@@ -504,6 +504,23 @@ 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.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_var_tuples(self) -> None:
+        self.assert_join(self.tuple(self.fx.a),
+                         self.var_tuple(self.fx.a),
+                         self.fx.o)
+        self.assert_join(self.var_tuple(self.fx.a),
+                         self.tuple(self.fx.a),
+                         self.fx.o)
+        self.assert_join(self.var_tuple(self.fx.a),
+                         self.tuple(),
                          self.fx.o)
 
     def test_function_types(self) -> None:
@@ -760,6 +777,9 @@ 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:
+        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.