[case testGenericFunction]
from typing import TypeVar, List
T = TypeVar('T')
def f(x: T) -> T:
    return x
def g(x: List[T]) -> List[T]:
    return [x[0]]
def h(x: int, y: List[int]) -> None:
    x = f(x)
    y = g(y)
[out]
def f(x):
    x :: object
L0:
    return x
def g(x):
    x :: list
    r0 :: object
    r1 :: list
    r2 :: ptr
L0:
    r0 = CPyList_GetItemShort(x, 0)
    r1 = PyList_New(1)
    r2 = list_items r1
    buf_init_item r2, 0, r0
    keep_alive r1
    return r1
def h(x, y):
    x :: int
    y :: list
    r0, r1 :: object
    r2 :: int
    r3 :: list
L0:
    r0 = box(int, x)
    r1 = f(r0)
    r2 = unbox(int, r1)
    x = r2
    r3 = g(y)
    y = r3
    return 1

[case testGenericAttrAndTypeApplication]
from typing import TypeVar, Generic
T = TypeVar('T')
class C(Generic[T]):
    x: T
def f() -> None:
    c = C[int]()
    c.x = 1
    2 + c.x
[out]
def f():
    r0, c :: __main__.C
    r1 :: object
    r2 :: bool
    r3 :: object
    r4, r5 :: int
L0:
    r0 = C()
    c = r0
    r1 = object 1
    c.x = r1; r2 = is_error
    r3 = borrow c.x
    r4 = unbox(int, r3)
    r5 = CPyTagged_Add(4, r4)
    keep_alive c
    return 1

[case testGenericMethod]
from typing import TypeVar, Generic
T = TypeVar('T')
class C(Generic[T]):
    x: T
    def __init__(self, x: T) -> None:
        self.x = x
    def get(self) -> T:
        return self.x
    def set(self, y: T) -> None:
        self.x = y
def f(x: C[int]) -> None:
    y = x.get()
    x.set(y + 1)
    x = C(2)
[out]
def C.__init__(self, x):
    self :: __main__.C
    x :: object
    r0 :: bool
L0:
    self.x = x; r0 = is_error
    return 1
def C.get(self):
    self :: __main__.C
    r0 :: object
L0:
    r0 = self.x
    return r0
def C.set(self, y):
    self :: __main__.C
    y :: object
    r0 :: bool
L0:
    self.x = y; r0 = is_error
    return 1
def f(x):
    x :: __main__.C
    r0 :: object
    r1, y, r2 :: int
    r3 :: object
    r4 :: None
    r5 :: object
    r6 :: __main__.C
L0:
    r0 = x.get()
    r1 = unbox(int, r0)
    y = r1
    r2 = CPyTagged_Add(y, 2)
    r3 = box(int, r2)
    r4 = x.set(r3)
    r5 = object 2
    r6 = C(r5)
    x = r6
    return 1

[case testMax]
from typing import TypeVar
T = TypeVar('T')
def f(x: T, y: T) -> T:
    return max(x, y)
[out]
def f(x, y):
    x, y, r0 :: object
    r1 :: i32
    r2 :: bit
    r3 :: bool
    r4 :: object
L0:
    r0 = PyObject_RichCompare(y, x, 4)
    r1 = PyObject_IsTrue(r0)
    r2 = r1 >= 0 :: signed
    r3 = truncate r1: i32 to builtins.bool
    if r3 goto L1 else goto L2 :: bool
L1:
    r4 = y
    goto L3
L2:
    r4 = x
L3:
    return r4


[case testParamSpec]
from typing import Callable, ParamSpec

P = ParamSpec("P")

def execute(func: Callable[P, int], *args: P.args, **kwargs: P.kwargs) -> int:
    return func(*args, **kwargs)

def f(x: int) -> int:
    return x

execute(f, 1)
[out]
def execute(func, args, kwargs):
    func :: object
    args :: tuple
    kwargs, r0 :: dict
    r1 :: object
    r2 :: int
L0:
    r0 = PyDict_Copy(kwargs)
    r1 = PyObject_Call(func, args, r0)
    r2 = unbox(int, r1)
    return r2
def f(x):
    x :: int
L0:
    return x

[case testTypeVarMappingBound]
# Dicts are special-cased for efficient iteration.
from typing import Dict, TypedDict, TypeVar, Union

