463 lines
8.4 KiB
Plaintext
463 lines
8.4 KiB
Plaintext
[case testTupleGet]
|
|
from typing import Tuple
|
|
|
|
def f(x: Tuple[Tuple[int, bool], bool]) -> int:
|
|
return x[0][0]
|
|
[out]
|
|
def f(x):
|
|
x :: tuple[tuple[int, bool], bool]
|
|
r0 :: tuple[int, bool]
|
|
r1 :: int
|
|
L0:
|
|
r0 = x[0]
|
|
r1 = r0[0]
|
|
return r1
|
|
|
|
[case testTupleNew]
|
|
from typing import Tuple
|
|
|
|
def f() -> int:
|
|
t = (True, 1)
|
|
return t[1]
|
|
[out]
|
|
def f():
|
|
r0, t :: tuple[bool, int]
|
|
r1 :: int
|
|
L0:
|
|
r0 = (1, 2)
|
|
t = r0
|
|
r1 = t[1]
|
|
return r1
|
|
|
|
[case testTupleLen]
|
|
from typing import Tuple
|
|
def f(x: Tuple[bool, bool, int]) -> int:
|
|
return len(x)
|
|
[out]
|
|
def f(x):
|
|
x :: tuple[bool, bool, int]
|
|
L0:
|
|
return 6
|
|
|
|
[case testSequenceTuple]
|
|
from typing import List
|
|
def f(x: List[bool]) -> bool:
|
|
return tuple(x)[1]
|
|
[out]
|
|
def f(x):
|
|
x :: list
|
|
r0 :: tuple
|
|
r1 :: object
|
|
r2 :: bool
|
|
L0:
|
|
r0 = PyList_AsTuple(x)
|
|
r1 = CPySequenceTuple_GetItem(r0, 2)
|
|
r2 = unbox(bool, r1)
|
|
return r2
|
|
|
|
[case testSequenceTupleLen]
|
|
from typing import Tuple
|
|
def f(x: Tuple[int, ...]) -> int:
|
|
return len(x)
|
|
[out]
|
|
def f(x):
|
|
x :: tuple
|
|
r0 :: ptr
|
|
r1 :: native_int
|
|
r2 :: short_int
|
|
L0:
|
|
r0 = get_element_ptr x ob_size :: PyVarObject
|
|
r1 = load_mem r0 :: native_int*
|
|
keep_alive x
|
|
r2 = r1 << 1
|
|
return r2
|
|
|
|
[case testSequenceTupleForced]
|
|
from typing import Tuple
|
|
def f() -> int:
|
|
t = (1, 2) # type: Tuple[int, ...]
|
|
return t[1]
|
|
[out]
|
|
def f():
|
|
r0 :: tuple[int, int]
|
|
r1 :: object
|
|
t :: tuple
|
|
r2 :: object
|
|
r3 :: int
|
|
L0:
|
|
r0 = (2, 4)
|
|
r1 = box(tuple[int, int], r0)
|
|
t = r1
|
|
r2 = CPySequenceTuple_GetItem(t, 2)
|
|
r3 = unbox(int, r2)
|
|
return r3
|
|
|
|
[case testTupleDisplay]
|
|
from typing import Sequence, Tuple
|
|
def f(x: Sequence[int], y: Sequence[int]) -> Tuple[int, ...]:
|
|
return (1, 2, *x, *y, 3)
|
|
[out]
|
|
def f(x, y):
|
|
x, y :: object
|
|
r0 :: list
|
|
r1, r2 :: object
|
|
r3, r4, r5 :: ptr
|
|
r6, r7, r8 :: object
|
|
r9 :: int32
|
|
r10 :: bit
|
|
r11 :: tuple
|
|
L0:
|
|
r0 = PyList_New(2)
|
|
r1 = object 1
|
|
r2 = object 2
|
|
r3 = get_element_ptr r0 ob_item :: PyListObject
|
|
r4 = load_mem r3 :: ptr*
|
|
set_mem r4, r1 :: builtins.object*
|
|
r5 = r4 + WORD_SIZE*1
|
|
set_mem r5, r2 :: builtins.object*
|
|
keep_alive r0
|
|
r6 = CPyList_Extend(r0, x)
|
|
r7 = CPyList_Extend(r0, y)
|
|
r8 = object 3
|
|
r9 = PyList_Append(r0, r8)
|
|
r10 = r9 >= 0 :: signed
|
|
r11 = PyList_AsTuple(r0)
|
|
return r11
|
|
|
|
[case testTupleFor]
|
|
from typing import Tuple, List
|
|
def f(xs: Tuple[str, ...]) -> None:
|
|
for x in xs:
|
|
pass
|
|
[out]
|
|
def f(xs):
|
|
xs :: tuple
|
|
r0 :: short_int
|
|
r1 :: ptr
|
|
r2 :: native_int
|
|
r3 :: short_int
|
|
r4 :: bit
|
|
r5 :: object
|
|
r6, x :: str
|
|
r7 :: short_int
|
|
L0:
|
|
r0 = 0
|
|
L1:
|
|
r1 = get_element_ptr xs ob_size :: PyVarObject
|
|
r2 = load_mem r1 :: native_int*
|
|
keep_alive xs
|
|
r3 = r2 << 1
|
|
r4 = r0 < r3 :: signed
|
|
if r4 goto L2 else goto L4 :: bool
|
|
L2:
|
|
r5 = CPySequenceTuple_GetItem(xs, r0)
|
|
r6 = cast(str, r5)
|
|
x = r6
|
|
L3:
|
|
r7 = r0 + 2
|
|
r0 = r7
|
|
goto L1
|
|
L4:
|
|
return 1
|
|
|
|
[case testNamedTupleAttribute]
|
|
from typing import NamedTuple
|
|
|
|
NT = NamedTuple('NT', [('x', int), ('y', int)])
|
|
|
|
def f(nt: NT, b: bool) -> int:
|
|
if b:
|
|
return nt.x
|
|
return nt.y
|
|
[out]
|
|
def f(nt, b):
|
|
nt :: tuple
|
|
b :: bool
|
|
r0 :: object
|
|
r1 :: int
|
|
r2 :: object
|
|
r3 :: int
|
|
L0:
|
|
if b goto L1 else goto L2 :: bool
|
|
L1:
|
|
r0 = CPySequenceTuple_GetItem(nt, 0)
|
|
r1 = unbox(int, r0)
|
|
return r1
|
|
L2:
|
|
r2 = CPySequenceTuple_GetItem(nt, 2)
|
|
r3 = unbox(int, r2)
|
|
return r3
|
|
|
|
|
|
[case testTupleOperatorIn]
|
|
def f(i: int) -> bool:
|
|
return i in [1, 2, 3]
|
|
[out]
|
|
def f(i):
|
|
i :: int
|
|
r0 :: native_int
|
|
r1, r2 :: bit
|
|
r3 :: bool
|
|
r4 :: bit
|
|
r5 :: bool
|
|
r6 :: native_int
|
|
r7, r8 :: bit
|
|
r9 :: bool
|
|
r10 :: bit
|
|
r11 :: bool
|
|
r12 :: native_int
|
|
r13, r14 :: bit
|
|
r15 :: bool
|
|
r16 :: bit
|
|
L0:
|
|
r0 = i & 1
|
|
r1 = r0 == 0
|
|
if r1 goto L1 else goto L2 :: bool
|
|
L1:
|
|
r2 = i == 2
|
|
r3 = r2
|
|
goto L3
|
|
L2:
|
|
r4 = CPyTagged_IsEq_(i, 2)
|
|
r3 = r4
|
|
L3:
|
|
if r3 goto L4 else goto L5 :: bool
|
|
L4:
|
|
r5 = r3
|
|
goto L9
|
|
L5:
|
|
r6 = i & 1
|
|
r7 = r6 == 0
|
|
if r7 goto L6 else goto L7 :: bool
|
|
L6:
|
|
r8 = i == 4
|
|
r9 = r8
|
|
goto L8
|
|
L7:
|
|
r10 = CPyTagged_IsEq_(i, 4)
|
|
r9 = r10
|
|
L8:
|
|
r5 = r9
|
|
L9:
|
|
if r5 goto L10 else goto L11 :: bool
|
|
L10:
|
|
r11 = r5
|
|
goto L15
|
|
L11:
|
|
r12 = i & 1
|
|
r13 = r12 == 0
|
|
if r13 goto L12 else goto L13 :: bool
|
|
L12:
|
|
r14 = i == 6
|
|
r15 = r14
|
|
goto L14
|
|
L13:
|
|
r16 = CPyTagged_IsEq_(i, 6)
|
|
r15 = r16
|
|
L14:
|
|
r11 = r15
|
|
L15:
|
|
return r11
|
|
|
|
|
|
[case testTupleBuiltFromList]
|
|
def f(val: int) -> bool:
|
|
return val % 2 == 0
|
|
|
|
def test() -> None:
|
|
source = [1, 2, 3]
|
|
a = tuple(f(x) for x in source)
|
|
[out]
|
|
def f(val):
|
|
val, r0 :: int
|
|
r1 :: native_int
|
|
r2, r3 :: bit
|
|
r4 :: bool
|
|
r5 :: bit
|
|
L0:
|
|
r0 = CPyTagged_Remainder(val, 4)
|
|
r1 = r0 & 1
|
|
r2 = r1 == 0
|
|
if r2 goto L1 else goto L2 :: bool
|
|
L1:
|
|
r3 = r0 == 0
|
|
r4 = r3
|
|
goto L3
|
|
L2:
|
|
r5 = CPyTagged_IsEq_(r0, 0)
|
|
r4 = r5
|
|
L3:
|
|
return r4
|
|
def test():
|
|
r0 :: list
|
|
r1, r2, r3 :: object
|
|
r4, r5, r6, r7 :: ptr
|
|
source :: list
|
|
r8 :: ptr
|
|
r9 :: native_int
|
|
r10 :: tuple
|
|
r11 :: short_int
|
|
r12 :: ptr
|
|
r13 :: native_int
|
|
r14 :: short_int
|
|
r15 :: bit
|
|
r16 :: object
|
|
r17, x :: int
|
|
r18 :: bool
|
|
r19 :: object
|
|
r20 :: bit
|
|
r21 :: short_int
|
|
a :: tuple
|
|
L0:
|
|
r0 = PyList_New(3)
|
|
r1 = object 1
|
|
r2 = object 2
|
|
r3 = object 3
|
|
r4 = get_element_ptr r0 ob_item :: PyListObject
|
|
r5 = load_mem r4 :: ptr*
|
|
set_mem r5, r1 :: builtins.object*
|
|
r6 = r5 + WORD_SIZE*1
|
|
set_mem r6, r2 :: builtins.object*
|
|
r7 = r5 + WORD_SIZE*2
|
|
set_mem r7, r3 :: builtins.object*
|
|
keep_alive r0
|
|
source = r0
|
|
r8 = get_element_ptr source ob_size :: PyVarObject
|
|
r9 = load_mem r8 :: native_int*
|
|
keep_alive source
|
|
r10 = PyTuple_New(r9)
|
|
r11 = 0
|
|
L1:
|
|
r12 = get_element_ptr source ob_size :: PyVarObject
|
|
r13 = load_mem r12 :: native_int*
|
|
keep_alive source
|
|
r14 = r13 << 1
|
|
r15 = r11 < r14 :: signed
|
|
if r15 goto L2 else goto L4 :: bool
|
|
L2:
|
|
r16 = CPyList_GetItemUnsafe(source, r11)
|
|
r17 = unbox(int, r16)
|
|
x = r17
|
|
r18 = f(x)
|
|
r19 = box(bool, r18)
|
|
r20 = CPySequenceTuple_SetItemUnsafe(r10, r11, r19)
|
|
L3:
|
|
r21 = r11 + 2
|
|
r11 = r21
|
|
goto L1
|
|
L4:
|
|
a = r10
|
|
return 1
|
|
|
|
[case testTupleBuiltFromStr]
|
|
def f2(val: str) -> str:
|
|
return val + "f2"
|
|
|
|
def test() -> None:
|
|
source = "abc"
|
|
a = tuple(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 :: tuple
|
|
r4 :: short_int
|
|
r5 :: native_int
|
|
r6 :: bit
|
|
r7 :: short_int
|
|
r8 :: bit
|
|
r9, x, r10 :: str
|
|
r11 :: bit
|
|
r12 :: short_int
|
|
a :: tuple
|
|
L0:
|
|
r0 = 'abc'
|
|
source = r0
|
|
r1 = CPyStr_Size_size_t(source)
|
|
r2 = r1 >= 0 :: signed
|
|
r3 = PyTuple_New(r1)
|
|
r4 = 0
|
|
L1:
|
|
r5 = CPyStr_Size_size_t(source)
|
|
r6 = r5 >= 0 :: signed
|
|
r7 = r5 << 1
|
|
r8 = r4 < r7 :: signed
|
|
if r8 goto L2 else goto L4 :: bool
|
|
L2:
|
|
r9 = CPyStr_GetItem(source, r4)
|
|
x = r9
|
|
r10 = f2(x)
|
|
r11 = CPySequenceTuple_SetItemUnsafe(r3, r4, r10)
|
|
L3:
|
|
r12 = r4 + 2
|
|
r4 = r12
|
|
goto L1
|
|
L4:
|
|
a = r3
|
|
return 1
|
|
|
|
[case testTupleBuiltFromVariableLengthTuple]
|
|
from typing import Tuple
|
|
|
|
def f(val: bool) -> bool:
|
|
return not val
|
|
|
|
def test(source: Tuple[bool, ...]) -> None:
|
|
a = tuple(f(x) for x in source)
|
|
[out]
|
|
def f(val):
|
|
val, r0 :: bool
|
|
L0:
|
|
r0 = val ^ 1
|
|
return r0
|
|
def test(source):
|
|
source :: tuple
|
|
r0 :: ptr
|
|
r1 :: native_int
|
|
r2 :: tuple
|
|
r3 :: short_int
|
|
r4 :: ptr
|
|
r5 :: native_int
|
|
r6 :: short_int
|
|
r7 :: bit
|
|
r8 :: object
|
|
r9, x, r10 :: bool
|
|
r11 :: object
|
|
r12 :: bit
|
|
r13 :: short_int
|
|
a :: tuple
|
|
L0:
|
|
r0 = get_element_ptr source ob_size :: PyVarObject
|
|
r1 = load_mem r0 :: native_int*
|
|
keep_alive source
|
|
r2 = PyTuple_New(r1)
|
|
r3 = 0
|
|
L1:
|
|
r4 = get_element_ptr source ob_size :: PyVarObject
|
|
r5 = load_mem r4 :: native_int*
|
|
keep_alive source
|
|
r6 = r5 << 1
|
|
r7 = r3 < r6 :: signed
|
|
if r7 goto L2 else goto L4 :: bool
|
|
L2:
|
|
r8 = CPySequenceTuple_GetItem(source, r3)
|
|
r9 = unbox(bool, r8)
|
|
x = r9
|
|
r10 = f(x)
|
|
r11 = box(bool, r10)
|
|
r12 = CPySequenceTuple_SetItemUnsafe(r2, r3, r11)
|
|
L3:
|
|
r13 = r3 + 2
|
|
r3 = r13
|
|
goto L1
|
|
L4:
|
|
a = r2
|
|
return 1
|