-- 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, r2, r3 :: __main__.C

r4 :: tuple[__main__.C, __main__.C]

L0:

r0 = C()

a = r0

r1 = C()

b = r1

r2 = a

r3 = b

r4 = (r2, r3)

return r4

[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, r3, x, r4, y :: __main__.C

r5, r6, r7 :: int

L0:

r0 = g()

r1 = borrow r0[0]

r2 = borrow r0[1]

r3 = unborrow r1

x = r3

r4 = unborrow r2

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, r1 :: object

r2 :: object[2]

r3 :: object_ptr

r4, r5 :: object

r6 :: int

L0:

r0 = load_address PyLong_Type

r1 = object 2

r2 = [x, r1]

r3 = load_address r2

r4 = ('base',)

r5 = PyObject_Vectorcall(r0, r3, 1, 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 :: object

r3 :: tuple[bool, short_int, object]

r4 :: short_int

r5 :: bool

r6 :: object

r7, key :: int

r8, r9 :: object

r10 :: int

r11, r12 :: bit

L0:

r0 = 0

r1 = PyDict_Size(d)

r2 = CPyDict_GetKeysIter(d)

L1:

r3 = CPyDict_NextKey(r2, r0)

r4 = r3[1]

r0 = r4

r5 = r3[0]

if r5 goto L2 else goto L6 :: bool

L2:

r6 = r3[2]

dec_ref r3

r7 = unbox(int, r6)

dec_ref r6

key = r7

r8 = box(int, key)

r9 = CPyDict_GetItem(d, r8)

dec_ref r8

r10 = unbox(int, r9)

dec_ref r9

dec_ref r10 :: int

L3:

r11 = CPyDict_CheckSize(d, r1)

goto L1

L4:

r12 = CPy_NoErrOccurred()

L5:

return 1

L6:

dec_ref r2

dec_ref r3

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 testTupleUnpackUnused]

from typing import Tuple

def f(x: Tuple[str, int]) -> int:

a, xi = x

return 0

[out]

def f(x):

x :: tuple[str, int]

r0 :: str

r1 :: int

r2, a :: str

r3, xi :: int

L0:

r0 = borrow x[0]

r1 = borrow x[1]

inc_ref x

r2 = unborrow r0

a = r2

dec_ref a

r3 = unborrow r1

xi = r3

dec_ref xi :: int

return 0

[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]

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_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: