[case testListGet]

from typing import List

def f(x: List[int]) -> int:

return x[0]

[out]

def f(x):

x :: list

r0 :: object

r1 :: int

L0:

r0 = CPyList_GetItemShort(x, 0)

r1 = unbox(int, r0)

return r1

[case testListOfListGet]

from typing import List

def f(x: List[List[int]]) -> List[int]:

return x[0]

[out]

def f(x):

x :: list

r0 :: object

r1 :: list

L0:

r0 = CPyList_GetItemShort(x, 0)

r1 = cast(list, r0)

return r1

[case testListOfListGet2]

from typing import List

def f(x: List[List[int]]) -> int:

return x[0][1]

[out]

def f(x):

x :: list

r0 :: object

r1 :: list

r2 :: object

r3 :: int

L0:

r0 = CPyList_GetItemShortBorrow(x, 0)

r1 = borrow cast(list, r0)

r2 = CPyList_GetItemShort(r1, 2)

r3 = unbox(int, r2)

keep_alive x, r0

return r3

[case testListSet]

from typing import List

def f(x: List[int]) -> None:

x[0] = 1

[out]

def f(x):

x :: list

r0 :: object

r1 :: bit

L0:

r0 = object 1

r1 = CPyList_SetItem(x, 0, r0)

return 1

[case testNewListEmpty]

from typing import List

def f() -> None:

x = [] # type: List[int]

[out]

def f():

r0, x :: list

L0:

r0 = PyList_New(0)

x = r0

return 1

[case testNewListEmptyViaFunc]

from typing import List

def f() -> None:

x: List[int] = list()

[out]

def f():

r0, x :: list

L0:

r0 = PyList_New(0)

x = r0

return 1

[case testNewListEmptyViaAlias]

from typing import List

ListAlias = list

def f() -> None:

x: List[int] = ListAlias()

[out]

def f():

r0, x :: list

L0:

r0 = PyList_New(0)

x = r0

return 1

[case testNewListTwoItems]

from typing import List

def f() -> None:

x: List[int] = [1, 2]

[out]

def f():

r0 :: list

r1, r2 :: object

r3 :: ptr

x :: list

L0:

r0 = PyList_New(2)

r1 = object 1

r2 = object 2

r3 = list_items r0

buf_init_item r3, 0, r1

buf_init_item r3, 1, r2

keep_alive r0

x = r0

return 1

[case testNewListTenItems]

from typing import List

def f() -> None:

x: List[str] = ['a', 'b', 'c', 'd', 'e',

'f', 'g', 'h', 'i', 'j']

[out]

def f():

r0, r1, r2, r3, r4, r5, r6, r7, r8, r9 :: str

r10, x :: list

L0:

r0 = 'a'

r1 = 'b'

r2 = 'c'

r3 = 'd'

r4 = 'e'

r5 = 'f'

r6 = 'g'

r7 = 'h'

r8 = 'i'

r9 = 'j'

r10 = CPyList_Build(10, r0, r1, r2, r3, r4, r5, r6, r7, r8, r9)

x = r10

return 1

[case testListAdd]

from typing import List

def f(a: List[int], b: List[int]) -> None:

c = a + b

[out]

def f(a, b):

a, b, r0, c :: list

L0:

r0 = PySequence_Concat(a, b)

c = r0

return 1

[case testListIAdd]

from typing import List, Any

def f(a: List[int], b: Any) -> None:

a += b

[out]

def f(a, b):

a :: list

b :: object

r0 :: list

L0:

r0 = PySequence_InPlaceConcat(a, b)

a = r0

return 1

[case testListMultiply]

from typing import List

def f(a: List[int]) -> None:

b = a * 2

b = 3 * [4]

[out]

def f(a):

a, r0, b, r1 :: list

r2 :: object

r3 :: ptr

r4 :: list

L0:

r0 = CPySequence_Multiply(a, 4)

b = r0

r1 = PyList_New(1)

r2 = object 4

r3 = list_items r1

buf_init_item r3, 0, r2

keep_alive r1

r4 = CPySequence_RMultiply(6, r1)

b = r4

return 1

[case testListIMultiply]

from typing import List

def f(a: List[int]) -> None:

a *= 2

[out]

def f(a):

a, r0 :: list

L0:

r0 = CPySequence_InPlaceMultiply(a, 4)

a = r0

return 1

[case testListLen]

from typing import List

def f(a: List[int]) -> int:

return len(a)

[out]

def f(a):

