[case testTypeVarTupleBasic]

from typing import Any, Tuple

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def f(a: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:

return a

any: Any

args: Tuple[int, str] = (1, 'x')

args2: Tuple[bool, str] = (False, 'y')

args3: Tuple[int, str, bool] = (2, 'z', True)

varargs: Tuple[int, ...] = (1, 2, 3)

reveal_type(f(args)) # N: Revealed type is "tuple[builtins.int, builtins.str]"

reveal_type(f(varargs)) # N: Revealed type is "builtins.tuple[builtins.int, ...]"

f(0) # E: Argument 1 to "f" has incompatible type "int"; expected "tuple[Never, ...]"

def g(a: Tuple[Unpack[Ts]], b: Tuple[Unpack[Ts]]) -> Tuple[Unpack[Ts]]:

return a

reveal_type(g(args, args)) # N: Revealed type is "tuple[builtins.int, builtins.str]"

reveal_type(g(args, args2)) # N: Revealed type is "tuple[builtins.int, builtins.str]"

reveal_type(g(args, args3)) # N: Revealed type is "builtins.tuple[builtins.int | builtins.str, ...]"

reveal_type(g(any, any)) # N: Revealed type is "builtins.tuple[Any, ...]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleMixed]

from typing import Tuple

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def to_str(i: int) -> str:

...

def f(a: Tuple[int, Unpack[Ts]]) -> Tuple[str, Unpack[Ts]]:

return (to_str(a[0]),) + a[1:]

def g(a: Tuple[Unpack[Ts], int]) -> Tuple[Unpack[Ts], str]:

return a[:-1] + (to_str(a[-1]),)

def h(a: Tuple[bool, int, Unpack[Ts], str, object]) -> Tuple[Unpack[Ts]]:

return a[2:-2]

empty = ()

bad_args: Tuple[str, str]

var_len_tuple: Tuple[int, ...]

f_args: Tuple[int, str]

f_args2: Tuple[int]

f_args3: Tuple[int, str, bool]

reveal_type(f(f_args)) # N: Revealed type is "tuple[builtins.str, builtins.str]"

reveal_type(f(f_args2)) # N: Revealed type is "tuple[builtins.str]"

reveal_type(f(f_args3)) # N: Revealed type is "tuple[builtins.str, builtins.str, builtins.bool]"

f(empty) # E: Argument 1 to "f" has incompatible type "tuple[()]"; expected "tuple[int]"

f(bad_args) # E: Argument 1 to "f" has incompatible type "tuple[str, str]"; expected "tuple[int, str]"

# The reason for error in subtle: actual can be empty, formal cannot.

reveal_type(f(var_len_tuple)) # N: Revealed type is "tuple[builtins.str, Unpack[builtins.tuple[builtins.int, ...]]]" \

# E: Argument 1 to "f" has incompatible type "tuple[int, ...]"; expected "tuple[int, Unpack[tuple[int, ...]]]"

g_args: Tuple[str, int]

reveal_type(g(g_args)) # N: Revealed type is "tuple[builtins.str, builtins.str]"

h_args: Tuple[bool, int, str, int, str, object]

reveal_type(h(h_args)) # N: Revealed type is "tuple[builtins.str, builtins.int]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleChaining]

from typing import Tuple

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def to_str(i: int) -> str:

...

def f(a: Tuple[int, Unpack[Ts]]) -> Tuple[str, Unpack[Ts]]:

return (to_str(a[0]),) + a[1:]

def g(a: Tuple[bool, int, Unpack[Ts], str, object]) -> Tuple[str, Unpack[Ts]]:

return f(a[1:-2])

def h(a: Tuple[bool, int, Unpack[Ts], str, object]) -> Tuple[str, Unpack[Ts]]:

x = f(a[1:-2])

return x

args: Tuple[bool, int, str, int, str, object]

reveal_type(g(args)) # N: Revealed type is "tuple[builtins.str, builtins.str, builtins.int]"

reveal_type(h(args)) # N: Revealed type is "tuple[builtins.str, builtins.str, builtins.int]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleGenericClassDefn]

from typing import Generic, TypeVar, Tuple, Union

from typing_extensions import TypeVarTuple, Unpack

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

class Variadic(Generic[Unpack[Ts]]):

pass

class Mixed1(Generic[T, Unpack[Ts]]):

pass

class Mixed2(Generic[Unpack[Ts], T]):

pass

variadic: Variadic[int, str]

reveal_type(variadic) # N: Revealed type is "__main__.Variadic[builtins.int, builtins.str]"

variadic_single: Variadic[int]

reveal_type(variadic_single) # N: Revealed type is "__main__.Variadic[builtins.int]"

empty: Variadic[()]

reveal_type(empty) # N: Revealed type is "__main__.Variadic[()]"

omitted: Variadic

reveal_type(omitted) # N: Revealed type is "__main__.Variadic[Unpack[builtins.tuple[Any, ...]]]"

bad: Variadic[Unpack[Tuple[int, ...]], str, Unpack[Tuple[bool, ...]]] # E: More than one variadic Unpack in a type is not allowed

reveal_type(bad) # N: Revealed type is "__main__.Variadic[Unpack[builtins.tuple[builtins.int, ...]], builtins.str]"

bad2: Unpack[Tuple[int, ...]] # E: Unpack is only valid in a variadic position

m1: Mixed1[int, str, bool]

reveal_type(m1) # N: Revealed type is "__main__.Mixed1[builtins.int, builtins.str, builtins.bool]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleGenericClassWithFunctions]

from typing import Generic, Tuple, TypeVar

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

T = TypeVar("T")

S = TypeVar("S")

class Variadic(Generic[T, Unpack[Ts], S]):

pass

def foo(t: Variadic[int, Unpack[Ts], object]) -> Tuple[int, Unpack[Ts]]:

...

v: Variadic[int, str, bool, object]

reveal_type(foo(v)) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.bool]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleGenericClassWithMethods]

