Fix Tuple behavior

Author: pkch

mypy/checker.py

@@ -1511,7 +1511,7 @@ def append_types_for_inference(lvs: List[Expression], rv_types: List[Type]) -> N
 
         append_types_for_inference(right_lvs, right_rv_types)
 
-        return TupleType(type_parameters, self.named_type('builtins.tuple'))
+        return TupleType(type_parameters, self.named_generic_type('builtins.tuple', [AnyType()]))
 
     def split_around_star(self, items: List[T], star_index: int,
                           length: int) -> Tuple[List[T], List[T], List[T]]:
@@ -1574,7 +1574,7 @@ def check_lvalue(self, lvalue: Lvalue) -> Tuple[Type, IndexExpr, Var]:
             self.store_type(lvalue, lvalue_type)
         elif isinstance(lvalue, TupleExpr) or isinstance(lvalue, ListExpr):
             types = [self.check_lvalue(sub_expr)[0] for sub_expr in lvalue.items]
-            lvalue_type = TupleType(types, self.named_type('builtins.tuple'))
+            lvalue_type = TupleType(types, self.named_generic_type('builtins.tuple', [AnyType()]))
         else:
             lvalue_type = self.expr_checker.accept(lvalue)
 

mypy/checkexpr.py

@@ -1740,7 +1740,7 @@ def visit_dict_expr(self, e: DictExpr) -> Type:
             #
             #   def <unnamed>(*v: Tuple[kt, vt]) -> Dict[kt, vt]: ...
             constructor = CallableType(
-                [TupleType([kt, vt], self.named_type('builtins.tuple'))],
+                [TupleType([kt, vt], self.chk.named_generic_type('builtins.tuple', [AnyType()]))],
                 [nodes.ARG_STAR],
                 [None],
                 self.chk.named_generic_type('builtins.dict', [kt, vt]),

mypy/expandtype.py

@@ -7,6 +7,8 @@
     FunctionLike, TypeVarDef
 )
 