a :: list

r0 :: native_int

r1 :: short_int

L0:

r0 = var_object_size a

r1 = r0 << 1

return r1

[case testListClear]

from typing import List

def f(l: List[int]) -> None:

return l.clear()

[out]

def f(l):

l :: list

r0 :: bit

L0:

r0 = CPyList_Clear(l)

return 1

[case testListCopy]

from typing import List

from typing import Any

def f(a: List[Any]) -> List[Any]:

return a.copy()

[out]

def f(a):

a, r0 :: list

L0:

r0 = CPyList_Copy(a)

return r0

[case testListAppend]

from typing import List

def f(a: List[int], x: int) -> None:

a.append(x)

[out]

def f(a, x):

a :: list

x :: int

r0 :: object

r1 :: i32

r2 :: bit

L0:

r0 = box(int, x)

r1 = PyList_Append(a, r0)

r2 = r1 >= 0 :: signed

return 1

[case testIndexLvalue]

from typing import List

def increment(l: List[int]) -> List[int]:

for i in range(len(l)):

l[i] += 1

return l

[out]

def increment(l):

l :: list

r0 :: native_int

r1, r2 :: short_int

i :: int

r3 :: bit

r4, r5, r6 :: object

r7 :: bit

r8 :: short_int

L0:

r0 = var_object_size l

r1 = r0 << 1

r2 = 0

i = r2

L1:

r3 = int_lt r2, r1

if r3 goto L2 else goto L4 :: bool

L2:

i = r2

r4 = CPyList_GetItem(l, i)

r5 = object 1

r6 = PyNumber_InPlaceAdd(r4, r5)

r7 = CPyList_SetItem(l, i, r6)

L3:

r8 = r2 + 2

r2 = r8

goto L1

L4:

return l

[case testListDisplay]

from typing import List

def f(x: List[int], y: List[int]) -> List[int]:

return [1, 2, *x, *y, 3]

[out]

def f(x, y):

x, y, r0 :: list

r1, r2 :: object

r3 :: ptr

r4, r5, r6 :: object

r7 :: i32

r8 :: bit

L0:

r0 = PyList_New(2)

r1 = object 1

r2 = object 2

r3 = list_items r0

buf_init_item r3, 0, r1

buf_init_item r3, 1, r2

keep_alive r0

r4 = CPyList_Extend(r0, x)

r5 = CPyList_Extend(r0, y)

r6 = object 3

r7 = PyList_Append(r0, r6)

r8 = r7 >= 0 :: signed

return r0

[case testListIn]

from typing import List

def f(x: List[int], y: int) -> bool:

return y in x

[out]

def f(x, y):

x :: list

y :: int

r0 :: object

r1 :: i32

r2 :: bit

r3 :: bool

L0:

r0 = box(int, y)

r1 = PySequence_Contains(x, r0)

r2 = r1 >= 0 :: signed

r3 = truncate r1: i32 to builtins.bool

return r3

[case testListInsert]

from typing import List

def f(x: List[int], y: int) -> None:

x.insert(0, y)

[out]

def f(x, y):

x :: list

y :: int

r0 :: object

r1 :: i32

r2 :: bit

L0:

r0 = box(int, y)

r1 = CPyList_Insert(x, 0, r0)

r2 = r1 >= 0 :: signed

return 1

[case testListBuiltFromGenerator]

from typing import List

def f(source: List[int]) -> None:

a = list(x + 1 for x in source)

b = [x + 1 for x in source]

[out]

def f(source):

source :: list

r0 :: native_int

r1 :: list

r2, r3 :: native_int

r4 :: bit

r5 :: object

r6, x, r7 :: int

r8 :: object

r9 :: native_int

a :: list

r10 :: native_int

r11 :: list

r12, r13 :: native_int

r14 :: bit

r15 :: object

r16, x_2, r17 :: int

r18 :: object

r19 :: native_int

b :: list

L0:

r0 = var_object_size source

r1 = PyList_New(r0)

r2 = 0

L1:

r3 = var_object_size source

r4 = r2 < r3 :: signed

if r4 goto L2 else goto L4 :: bool

L2:

r5 = list_get_item_unsafe source, r2

r6 = unbox(int, r5)

x = r6

r7 = CPyTagged_Add(x, 2)

r8 = box(int, r7)

CPyList_SetItemUnsafe(r1, r2, r8)

L3:

r9 = r2 + 1

r2 = r9

goto L1

L4:

a = r1