from typing import Generic, Tuple, TypeVar

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

T = TypeVar("T")

S = TypeVar("S")

class Variadic(Generic[T, Unpack[Ts], S]):

def __init__(self, t: Tuple[Unpack[Ts]]) -> None:

...

def foo(self, t: int) -> Tuple[int, Unpack[Ts]]:

...

v: Variadic[float, str, bool, object]

reveal_type(v.foo(0)) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.bool]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleIsNotValidAliasTarget]

from typing_extensions import TypeVarTuple

Ts = TypeVarTuple("Ts")

B = Ts # E: Type variable "__main__.Ts" is invalid as target for type alias

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646ArrayExample]

from typing import Generic, Tuple, TypeVar, Protocol, NewType

from typing_extensions import TypeVarTuple, Unpack

Shape = TypeVarTuple('Shape')

Height = NewType('Height', int)

Width = NewType('Width', int)

T_co = TypeVar("T_co", covariant=True)

T = TypeVar("T")

class SupportsAbs(Protocol[T_co]):

def __abs__(self) -> T_co: pass

def abs(a: SupportsAbs[T]) -> T:

...

class Array(Generic[Unpack[Shape]]):

def __init__(self, shape: Tuple[Unpack[Shape]]):

self._shape: Tuple[Unpack[Shape]] = shape

def get_shape(self) -> Tuple[Unpack[Shape]]:

return self._shape

def __abs__(self) -> Array[Unpack[Shape]]: ...

def __add__(self, other: Array[Unpack[Shape]]) -> Array[Unpack[Shape]]: ...

shape = (Height(480), Width(640))

x: Array[Height, Width] = Array(shape)

reveal_type(abs(x)) # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"

reveal_type(x + x) # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646ArrayExampleWithDType]

from typing import Generic, Tuple, TypeVar, Protocol, NewType

from typing_extensions import TypeVarTuple, Unpack

DType = TypeVar("DType")

Shape = TypeVarTuple('Shape')

Height = NewType('Height', int)

Width = NewType('Width', int)

T_co = TypeVar("T_co", covariant=True)

T = TypeVar("T")

class SupportsAbs(Protocol[T_co]):

def __abs__(self) -> T_co: pass

def abs(a: SupportsAbs[T]) -> T:

...

class Array(Generic[DType, Unpack[Shape]]):

def __init__(self, shape: Tuple[Unpack[Shape]]):

self._shape: Tuple[Unpack[Shape]] = shape

def get_shape(self) -> Tuple[Unpack[Shape]]:

return self._shape

def __abs__(self) -> Array[DType, Unpack[Shape]]: ...

def __add__(self, other: Array[DType, Unpack[Shape]]) -> Array[DType, Unpack[Shape]]: ...

shape = (Height(480), Width(640))

x: Array[float, Height, Width] = Array(shape)

reveal_type(abs(x)) # N: Revealed type is "__main__.Array[builtins.float, __main__.Height, __main__.Width]"

reveal_type(x + x) # N: Revealed type is "__main__.Array[builtins.float, __main__.Height, __main__.Width]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646ArrayExampleInfer]

from typing import Generic, Tuple, TypeVar, NewType

from typing_extensions import TypeVarTuple, Unpack

Shape = TypeVarTuple('Shape')

Height = NewType('Height', int)

Width = NewType('Width', int)

class Array(Generic[Unpack[Shape]]):

pass

x: Array[float, Height, Width] = Array()

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeConcatenation]

from typing import Generic, TypeVar, NewType

from typing_extensions import TypeVarTuple, Unpack

Shape = TypeVarTuple('Shape')

Channels = NewType("Channels", int)

Batch = NewType("Batch", int)

Height = NewType('Height', int)

