jaclang 0.7.34__py3-none-any.whl → 0.8.1__py3-none-any.whl

jaclang/vendor/mypyc/test-data/refcount.test

@@ -1,1482 +0,0 @@
--- Test cases for reference count  insertion.
-
-[case testReturnLiteral]
-def f() -> int:
-    return 1
-[out]
-def f():
-L0:
-    return 2
-
-[case testReturnLocal]
-def f() -> int:
-    x = 1
-    return x
-[out]
-def f():
-    x :: int
-L0:
-    x = 2
-    return x
-
-[case testLocalVars]
-def f() -> int:
-    x = 1
-    y = x
-    x = y
-    return x
-[out]
-def f():
-    x, y :: int
-L0:
-    x = 2
-    y = x
-    x = y
-    return x
-
-[case testLocalVars2]
-def f() -> int:
-    x = 1
-    y = x
-    z = x
-    return y + z
-[out]
-def f():
-    x, y, z, r0 :: int
-L0:
-    x = 2
-    inc_ref x :: int
-    y = x
-    z = x
-    r0 = CPyTagged_Add(y, z)
-    dec_ref y :: int
-    dec_ref z :: int
-    return r0
-
-[case testFreeAtReturn]
-def f() -> int:
-    x = 1
-    y = 2
-    if x == 1:
-        return x
-    return y
-[out]
-def f():
-    x, y :: int
-    r0 :: bit
-L0:
-    x = 2
-    y = 4
-    r0 = int_eq x, 2
-    if r0 goto L3 else goto L4 :: bool
-L1:
-    return x
-L2:
-    return y
-L3:
-    dec_ref y :: int
-    goto L1
-L4:
-    dec_ref x :: int
-    goto L2
-
-[case testArgumentsInOps]
-def f(a: int, b: int) -> int:
-    x = a + 1
-    y = x + a
-    return y
-[out]
-def f(a, b):
-    a, b, r0, x, r1, y :: int
-L0:
-    r0 = CPyTagged_Add(a, 2)
-    x = r0
-    r1 = CPyTagged_Add(x, a)
-    dec_ref x :: int
-    y = r1
-    return y
-
-[case testArgumentsInAssign]
-def f(a: int) -> int:
-    x = a
-    y = a
-    x = 1
-    return x + y
-[out]
-def f(a):
-    a, x, y, r0 :: int
-L0:
-    inc_ref a :: int
-    x = a
-    dec_ref x :: int
-    inc_ref a :: int
-    y = a
-    x = 2
-    r0 = CPyTagged_Add(x, y)
-    dec_ref x :: int
-    dec_ref y :: int
-    return r0
-
-[case testAssignToArgument1]
-def f(a: int) -> int:
-    a = 1
-    y = a
-    return y
-[out]
-def f(a):
-    a, y :: int
-L0:
-    a = 2
-    y = a
-    return y
-
-[case testAssignToArgument2]
-def f(a: int) -> int:
-    a = 1
-    a = 2
-    a = 3
-    return a
-[out]
-def f(a):
-    a :: int
-L0:
-    a = 2
-    dec_ref a :: int
-    a = 4
-    dec_ref a :: int
-    a = 6
-    return a
-
-[case testAssignToArgument3]
-def f(a: int) -> int:
-    x = 1
-    a = x
-    y = x
-    return a
-[out]
-def f(a):
-    a, x, y :: int
-L0:
-    x = 2
-    inc_ref x :: int
-    a = x
-    y = x
-    dec_ref y :: int
-    return a
-
-[case testReturnArgument]
-def f(a: int) -> int:
-    return a
-[out]
-def f(a):
-    a :: int
-L0:
-    inc_ref a :: int
-    return a
-
-[case testConditionalAssignToArgument1]
-def f(a: int) -> int:
-    if a == a:
-        a = 1
-    else:
-        x = 2
-    y = a + 1
-    return y
-[out]
-def f(a):
-    a :: int
-    r0 :: bit
-    x, r1, y :: int
-L0:
-    r0 = int_eq a, a
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    a = 2
-    goto L3
-L2:
-    x = 4
-    dec_ref x :: int
-    goto L4
-L3:
-    r1 = CPyTagged_Add(a, 2)
-    dec_ref a :: int
-    y = r1
-    return y
-L4:
-    inc_ref a :: int
-    goto L3
-
-[case testConditionalAssignToArgument2]
-def f(a: int) -> int:
-    if a == a:
-        x = 2
-    else:
-        a = 1
-    y = a + 1
-    return y
-[out]
-def f(a):
-    a :: int
-    r0 :: bit
-    x, r1, y :: int
-L0:
-    r0 = int_eq a, a
-    if r0 goto L1 else goto L2 :: bool
-L1:
-    x = 4
-    dec_ref x :: int
-    goto L4
-L2:
-    a = 2
-L3:
-    r1 = CPyTagged_Add(a, 2)
-    dec_ref a :: int
-    y = r1
-    return y
-L4:
-    inc_ref a :: int
-    goto L3
-
-[case testConditionalAssignToArgument3]
-def f(a: int) -> int:
-    if a == a:
-        a = 1
-    return a
-[out]
-def f(a):
-    a :: int
-    r0 :: bit
-L0:
-    r0 = int_eq a, a
-    if r0 goto L1 else goto L3 :: bool
-L1:
-    a = 2
-L2:
-    return a
-L3:
-    inc_ref a :: int
-    goto L2
-
-[case testAssignRegisterToItself]
-def f(a: int) -> int:
-    a = a
-    x = 1
-    x = x
-    return x + a
--- This is correct but bad code
-[out]
-def f(a):
-    a, x, r0 :: int
-L0:
-    inc_ref a :: int
-    a = a
-    x = 2
-    inc_ref x :: int
-    dec_ref x :: int
-    x = x
-    r0 = CPyTagged_Add(x, a)
-    dec_ref x :: int
-    dec_ref a :: int
-    return r0
-
-[case testIncrement1]
-def f(a: int) -> int:
-    a = a + 1
-    x = 1
-    x = x + 1
-    return a + x
-[out]
-def f(a):
-    a, r0, x, r1, r2 :: int
-L0:
-    r0 = CPyTagged_Add(a, 2)
-    a = r0
-    x = 2
-    r1 = CPyTagged_Add(x, 2)
-    dec_ref x :: int
-    x = r1
-    r2 = CPyTagged_Add(a, x)
-    dec_ref a :: int
-    dec_ref x :: int
-    return r2
-
-[case testIncrement2]
-def f() -> None:
-    x = 1
-    x = x + 1
-[out]
-def f():
-    x, r0 :: int
-L0:
-    x = 2
-    r0 = CPyTagged_Add(x, 2)
-    dec_ref x :: int
-    x = r0
-    dec_ref x :: int
-    return 1
-
-[case testAdd1]
-def f() -> None:
-    y = 1
-    x = y + 1
-[out]
-def f():
-    y, r0, x :: int
-L0:
-    y = 2
-    r0 = CPyTagged_Add(y, 2)
-    dec_ref y :: int
-    x = r0
-    dec_ref x :: int
-    return 1
-
-[case testAdd2]
-def f(a: int) -> int:
-    a = a + a
-    x = a
-    x = x + x
-    return x
-[out]
-def f(a):
-    a, r0, x, r1 :: int
-L0:
-    r0 = CPyTagged_Add(a, a)
-    a = r0
-    x = a
-    r1 = CPyTagged_Add(x, x)
-    dec_ref x :: int
-    x = r1
-    return x
-
-[case testAdd3]
-def f(a: int) -> int:
-    x = a + a
-    y = x + x
-    return y
-[out]
-def f(a):
-    a, r0, x, r1, y :: int
-L0:
-    r0 = CPyTagged_Add(a, a)
-    x = r0
-    r1 = CPyTagged_Add(x, x)
-    dec_ref x :: int
-    y = r1
-    return y
-
-[case testAdd4]
-def f(a: int) -> None:
-    x = a + a
-    y = 1
-    z = y + y
-[out]
-def f(a):
-    a, r0, x, y, r1, z :: int
-L0:
-    r0 = CPyTagged_Add(a, a)
-    x = r0
-    dec_ref x :: int
-    y = 2
-    r1 = CPyTagged_Add(y, y)
-    dec_ref y :: int
-    z = r1
-    dec_ref z :: int
-    return 1
-
-[case testAdd5]
-def f(a: int) -> None:
-    a = a + a
-    x = 1
-    x = x + x
-[out]
-def f(a):
-    a, r0, x, r1 :: int
-L0:
-    r0 = CPyTagged_Add(a, a)
-    a = r0
-    dec_ref a :: int
-    x = 2
-    r1 = CPyTagged_Add(x, x)
-    dec_ref x :: int
-    x = r1
-    dec_ref x :: int
-    return 1
-
-[case testReturnInMiddleOfFunction]
-def f() -> int:
-    x = 1
-    y = 2
-    z = 3
-    if z == z:
-        return z
-    a = 1
-    return x + y - a
-[out]
-def f():
-    x, y, z :: int
-    r0 :: bit
-    a, r1, r2 :: int
-L0:
-    x = 2
-    y = 4
-    z = 6
-    r0 = int_eq z, z
-    if r0 goto L3 else goto L4 :: bool
-L1:
-    return z
-L2:
-    a = 2
-    r1 = CPyTagged_Add(x, y)
-    dec_ref x :: int
-    dec_ref y :: int
-    r2 = CPyTagged_Subtract(r1, a)
-    dec_ref r1 :: int
-    dec_ref a :: int
-    return r2
-L3:
-    dec_ref x :: int
-    dec_ref y :: int
-    goto L1
-L4:
-    dec_ref z :: int
-    goto L2
-
-[case testLoop]
-def f(a: int) -> int:
-    sum = 0
-    i = 0
-    while i <= a:
-        sum = sum + i
-        i = i + 1
-    return sum
-[out]
-def f(a):
-    a, sum, i :: int
-    r0 :: bit
-    r1, r2 :: int
-L0:
-    sum = 0
-    i = 0
-L1:
-    r0 = int_le i, a
-    if r0 goto L2 else goto L4 :: bool
-L2:
-    r1 = CPyTagged_Add(sum, i)
-    dec_ref sum :: int
-    sum = r1
-    r2 = CPyTagged_Add(i, 2)
-    dec_ref i :: int
-    i = r2
-    goto L1
-L3:
-    return sum
-L4:
-    dec_ref i :: int
-    goto L3
-
-[case testCall]
-def f(a: int) -> int:
-    return f(a + 1)
-[out]
-def f(a):
-    a, r0, r1 :: int
-L0:
-    r0 = CPyTagged_Add(a, 2)
-    r1 = f(r0)
-    dec_ref r0 :: int
-    return r1
-
-[case testError]
-def f(x: List[int]) -> None: pass # E: Name "List" is not defined \
-                                  # N: Did you forget to import it from "typing"? (Suggestion: "from typing import List")
-
-[case testNewList]
-def f() -> int:
-    a = [0, 1]
-    return 0
-[out]
-def f():
-    r0 :: list
-    r1, r2 :: object
-    r3 :: ptr
-    a :: list
-L0:
-    r0 = PyList_New(2)
-    r1 = object 0
-    r2 = object 1
-    r3 = list_items r0
-    inc_ref r1
-    buf_init_item r3, 0, r1
-    inc_ref r2
-    buf_init_item r3, 1, r2
-    a = r0
-    dec_ref a
-    return 0
-
-[case testListSet]
-from typing import List
-def f(a: List[int], b: List[int]) -> None:
-    a[0] = b[0]
-[out]
-def f(a, b):
-    a, b :: list
-    r0 :: object
-    r1 :: int
-    r2 :: object
-    r3 :: bit
-L0:
-    r0 = CPyList_GetItemShort(b, 0)
-    r1 = unbox(int, r0)
-    dec_ref r0
-    r2 = box(int, r1)
-    r3 = CPyList_SetItem(a, 0, r2)
-    return 1
-
-[case testTupleRefcount]
-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]
-    dec_ref r0
-    return r1
-
-[case testUserClassRefCount]
-class C:
-    x: 'C'
-def f() -> None:
-    c = C()
-    c.x = C()
-[out]
-def f():
-    r0, c, r1 :: __main__.C
-    r2 :: bool
-L0:
-    r0 = C()
-    c = r0
-    r1 = C()
-    c.x = r1; r2 = is_error
-    dec_ref c
-    return 1
-
-[case testCastRefCount]
-class C: pass
-
-def f() -> None:
-    a = [C()]
-    d = a[0]
-[out]
-def f():
-    r0 :: __main__.C
-    r1 :: list
-    r2 :: ptr
-    a :: list
-    r3 :: object
-    r4, d :: __main__.C
-L0:
-    r0 = C()
-    r1 = PyList_New(1)
-    r2 = list_items r1
-    buf_init_item r2, 0, r0
-    a = r1
-    r3 = CPyList_GetItemShort(a, 0)
-    dec_ref a
-    r4 = cast(__main__.C, r3)
-    d = r4
-    dec_ref d
-    return 1
-
-[case testUnaryBranchSpecialCase]
-def f(x: bool) -> int:
-    if x:
-        return 1
-    return 2
-[out]
-def f(x):
-    x :: bool
-L0:
-    if x goto L1 else goto L2 :: bool
-L1:
-    return 2
-L2:
-    return 4
-
-[case testReturnTuple]
-from typing import Tuple
-
-class C: pass
-def f() -> Tuple[C, C]:
-    a = C()
-    b = C()
-    return a, b
-[out]
-def f():
-    r0, a, r1, b :: __main__.C
-    r2 :: tuple[__main__.C, __main__.C]
-L0:
-    r0 = C()
-    a = r0
-    r1 = C()
-    b = r1
-    r2 = (a, b)
-    return r2
-
-[case testDecomposeTuple]
-from typing import Tuple
-
-class C:
-    a: int
-
-def f() -> int:
-    x, y = g()
-    return x.a + y.a
-
-def g() -> Tuple[C, C]:
-    return C(), C()
-[out]
-def f():
-    r0 :: tuple[__main__.C, __main__.C]
-    r1, r2, x, r3, r4, y :: __main__.C
-    r5, r6, r7 :: int
-L0:
-    r0 = g()
-    r1 = borrow r0[0]
-    r2 = unborrow r1
-    x = r2
-    r3 = borrow r0[1]
-    r4 = unborrow r3
-    y = r4
-    r5 = borrow x.a
-    r6 = borrow y.a
-    r7 = CPyTagged_Add(r5, r6)
-    dec_ref x
-    dec_ref y
-    return r7
-def g():
-    r0, r1 :: __main__.C
-    r2 :: tuple[__main__.C, __main__.C]
-L0:
-    r0 = C()
-    r1 = C()
-    r2 = (r0, r1)
-    return r2
-
-[case testUnicodeLiteral]
-def f() -> str:
-    return "some string"
-[out]
-def f():
-    r0 :: str
-L0:
-    r0 = 'some string'
-    inc_ref r0
-    return r0
-
-[case testPyMethodCall]
-def g(x: str) -> int:
-    return int(x, base=2)
-[out]
-def g(x):
-    x :: str
-    r0 :: object
-    r1 :: str
-    r2 :: tuple
-    r3 :: object
-    r4 :: dict
-    r5 :: object
-    r6 :: int
-L0:
-    r0 = load_address PyLong_Type
-    r1 = 'base'
-    r2 = PyTuple_Pack(1, x)
-    r3 = object 2
-    r4 = CPyDict_Build(1, r1, r3)
-    r5 = PyObject_Call(r0, r2, r4)
-    dec_ref r2
-    dec_ref r4
-    r6 = unbox(int, r5)
-    dec_ref r5
-    return r6
-
-[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:
-    inc_ref x :: int
-    r0 = box(int, x)
-    r1 = PyList_Append(a, r0)
-    dec_ref r0
-    r2 = r1 >= 0 :: signed
-    return 1
-
-[case testForDict]
-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 L6 :: bool
-L2:
-    r7 = r4[2]
-    dec_ref r4
-    r8 = unbox(int, r7)
-    dec_ref r7
-    key = r8
-    r9 = box(int, key)
-    r10 = CPyDict_GetItem(d, r9)
-    dec_ref r9
-    r11 = unbox(int, r10)
-    dec_ref r10
-    dec_ref r11 :: int
-L3:
-    r12 = CPyDict_CheckSize(d, r2)
-    goto L1
-L4:
-    r13 = CPy_NoErrOccured()
-L5:
-    return 1
-L6:
-    dec_ref r3
-    dec_ref r4
-    goto L4
-
-[case testBorrowRefs]
-def make_garbage(arg: object) -> None:
-    b = True
-    while b:
-        arg = None
-        b = False
-[out]
-def make_garbage(arg):
-    arg :: object
-    b :: bool
-    r0 :: object
-L0:
-    b = 1
-L1:
-    if b goto L2 else goto L3 :: bool
-L2:
-    r0 = box(None, 1)
-    inc_ref r0
-    arg = r0
-    dec_ref arg
-    b = 0
-    goto L1
-L3:
-    return 1
-
-[case testGetElementPtrLifeTime]
-from typing import List
-
-def f() -> int:
-    x: List[str] = []
-    return len(x)
-[out]
-def f():
-    r0, x :: list
-    r1 :: native_int
-    r2 :: short_int
-L0:
-    r0 = PyList_New(0)
-    x = r0
-    r1 = var_object_size x
-    dec_ref x
-    r2 = r1 << 1
-    return r2
-
-[case testSometimesUninitializedVariable]
-def f(x: bool) -> int:
-    if x:
-        y = 1
-    else:
-        z = 2
-    return y + z
-[out]
-def f(x):
-    x :: bool
-    r0, y, r1, z :: int
-    r2, r3 :: bool
-    r4 :: int
-L0:
-    r0 = <error> :: int
-    y = r0
-    r1 = <error> :: int
-    z = r1
-    if x goto L8 else goto L9 :: bool
-L1:
-    y = 2
-    goto L3
-L2:
-    z = 4
-L3:
-    if is_error(y) goto L10 else goto L5
-L4:
-    r2 = raise UnboundLocalError('local variable "y" referenced before assignment')
-    unreachable
-L5:
-    if is_error(z) goto L11 else goto L7
-L6:
-    r3 = raise UnboundLocalError('local variable "z" referenced before assignment')
-    unreachable
-L7:
-    r4 = CPyTagged_Add(y, z)
-    xdec_ref y :: int
-    xdec_ref z :: int
-    return r4
-L8:
-    xdec_ref y :: int
-    goto L1
-L9:
-    xdec_ref z :: int
-    goto L2
-L10:
-    xdec_ref z :: int
-    goto L4
-L11:
-    xdec_ref y :: int
-    goto L6
-
-[case testVectorcall_python3_8]
-from typing import Any
-
-def call(f: Any, x: int) -> int:
-    return f(x)
-[out]
-def call(f, x):
-    f :: object
-    x :: int
-    r0 :: object
-    r1 :: object[1]
-    r2 :: object_ptr
-    r3 :: object
-    r4 :: int
-L0:
-    inc_ref x :: int
-    r0 = box(int, x)
-    r1 = [r0]
-    r2 = load_address r1
-    r3 = _PyObject_Vectorcall(f, r2, 1, 0)
-    dec_ref r0
-    r4 = unbox(int, r3)
-    dec_ref r3
-    return r4
-
-[case testVectorcallMethod_python3_9_64bit]
-from typing import Any
-
-def call(o: Any, x: int) -> int:
-    return o.m(x)
-[out]
-def call(o, x):
-    o :: object
-    x :: int
-    r0 :: str
-    r1 :: object
-    r2 :: object[2]
-    r3 :: object_ptr
-    r4 :: object
-    r5 :: int
-L0:
-    r0 = 'm'
-    inc_ref x :: int
-    r1 = box(int, x)
-    r2 = [o, r1]
-    r3 = load_address r2
-    r4 = PyObject_VectorcallMethod(r0, r3, 9223372036854775810, 0)
-    dec_ref r1
-    r5 = unbox(int, r4)
-    dec_ref r4
-    return r5
-
-[case testBorrowAttribute]
-def g() -> int:
-    d = D()
-    return d.c.x
-
-def f(d: D) -> int:
-    return d.c.x
-
-class C:
-    x: int
-class D:
-    c: C
-[out]
-def g():
-    r0, d :: __main__.D
-    r1 :: __main__.C
-    r2 :: int
-L0:
-    r0 = D()
-    d = r0
-    r1 = borrow d.c
-    r2 = r1.x
-    dec_ref d
-    return r2
-def f(d):
-    d :: __main__.D
-    r0 :: __main__.C
-    r1 :: int
-L0:
-    r0 = borrow d.c
-    r1 = r0.x
-    return r1
-
-[case testBorrowAttributeTwice]
-def f(e: E) -> int:
-    return e.d.c.x
-
-class C:
-    x: int
-class D:
-    c: C
-class E:
-    d: D
-[out]
-def f(e):
-    e :: __main__.E
-    r0 :: __main__.D
-    r1 :: __main__.C
-    r2 :: int
-L0:
-    r0 = borrow e.d
-    r1 = borrow r0.c
-    r2 = r1.x
-    return r2
-
-[case testBorrowAttributeIsNone]
-from typing import Optional
-
-def f(c: C) -> bool:
-    return c.x is not None
-
-def g(c: C) -> bool:
-    return c.x is None
-
-class C:
-    x: Optional[str]
-[out]
-def f(c):
-    c :: __main__.C
-    r0 :: union[str, None]
-    r1 :: object
-    r2 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    return r2
-def g(c):
-    c :: __main__.C
-    r0 :: union[str, None]
-    r1 :: object
-    r2 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 == r1
-    return r2
-
-[case testBorrowAttributeNarrowOptional]
-from typing import Optional
-
-def f(c: C) -> bool:
-    if c.x is not None:
-        return c.x.b
-    return False
-
-class C:
-    x: Optional[D]
-
-class D:
-    b: bool
-[out]
-def f(c):
-    c :: __main__.C
-    r0 :: union[__main__.D, None]
-    r1 :: object
-    r2 :: bit
-    r3 :: union[__main__.D, None]
-    r4 :: __main__.D
-    r5 :: bool
-L0:
-    r0 = borrow c.x
-    r1 = load_address _Py_NoneStruct
-    r2 = r0 != r1
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = borrow c.x
-    r4 = borrow cast(__main__.D, r3)
-    r5 = r4.b
-    return r5
-L2:
-    return 0
-
-[case testBorrowLenArgument]
-from typing import List
-
-def f(x: C) -> int:
-    return len(x.a)
-
-class C:
-    a: List[str]
-[out]
-def f(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: native_int
-    r2 :: short_int
-L0:
-    r0 = borrow x.a
-    r1 = var_object_size r0
-    r2 = r1 << 1
-    return r2
-
-[case testBorrowIsinstanceArgument]
-from typing import List
-
-def f(x: C) -> bool:
-    if isinstance(x.a, D):
-        return x.a.b
-    else:
-        return True
-
-class C:
-    a: object
-
-class D:
-    b: bool
-[out]
-def f(x):
-    x :: __main__.C
-    r0, r1 :: object
-    r2 :: ptr
-    r3 :: object
-    r4 :: bit
-    r5 :: object
-    r6 :: __main__.D
-    r7 :: bool
-L0:
-    r0 = borrow x.a
-    r1 = __main__.D :: type
-    r2 = get_element_ptr r0 ob_type :: PyObject
-    r3 = load_mem r2 :: builtins.object*
-    r4 = r3 == r1
-    if r4 goto L1 else goto L2 :: bool
-L1:
-    r5 = borrow x.a
-    r6 = borrow cast(__main__.D, r5)
-    r7 = r6.b
-    return r7
-L2:
-    return 1
-
-[case testBorrowListGetItem1]
-from typing import List
-
-def literal_index(x: C) -> str:
-    return x.a[0]
-
-def negative_index(x: C) -> str:
-    return x.a[-1]
-
-def lvar_index(x: C, n: int) -> str:
-    return x.a[n]
-
-class C:
-    a: List[str]
-
-[out]
-def literal_index(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: object
-    r2 :: str
-L0:
-    r0 = borrow x.a
-    r1 = CPyList_GetItemShort(r0, 0)
-    r2 = cast(str, r1)
-    return r2
-def negative_index(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: object
-    r2 :: str
-L0:
-    r0 = borrow x.a
-    r1 = CPyList_GetItemShort(r0, -2)
-    r2 = cast(str, r1)
-    return r2
-def lvar_index(x, n):
-    x :: __main__.C
-    n :: int
-    r0 :: list
-    r1 :: object
-    r2 :: str
-L0:
-    r0 = borrow x.a
-    r1 = CPyList_GetItem(r0, n)
-    r2 = cast(str, r1)
-    return r2
-
-[case testBorrowListGetItem2]
-from typing import List
-
-def attr_before_index(x: C) -> str:
-    return x.a[x.n]
-
-def attr_after_index(a: List[C], i: int) -> int:
-    return a[i].n
-
-def attr_after_index_literal(a: List[C]) -> int:
-    return a[0].n
-
-class C:
-    a: List[str]
-    n: int
-[out]
-def attr_before_index(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: int
-    r2 :: object
-    r3 :: str
-L0:
-    r0 = borrow x.a
-    r1 = borrow x.n
-    r2 = CPyList_GetItem(r0, r1)
-    r3 = cast(str, r2)
-    return r3
-def attr_after_index(a, i):
-    a :: list
-    i :: int
-    r0 :: object
-    r1 :: __main__.C
-    r2 :: int
-L0:
-    r0 = CPyList_GetItemBorrow(a, i)
-    r1 = borrow cast(__main__.C, r0)
-    r2 = r1.n
-    return r2
-def attr_after_index_literal(a):
-    a :: list
-    r0 :: object
-    r1 :: __main__.C
-    r2 :: int
-L0:
-    r0 = CPyList_GetItemShortBorrow(a, 0)
-    r1 = borrow cast(__main__.C, r0)
-    r2 = r1.n
-    return r2
-
-[case testCannotBorrowListGetItem]
-from typing import List
-
-def func_index(x: C) -> str:
-    return x.a[f()]
-
-def f() -> int: return 0
-
-class C:
-    a: List[str]
-[out]
-def func_index(x):
-    x :: __main__.C
-    r0 :: list
-    r1 :: int
-    r2 :: object
-    r3 :: str
-L0:
-    r0 = x.a
-    r1 = f()
-    r2 = CPyList_GetItem(r0, r1)
-    dec_ref r0
-    dec_ref r1 :: int
-    r3 = cast(str, r2)
-    return r3
-def f():
-L0:
-    return 0
-
-[case testBorrowListGetItemKeepAlive]
-from typing import List
-
-def f() -> str:
-    a = [C()]
-    return a[0].s
-
-class C:
-    s: str
-[out]
-def f():
-    r0 :: __main__.C
-    r1 :: list
-    r2 :: ptr
-    a :: list
-    r3 :: object
-    r4 :: __main__.C
-    r5 :: str
-L0:
-    r0 = C()
-    r1 = PyList_New(1)
-    r2 = list_items r1
-    buf_init_item r2, 0, r0
-    a = r1
-    r3 = CPyList_GetItemShortBorrow(a, 0)
-    r4 = borrow cast(__main__.C, r3)
-    r5 = r4.s
-    dec_ref a
-    return r5
-
-[case testBorrowSetAttrObject]
-from typing import Optional
-
-def f(x: Optional[C]) -> None:
-    if x is not None:
-        x.b = True
-
-def g(x: D) -> None:
-    x.c.b = False
-
-class C:
-    b: bool
-
-class D:
-    c: C
-[out]
-def f(x):
-    x :: union[__main__.C, None]
-    r0 :: object
-    r1 :: bit
-    r2 :: __main__.C
-    r3 :: bool
-L0:
-    r0 = load_address _Py_NoneStruct
-    r1 = x != r0
-    if r1 goto L1 else goto L2 :: bool
-L1:
-    r2 = borrow cast(__main__.C, x)
-    r2.b = 1; r3 = is_error
-L2:
-    return 1
-def g(x):
-    x :: __main__.D
-    r0 :: __main__.C
-    r1 :: bool
-L0:
-    r0 = borrow x.c
-    r0.b = 0; r1 = is_error
-    return 1
-
-[case testBorrowIntEquality]
-def add(c: C) -> bool:
-    return c.x == c.y
-
-class C:
-    x: int
-    y: int
-[out]
-def add(c):
-    c :: __main__.C
-    r0, r1 :: int
-    r2 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = int_eq r0, r1
-    return r2
-
-[case testBorrowIntLessThan]
-def add(c: C) -> bool:
-    return c.x < c.y
-
-class C:
-    x: int
-    y: int
-[out]
-def add(c):
-    c :: __main__.C
-    r0, r1 :: int
-    r2 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = int_lt r0, r1
-    return r2
-
-[case testBorrowIntCompareFinal]
-from typing_extensions import Final
-
-X: Final = 10
-
-def add(c: C) -> bool:
-    return c.x == X
-
-class C:
-    x: int
-[out]
-def add(c):
-    c :: __main__.C
-    r0 :: int
-    r1 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = int_eq r0, 20
-    return r1
-
-[case testBorrowIntArithmetic]
-def add(c: C) -> int:
-    return c.x + c.y
-
-def sub(c: C) -> int:
-    return c.x - c.y
-
-class C:
-    x: int
-    y: int
-[out]
-def add(c):
-    c :: __main__.C
-    r0, r1, r2 :: int
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = CPyTagged_Add(r0, r1)
-    return r2
-def sub(c):
-    c :: __main__.C
-    r0, r1, r2 :: int
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = CPyTagged_Subtract(r0, r1)
-    return r2
-
-[case testBorrowIntComparisonInIf]
-def add(c: C, n: int) -> bool:
-    if c.x == c.y:
-        return True
-    return False
-
-class C:
-    x: int
-    y: int
-[out]
-def add(c, n):
-    c :: __main__.C
-    n, r0, r1 :: int
-    r2 :: bit
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = int_eq r0, r1
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    return 1
-L2:
-    return 0
-
-[case testBorrowIntInPlaceOp]
-def add(c: C, n: int) -> None:
-    c.x += n
-
-def sub(c: C, n: int) -> None:
-    c.x -= c.y
-
-class C:
-    x: int
-    y: int
-[out]
-def add(c, n):
-    c :: __main__.C
-    n, r0, r1 :: int
-    r2 :: bool
-L0:
-    r0 = borrow c.x
-    r1 = CPyTagged_Add(r0, n)
-    c.x = r1; r2 = is_error
-    return 1
-def sub(c, n):
-    c :: __main__.C
-    n, r0, r1, r2 :: int
-    r3 :: bool
-L0:
-    r0 = borrow c.x
-    r1 = borrow c.y
-    r2 = CPyTagged_Subtract(r0, r1)
-    c.x = r2; r3 = is_error
-    return 1
-
-[case testCoerceIntToI64_64bit]
-from mypy_extensions import i64
-
-def f(x: int) -> i64:
-    # TODO: On the fast path we shouldn't have a decref. Once we have high-level IR,
-    #       coercion from int to i64 can be a single op, which makes it easier to
-    #       generate optimal refcount handling for this case.
-    return x + 1
-[out]
-def f(x):
-    x, r0 :: int
-    r1 :: native_int
-    r2 :: bit
-    r3, r4 :: i64
-    r5 :: ptr
-    r6 :: c_ptr
-    r7 :: i64
-L0:
-    r0 = CPyTagged_Add(x, 2)
-    r1 = r0 & 1
-    r2 = r1 == 0
-    if r2 goto L1 else goto L2 :: bool
-L1:
-    r3 = r0 >> 1
-    dec_ref r0 :: int
-    r4 = r3
-    goto L3
-L2:
-    r5 = r0 ^ 1
-    r6 = r5
-    r7 = CPyLong_AsInt64(r6)
-    r4 = r7
-    dec_ref r0 :: int
-L3:
-    return r4