r10 = var_object_size source

r11 = PyList_New(r10)

r12 = 0

L5:

r13 = var_object_size source

r14 = r12 < r13 :: signed

if r14 goto L6 else goto L8 :: bool

L6:

r15 = list_get_item_unsafe source, r12

r16 = unbox(int, r15)

x_2 = r16

r17 = CPyTagged_Add(x_2, 2)

r18 = box(int, r17)

CPyList_SetItemUnsafe(r11, r12, r18)

L7:

r19 = r12 + 1

r12 = r19

goto L5

L8:

b = r11

return 1

[case testGeneratorNext]

from typing import List, Optional

def test(x: List[int]) -> None:

res = next((i for i in x), None)

[out]

def test(x):

x :: list

r0, r1 :: native_int

r2 :: bit

r3 :: object

r4, i :: int

r5 :: object

r6 :: union[int, None]

r7 :: native_int

r8 :: object

res :: union[int, None]

L0:

r0 = 0

L1:

r1 = var_object_size x

r2 = r0 < r1 :: signed

if r2 goto L2 else goto L4 :: bool

L2:

r3 = list_get_item_unsafe x, r0

r4 = unbox(int, r3)

i = r4

r5 = box(int, i)

r6 = r5

goto L5

L3:

r7 = r0 + 1

r0 = r7

goto L1

L4:

r8 = box(None, 1)

r6 = r8

L5:

res = r6

return 1

[case testSimplifyListUnion]

from typing import List, Union, Optional

def narrow(a: Union[List[str], List[bytes], int]) -> int:

if isinstance(a, list):

return len(a)

return a

def loop(a: Union[List[str], List[bytes]]) -> None:

for x in a:

pass

def nested_union(a: Union[List[str], List[Optional[str]]]) -> None:

for x in a:

pass

[out]

def narrow(a):

a :: union[list, int]

r0 :: bit

r1 :: list

r2 :: native_int

r3 :: short_int

r4 :: int

L0:

r0 = PyList_Check(a)

if r0 goto L1 else goto L2 :: bool

L1:

r1 = borrow cast(list, a)

r2 = var_object_size r1

r3 = r2 << 1

keep_alive a

return r3

L2:

r4 = unbox(int, a)

return r4

def loop(a):

a :: list

r0, r1 :: native_int

r2 :: bit

r3 :: object

r4, x :: union[str, bytes]

r5 :: native_int

L0:

r0 = 0

L1:

r1 = var_object_size a

r2 = r0 < r1 :: signed

if r2 goto L2 else goto L4 :: bool

L2:

r3 = list_get_item_unsafe a, r0

r4 = cast(union[str, bytes], r3)

x = r4

L3:

r5 = r0 + 1

r0 = r5

goto L1

L4:

return 1

def nested_union(a):

a :: list

r0, r1 :: native_int

r2 :: bit

r3 :: object

r4, x :: union[str, None]

r5 :: native_int

L0:

r0 = 0

L1:

r1 = var_object_size a

r2 = r0 < r1 :: signed

if r2 goto L2 else goto L4 :: bool

L2:

r3 = list_get_item_unsafe a, r0

r4 = cast(union[str, None], r3)

x = r4

L3:

r5 = r0 + 1

r0 = r5

goto L1

L4:

return 1

[case testSorted]

from typing import List, Any

def list_sort(a: List[int]) -> None:

a.sort()

def sort_iterable(a: Any) -> None:

sorted(a)

[out]

def list_sort(a):

a :: list

r0 :: i32

r1 :: bit

L0:

r0 = PyList_Sort(a)

r1 = r0 >= 0 :: signed

return 1

def sort_iterable(a):

a :: object

r0 :: list

L0:

r0 = CPySequence_Sort(a)

return 1

[case testListBuiltFromStr]

def f2(val: str) -> str:

return val + "f2"

def test() -> None:

source = "abc"

a = [f2(x) for x in source]

[out]

def f2(val):

val, r0, r1 :: str

L0:

r0 = 'f2'

r1 = PyUnicode_Concat(val, r0)

return r1

def test():

r0, source :: str

r1 :: native_int

r2 :: bit

r3 :: list

r4 :: native_int

r5 :: bit

r6, x, r7 :: str

r8 :: native_int

a :: list

L0:

r0 = 'abc'

source = r0

r1 = CPyStr_Size_size_t(source)

r2 = r1 >= 0 :: signed

r3 = PyList_New(r1)

r4 = 0