Width = NewType('Width', int)

class Array(Generic[Unpack[Shape]]):

pass

def add_batch_axis(x: Array[Unpack[Shape]]) -> Array[Batch, Unpack[Shape]]: ...

def del_batch_axis(x: Array[Batch, Unpack[Shape]]) -> Array[Unpack[Shape]]: ...

def add_batch_channels(

x: Array[Unpack[Shape]]

) -> Array[Batch, Unpack[Shape], Channels]: ...

a: Array[Height, Width]

b = add_batch_axis(a)

reveal_type(b) # N: Revealed type is "__main__.Array[__main__.Batch, __main__.Height, __main__.Width]"

c = del_batch_axis(b)

reveal_type(c) # N: Revealed type is "__main__.Array[__main__.Height, __main__.Width]"

d = add_batch_channels(a)

reveal_type(d) # N: Revealed type is "__main__.Array[__main__.Batch, __main__.Height, __main__.Width, __main__.Channels]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarConcatenation]

from typing import Generic, TypeVar, NewType, Tuple

from typing_extensions import TypeVarTuple, Unpack

T = TypeVar('T')

Ts = TypeVarTuple('Ts')

def prefix_tuple(

x: T,

y: Tuple[Unpack[Ts]],

) -> Tuple[T, Unpack[Ts]]:

...

z = prefix_tuple(x=0, y=(True, 'a'))

reveal_type(z) # N: Revealed type is "tuple[builtins.int, builtins.bool, builtins.str]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarTupleUnpacking]

from typing import Generic, TypeVar, NewType, Any, Tuple

from typing_extensions import TypeVarTuple, Unpack

Shape = TypeVarTuple('Shape')

Channels = NewType("Channels", int)

Batch = NewType("Batch", int)

Height = NewType('Height', int)

Width = NewType('Width', int)

class Array(Generic[Unpack[Shape]]):

pass

def process_batch_channels(

x: Array[Batch, Unpack[Tuple[Any, ...]], Channels]

) -> None:

...

x: Array[Batch, Height, Width, Channels]

process_batch_channels(x)

y: Array[Batch, Channels]

process_batch_channels(y)

z: Array[Batch]

process_batch_channels(z) # E: Argument 1 to "process_batch_channels" has incompatible type "Array[Batch]"; expected "Array[Batch, Unpack[tuple[Any, ...]], Channels]"

u: Array[Unpack[Tuple[Any, ...]]]

def expect_variadic_array(

x: Array[Batch, Unpack[Shape]]

) -> None:

...

def expect_variadic_array_2(

x: Array[Batch, Height, Width, Channels]

) -> None:

...

expect_variadic_array(u)

expect_variadic_array_2(u)

Ts = TypeVarTuple("Ts")

Ts2 = TypeVarTuple("Ts2")

def bad(x: Tuple[int, Unpack[Ts], str, Unpack[Ts2]]) -> None: # E: More than one variadic Unpack in a type is not allowed

...

reveal_type(bad) # N: Revealed type is "def [Ts, Ts2] (x: tuple[builtins.int, Unpack[Ts`-1], builtins.str])"

def bad2(x: Tuple[int, Unpack[Tuple[int, ...]], str, Unpack[Tuple[str, ...]]]) -> None: # E: More than one variadic Unpack in a type is not allowed

...

reveal_type(bad2) # N: Revealed type is "def (x: tuple[builtins.int, Unpack[builtins.tuple[builtins.int, ...]], builtins.str])"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarStarArgsBasic]

from typing import Tuple

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

def args_to_tuple(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]:

reveal_type(args) # N: Revealed type is "tuple[Unpack[Ts`-1]]"

reveal_type(args_to_tuple(1, *args)) # N: Revealed type is "tuple[Literal[1]?, Unpack[Ts`-1]]"

reveal_type(args_to_tuple(*args, 'a')) # N: Revealed type is "tuple[Unpack[Ts`-1], Literal['a']?]"

reveal_type(args_to_tuple(1, *args, 'a')) # N: Revealed type is "tuple[Literal[1]?, Unpack[Ts`-1], Literal['a']?]"

args_to_tuple(*args, *args) # E: Passing multiple variadic unpacks in a call is not supported

ok = (1, 'a')

reveal_type(args_to_tuple(*ok, *ok)) # N: Revealed type is "tuple[builtins.int, builtins.str, builtins.int, builtins.str]"

if int():

return args

else:

return args_to_tuple(*args)

reveal_type(args_to_tuple(1, 'a')) # N: Revealed type is "tuple[Literal[1]?, Literal['a']?]"

vt: Tuple[int, ...]

reveal_type(args_to_tuple(1, *vt)) # N: Revealed type is "tuple[Literal[1]?, Unpack[builtins.tuple[builtins.int, ...]]]"