+import mypy
+
 
 def expand_type(typ: Type, env: Mapping[TypeVarId, Type]) -> Type:
     """Substitute any type variable references in a type given by a type
@@ -109,7 +111,10 @@ def visit_overloaded(self, t: Overloaded) -> Type:
         return Overloaded(items)
 
     def visit_tuple_type(self, t: TupleType) -> Type:
-        return t.copy_modified(items=self.expand_types(t.items))
+        new_items = self.expand_types(t.items)
+        new_fallback_arg = mypy.join.join_type_list(new_items)
+        new_fallback = t.fallback.copy_modified(args=[new_fallback_arg])
+        return t.copy_modified(items=new_items, fallback=new_fallback)
 
     def visit_typeddict_type(self, t: TypedDictType) -> Type:
         return t.copy_modified(item_types=self.expand_types(t.items.values()))

mypy/join.py

@@ -386,7 +386,4 @@ def join_type_list(types: List[Type]) -> Type:
         # This is a little arbitrary but reasonable. Any empty tuple should be compatible
         # with all variable length tuples, and this makes it possible.
         return UninhabitedType()
-    joined = types[0]
-    for t in types[1:]:
-        joined = join_types(joined, t)
-    return joined
+    return UnionType.make_simplified_union(types)

mypy/messages.py

@@ -260,7 +260,10 @@ def format_simple(self, typ: Type, verbosity: int = 0) -> str:
                 return '"{}"'.format(base_str)
             elif itype.type.fullname() == 'builtins.tuple':
                 item_type_str = strip_quotes(self.format(itype.args[0]))
-                return 'Tuple[{}, ...]'.format(item_type_str)
+                if isinstance(itype.args[0], AnyType):
+                    return 'tuple'
+                else:
+                    return 'Tuple[{}, ...]'.format(item_type_str)
             elif itype.type.fullname() in reverse_type_aliases:
                 alias = reverse_type_aliases[itype.type.fullname()]
                 alias = alias.split('.')[-1]

mypy/semanal.py

@@ -2107,7 +2107,7 @@ def build_namedtuple_typeinfo(self, name: str, items: List[str], types: List[Typ
         # Actual signature should return OrderedDict[str, Union[types]]
         ordereddictype = (self.named_type_or_none('builtins.dict', [strtype, AnyType()])
                           or self.object_type())
-        fallback = self.named_type('__builtins__.tuple', types)
+        fallback = self.named_type('__builtins__.tuple', [join.join_type_list(types)])
         # Note: actual signature should accept an invariant version of Iterable[UnionType[types]].
         # but it can't be expressed. 'new' and 'len' should be callable types.
         iterable_type = self.named_type_or_none('typing.Iterable', [AnyType()])

mypy/subtypes.py

@@ -145,13 +145,7 @@ def visit_instance(self, left: Instance) -> bool:
                 return False
             # Map left type to corresponding right instances.
             t = map_instance_to_supertype(left, right.type)
-            # Check that one of the types does not have type args or
-            # the number of type args is the same and
-            # each left type arg is acceptable in place of the matching right one
-            if not t.args or not right.args:
-                return True
-            if len(t.args) != len(right.args):
-                return False
+            # TODO: assert len(t.args) == len(right.args)
             return all(self.check_type_parameter(lefta, righta, tvar.variance)
                        for lefta, righta, tvar in
                        zip(t.args, right.args, right.type.defn.type_vars))

mypy/typeanal.py

@@ -18,6 +18,7 @@
 from mypy.exprtotype import expr_to_unanalyzed_type, TypeTranslationError
 from mypy.subtypes import is_subtype
 from mypy import nodes
+from mypy import join
 from mypy import experiments
 
 
@@ -137,7 +138,7 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
             elif fullname == 'typing.Tuple':
                 if len(t.args) == 0 and not t.empty_tuple_index:
                     # Bare 'Tuple' is same as 'tuple'
-                    return self.builtin_type('builtins.tuple')
+                    return self.builtin_type('builtins.tuple', [AnyType()])
                 if len(t.args) == 2 and isinstance(t.args[1], EllipsisType):
                     # Tuple[T, ...] (uniform, variable-length tuple)
                     instance = self.builtin_type('builtins.tuple', [self.anal_type(t.args[0])])
@@ -211,37 +212,35 @@ def visit_unbound_type(self, t: UnboundType) -> Type:
                     self.fail('Invalid type "{}"'.format(name), t)
                 return t
             info = sym.node  # type: TypeInfo
-            if len(t.args) > 0 and info.fullname() == 'builtins.tuple':
-                return TupleType(self.anal_array(t.args),
-                                 Instance(info, [AnyType()], t.line),
-                                 t.line)
-            else:
-                # Analyze arguments and construct Instance type. The
-                # number of type arguments and their values are
-                # checked only later, since we do not always know the
-                # valid count at this point. Thus we may construct an
-                # Instance with an invalid number of type arguments.
-                instance = Instance(info, self.anal_array(t.args), t.line, t.column)
-                tup = info.tuple_type
-                if tup is not None:
-                    # The class has a Tuple[...] base class so it will be
-                    # represented as a tuple type.
-                    if t.args:
-                        self.fail('Generic tuple types not supported', t)
-                        return AnyType()
-                    return tup.copy_modified(items=self.anal_array(tup.items),
-                                             fallback=instance)
-                td = info.typeddict_type
-                if td is not None:
-                    # The class has a TypedDict[...] base class so it will be
-                    # represented as a typeddict type.
-                    if t.args:
-                        self.fail('Generic TypedDict types not supported', t)
-                        return AnyType()
-                    # Create a named TypedDictType
-                    return td.copy_modified(item_types=self.anal_array(list(td.items.values())),
-                                            fallback=instance)
-                return instance
+            if info.fullname() == 'builtins.tuple':
+                assert not t.args
+                t.args = [AnyType()]
+            # Analyze arguments and construct Instance type. The
+            # number of type arguments and their values are
+            # checked only later, since we do not always know the
+            # valid count at this point. Thus we may construct an
+            # Instance with an invalid number of type arguments.
+            instance = Instance(info, self.anal_array(t.args), t.line, t.column)
+            tup = info.tuple_type
+            if tup is not None:
+                # The class has a Tuple[...] base class so it will be
+                # represented as a tuple type.
+                if t.args:
+                    self.fail('Generic tuple types not supported', t)
+                    return AnyType()
+                return tup.copy_modified(items=self.anal_array(tup.items),
+                                         fallback=instance)
+            td = info.typeddict_type
+            if td is not None:
+                # The class has a TypedDict[...] base class so it will be
+                # represented as a typeddict type.
+                if t.args:
+                    self.fail('Generic TypedDict types not supported', t)
+                    return AnyType()
+                # Create a named TypedDictType
+                return td.copy_modified(item_types=self.anal_array(list(td.items.values())),
+                                        fallback=instance)
+            return instance
         else:
             return AnyType()
 
@@ -332,7 +331,7 @@ def visit_tuple_type(self, t: TupleType) -> Type:
             self.fail('At most one star type allowed in a tuple', t)
             if t.implicit:
                 return TupleType([AnyType() for _ in t.items],
-                                 self.builtin_type('builtins.tuple'),
+                                 self.builtin_type('builtins.tuple', [AnyType()]),
                                  t.line)
             else:
                 return AnyType()
@@ -520,6 +519,11 @@ def visit_callable_type(self, t: CallableType) -> None:
     def visit_tuple_type(self, t: TupleType) -> None:
         for item in t.items:
             item.accept(self)
+        # if it's not builtins.tuple, then its bases should have tuple[Any]
+        # TODO: put assert here if it's not too slow
+        if type(t.fallback) == Instance and t.fallback.type.fullname() == 'builtins.tuple':
+            fallback_item = join.join_type_list(t.items)
+            t.fallback.args = [fallback_item]
 
     def visit_typeddict_type(self, t: TypedDictType) -> None:
         for item_type in t.items.values():

mypy/types.py

@@ -15,6 +15,11 @@
 )
 
 from mypy.sharedparse import argument_elide_name
+import mypy
+
+MYPY = False
+if MYPY:
+    from mypy import join
 
 
 T = TypeVar('T')
@@ -378,6 +383,7 @@ class Instance(Type):
     def __init__(self, typ: Optional[mypy.nodes.TypeInfo], args: List[Type],
                  line: int = -1, column: int = -1, erased: bool = False) -> None:
         assert(typ is None or typ.fullname() not in ["builtins.Any", "typing.Any"])
+        # TODO: assert(typ is None or typ.fullname() != 'builtins.tuple' or len(args) == 1)
         self.type = typ
         self.args = args
         self.erased = erased
@@ -833,6 +839,8 @@ def __init__(self, items: List[Type], fallback: Instance, line: int = -1,
                  column: int = -1, implicit: bool = False) -> None:
         self.items = items
         self.fallback = fallback
+        # TODO: assert not (isinstance(fallback, Instance) and fallback.type and
+        #            fallback.type.fullname() == 'builtins.tuple' and not fallback.args)
         self.implicit = implicit
         self.can_be_true = len(self.items) > 0
         self.can_be_false = len(self.items) == 0
@@ -867,7 +875,10 @@ def copy_modified(self, *, fallback: Instance = None,
         return TupleType(items, fallback, self.line, self.column)
 
     def slice(self, begin: int, stride: int, end: int) -> 'TupleType':
-        return TupleType(self.items[begin:end:stride], self.fallback,
+        new_items = self.items[begin:end:stride]
+        fallback_args = [mypy.join.join_type_list(new_items)]
+        new_fallback = self.fallback.copy_modified(args=fallback_args)
+        return TupleType(new_items, new_fallback,
                          self.line, self.column, self.implicit)
 
 
@@ -1707,7 +1718,9 @@ def set_typ_args(tp: Type, new_args: List[Type], line: int = -1, column: int = -
     if isinstance(tp, Instance):
         return Instance(tp.type, new_args, line, column)
     if isinstance(tp, TupleType):
-        return tp.copy_modified(items=new_args)
+        fallback_args = [mypy.join.join_type_list(new_args)]
+        fallback = tp.fallback.copy_modified(args=fallback_args)
+        return tp.copy_modified(items=new_args, fallback=fallback)
     if isinstance(tp, UnionType):
         return UnionType.make_simplified_union(new_args, line, column)
     if isinstance(tp, CallableType):

test-data/unit/check-functions.test

@@ -1486,7 +1486,7 @@ f(1, thing_in_kwargs=["hey"])
 from typing import Tuple, Any
 def f(x, *args): # type: (...) -> None
     success_tuple_type = args # type: Tuple[Any, ...]
-    fail_tuple_type = args # type: None # E: Incompatible types in assignment (expression has type Tuple[Any, ...], variable has type None)
+    fail_tuple_type = args # type: None # E: Incompatible types in assignment (expression has type tuple, variable has type None)
 f(1, "hello")
 [builtins fixtures/tuple.pyi]
 [out]

test-data/unit/check-inference.test

@@ -1775,6 +1775,8 @@ def g(x: Union[int, str]): pass
 c = a if f() else b
 g(c) # E: Argument 1 to "g" has incompatible type "Union[int, str, tuple]"; expected "Union[int, str]"
 
+[builtins fixtures/list.pyi]
+
 [case testUnificationMultipleInheritance]
 class A: pass
 class B:

test-data/unit/check-tuples.test

@@ -91,7 +91,7 @@ from typing import Tuple
 t1 = None # type: Tuple[A, A]
 t2 = None # type: tuple
 
-t1 = t2 # E: Incompatible types in assignment (expression has type Tuple[Any, ...], variable has type "Tuple[A, A]")
+t1 = t2 # E: Incompatible types in assignment (expression has type tuple, variable has type "Tuple[A, A]")
 t2 = t1
 
 class A: pass
@@ -702,6 +702,7 @@ B()[100]
 [case testValidTupleBaseClass]
 from typing import Tuple
 class A(tuple): pass
+[builtins fixtures/tuple.pyi]
 [out]
 
 [case testTupleBaseClass2-skip]
@@ -913,7 +914,7 @@ def f(a: Tuple) -> None: pass
 f(())
 f((1,))
 f(('', ''))
-f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected Tuple[Any, ...]
+f(0)  # E: Argument 1 to "f" has incompatible type "int"; expected tuple
 [builtins fixtures/tuple.pyi]
 
 [case testTupleSingleton]

test-data/unit/check-typeddict.test

@@ -367,7 +367,7 @@ Point3D = TypedDict('Point3D', {'x': int, 'y': int, 'z': int})
 p1 = TaggedPoint(type='2d', x=0, y=0)
 p2 = Point3D(x=1, y=1, z=1)
 joined_points = [p1, p2]
-reveal_type(p1)             # E: Revealed type is 'TypedDict(type=builtins.str, x=builtins.int, y=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.object])'
+reveal_type(p1)             # E: Revealed type is 'TypedDict(type=builtins.str, x=builtins.int, y=builtins.int, _fallback=typing.Mapping[builtins.str, Union[builtins.str, builtins.int]])'
 reveal_type(p2)             # E: Revealed type is 'TypedDict(x=builtins.int, y=builtins.int, z=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])'
 reveal_type(joined_points)  # E: Revealed type is 'builtins.list[TypedDict(x=builtins.int, y=builtins.int, _fallback=typing.Mapping[builtins.str, builtins.int])]'
 [builtins fixtures/dict.pyi]

test-data/unit/fixtures/isinstancelist.pyi

@@ -1,4 +1,4 @@
-from typing import builtinclass, Iterable, Iterator, TypeVar, List, Mapping, overload, Tuple, Set, Union
+from typing import builtinclass, Iterable, Iterator, TypeVar, List, Mapping, overload, Tuple, Set, Union, Sequence, Generic
 
 @builtinclass
 class object:
@@ -8,7 +8,11 @@ class object:
 class type:
     def __init__(self, x) -> None: pass
 
-class tuple: pass
+Tco = TypeVar('Tco', covariant=True)
+class tuple(Sequence[Tco], Generic[Tco]):
+    def __iter__(self) -> Iterator[Tco]: pass
+    def __getitem__(self, x: int) -> Tco: pass
+
 class function: pass
 
 def isinstance(x: object, t: Union[type, Tuple]) -> bool: pass