L1:

r5 = r4 < r1 :: signed

if r5 goto L2 else goto L4 :: bool

L2:

r6 = CPyStr_GetItemUnsafe(source, r4)

x = r6

r7 = f2(x)

CPyList_SetItemUnsafe(r3, r4, r7)

L3:

r8 = r4 + 1

r4 = r8

goto L1

L4:

a = r3

return 1

[case testListBuiltFromStrExpr]

def f2(val: str) -> str:

return val + "f2"

def test() -> None:

a = [f2(x) for x in "abc"]

[out]

def f2(val):

val, r0, r1 :: str

L0:

r0 = 'f2'

r1 = PyUnicode_Concat(val, r0)

return r1

def test():

r0 :: str

r1 :: list

r2 :: native_int

r3 :: bit

r4, x, r5 :: str

r6 :: native_int

a :: list

L0:

r0 = 'abc'

r1 = PyList_New(3)

r2 = 0

goto L2

L1:

r3 = r2 < 3 :: signed

if r3 goto L2 else goto L4 :: bool

L2:

r4 = CPyStr_GetItemUnsafe(r0, r2)

x = r4

r5 = f2(x)

CPyList_SetItemUnsafe(r1, r2, r5)

L3:

r6 = r2 + 1

r2 = r6

goto L1

L4:

a = r1

return 1

[case testListBuiltFromFinalStr]

from typing import Final

source: Final = "abc"

def f2(val: str) -> str:

return val + "f2"

def test() -> None:

a = [f2(x) for x in source]

[out]

def f2(val):

val, r0, r1 :: str

L0:

r0 = 'f2'

r1 = PyUnicode_Concat(val, r0)

return r1

def test():

r0 :: str

r1 :: list

r2 :: native_int

r3 :: bit

r4, x, r5 :: str

r6 :: native_int

a :: list

L0:

r0 = 'abc'

r1 = PyList_New(3)

r2 = 0

goto L2

L1:

r3 = r2 < 3 :: signed

if r3 goto L2 else goto L4 :: bool

L2:

r4 = CPyStr_GetItemUnsafe(r0, r2)

x = r4

r5 = f2(x)

CPyList_SetItemUnsafe(r1, r2, r5)

L3:

r6 = r2 + 1

r2 = r6

goto L1

L4:

a = r1

return 1

[case testListBuiltFromBytes_64bit]

def f2(val: int) -> int:

return val + 2

def test() -> None:

source = b"abc"

a = [f2(x) for x in source]

[out]

def f2(val):

val, r0 :: int

L0:

r0 = CPyTagged_Add(val, 4)

return r0

def test():

r0, source :: bytes

r1 :: native_int

r2 :: list

r3 :: native_int

r4, r5, r6 :: bit

r7, r8, r9, r10 :: int

r11 :: object

r12, x, r13 :: int

r14 :: object

r15 :: native_int

a :: list

L0:

r0 = b'abc'

source = r0

r1 = var_object_size source

r2 = PyList_New(r1)

r3 = 0

L1:

r4 = r3 < r1 :: signed

if r4 goto L2 else goto L8 :: bool

L2:

r5 = r3 <= 4611686018427387903 :: signed

if r5 goto L3 else goto L4 :: bool

L3:

r6 = r3 >= -4611686018427387904 :: signed

if r6 goto L5 else goto L4 :: bool

L4:

r7 = CPyTagged_FromInt64(r3)

r8 = r7

goto L6

L5:

r9 = r3 << 1

r8 = r9

L6:

r10 = CPyBytes_GetItem(source, r8)

r11 = box(int, r10)

r12 = unbox(int, r11)

x = r12

r13 = f2(x)

r14 = box(int, r13)

CPyList_SetItemUnsafe(r2, r3, r14)

L7:

r15 = r3 + 1

r3 = r15

goto L1

L8:

a = r2

return 1

[case testListBuiltFromBytesExpr_64bit]

def f2(val: int) -> int:

return val + 2

def test() -> None:

a = [f2(x) for x in b"abc"]

[out]

def f2(val):

val, r0 :: int

L0:

r0 = CPyTagged_Add(val, 4)

return r0

def test():

r0 :: bytes

r1 :: list

r2 :: native_int

r3, r4, r5 :: bit

r6, r7, r8, r9 :: int

r10 :: object

r11, x, r12 :: int

r13 :: object

r14 :: native_int

a :: list

L0:

r0 = b'abc'

r1 = PyList_New(3)