reveal_type(args_to_tuple(*vt, 'a')) # N: Revealed type is "tuple[Unpack[builtins.tuple[builtins.int, ...]], Literal['a']?]"

reveal_type(args_to_tuple(1, *vt, 'a')) # N: Revealed type is "tuple[Literal[1]?, Unpack[builtins.tuple[builtins.int, ...]], Literal['a']?]"

args_to_tuple(*vt, *vt) # E: Passing multiple variadic unpacks in a call is not supported

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarStarArgs]

from typing import Tuple

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

def args_to_tuple(*args: Unpack[Ts]) -> Tuple[Unpack[Ts]]:

with_prefix_suffix(*args) # E: Too few arguments for "with_prefix_suffix" \

# E: Argument 1 to "with_prefix_suffix" has incompatible type "*tuple[Unpack[Ts]]"; expected "bool"

new_args = (True, "foo", *args, 5)

with_prefix_suffix(*new_args)

return args

def with_prefix_suffix(*args: Unpack[Tuple[bool, str, Unpack[Ts], int]]) -> Tuple[bool, str, Unpack[Ts], int]:

reveal_type(args) # N: Revealed type is "tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"

reveal_type(args_to_tuple(*args)) # N: Revealed type is "tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"

reveal_type(args_to_tuple(1, *args, 'a')) # N: Revealed type is "tuple[Literal[1]?, builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int, Literal['a']?]"

return args

reveal_type(with_prefix_suffix(True, "bar", "foo", 5)) # N: Revealed type is "tuple[builtins.bool, builtins.str, Literal['foo']?, builtins.int]"

reveal_type(with_prefix_suffix(True, "bar", 5)) # N: Revealed type is "tuple[builtins.bool, builtins.str, builtins.int]"

with_prefix_suffix(True, "bar", "foo", 1.0) # E: Argument 4 to "with_prefix_suffix" has incompatible type "float"; expected "int"

with_prefix_suffix(True, "bar") # E: Too few arguments for "with_prefix_suffix"

t = (True, "bar", "foo", 5)

reveal_type(with_prefix_suffix(*t)) # N: Revealed type is "tuple[builtins.bool, builtins.str, builtins.str, builtins.int]"

reveal_type(with_prefix_suffix(True, *("bar", "foo"), 5)) # N: Revealed type is "tuple[builtins.bool, builtins.str, Literal['foo']?, builtins.int]"

reveal_type(with_prefix_suffix(True, "bar", *["foo1", "foo2"], 5)) # N: Revealed type is "tuple[builtins.bool, builtins.str, Unpack[builtins.tuple[builtins.str, ...]], builtins.int]"

bad_t = (True, "bar")

with_prefix_suffix(*bad_t) # E: Too few arguments for "with_prefix_suffix"

def foo(*args: Unpack[Ts]) -> None:

reveal_type(with_prefix_suffix(True, "bar", *args, 5)) # N: Revealed type is "tuple[builtins.bool, builtins.str, Unpack[Ts`-1], builtins.int]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarStarArgsFixedLengthTuple]

from typing import Tuple

from typing_extensions import Unpack

def foo(*args: Unpack[Tuple[int, str]]) -> None:

reveal_type(args) # N: Revealed type is "tuple[builtins.int, builtins.str]"

foo(0, "foo")

foo(0, 1) # E: Argument 2 to "foo" has incompatible type "int"; expected "str"

foo("foo", "bar") # E: Argument 1 to "foo" has incompatible type "str"; expected "int"

foo(0, "foo", 1) # E: Too many arguments for "foo"

foo(0) # E: Too few arguments for "foo"

foo() # E: Too few arguments for "foo"

foo(*(0, "foo"))

def foo2(*args: Unpack[Tuple[bool, Unpack[Tuple[int, str]], bool]]) -> None:

reveal_type(args) # N: Revealed type is "tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]"

# It is hard to normalize callable types in definition, because there is deep relation between `FuncDef.type`

# and `FuncDef.arguments`, therefore various typeops need to be sure to normalize Callable types before using them.

reveal_type(foo2) # N: Revealed type is "def (*args: Unpack[tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]])"

class C:

def foo2(self, *args: Unpack[Tuple[bool, Unpack[Tuple[int, str]], bool]]) -> None: ...

reveal_type(C().foo2) # N: Revealed type is "def (*args: Unpack[tuple[builtins.bool, builtins.int, builtins.str, builtins.bool]])"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646TypeVarStarArgsVariableLengthTuple]

from typing import Tuple

from typing_extensions import Unpack, TypeVarTuple

def foo(*args: Unpack[Tuple[int, ...]]) -> None:

reveal_type(args) # N: Revealed type is "builtins.tuple[builtins.int, ...]"

foo(0, 1, 2)

foo(0, 1, "bar") # E: Argument 3 to "foo" has incompatible type "str"; expected "int"