class TD(TypedDict):
    foo: int

M = TypeVar("M", bound=Dict[str, int])
U = TypeVar("U", bound=Union[Dict[str, int], Dict[str, str]])
T = TypeVar("T", bound=TD)

def fn_mapping(m: M) -> None:
    [x for x in m]
    [x for x in m.values()]
    {x for x in m.keys()}
    {k: v for k, v in m.items()}

def fn_union(m: U) -> None:
    [x for x in m]
    [x for x in m.values()]
    {x for x in m.keys()}
    {k: v for k, v in m.items()}

def fn_typeddict(t: T) -> None:
    [x for x in t]
    [x for x in t.values()]
    {x for x in t.keys()}
    {k: v for k, v in t.items()}

[typing fixtures/typing-full.pyi]
[out]
def fn_mapping(m):
    m :: dict
    r0 :: list
    r1 :: short_int
    r2 :: native_int
    r3 :: object
    r4 :: tuple[bool, short_int, object]
    r5 :: short_int
    r6 :: bool
    r7 :: object
    r8, x :: str
    r9 :: i32
    r10, r11, r12 :: bit
    r13 :: list
    r14 :: short_int
    r15 :: native_int
    r16 :: object
    r17 :: tuple[bool, short_int, object]
    r18 :: short_int
    r19 :: bool
    r20 :: object
    r21, x_2 :: int
    r22 :: object
    r23 :: i32
    r24, r25, r26 :: bit
    r27 :: set
    r28 :: short_int
    r29 :: native_int
    r30 :: object
    r31 :: tuple[bool, short_int, object]
    r32 :: short_int
    r33 :: bool
    r34 :: object
    r35, x_3 :: str
    r36 :: i32
    r37, r38, r39 :: bit
    r40 :: dict
    r41 :: short_int
    r42 :: native_int
    r43 :: object
    r44 :: tuple[bool, short_int, object, object]
    r45 :: short_int
    r46 :: bool
    r47, r48 :: object
    r49 :: str
    r50 :: int
    k :: str
    v :: int
    r51 :: object
    r52 :: i32
    r53, r54, r55 :: bit
L0:
    r0 = PyList_New(0)
    r1 = 0
    r2 = PyDict_Size(m)
    r3 = CPyDict_GetKeysIter(m)
L1:
    r4 = CPyDict_NextKey(r3, r1)
    r5 = r4[1]
    r1 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L4 :: bool
L2:
    r7 = r4[2]
    r8 = cast(str, r7)
    x = r8
    r9 = PyList_Append(r0, x)
    r10 = r9 >= 0 :: signed
L3:
    r11 = CPyDict_CheckSize(m, r2)
    goto L1
L4:
    r12 = CPy_NoErrOccurred()
L5:
    r13 = PyList_New(0)
    r14 = 0
    r15 = PyDict_Size(m)
    r16 = CPyDict_GetValuesIter(m)
L6:
    r17 = CPyDict_NextValue(r16, r14)
    r18 = r17[1]
    r14 = r18
    r19 = r17[0]
    if r19 goto L7 else goto L9 :: bool
L7:
    r20 = r17[2]
    r21 = unbox(int, r20)
    x_2 = r21
    r22 = box(int, x_2)
    r23 = PyList_Append(r13, r22)
    r24 = r23 >= 0 :: signed
L8:
    r25 = CPyDict_CheckSize(m, r15)
    goto L6
L9:
    r26 = CPy_NoErrOccurred()
L10:
    r27 = PySet_New(0)
    r28 = 0
    r29 = PyDict_Size(m)
    r30 = CPyDict_GetKeysIter(m)
L11:
    r31 = CPyDict_NextKey(r30, r28)
    r32 = r31[1]
    r28 = r32
    r33 = r31[0]
    if r33 goto L12 else goto L14 :: bool
L12:
    r34 = r31[2]
    r35 = cast(str, r34)
    x_3 = r35
    r36 = PySet_Add(r27, x_3)
    r37 = r36 >= 0 :: signed
L13:
    r38 = CPyDict_CheckSize(m, r29)
    goto L11
L14:
    r39 = CPy_NoErrOccurred()
L15:
    r40 = PyDict_New()
    r41 = 0
    r42 = PyDict_Size(m)
    r43 = CPyDict_GetItemsIter(m)
