jaclang 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

jaclang/vendor/mypyc/test-data/irbuild-statements.test

@@ -0,0 +1,1149 @@
+[case testForInRange]
+def f() -> None:
+    x = 0
+    for i in range(5):
+        x = x + i
+[out]
+def f():
+    x :: int
+    r0 :: short_int
+    i :: int
+    r1 :: bit
+    r2 :: int
+    r3 :: short_int
+L0:
+    x = 0
+    r0 = 0
+    i = r0
+L1:
+    r1 = r0 < 10 :: signed
+    if r1 goto L2 else goto L4 :: bool
+L2:
+    r2 = CPyTagged_Add(x, i)
+    x = r2
+L3:
+    r3 = r0 + 2
+    r0 = r3
+    i = r3
+    goto L1
+L4:
+    return 1
+
+[case testForInRangeVariableEndIndxe]
+def f(a: int) -> None:
+    for i in range(a):
+        pass
+[out]
+def f(a):
+    a, r0, i :: int
+    r1 :: native_int
+    r2 :: bit
+    r3 :: native_int
+    r4, r5, r6 :: bit
+    r7 :: bool
+    r8 :: bit
+    r9 :: int
+L0:
+    r0 = 0
+    i = r0
+L1:
+    r1 = r0 & 1
+    r2 = r1 == 0
+    r3 = a & 1
+    r4 = r3 == 0
+    r5 = r2 & r4
+    if r5 goto L2 else goto L3 :: bool
+L2:
+    r6 = r0 < a :: signed
+    r7 = r6
+    goto L4
+L3:
+    r8 = CPyTagged_IsLt_(r0, a)
+    r7 = r8
+L4:
+    if r7 goto L5 else goto L7 :: bool
+L5:
+L6:
+    r9 = CPyTagged_Add(r0, 2)
+    r0 = r9
+    i = r9
+    goto L1
+L7:
+    return 1
+
+[case testForInNegativeRange]
+def f() -> None:
+    for i in range(10, 0, -1):
+        pass
+[out]
+def f():
+    r0 :: short_int
+    i :: int
+    r1 :: bit
+    r2 :: short_int
+L0:
+    r0 = 20
+    i = r0
+L1:
+    r1 = r0 > 0 :: signed
+    if r1 goto L2 else goto L4 :: bool
+L2:
+L3:
+    r2 = r0 + -2
+    r0 = r2
+    i = r2
+    goto L1
+L4:
+    return 1
+
+[case testBreak]
+def f() -> None:
+  n = 0
+  while n < 5:
+      break
+[out]
+def f():
+    n :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+L0:
+    n = 0
+L1:
+    r0 = n & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L3 :: bool
+L2:
+    r2 = CPyTagged_IsLt_(n, 10)
+    if r2 goto L4 else goto L5 :: bool
+L3:
+    r3 = n < 10 :: signed
+    if r3 goto L4 else goto L5 :: bool
+L4:
+L5:
+    return 1
+
+[case testBreakFor]
+def f() -> None:
+    for n in range(5):
+        break
+[out]
+def f():
+    r0 :: short_int
+    n :: int
+    r1 :: bit
+    r2 :: short_int
+L0:
+    r0 = 0
+    n = r0
+L1:
+    r1 = r0 < 10 :: signed
+    if r1 goto L2 else goto L4 :: bool
+L2:
+    goto L4
+L3:
+    r2 = r0 + 2
+    r0 = r2
+    n = r2
+    goto L1
+L4:
+    return 1
+
+[case testBreakNested]
+def f() -> None:
+    n = 0
+    while n < 5:
+        while n < 4:
+            break
+        break
+[out]
+def f():
+    n :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6, r7 :: bit
+L0:
+    n = 0
+L1:
+    r0 = n & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L3 :: bool
+L2:
+    r2 = CPyTagged_IsLt_(n, 10)
+    if r2 goto L4 else goto L10 :: bool
+L3:
+    r3 = n < 10 :: signed
+    if r3 goto L4 else goto L10 :: bool
+L4:
+L5:
+    r4 = n & 1
+    r5 = r4 != 0
+    if r5 goto L6 else goto L7 :: bool
+L6:
+    r6 = CPyTagged_IsLt_(n, 8)
+    if r6 goto L8 else goto L9 :: bool
+L7:
+    r7 = n < 8 :: signed
+    if r7 goto L8 else goto L9 :: bool
+L8:
+L9:
+L10:
+    return 1
+
+[case testContinue]
+def f() -> None:
+  n = 0
+  while n < 5:
+      continue
+[out]
+def f():
+    n :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+L0:
+    n = 0
+L1:
+    r0 = n & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L3 :: bool
+L2:
+    r2 = CPyTagged_IsLt_(n, 10)
+    if r2 goto L4 else goto L5 :: bool
+L3:
+    r3 = n < 10 :: signed
+    if r3 goto L4 else goto L5 :: bool
+L4:
+    goto L1
+L5:
+    return 1
+
+[case testContinueFor]
+def f() -> None:
+    for n in range(5):
+        continue
+[out]
+def f():
+    r0 :: short_int
+    n :: int
+    r1 :: bit
+    r2 :: short_int
+L0:
+    r0 = 0
+    n = r0
+L1:
+    r1 = r0 < 10 :: signed
+    if r1 goto L2 else goto L4 :: bool
+L2:
+L3:
+    r2 = r0 + 2
+    r0 = r2
+    n = r2
+    goto L1
+L4:
+    return 1
+
+[case testContinueNested]
+def f() -> None:
+    n = 0
+    while n < 5:
+        while n < 4:
+            continue
+        continue
+[out]
+def f():
+    n :: int
+    r0 :: native_int
+    r1, r2, r3 :: bit
+    r4 :: native_int
+    r5, r6, r7 :: bit
+L0:
+    n = 0
+L1:
+    r0 = n & 1
+    r1 = r0 != 0
+    if r1 goto L2 else goto L3 :: bool
+L2:
+    r2 = CPyTagged_IsLt_(n, 10)
+    if r2 goto L4 else goto L10 :: bool
+L3:
+    r3 = n < 10 :: signed
+    if r3 goto L4 else goto L10 :: bool
+L4:
+L5:
+    r4 = n & 1
+    r5 = r4 != 0
+    if r5 goto L6 else goto L7 :: bool
+L6:
+    r6 = CPyTagged_IsLt_(n, 8)
+    if r6 goto L8 else goto L9 :: bool
+L7:
+    r7 = n < 8 :: signed
+    if r7 goto L8 else goto L9 :: bool
+L8:
+    goto L5
+L9:
+    goto L1
+L10:
+    return 1
+
+[case testForList]
+from typing import List
+
+def f(ls: List[int]) -> int:
+    y = 0
+    for x in ls:
+        y = y + x
+    return y
+[out]
+def f(ls):
+    ls :: list
+    y :: int
+    r0 :: short_int
+    r1 :: ptr
+    r2 :: native_int
+    r3 :: short_int
+    r4 :: bit
+    r5 :: object
+    r6, x, r7 :: int
+    r8 :: short_int
+L0:
+    y = 0
+    r0 = 0
+L1:
+    r1 = get_element_ptr ls ob_size :: PyVarObject
+    r2 = load_mem r1 :: native_int*
+    keep_alive ls
+    r3 = r2 << 1
+    r4 = r0 < r3 :: signed
+    if r4 goto L2 else goto L4 :: bool
+L2:
+    r5 = CPyList_GetItemUnsafe(ls, r0)
+    r6 = unbox(int, r5)
+    x = r6
+    r7 = CPyTagged_Add(y, x)
+    y = r7
+L3:
+    r8 = r0 + 2
+    r0 = r8
+    goto L1
+L4:
+    return y
+
+[case testForDictBasic]
+from typing import Dict
+
+def f(d: Dict[int, int]) -> None:
+    for key in d:
+        d[key]
+[out]
+def f(d):
+    d :: dict
+    r0 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: object
+    r4 :: tuple[bool, short_int, object]
+    r5 :: short_int
+    r6 :: bool
+    r7 :: object
+    r8, key :: int
+    r9, r10 :: object
+    r11 :: int
+    r12, r13 :: bit
+L0:
+    r0 = 0
+    r1 = PyDict_Size(d)
+    r2 = r1 << 1
+    r3 = CPyDict_GetKeysIter(d)
+L1:
+    r4 = CPyDict_NextKey(r3, r0)
+    r5 = r4[1]
+    r0 = r5
+    r6 = r4[0]
+    if r6 goto L2 else goto L4 :: bool
+L2:
+    r7 = r4[2]
+    r8 = unbox(int, r7)
+    key = r8
+    r9 = box(int, key)
+    r10 = CPyDict_GetItem(d, r9)
+    r11 = unbox(int, r10)
+L3:
+    r12 = CPyDict_CheckSize(d, r2)
+    goto L1
+L4:
+    r13 = CPy_NoErrOccured()
+L5:
+    return 1
+
+[case testForDictContinue]
+from typing import Dict
+
+def sum_over_even_values(d: Dict[int, int]) -> int:
+    s = 0
+    for key in d:
+        if d[key] % 2:
+            continue
+        s = s + d[key]
+    return s
+[out]
+def sum_over_even_values(d):
+    d :: dict
+    s :: int
+    r0 :: short_int
+    r1 :: native_int
+    r2 :: short_int
+    r3 :: object
+    r4 :: tuple[bool, short_int, object]
+    r5 :: short_int
+    r6 :: bool
+    r7 :: object
+    r8, key :: int
+    r9, r10 :: object
+    r11, r12 :: int
+    r13 :: bit
+    r14, r15 :: object
+    r16, r17 :: int
+    r18, r19 :: bit
+L0:
+    s = 0
+    r0 = 0
+    r1 = PyDict_Size(d)
+    r2 = r1 << 1
+    r3 = CPyDict_GetKeysIter(d)
+L1:
+    r4 = CPyDict_NextKey(r3, r0)
+    r5 = r4[1]
+    r0 = r5
+    r6 = r4[0]
+    if r6 goto L2 else goto L6 :: bool
+L2:
+    r7 = r4[2]
+    r8 = unbox(int, r7)
+    key = r8
+    r9 = box(int, key)
+    r10 = CPyDict_GetItem(d, r9)
+    r11 = unbox(int, r10)
+    r12 = CPyTagged_Remainder(r11, 4)
+    r13 = r12 != 0
+    if r13 goto L3 else goto L4 :: bool
+L3:
+    goto L5
+L4:
+    r14 = box(int, key)
+    r15 = CPyDict_GetItem(d, r14)
+    r16 = unbox(int, r15)
+    r17 = CPyTagged_Add(s, r16)
+    s = r17
+L5:
+    r18 = CPyDict_CheckSize(d, r2)
+    goto L1
+L6:
+    r19 = CPy_NoErrOccured()
+L7:
+    return s
+
+[case testMultipleAssignmentWithNoUnpacking]
+from typing import Tuple
+
+def f(x: int, y: int) -> Tuple[int, int]:
+    x, y = y, x
+    return (x, y)
+
+def f2(x: int, y: str, z: float) -> Tuple[float, str, int]:
+    a, b, c = x, y, z
+    return (c, b, a)
+
+def f3(x: int, y: int) -> Tuple[int, int]:
+    [x, y] = [y, x]
+    return (x, y)
+[out]
+def f(x, y):
+    x, y, r0, r1 :: int
+    r2 :: tuple[int, int]
+L0:
+    r0 = y
+    r1 = x
+    x = r0
+    y = r1
+    r2 = (x, y)
+    return r2
+def f2(x, y, z):
+    x :: int
+    y :: str
+    z :: float
+    r0 :: int
+    r1 :: str
+    r2 :: float
+    a :: int
+    b :: str
+    c :: float
+    r3 :: tuple[float, str, int]
+L0:
+    r0 = x
+    r1 = y
+    r2 = z
+    a = r0
+    b = r1
+    c = r2
+    r3 = (c, b, a)
+    return r3
+def f3(x, y):
+    x, y, r0, r1 :: int
+    r2 :: tuple[int, int]
+L0:
+    r0 = y
+    r1 = x
+    x = r0
+    y = r1
+    r2 = (x, y)
+    return r2
+
+[case testMultipleAssignmentBasicUnpacking]
+from typing import Tuple, Any
+
+def from_tuple(t: Tuple[bool, None]) -> None:
+    x, y = t
+
+def from_any(a: Any) -> None:
+    x, y = a
+[out]
+def from_tuple(t):
+    t :: tuple[bool, None]
+    r0, x :: bool
+    r1, y :: None
+L0:
+    r0 = t[0]
+    x = r0
+    r1 = t[1]
+    y = r1
+    return 1
+def from_any(a):
+    a, r0, r1 :: object
+    r2 :: bool
+    x, r3 :: object
+    r4 :: bool
+    y, r5 :: object
+    r6 :: bool
+L0:
+    r0 = PyObject_GetIter(a)
+    r1 = PyIter_Next(r0)
+    if is_error(r1) goto L1 else goto L2
+L1:
+    r2 = raise ValueError('not enough values to unpack')
+    unreachable
+L2:
+    x = r1
+    r3 = PyIter_Next(r0)
+    if is_error(r3) goto L3 else goto L4
+L3:
+    r4 = raise ValueError('not enough values to unpack')
+    unreachable
+L4:
+    y = r3
+    r5 = PyIter_Next(r0)
+    if is_error(r5) goto L6 else goto L5
+L5:
+    r6 = raise ValueError('too many values to unpack')
+    unreachable
+L6:
+    return 1
+
+[case testMultiAssignmentCoercions]
+from typing import Tuple, Any
+
+def from_tuple(t: Tuple[int, Any]) -> None:
+    x: object
+    y: int
+    x, y = t
+
+def from_any(a: Any) -> None:
+    x: int
+    x, y = a
+[out]
+def from_tuple(t):
+    t :: tuple[int, object]
+    r0, r1 :: int
+    r2, x, r3, r4 :: object
+    r5, y :: int
+L0:
+    r0 = borrow t[0]
+    r1 = unborrow r0
+    r2 = box(int, r1)
+    x = r2
+    r3 = borrow t[1]
+    r4 = unborrow r3
+    r5 = unbox(int, r4)
+    y = r5
+    keep_alive steal t
+    return 1
+def from_any(a):
+    a, r0, r1 :: object
+    r2 :: bool
+    r3, x :: int
+    r4 :: object
+    r5 :: bool
+    y, r6 :: object
+    r7 :: bool
+L0:
+    r0 = PyObject_GetIter(a)
+    r1 = PyIter_Next(r0)
+    if is_error(r1) goto L1 else goto L2
+L1:
+    r2 = raise ValueError('not enough values to unpack')
+    unreachable
+L2:
+    r3 = unbox(int, r1)
+    x = r3
+    r4 = PyIter_Next(r0)
+    if is_error(r4) goto L3 else goto L4
+L3:
+    r5 = raise ValueError('not enough values to unpack')
+    unreachable
+L4:
+    y = r4
+    r6 = PyIter_Next(r0)
+    if is_error(r6) goto L6 else goto L5
+L5:
+    r7 = raise ValueError('too many values to unpack')
+    unreachable
+L6:
+    return 1
+
+[case testMultiAssignmentNested]
+from typing import Tuple, Any, List
+
+class A:
+    x: int
+
+def multi_assign(t: Tuple[int, Tuple[str, Any]], a: A, l: List[str]) -> None:
+    z: int
+    a.x, (l[0], z) = t
+[out]
+def multi_assign(t, a, l):
+    t :: tuple[int, tuple[str, object]]
+    a :: __main__.A
+    l :: list
+    r0 :: int
+    r1 :: bool
+    r2 :: tuple[str, object]
+    r3 :: str
+    r4 :: bit
+    r5 :: object
+    r6, z :: int
+L0:
+    r0 = t[0]
+    a.x = r0; r1 = is_error
+    r2 = t[1]
+    r3 = r2[0]
+    r4 = CPyList_SetItem(l, 0, r3)
+    r5 = r2[1]
+    r6 = unbox(int, r5)
+    z = r6
+    return 1
+
+[case testMultipleAssignmentUnpackFromSequence]
+from typing import List, Tuple
+
+def f(l: List[int], t: Tuple[int, ...]) -> None:
+    x: object
+    y: int
+    x, y = l
+    x, y = t
+[out]
+def f(l, t):
+    l :: list
+    t :: tuple
+    r0 :: i32
+    r1 :: bit
+    r2, r3, x :: object
+    r4, y :: int
+    r5 :: i32
+    r6 :: bit
+    r7, r8 :: object
+    r9 :: int
+L0:
+    r0 = CPySequence_CheckUnpackCount(l, 2)
+    r1 = r0 >= 0 :: signed
+    r2 = CPyList_GetItemUnsafe(l, 0)
+    r3 = CPyList_GetItemUnsafe(l, 2)
+    x = r2
+    r4 = unbox(int, r3)
+    y = r4
+    r5 = CPySequence_CheckUnpackCount(t, 2)
+    r6 = r5 >= 0 :: signed
+    r7 = CPySequenceTuple_GetItem(t, 0)
+    r8 = CPySequenceTuple_GetItem(t, 2)
+    r9 = unbox(int, r8)
+    x = r7
+    y = r9
+    return 1
+
+[case testAssert]
+from typing import Optional
+
+def no_msg(x: bool) -> int:
+    assert x
+    return 1
+
+def literal_msg(x: object) -> int:
+    assert x, 'message'
+    return 2
+
+def complex_msg(x: Optional[str], s: str) -> None:
+    assert x, s
+[out]
+def no_msg(x):
+    x, r0 :: bool
+L0:
+    if x goto L2 else goto L1 :: bool
+L1:
+    r0 = raise AssertionError
+    unreachable
+L2:
+    return 2
+def literal_msg(x):
+    x :: object
+    r0 :: i32
+    r1 :: bit
+    r2, r3 :: bool
+L0:
+    r0 = PyObject_IsTrue(x)
+    r1 = r0 >= 0 :: signed
+    r2 = truncate r0: i32 to builtins.bool
+    if r2 goto L2 else goto L1 :: bool
+L1:
+    r3 = raise AssertionError('message')
+    unreachable
+L2:
+    return 4
+def complex_msg(x, s):
+    x :: union[str, None]
+    s :: str
+    r0 :: object
+    r1 :: bit
+    r2 :: str
+    r3 :: bit
+    r4 :: object
+    r5 :: str
+    r6, r7 :: object
+L0:
+    r0 = load_address _Py_NoneStruct
+    r1 = x != r0
+    if r1 goto L1 else goto L2 :: bool
+L1:
+    r2 = cast(str, x)
+    r3 = CPyStr_IsTrue(r2)
+    if r3 goto L3 else goto L2 :: bool
+L2:
+    r4 = builtins :: module
+    r5 = 'AssertionError'
+    r6 = CPyObject_GetAttr(r4, r5)
+    r7 = PyObject_CallFunctionObjArgs(r6, s, 0)
+    CPy_Raise(r7)
+    unreachable
+L3:
+    return 1
+
+[case testDelList]
+def delList() -> None:
+    l = [1, 2]
+    del l[1]
+def delListMultiple() -> None:
+    l = [1, 2, 3, 4, 5, 6, 7]
+    del l[1], l[2], l[3]
+[out]
+def delList():
+    r0 :: list
+    r1, r2 :: object
+    r3, r4, r5 :: ptr
+    l :: list
+    r6 :: object
+    r7 :: i32
+    r8 :: bit
+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
+    l = r0
+    r6 = object 1
+    r7 = PyObject_DelItem(l, r6)
+    r8 = r7 >= 0 :: signed
+    return 1
+def delListMultiple():
+    r0 :: list
+    r1, r2, r3, r4, r5, r6, r7 :: object
+    r8, r9, r10, r11, r12, r13, r14, r15 :: ptr
+    l :: list
+    r16 :: object
+    r17 :: i32
+    r18 :: bit
+    r19 :: object
+    r20 :: i32
+    r21 :: bit
+    r22 :: object
+    r23 :: i32
+    r24 :: bit
+L0:
+    r0 = PyList_New(7)
+    r1 = object 1
+    r2 = object 2
+    r3 = object 3
+    r4 = object 4
+    r5 = object 5
+    r6 = object 6
+    r7 = object 7
+    r8 = get_element_ptr r0 ob_item :: PyListObject
+    r9 = load_mem r8 :: ptr*
+    set_mem r9, r1 :: builtins.object*
+    r10 = r9 + WORD_SIZE*1
+    set_mem r10, r2 :: builtins.object*
+    r11 = r9 + WORD_SIZE*2
+    set_mem r11, r3 :: builtins.object*
+    r12 = r9 + WORD_SIZE*3
+    set_mem r12, r4 :: builtins.object*
+    r13 = r9 + WORD_SIZE*4
+    set_mem r13, r5 :: builtins.object*
+    r14 = r9 + WORD_SIZE*5
+    set_mem r14, r6 :: builtins.object*
+    r15 = r9 + WORD_SIZE*6
+    set_mem r15, r7 :: builtins.object*
+    keep_alive r0
+    l = r0
+    r16 = object 1
+    r17 = PyObject_DelItem(l, r16)
+    r18 = r17 >= 0 :: signed
+    r19 = object 2
+    r20 = PyObject_DelItem(l, r19)
+    r21 = r20 >= 0 :: signed
+    r22 = object 3
+    r23 = PyObject_DelItem(l, r22)
+    r24 = r23 >= 0 :: signed
+    return 1
+
+[case testDelDict]
+def delDict() -> None:
+    d = {"one":1, "two":2}
+    del d["one"]
+def delDictMultiple() -> None:
+    d = {"one":1, "two":2, "three":3, "four":4}
+    del d["one"], d["four"]
+[out]
+def delDict():
+    r0, r1 :: str
+    r2, r3 :: object
+    r4, d :: dict
+    r5 :: str
+    r6 :: i32
+    r7 :: bit
+L0:
+    r0 = 'one'
+    r1 = 'two'
+    r2 = object 1
+    r3 = object 2
+    r4 = CPyDict_Build(2, r0, r2, r1, r3)
+    d = r4
+    r5 = 'one'
+    r6 = PyObject_DelItem(d, r5)
+    r7 = r6 >= 0 :: signed
+    return 1
+def delDictMultiple():
+    r0, r1, r2, r3 :: str
+    r4, r5, r6, r7 :: object
+    r8, d :: dict
+    r9, r10 :: str
+    r11 :: i32
+    r12 :: bit
+    r13 :: i32
+    r14 :: bit
+L0:
+    r0 = 'one'
+    r1 = 'two'
+    r2 = 'three'
+    r3 = 'four'
+    r4 = object 1
+    r5 = object 2
+    r6 = object 3
+    r7 = object 4
+    r8 = CPyDict_Build(4, r0, r4, r1, r5, r2, r6, r3, r7)
+    d = r8
+    r9 = 'one'
+    r10 = 'four'
+    r11 = PyObject_DelItem(d, r9)
+    r12 = r11 >= 0 :: signed
+    r13 = PyObject_DelItem(d, r10)
+    r14 = r13 >= 0 :: signed
+    return 1
+
+[case testDelAttribute]
+class Dummy():
+    __deletable__ = ('x', 'y')
+    def __init__(self, x: int, y: int) -> None:
+        self.x = x
+        self.y = y
+def delAttribute() -> None:
+    dummy = Dummy(1, 2)
+    del dummy.x
+def delAttributeMultiple() -> None:
+    dummy = Dummy(1, 2)
+    del dummy.x, dummy.y
+[out]
+def Dummy.__init__(self, x, y):
+    self :: __main__.Dummy
+    x, y :: int
+L0:
+    self.x = x
+    self.y = y
+    return 1
+def delAttribute():
+    r0, dummy :: __main__.Dummy
+    r1 :: str
+    r2 :: i32
+    r3 :: bit
+L0:
+    r0 = Dummy(2, 4)
+    dummy = r0
+    r1 = 'x'
+    r2 = PyObject_DelAttr(dummy, r1)
+    r3 = r2 >= 0 :: signed
+    return 1
+def delAttributeMultiple():
+    r0, dummy :: __main__.Dummy
+    r1 :: str
+    r2 :: i32
+    r3 :: bit
+    r4 :: str
+    r5 :: i32
+    r6 :: bit
+L0:
+    r0 = Dummy(2, 4)
+    dummy = r0
+    r1 = 'x'
+    r2 = PyObject_DelAttr(dummy, r1)
+    r3 = r2 >= 0 :: signed
+    r4 = 'y'
+    r5 = PyObject_DelAttr(dummy, r4)
+    r6 = r5 >= 0 :: signed
+    return 1
+
+[case testForEnumerate]
+from typing import List, Iterable
+
+def f(a: List[int]) -> None:
+    for i, x in enumerate(a):
+        i + x
+def g(x: Iterable[int]) -> None:
+    for i, n in enumerate(x):
+        pass
+[out]
+def f(a):
+    a :: list
+    r0 :: short_int
+    i :: int
+    r1 :: short_int
+    r2 :: ptr
+    r3 :: native_int
+    r4 :: short_int
+    r5 :: bit
+    r6 :: object
+    r7, x, r8 :: int
+    r9, r10 :: short_int
+L0:
+    r0 = 0
+    i = 0
+    r1 = 0
+L1:
+    r2 = get_element_ptr a ob_size :: PyVarObject
+    r3 = load_mem r2 :: native_int*
+    keep_alive a
+    r4 = r3 << 1
+    r5 = r1 < r4 :: signed
+    if r5 goto L2 else goto L4 :: bool
+L2:
+    r6 = CPyList_GetItemUnsafe(a, r1)
+    r7 = unbox(int, r6)
+    x = r7
+    r8 = CPyTagged_Add(i, x)
+L3:
+    r9 = r0 + 2
+    r0 = r9
+    i = r9
+    r10 = r1 + 2
+    r1 = r10
+    goto L1
+L4:
+L5:
+    return 1
+def g(x):
+    x :: object
+    r0 :: short_int
+    i :: int
+    r1, r2 :: object
+    r3, n :: int
+    r4 :: short_int
+    r5 :: bit
+L0:
+    r0 = 0
+    i = 0
+    r1 = PyObject_GetIter(x)
+L1:
+    r2 = PyIter_Next(r1)
+    if is_error(r2) goto L4 else goto L2
+L2:
+    r3 = unbox(int, r2)
+    n = r3
+L3:
+    r4 = r0 + 2
+    r0 = r4
+    i = r4
+    goto L1
+L4:
+    r5 = CPy_NoErrOccured()
+L5:
+    return 1
+
+[case testForZip]
+from typing import List, Iterable, Sequence
+
+def f(a: List[int], b: Sequence[bool]) -> None:
+    for x, y in zip(a, b):
+        if b:
+            x = 1
+
+def g(a: Iterable[bool], b: List[int]) -> None:
+    for x, y, z in zip(a, b, range(5)):
+        x = False
+[out]
+def f(a, b):
+    a :: list
+    b :: object
+    r0 :: short_int
+    r1 :: object
+    r2 :: ptr
+    r3 :: native_int
+    r4 :: short_int
+    r5 :: bit
+    r6, r7 :: object
+    r8, x :: int
+    r9, y :: bool
+    r10 :: i32
+    r11 :: bit
+    r12 :: bool
+    r13 :: short_int
+    r14 :: bit
+L0:
+    r0 = 0
+    r1 = PyObject_GetIter(b)
+L1:
+    r2 = get_element_ptr a ob_size :: PyVarObject
+    r3 = load_mem r2 :: native_int*
+    keep_alive a
+    r4 = r3 << 1
+    r5 = r0 < r4 :: signed
+    if r5 goto L2 else goto L7 :: bool
+L2:
+    r6 = PyIter_Next(r1)
+    if is_error(r6) goto L7 else goto L3
+L3:
+    r7 = CPyList_GetItemUnsafe(a, r0)
+    r8 = unbox(int, r7)
+    x = r8
+    r9 = unbox(bool, r6)
+    y = r9
+    r10 = PyObject_IsTrue(b)
+    r11 = r10 >= 0 :: signed
+    r12 = truncate r10: i32 to builtins.bool
+    if r12 goto L4 else goto L5 :: bool
+L4:
+    x = 2
+L5:
+L6:
+    r13 = r0 + 2
+    r0 = r13
+    goto L1
+L7:
+    r14 = CPy_NoErrOccured()
+L8:
+    return 1
+def g(a, b):
+    a :: object
+    b :: list
+    r0 :: object
+    r1, r2 :: short_int
+    z :: int
+    r3 :: object
+    r4 :: ptr
+    r5 :: native_int
+    r6 :: short_int
+    r7, r8 :: bit
+    r9, x :: bool
+    r10 :: object
+    r11, y :: int
+    r12, r13 :: short_int
+    r14 :: bit
+L0:
+    r0 = PyObject_GetIter(a)
+    r1 = 0
+    r2 = 0
+    z = r2
+L1:
+    r3 = PyIter_Next(r0)
+    if is_error(r3) goto L6 else goto L2
+L2:
+    r4 = get_element_ptr b ob_size :: PyVarObject
+    r5 = load_mem r4 :: native_int*
+    keep_alive b
+    r6 = r5 << 1
+    r7 = r1 < r6 :: signed
+    if r7 goto L3 else goto L6 :: bool
+L3:
+    r8 = r2 < 10 :: signed
+    if r8 goto L4 else goto L6 :: bool
+L4:
+    r9 = unbox(bool, r3)
+    x = r9
+    r10 = CPyList_GetItemUnsafe(b, r1)
+    r11 = unbox(int, r10)
+    y = r11
+    x = 0
+L5:
+    r12 = r1 + 2
+    r1 = r12
+    r13 = r2 + 2
+    r2 = r13
+    z = r13
+    goto L1
+L6:
+    r14 = CPy_NoErrOccured()
+L7:
+    return 1
+
+[case testConditionalFunctionDefinition]
+if int():
+    def foo() -> int:
+        return 0
+else:
+    def foo() -> int:  # E
+        return 1
+
+def bar() -> int:
+    return 0
+
+if int():
+    def bar() -> int:  # E
+        return 1
+[out]
+main:5: error: Duplicate definition of "foo" not supported by mypyc
+main:12: error: Duplicate definition of "bar" not supported by mypyc
+
+[case testRepeatedUnderscoreFunctions]
+def _(arg): pass
+def _(arg): pass
+[out]
+main:2: error: Duplicate definition of "_" not supported by mypyc