def foo2(*args: Unpack[Tuple[str, Unpack[Tuple[int, ...]], bool, bool]]) -> None:

reveal_type(args) # N: Revealed type is "tuple[builtins.str, Unpack[builtins.tuple[builtins.int, ...]], builtins.bool, builtins.bool]"

reveal_type(args[1]) # N: Revealed type is "builtins.int"

def foo3(*args: Unpack[Tuple[str, Unpack[Tuple[int, ...]], str, float]]) -> None:

reveal_type(args[0]) # N: Revealed type is "builtins.str"

reveal_type(args[1]) # N: Revealed type is "builtins.int | builtins.str"

reveal_type(args[2]) # N: Revealed type is "builtins.int | builtins.str | builtins.float"

args[3] # E: Tuple index out of range \

# N: Variadic tuple can have length 3

reveal_type(args[-1]) # N: Revealed type is "builtins.float"

reveal_type(args[-2]) # N: Revealed type is "builtins.str"

reveal_type(args[-3]) # N: Revealed type is "builtins.str | builtins.int"

args[-4] # E: Tuple index out of range \

# N: Variadic tuple can have length 3

reveal_type(args[::-1]) # N: Revealed type is "tuple[builtins.float, builtins.str, Unpack[builtins.tuple[builtins.int, ...]], builtins.str]"

args[::2] # E: Ambiguous slice of a variadic tuple

args[:2] # E: Ambiguous slice of a variadic tuple

Ts = TypeVarTuple("Ts")

def foo4(*args: Unpack[Tuple[str, Unpack[Ts], bool, bool]]) -> None:

reveal_type(args[1]) # N: Revealed type is "builtins.object"

foo2("bar", 1, 2, 3, False, True)

foo2(0, 1, 2, 3, False, True) # E: Argument 1 to "foo2" has incompatible type "int"; expected "str"

foo2("bar", "bar", 2, 3, False, True) # E: Argument 2 to "foo2" has incompatible type "str"; expected "Unpack[tuple[Unpack[tuple[int, ...]], bool, bool]]"

foo2("bar", 1, 2, 3, 4, True) # E: Argument 5 to "foo2" has incompatible type "int"; expected "Unpack[tuple[Unpack[tuple[int, ...]], bool, bool]]"

foo2(*("bar", 1, 2, 3, False, True))

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646Callable]

from typing import Tuple, Callable

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def call(

target: Callable[[Unpack[Ts]], None],

args: Tuple[Unpack[Ts]],

) -> None:

pass

def func(arg1: int, arg2: str) -> None: ...

def func2(arg1: int, arg2: int) -> None: ...

def func3(*args: int) -> None: ...

vargs: Tuple[int, ...]

vargs_str: Tuple[str, ...]

call(target=func, args=(0, 'foo'))

call(target=func, args=('bar', 'foo')) # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[str, str], None]"

call(target=func, args=(True, 'foo', 0)) # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[bool, str, int], None]"

call(target=func, args=(0, 0, 'foo')) # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, int, str], None]"

call(target=func, args=vargs) # E: Argument "target" to "call" has incompatible type "Callable[[int, str], None]"; expected "def (*int) -> None"

# NOTE: This behavior may be a bit contentious, it is maybe inconsistent with our handling of

# PEP646 but consistent with our handling of callable constraints.

call(target=func2, args=vargs) # E: Argument "target" to "call" has incompatible type "Callable[[int, int], None]"; expected "def (*int) -> None"

call(target=func3, args=vargs)

call(target=func3, args=(0,1))

call(target=func3, args=(0,'foo')) # E: Argument "target" to "call" has incompatible type "def func3(*args: int) -> None"; expected "Callable[[int, str], None]"

call(target=func3, args=vargs_str) # E: Argument "target" to "call" has incompatible type "def func3(*args: int) -> None"; expected "def (*str) -> None"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646CallableWithPrefixSuffix]

from typing import Tuple, Callable

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def call_prefix(

target: Callable[[bytes, Unpack[Ts]], None],

args: Tuple[Unpack[Ts]],

) -> None:

pass

def func_prefix(arg0: bytes, arg1: int, arg2: str) -> None: ...

def func2_prefix(arg0: str, arg1: int, arg2: str) -> None: ...

call_prefix(target=func_prefix, args=(0, 'foo'))

call_prefix(target=func2_prefix, args=(0, 'foo')) # E: Argument "target" to "call_prefix" has incompatible type "Callable[[str, int, str], None]"; expected "Callable[[bytes, int, str], None]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646CallableSuffixSyntax]

from typing import Callable, Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

x: Callable[[str, Unpack[Tuple[int, ...]], bool], None]

reveal_type(x) # N: Revealed type is "def (builtins.str, *Unpack[tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.bool]])"

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

A = Callable[[T, Unpack[Ts], S], int]

