Interpret *args as Tuple[T, ...] instead of Sequence[T]

This breaks some buggy code.

Author: o11c

lib-python/3.2/test/test_base64.py

@@ -229,8 +229,8 @@ def test_ErrorHeritage(self) -> None:
 
 
 class TestMain(unittest.TestCase):
-    def get_output(self, *args: str, **options: Any) -> Any:
-        args = [sys.executable, '-m', 'base64'] + list(args)
+    def get_output(self, *args_tuple: str, **options: Any) -> Any:
+        args = [sys.executable, '-m', 'base64'] + list(args_tuple)
         return subprocess.check_output(args, **options)
 
     def test_encode_decode(self) -> None:

mypy/checker.py

@@ -511,8 +511,8 @@ def check_func_def(self, defn: FuncItem, typ: CallableType, name: str) -> None:
             for i in range(len(typ.arg_types)):
                 arg_type = typ.arg_types[i]
                 if typ.arg_kinds[i] == nodes.ARG_STAR:
-                    # TODO: This should actually be Tuple[t, ...] once it's supported.
-                    arg_type = self.named_generic_type('typing.Sequence',
+                    # builtins.tuple[T] is typing.Tuple[T, ...]
+                    arg_type = self.named_generic_type('builtins.tuple',
                                                        [arg_type])
                 elif typ.arg_kinds[i] == nodes.ARG_STAR2:
                     arg_type = self.named_generic_type('builtins.dict',

mypy/test/data/check-varargs.test

@@ -6,22 +6,33 @@
 
 
 [case testVarArgsWithinFunction]
-from typing import Sequence
+from typing import Tuple
 def f( *b: 'B') -> None:
-    ab = None # type: Sequence[B]
-    ac = None # type: Sequence[C]
-    b = ac # E: Incompatible types in assignment (expression has type Sequence[C], variable has type Sequence[B])
-    ac = b # E: Incompatible types in assignment (expression has type Sequence[B], variable has type Sequence[C])
+    ab = None # type: Tuple[B, ...]
+    ac = None # type: Tuple[C, ...]
+    b = ac # E: Incompatible types in assignment (expression has type Tuple[C, ...], variable has type Tuple[B, ...])
+    ac = b # E: Incompatible types in assignment (expression has type Tuple[B, ...], variable has type Tuple[C, ...])
     b = ab
     ab = b
 
 class B: pass
 class C: pass
-[builtins fixtures/list.py]
+[builtins fixtures/tuple.py]
 [out]
 main: note: In function "f":
 
 
+[case testVarArgsAreTuple]
+from typing import Tuple, Sequence
+def want_tuple(types: Tuple[type, ...]): pass
+def want_sequence(types: Sequence[type]): pass
+def test(*t: type) -> None:
+    want_tuple(t)
+    want_sequence(t)
+[builtins fixtures/tuple.py]
+[out]
+
+
 -- Calling varargs function
 -- ------------------------
 

mypy/test/data/fixtures/tuple.py

@@ -1,14 +1,14 @@
 # Builtins stub used in tuple-related test cases.
 
-from typing import Iterable, TypeVar, Generic
+from typing import Iterable, TypeVar, Generic, Sequence
 
 Tco = TypeVar('Tco', covariant=True)
 
 class object:
     def __init__(self): pass
 
 class type: pass
-class tuple(Generic[Tco]):
+class tuple(Sequence[Tco], Generic[Tco]):
     def __getitem__(self, x: int) -> Tco: pass
 class function: pass
 

mypy/test/data/pythoneval.test

@@ -972,7 +972,7 @@ def f(*x: int) -> None:
 f(1)
 [out]
 _program.py: note: In function "f":
-_program.py:3: error: Sequence[int] has no attribute "append"
+_program.py:3: error: Tuple[int, ...] has no attribute "append"
 
 [case testExit]
 print('a')