L16:
    r44 = CPyDict_NextItem(r43, r41)
    r45 = r44[1]
    r41 = r45
    r46 = r44[0]
    if r46 goto L17 else goto L19 :: bool
L17:
    r47 = r44[2]
    r48 = r44[3]
    r49 = cast(str, r47)
    r50 = unbox(int, r48)
    k = r49
    v = r50
    r51 = box(int, v)
    r52 = PyDict_SetItem(r40, k, r51)
    r53 = r52 >= 0 :: signed
L18:
    r54 = CPyDict_CheckSize(m, r42)
    goto L16
L19:
    r55 = CPy_NoErrOccurred()
L20:
    return 1
def fn_union(m):
    m :: dict
    r0 :: list
    r1 :: short_int
    r2 :: native_int
    r3 :: object
    r4 :: tuple[bool, short_int, object]
    r5 :: short_int
    r6 :: bool
    r7 :: object
    r8, x :: str
    r9 :: i32
    r10, r11, r12 :: bit
    r13 :: list
    r14 :: short_int
    r15 :: native_int
    r16 :: object
    r17 :: tuple[bool, short_int, object]
    r18 :: short_int
    r19 :: bool
    r20 :: object
    r21, x_2 :: union[int, str]
    r22 :: i32
    r23, r24, r25 :: bit
    r26 :: set
    r27 :: short_int
    r28 :: native_int
    r29 :: object
    r30 :: tuple[bool, short_int, object]
    r31 :: short_int
    r32 :: bool
    r33 :: object
    r34, x_3 :: str
    r35 :: i32
    r36, r37, r38 :: bit
    r39 :: dict
    r40 :: short_int
    r41 :: native_int
    r42 :: object
    r43 :: tuple[bool, short_int, object, object]
    r44 :: short_int
    r45 :: bool
    r46, r47 :: object
    r48 :: str
    r49 :: union[int, str]
    k :: str
    v :: union[int, str]
    r50 :: i32
    r51, r52, r53 :: bit
L0:
    r0 = PyList_New(0)
    r1 = 0
    r2 = PyDict_Size(m)
    r3 = CPyDict_GetKeysIter(m)
L1:
    r4 = CPyDict_NextKey(r3, r1)
    r5 = r4[1]
    r1 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L4 :: bool
L2:
    r7 = r4[2]
    r8 = cast(str, r7)
    x = r8
    r9 = PyList_Append(r0, x)
    r10 = r9 >= 0 :: signed
L3:
    r11 = CPyDict_CheckSize(m, r2)
    goto L1
L4:
    r12 = CPy_NoErrOccurred()
L5:
    r13 = PyList_New(0)
    r14 = 0
    r15 = PyDict_Size(m)
    r16 = CPyDict_GetValuesIter(m)
L6:
    r17 = CPyDict_NextValue(r16, r14)
    r18 = r17[1]
    r14 = r18
    r19 = r17[0]
    if r19 goto L7 else goto L9 :: bool
L7:
    r20 = r17[2]
    r21 = cast(union[int, str], r20)
    x_2 = r21
    r22 = PyList_Append(r13, x_2)
    r23 = r22 >= 0 :: signed
L8:
    r24 = CPyDict_CheckSize(m, r15)
    goto L6
L9:
    r25 = CPy_NoErrOccurred()
L10:
    r26 = PySet_New(0)
    r27 = 0
    r28 = PyDict_Size(m)
    r29 = CPyDict_GetKeysIter(m)
L11:
    r30 = CPyDict_NextKey(r29, r27)
    r31 = r30[1]
    r27 = r31
    r32 = r30[0]
    if r32 goto L12 else goto L14 :: bool
L12:
    r33 = r30[2]
    r34 = cast(str, r33)
    x_3 = r34
    r35 = PySet_Add(r26, x_3)
    r36 = r35 >= 0 :: signed
L13:
    r37 = CPyDict_CheckSize(m, r28)
    goto L11
L14:
    r38 = CPy_NoErrOccurred()
L15:
    r39 = PyDict_New()
    r40 = 0
    r41 = PyDict_Size(m)
    r42 = CPyDict_GetItemsIter(m)
L16:
    r43 = CPyDict_NextItem(r42, r40)
    r44 = r43[1]
    r40 = r44
    r45 = r43[0]
    if r45 goto L17 else goto L19 :: bool