r2 = 0

goto L2

L1:

r3 = r2 < 3 :: signed

if r3 goto L2 else goto L8 :: bool

L2:

r4 = r2 <= 4611686018427387903 :: signed

if r4 goto L3 else goto L4 :: bool

L3:

r5 = r2 >= -4611686018427387904 :: signed

if r5 goto L5 else goto L4 :: bool

L4:

r6 = CPyTagged_FromInt64(r2)

r7 = r6

goto L6

L5:

r8 = r2 << 1

r7 = r8

L6:

r9 = CPyBytes_GetItem(r0, r7)

r10 = box(int, r9)

r11 = unbox(int, r10)

x = r11

r12 = f2(x)

r13 = box(int, r12)

CPyList_SetItemUnsafe(r1, r2, r13)

L7:

r14 = r2 + 1

r2 = r14

goto L1

L8:

a = r1

return 1

[case testListBuiltFromFinalBytes_64bit]

from typing import Final

source: Final = b"abc"

def f2(val: int) -> int:

return val + 2

def test() -> None:

a = [f2(x) for x in source]

[out]

def f2(val):

val, r0 :: int

L0:

r0 = CPyTagged_Add(val, 4)

return r0

def test():

r0 :: bytes

r1 :: bool

r2 :: native_int

r3 :: list

r4 :: native_int

r5, r6, r7 :: bit

r8, r9, r10, r11 :: int

r12 :: object

r13, x, r14 :: int

r15 :: object

r16 :: native_int

a :: list

L0:

r0 = __main__.source :: static

if is_error(r0) goto L1 else goto L2

L1:

r1 = raise NameError('value for final name "source" was not set')

unreachable

L2:

r2 = var_object_size r0

r3 = PyList_New(r2)

r4 = 0

L3:

r5 = r4 < r2 :: signed

if r5 goto L4 else goto L10 :: bool

L4:

r6 = r4 <= 4611686018427387903 :: signed

if r6 goto L5 else goto L6 :: bool

L5:

r7 = r4 >= -4611686018427387904 :: signed

if r7 goto L7 else goto L6 :: bool

L6:

r8 = CPyTagged_FromInt64(r4)

r9 = r8

goto L8

L7:

r10 = r4 << 1

r9 = r10

L8:

r11 = CPyBytes_GetItem(r0, r9)

r12 = box(int, r11)

r13 = unbox(int, r12)

x = r13

r14 = f2(x)

r15 = box(int, r14)

CPyList_SetItemUnsafe(r3, r4, r15)

L9:

r16 = r4 + 1

r4 = r16

goto L3

L10:

a = r3

return 1

[case testListBuiltFromStars]

from typing import Final

abc: Final = "abc"

def test() -> None:

a = [str(x) for x in [*abc, *"def", *b"ghi", ("j", "k"), *("l", "m", "n")]]

[out]

def test():

r0, r1 :: str

r2 :: bytes

r3, r4 :: str

r5 :: tuple[str, str]

r6, r7, r8 :: str

r9 :: tuple[str, str, str]

r10 :: list

r11, r12, r13, r14 :: object

r15 :: i32

r16 :: bit

r17, r18 :: object

r19 :: list

r20, r21 :: native_int

r22 :: bit

r23, x :: object

r24 :: str

r25 :: native_int

a :: list

L0:

r0 = 'abc'

r1 = 'def'

r2 = b'ghi'

r3 = 'j'

r4 = 'k'

r5 = (r3, r4)

r6 = 'l'

r7 = 'm'

r8 = 'n'

r9 = (r6, r7, r8)

r10 = PyList_New(0)

r11 = CPyList_Extend(r10, r0)

r12 = CPyList_Extend(r10, r1)

r13 = CPyList_Extend(r10, r2)

r14 = box(tuple[str, str], r5)

r15 = PyList_Append(r10, r14)

r16 = r15 >= 0 :: signed

r17 = box(tuple[str, str, str], r9)

r18 = CPyList_Extend(r10, r17)

r19 = PyList_New(13)

r20 = 0

goto L2

L1:

r21 = var_object_size r10

r22 = r20 < r21 :: signed

if r22 goto L2 else goto L4 :: bool

L2:

r23 = list_get_item_unsafe r10, r20

x = r23

r24 = PyObject_Str(x)

CPyList_SetItemUnsafe(r19, r20, r24)

L3:

r25 = r20 + 1

r20 = r25

goto L1

L4:

a = r19

return 1