y: A[int, str, bool]

reveal_type(y) # N: Revealed type is "def (builtins.int, builtins.str, builtins.bool) -> builtins.int"

z: A[Unpack[Tuple[int, ...]]]

reveal_type(z) # N: Revealed type is "def (builtins.int, *Unpack[tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.int]]) -> builtins.int"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646CallableInvalidSyntax]

from typing import Callable, Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

Us = TypeVarTuple("Us")

a: Callable[[Unpack[Ts], Unpack[Us]], int] # E: More than one variadic Unpack in a type is not allowed

reveal_type(a) # N: Revealed type is "def [Ts, Us] (*Unpack[Ts`-1]) -> builtins.int"

b: Callable[[Unpack], int] # E: Unpack[...] requires exactly one type argument

reveal_type(b) # N: Revealed type is "def (*Any) -> builtins.int"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646CallableNewSyntax]

from typing import Callable, Generic, Tuple

from typing_extensions import ParamSpec

x: Callable[[str, *Tuple[int, ...]], None]

reveal_type(x) # N: Revealed type is "def (builtins.str, *builtins.int)"

y: Callable[[str, *Tuple[int, ...], bool], None]

reveal_type(y) # N: Revealed type is "def (builtins.str, *Unpack[tuple[Unpack[builtins.tuple[builtins.int, ...]], builtins.bool]])"

P = ParamSpec("P")

class C(Generic[P]): ...

bad: C[[int, *Tuple[int, ...], int]] # E: Unpack is only valid in a variadic position

reveal_type(bad) # N: Revealed type is "__main__.C[[builtins.int, *Any]]"

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646UnspecifiedParameters]

from typing import Tuple, Generic, TypeVar

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

class Array(Generic[Unpack[Ts]]):

...

def takes_any_array(arr: Array) -> None:

...

x: Array[int, bool]

takes_any_array(x)

T = TypeVar("T")

class Array2(Generic[T, Unpack[Ts]]):

...

def takes_empty_array2(arr: Array2[int]) -> None:

...

y: Array2[int]

takes_empty_array2(y)

[builtins fixtures/tuple.pyi]

[case testTypeVarTuplePep646CallableStarArgs]

from typing import Tuple, Callable

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

def call(

target: Callable[[Unpack[Ts]], None],

*args: Unpack[Ts],

) -> None:

...

target(*args)

class A:

def func(self, arg1: int, arg2: str) -> None: ...

def func2(self, arg1: int, arg2: int) -> None: ...

def func3(self, *args: int) -> None: ...

vargs: Tuple[int, ...]

vargs_str: Tuple[str, ...]

call(A().func) # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[], None]"

call(A().func, 0, 'foo')

call(A().func, 0, 'foo', 0) # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, str, int], None]"

call(A().func, 0) # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int], None]"

call(A().func, 0, 1) # E: Argument 1 to "call" has incompatible type "Callable[[int, str], None]"; expected "Callable[[int, int], None]"

call(A().func2, 0, 0)

call(A().func3, 0, 1, 2)

call(A().func3)

[builtins fixtures/tuple.pyi]

[case testVariadicAliasBasicTuple]

from typing import Tuple, List, TypeVar

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

A = List[Tuple[T, Unpack[Ts], T]]

x: A[int, str, str]

reveal_type(x) # N: Revealed type is "builtins.list[tuple[builtins.int, builtins.str, builtins.str, builtins.int]]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasBasicCallable]

from typing import TypeVar, Callable

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

A = Callable[[T, Unpack[Ts]], S]

x: A[int, str, int, str]

reveal_type(x) # N: Revealed type is "def (builtins.int, builtins.str, builtins.int) -> builtins.str"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasBasicInstance]

from typing import TypeVar, Generic

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

class G(Generic[Unpack[Ts], T]): ...

A = G[T, Unpack[Ts], T]

x: A[int, str, str]

reveal_type(x) # N: Revealed type is "__main__.G[builtins.int, builtins.str, builtins.str, builtins.int]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasUnpackFixedTupleArgs]

from typing import Tuple, List, TypeVar

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

Start = Tuple[int, str]

A = List[Tuple[T, Unpack[Ts], S]]

x: A[Unpack[Start], int]

reveal_type(x) # N: Revealed type is "builtins.list[tuple[builtins.int, builtins.str, builtins.int]]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasUnpackFixedTupleTarget]

from typing import Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

Prefix = Tuple[int, int]

A = Tuple[Unpack[Prefix], Unpack[Ts]]

x: A[str, str]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.int, builtins.str, builtins.str]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasMultipleUnpacks]

from typing import Tuple, Generic, Callable

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

Us = TypeVarTuple("Us")

class G(Generic[Unpack[Ts]]): ...

A = Tuple[Unpack[Ts], Unpack[Us]] # E: More than one variadic Unpack in a type is not allowed