L17:
    r46 = r43[2]
    r47 = r43[3]
    r48 = cast(str, r46)
    r49 = cast(union[int, str], r47)
    k = r48
    v = r49
    r50 = PyDict_SetItem(r39, k, v)
    r51 = r50 >= 0 :: signed
L18:
    r52 = CPyDict_CheckSize(m, r41)
    goto L16
L19:
    r53 = CPy_NoErrOccurred()
L20:
    return 1
def fn_typeddict(t):
    t :: dict
    r0 :: list
    r1 :: short_int
    r2 :: native_int
    r3 :: object
    r4 :: tuple[bool, short_int, object]
    r5 :: short_int
    r6 :: bool
    r7 :: object
    r8, x :: str
    r9 :: i32
    r10, r11, r12 :: bit
    r13 :: list
    r14 :: short_int
    r15 :: native_int
    r16 :: object
    r17 :: tuple[bool, short_int, object]
    r18 :: short_int
    r19 :: bool
    r20, x_2 :: object
    r21 :: i32
    r22, r23, r24 :: bit
    r25 :: set
    r26 :: short_int
    r27 :: native_int
    r28 :: object
    r29 :: tuple[bool, short_int, object]
    r30 :: short_int
    r31 :: bool
    r32 :: object
    r33, x_3 :: str
    r34 :: i32
    r35, r36, r37 :: bit
    r38 :: dict
    r39 :: short_int
    r40 :: native_int
    r41 :: object
    r42 :: tuple[bool, short_int, object, object]
    r43 :: short_int
    r44 :: bool
    r45, r46 :: object
    r47, k :: str
    v :: object
    r48 :: i32
    r49, r50, r51 :: bit
L0:
    r0 = PyList_New(0)
    r1 = 0
    r2 = PyDict_Size(t)
    r3 = CPyDict_GetKeysIter(t)
L1:
    r4 = CPyDict_NextKey(r3, r1)
    r5 = r4[1]
    r1 = r5
    r6 = r4[0]
    if r6 goto L2 else goto L4 :: bool
L2:
    r7 = r4[2]
    r8 = cast(str, r7)
    x = r8
    r9 = PyList_Append(r0, x)
    r10 = r9 >= 0 :: signed
L3:
    r11 = CPyDict_CheckSize(t, r2)
    goto L1
L4:
    r12 = CPy_NoErrOccurred()
L5:
    r13 = PyList_New(0)
    r14 = 0
    r15 = PyDict_Size(t)
    r16 = CPyDict_GetValuesIter(t)
L6:
    r17 = CPyDict_NextValue(r16, r14)
    r18 = r17[1]
    r14 = r18
    r19 = r17[0]
    if r19 goto L7 else goto L9 :: bool
L7:
    r20 = r17[2]
    x_2 = r20
    r21 = PyList_Append(r13, x_2)
    r22 = r21 >= 0 :: signed
L8:
    r23 = CPyDict_CheckSize(t, r15)
    goto L6
L9:
    r24 = CPy_NoErrOccurred()
L10:
    r25 = PySet_New(0)
    r26 = 0
    r27 = PyDict_Size(t)
    r28 = CPyDict_GetKeysIter(t)
L11:
    r29 = CPyDict_NextKey(r28, r26)
    r30 = r29[1]
    r26 = r30
    r31 = r29[0]
    if r31 goto L12 else goto L14 :: bool
L12:
    r32 = r29[2]
    r33 = cast(str, r32)
    x_3 = r33
    r34 = PySet_Add(r25, x_3)
    r35 = r34 >= 0 :: signed
L13:
    r36 = CPyDict_CheckSize(t, r27)
    goto L11
L14:
    r37 = CPy_NoErrOccurred()
L15:
    r38 = PyDict_New()
    r39 = 0
    r40 = PyDict_Size(t)
    r41 = CPyDict_GetItemsIter(t)
L16:
    r42 = CPyDict_NextItem(r41, r39)
    r43 = r42[1]
    r39 = r43
    r44 = r42[0]
    if r44 goto L17 else goto L19 :: bool
L17:
    r45 = r42[2]
    r46 = r42[3]
    r47 = cast(str, r45)
    k = r47
    v = r46
    r48 = PyDict_SetItem(r38, k, v)
    r49 = r48 >= 0 :: signed
L18:
    r50 = CPyDict_CheckSize(t, r40)
    goto L16
L19:
    r51 = CPy_NoErrOccurred()
L20:
    return 1

[case testParamSpecComponentsAreUsable]
from typing import Callable, ParamSpec

P = ParamSpec("P")

def deco(func: Callable[P, int]) -> Callable[P, int]:
    def inner(*args: P.args, **kwargs: P.kwargs) -> int:
        can_listcomp = [x for x in args]
        can_dictcomp = {k: v for k, v in kwargs.items()}
        can_iter = list(kwargs)
        can_use_keys = list(kwargs.keys())
        can_use_values = list(kwargs.values())
        return func(*args, **kwargs)

    return inner

@deco
def f(x: int) -> int:
    return x

f(1)
[out]
def inner_deco_obj.__get__(__mypyc_self__, instance, owner):
    __mypyc_self__, instance, owner, r0 :: object
    r1 :: bit
    r2 :: object
L0:
    r0 = load_address _Py_NoneStruct
    r1 = instance == r0
    if r1 goto L1 else goto L2 :: bool
L1:
    return __mypyc_self__
L2:
    r2 = PyMethod_New(__mypyc_self__, instance)
    return r2
def inner_deco_obj.__call__(__mypyc_self__, args, kwargs):
    __mypyc_self__ :: __main__.inner_deco_obj
    args :: tuple
    kwargs :: dict
    r0 :: __main__.deco_env
    r1 :: native_int
    r2 :: list
    r3 :: native_int
    r4 :: bit
    r5, x :: object
    r6 :: native_int
    can_listcomp :: list
    r7 :: dict
    r8 :: short_int
    r9 :: native_int
    r10 :: object
    r11 :: tuple[bool, short_int, object, object]
    r12 :: short_int
    r13 :: bool
    r14, r15 :: object
    r16, k :: str
    v :: object
    r17 :: i32
    r18, r19, r20 :: bit
    can_dictcomp :: dict
    r21, can_iter, r22, can_use_keys, r23, can_use_values :: list
    r24 :: object
    r25 :: dict
    r26 :: object
    r27 :: int
L0:
    r0 = __mypyc_self__.__mypyc_env__
    r1 = var_object_size args
    r2 = PyList_New(r1)
    r3 = 0
L1:
    r4 = r3 < r1 :: signed
    if r4 goto L2 else goto L4 :: bool
L2:
    r5 = CPySequenceTuple_GetItemUnsafe(args, r3)
    x = r5
    CPyList_SetItemUnsafe(r2, r3, x)
L3:
    r6 = r3 + 1
    r3 = r6
    goto L1
L4:
    can_listcomp = r2
    r7 = PyDict_New()
    r8 = 0
    r9 = PyDict_Size(kwargs)
    r10 = CPyDict_GetItemsIter(kwargs)
L5:
    r11 = CPyDict_NextItem(r10, r8)
    r12 = r11[1]
    r8 = r12
    r13 = r11[0]
    if r13 goto L6 else goto L8 :: bool
L6:
    r14 = r11[2]
    r15 = r11[3]
    r16 = cast(str, r14)
    k = r16
    v = r15
    r17 = PyDict_SetItem(r7, k, v)
    r18 = r17 >= 0 :: signed
L7:
    r19 = CPyDict_CheckSize(kwargs, r9)
    goto L5
L8:
    r20 = CPy_NoErrOccurred()
L9:
    can_dictcomp = r7
    r21 = PySequence_List(kwargs)
    can_iter = r21
    r22 = CPyDict_Keys(kwargs)
    can_use_keys = r22
    r23 = CPyDict_Values(kwargs)
    can_use_values = r23
    r24 = r0.func
    r25 = PyDict_Copy(kwargs)
    r26 = PyObject_Call(r24, args, r25)
    r27 = unbox(int, r26)
    return r27
def deco(func):
    func :: object
    r0 :: __main__.deco_env
    r1 :: bool
    r2 :: __main__.inner_deco_obj
    r3 :: bool
    inner :: object
L0:
    r0 = deco_env()
    r0.func = func; r1 = is_error
    r2 = inner_deco_obj()
    r2.__mypyc_env__ = r0; r3 = is_error
    inner = r2
    return inner
def f(x):
    x :: int
L0:
    return x