x: A[int, str]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.str]"

B = Callable[[Unpack[Ts], Unpack[Us]], int] # E: More than one variadic Unpack in a type is not allowed

y: B[int, str]

reveal_type(y) # N: Revealed type is "def (builtins.int, builtins.str) -> builtins.int"

C = G[Unpack[Ts], Unpack[Us]] # E: More than one variadic Unpack in a type is not allowed

z: C[int, str]

reveal_type(z) # N: Revealed type is "__main__.G[builtins.int, builtins.str]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasNoArgs]

from typing import Tuple, TypeVar, Generic, Callable, List

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

class G(Generic[Unpack[Ts]]): ...

A = List[Tuple[T, Unpack[Ts], T]]

x: A

reveal_type(x) # N: Revealed type is "builtins.list[tuple[Any, Unpack[builtins.tuple[Any, ...]], Any]]"

B = Callable[[T, Unpack[Ts]], int]

y: B

reveal_type(y) # N: Revealed type is "def (Any, *Any) -> builtins.int"

C = G[T, Unpack[Ts], T]

z: C

reveal_type(z) # N: Revealed type is "__main__.G[Any, Unpack[builtins.tuple[Any, ...]], Any]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasFewArgs]

from typing import Tuple, List, TypeVar, Generic, Callable

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

class G(Generic[Unpack[Ts]]): ...

A = List[Tuple[T, Unpack[Ts], S]]

x: A[int] # E: Bad number of arguments for type alias, expected at least 2, given 1

reveal_type(x) # N: Revealed type is "builtins.list[tuple[Any, Unpack[builtins.tuple[Any, ...]], Any]]"

B = Callable[[T, S, Unpack[Ts]], int]

y: B[int] # E: Bad number of arguments for type alias, expected at least 2, given 1

reveal_type(y) # N: Revealed type is "def (Any, Any, *Any) -> builtins.int"

C = G[T, Unpack[Ts], S]

z: C[int] # E: Bad number of arguments for type alias, expected at least 2, given 1

reveal_type(z) # N: Revealed type is "__main__.G[Any, Unpack[builtins.tuple[Any, ...]], Any]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasRecursiveUnpack]

from typing import Tuple, Optional

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

A = Tuple[Unpack[Ts], Optional[A[Unpack[Ts]]]]

x: A[int, str]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.str, ... | None]"

*_, last = x

if last is not None:

reveal_type(last) # N: Revealed type is "tuple[builtins.int, builtins.str, tuple[builtins.int, builtins.str, ... | None] | None]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasUpperBoundCheck]

from typing import Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

class A: ...

class B: ...

class C: ...

class D: ...

T = TypeVar("T", bound=int)

S = TypeVar("S", bound=str)

Ts = TypeVarTuple("Ts")

Alias = Tuple[T, Unpack[Ts], S]

First = Tuple[A, B]

Second = Tuple[C, D]

x: Alias[Unpack[First], Unpack[Second]] # E: Type argument "A" of "Alias" must be a subtype of "int" \

# E: Type argument "D" of "Alias" must be a subtype of "str"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasEmptyArg]

from typing import Tuple

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

A = Tuple[int, Unpack[Ts], str]

x: A[()]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.str]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasVariadicTupleArg]

from typing import Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

Ts = TypeVarTuple("Ts")

A = Tuple[int, Unpack[Ts]]

B = A[str, Unpack[Ts]]

C = B[Unpack[Tuple[bool, ...]]]

x: C

reveal_type(x) # N: Revealed type is "tuple[builtins.int, builtins.str, Unpack[builtins.tuple[builtins.bool, ...]]]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasVariadicTupleArgGeneric]

from typing import Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

A = Tuple[int, Unpack[Ts]]

B = A[Unpack[Tuple[T, ...]]]

x: B[str]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, Unpack[builtins.tuple[builtins.str, ...]]]"

[builtins fixtures/tuple.pyi]

[case testVariadicAliasVariadicTupleArgSplit]

from typing import Tuple, TypeVar

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")

A = Tuple[T, Unpack[Ts], S, T]

x: A[int, Unpack[Tuple[bool, ...]], str]

reveal_type(x) # N: Revealed type is "tuple[builtins.int, Unpack[builtins.tuple[builtins.bool, ...]], builtins.str, builtins.int]"

y: A[Unpack[Tuple[bool, ...]]]

reveal_type(y) # N: Revealed type is "tuple[builtins.bool, Unpack[builtins.tuple[builtins.bool, ...]], builtins.bool, builtins.bool]"

[builtins fixtures/tuple.pyi]

[case testBanPathologicalRecursiveTuples]

from typing import Tuple

from typing_extensions import Unpack

A = Tuple[int, Unpack[A]] # E: Invalid recursive alias: a tuple item of itself

B = Tuple[int, Unpack[C]] # E: Invalid recursive alias: a tuple item of itself \

# E: Name "C" is used before definition

C = Tuple[int, Unpack[B]]

x: A

y: B

z: C

reveal_type(x) # N: Revealed type is "Any"

reveal_type(y) # N: Revealed type is "Any"

reveal_type(z) # N: Revealed type is "tuple[builtins.int, Unpack[builtins.tuple[Any, ...]]]"

[builtins fixtures/tuple.pyi]

[case testInferenceAgainstGenericVariadicWithBadType]

from typing import TypeVar, Callable, Generic

from typing_extensions import Unpack, TypeVarTuple

T = TypeVar("T")

Ts = TypeVarTuple("Ts")

Us = TypeVarTuple("Us")

class Foo(Generic[Unpack[Ts]]): ...

def dec(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], T]: ...

def f(*args: Unpack[Us]) -> Foo[Us]: ... # E: TypeVarTuple "Us" is only valid with an unpack

dec(f) # No crash

[builtins fixtures/tuple.pyi]

[case testHomogeneousGenericTupleUnpackInferenceNoCrash1]

from typing import Any, TypeVar, Tuple, Type, Optional

from typing_extensions import Unpack

T = TypeVar("T")

def convert(obj: Any, *to_classes: Unpack[Tuple[Type[T], ...]]) -> Optional[T]:

...

x = convert(1, int, float)

reveal_type(x) # N: Revealed type is "builtins.float | None"

[builtins fixtures/tuple.pyi]

[case testHomogeneousGenericTupleUnpackInferenceNoCrash2]

from typing import TypeVar, Tuple, Callable, Iterable

from typing_extensions import Unpack

T = TypeVar("T")

def combine(x: T, y: T) -> T: ...

def reduce(fn: Callable[[T, T], T], xs: Iterable[T]) -> T: ...

def pipeline(*xs: Unpack[Tuple[int, Unpack[Tuple[str, ...]], bool]]) -> None:

reduce(combine, xs)

[builtins fixtures/tuple.pyi]

[case testVariadicStarArgsCallNoCrash]

from typing import TypeVar, Callable, Tuple

from typing_extensions import TypeVarTuple, Unpack

X = TypeVar("X")

Y = TypeVar("Y")

Xs = TypeVarTuple("Xs")

Ys = TypeVarTuple("Ys")

def nil() -> Tuple[()]:

return ()

def cons(

f: Callable[[X], Y],

g: Callable[[Unpack[Xs]], Tuple[Unpack[Ys]]],

) -> Callable[[X, Unpack[Xs]], Tuple[Y, Unpack[Ys]]]:

def wrapped(x: X, *xs: Unpack[Xs]) -> Tuple[Y, Unpack[Ys]]:

y, ys = f(x), g(*xs)

return y, *ys

return wrapped

def star(f: Callable[[X], Y]) -> Callable[[Unpack[Tuple[X, ...]]], Tuple[Y, ...]]:

def wrapped(*xs: X) -> Tuple[Y, ...]:

if not xs:

return nil()

return cons(f, star(f))(*xs)

return wrapped

[builtins fixtures/tuple.pyi]

[case testInvalidTypeVarTupleUseNoCrash]

from typing_extensions import TypeVarTuple

Ts = TypeVarTuple("Ts")

def f(x: Ts) -> Ts: # E: TypeVarTuple "Ts" is only valid with an unpack

return x

v = f(1, 2, "A") # E: Too many arguments for "f"

reveal_type(v) # N: Revealed type is "Any"

[builtins fixtures/tuple.pyi]

[case testTypeVarTupleSimpleDecoratorWorks]

from typing import TypeVar, Callable

from typing_extensions import TypeVarTuple, Unpack

Ts = TypeVarTuple("Ts")

T = TypeVar("T")

def decorator(f: Callable[[Unpack[Ts]], T]) -> Callable[[Unpack[Ts]], T]:

def wrapper(*args: Unpack[Ts]) -> T:

return f(*args)

return wrapper

@decorator

def f(a: int, b: int) -> int: ...

reveal_type(f) # N: Revealed type is "def (builtins.int, builtins.int) -> builtins.int"

[builtins fixtures/tuple.pyi]

[case testTupleWithUnpackIterator]

from typing import Tuple

from typing_extensions import Unpack

def pipeline(*xs: Unpack[Tuple[int, Unpack[Tuple[float, ...]], bool]]) -> None:

for x in xs:

reveal_type(x) # N: Revealed type is "builtins.int | builtins.float"

[builtins fixtures/tuple.pyi]

[case testFixedUnpackItemInInstanceArguments]

from typing import TypeVar, Callable, Tuple, Generic

from typing_extensions import TypeVarTuple, Unpack

T = TypeVar("T")

S = TypeVar("S")

Ts = TypeVarTuple("Ts")