[case testTrivialFunction]

def f() -> int:

return 1

[out]

def f():

L0:

return 2

[case testFunctionArgument]

def f(x: int) -> int:

return x

[out]

def f(x):

x :: int

L0:

return x

[case testExplicitNoneReturn]

def f() -> None:

return

[out]

def f():

L0:

return 1

[case testExplicitNoneReturn2]

def f() -> None:

return None

[out]

def f():

L0:

return 1

[case testAssignment]

def f() -> int:

x = 1

y = x

return y

[out]

def f():

x, y :: int

L0:

x = 2

y = x

return y

[case testAssignmentTwice]

def f(x: int) -> None:

y = 1

y = x

return

[out]

def f(x):

x, y :: int

L0:

y = 2

y = x

return 1

[case testIntArithmetic]

def f(x: int, y: int) -> int:

return x * (y + 1)

[out]

def f(x, y):

x, y, r0, r1 :: int

L0:

r0 = CPyTagged_Add(y, 2)

r1 = CPyTagged_Multiply(x, r0)

return r1

[case testIf]

def f(x: int, y: int) -> int:

if x < y:

x = 1

return x

[out]

def f(x, y):

x, y :: int

r0 :: bit

L0:

r0 = int_lt x, y

if r0 goto L1 else goto L2 :: bool

L1:

x = 2

L2:

return x

[case testIfElse]

def f(x: int, y: int) -> int:

if x < y:

x = 1

else:

x = 2

return x

[out]

def f(x, y):

x, y :: int

r0 :: bit

L0:

r0 = int_lt x, y

if r0 goto L1 else goto L2 :: bool

L1:

x = 2

goto L3

L2:

x = 4

L3:

return x

[case testAnd1]

def f(x: int, y: int) -> int:

if x < y and x > y:

x = 1

else:

x = 2

return x

[out]

def f(x, y):

x, y :: int

r0, r1 :: bit

L0:

r0 = int_lt x, y

if r0 goto L1 else goto L3 :: bool

L1:

r1 = int_gt x, y

if r1 goto L2 else goto L3 :: bool

L2:

x = 2

goto L4

L3:

x = 4

L4:

return x

[case testAnd2]

def f(x: object, y: object) -> str:

return str(x) or str(y)

[out]

def f(x, y):

x, y :: object

r0 :: str

r1 :: bit

r2, r3 :: str

L0:

r0 = PyObject_Str(x)

r1 = CPyStr_IsTrue(r0)

if r1 goto L1 else goto L2 :: bool

L1:

r2 = r0

goto L3

L2:

r3 = PyObject_Str(y)

r2 = r3

L3:

return r2

[case testOr]

def f(x: int, y: int) -> int:

if x < y or x > y:

x = 1

else:

x = 2

return x

[out]

def f(x, y):

x, y :: int

r0, r1 :: bit

L0:

r0 = int_lt x, y

if r0 goto L2 else goto L1 :: bool

L1:

r1 = int_gt x, y

if r1 goto L2 else goto L3 :: bool

L2:

x = 2

goto L4

L3:

x = 4

L4:

return x

[case testOr2]

def f(x: object, y: object) -> str:

return str(x) and str(y)

[out]

def f(x, y):

x, y :: object

r0 :: str

r1 :: bit

r2, r3 :: str

L0:

r0 = PyObject_Str(x)

r1 = CPyStr_IsTrue(r0)

if r1 goto L2 else goto L1 :: bool

L1:

r2 = r0

goto L3

L2:

r3 = PyObject_Str(y)

r2 = r3

L3:

return r2

[case testSimpleNot]

def f(x: int, y: int) -> int:

if not (x < y):

x = 1

return x

[out]

def f(x, y):

x, y :: int

r0 :: bit

L0:

r0 = int_lt x, y

if r0 goto L2 else goto L1 :: bool

L1:

x = 2

L2:

return x

[case testNotAnd]

def f(x: int, y: int) -> int:

if not (x < y and x > y):

x = 1

return x

[out]

def f(x, y):

x, y :: int

r0, r1 :: bit

L0:

r0 = int_lt x, y

if r0 goto L1 else goto L2 :: bool

L1:

r1 = int_gt x, y

if r1 goto L3 else goto L2 :: bool

L2:

x = 2

L3:

return x

[case testWhile]

def f(x: int, y: int) -> int:

while x > y:

x = x - y

return x

[out]

def f(x, y):

x, y :: int

r0 :: bit

r1 :: int

L0:

L1:

r0 = int_gt x, y

if r0 goto L2 else goto L3 :: bool

L2:

r1 = CPyTagged_Subtract(x, y)

x = r1

goto L1

L3:

return x

[case testWhile2]

def f(x: int, y: int) -> int:

x = 1

while x > y:

x = x - y

return x

[out]

def f(x, y):

x, y :: int

r0 :: bit

r1 :: int

L0:

x = 2

L1:

r0 = int_gt x, y

if r0 goto L2 else goto L3 :: bool

L2:

r1 = CPyTagged_Subtract(x, y)

x = r1

goto L1

L3:

return x

[case testImplicitNoneReturn]

def f() -> None:

pass

[out]

def f():

L0:

return 1

[case testImplicitNoneReturn2]

def f() -> None:

x = 1

[out]

def f():

x :: int

L0:

x = 2

return 1

[case testImplicitNoneReturnAndIf]

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

if x < y:

x = 1

else:

y = 2

[out]

def f(x, y):

x, y :: int

r0 :: bit

L0:

r0 = int_lt x, y

if r0 goto L1 else goto L2 :: bool

L1:

x = 2

goto L3

L2:

y = 4

L3:

return 1

[case testRecursion]

def f(n: int) -> int:

if n <= 1:

return 1

else:

return f(n - 1) + f(n - 2)

[out]

def f(n):

n :: int

r0 :: bit

r1, r2, r3, r4, r5 :: int

L0:

r0 = int_le n, 2

if r0 goto L1 else goto L2 :: bool

L1:

return 2

L2:

r1 = CPyTagged_Subtract(n, 2)

r2 = f(r1)

r3 = CPyTagged_Subtract(n, 4)

r4 = f(r3)

r5 = CPyTagged_Add(r2, r4)

return r5

L3:

unreachable

[case testReportTypeCheckError]

def f() -> None:

return 1 # E: No return value expected

[case testReportSemanticaAnalysisError1]

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

def f() -> None:

x # E: Name "x" is not defined

[case testElif]

def f(n: int) -> int:

if n < 0:

x = 1

elif n == 0:

x = 1

else:

x = 2

return x

[out]

def f(n):

n :: int

r0 :: bit

x :: int

r1 :: bit

L0:

r0 = int_lt n, 0

if r0 goto L1 else goto L2 :: bool

L1:

x = 2

goto L6

L2:

r1 = int_eq n, 0

if r1 goto L3 else goto L4 :: bool

L3:

x = 2

goto L5

L4:

x = 4

L5:

L6:

return x

[case testUnaryMinus]

def f(n: int) -> int:

return -n

[out]

def f(n):

n, r0 :: int

L0:

r0 = CPyTagged_Negate(n)

return r0

[case testConditionalExpr]

def f(n: int) -> int:

return 0 if n == 0 else 1

[out]

def f(n):

n :: int

r0 :: bit

r1 :: int

L0:

r0 = int_eq n, 0

if r0 goto L1 else goto L2 :: bool

L1:

r1 = 0

goto L3

L2:

r1 = 2

L3:

return r1

[case testOperatorAssignment]

def f() -> int:

x = 0

x += 1

return x

[out]

def f():

x, r0 :: int

L0:

x = 0

r0 = CPyTagged_Add(x, 2)

x = r0

return x

[case testTrue]

def f() -> bool:

return True

[out]

def f():

L0:

return 1

[case testFalse]

def f() -> bool:

return False

[out]

def f():

L0:

return 0

[case testBoolCond]

def f(x: bool) -> bool:

if x:

return False

else:

return True

[out]

def f(x):

x :: bool

L0:

if x goto L1 else goto L2 :: bool

L1:

return 0

L2:

return 1

L3:

unreachable

[case testPycall]

import testmodule

def f(x: int) -> int:

return testmodule.factorial(x)

[file testmodule.py]

def factorial(x: int) -> int:

if x == 0:

return 1

else:

return x * factorial(x-1)

[out]

def f(x):

x :: int

r0 :: object

r1 :: str

r2, r3 :: object

r4 :: object[1]

r5 :: object_ptr

r6 :: object

r7 :: int

L0:

r0 = testmodule :: module

r1 = 'factorial'

r2 = CPyObject_GetAttr(r0, r1)

r3 = box(int, x)

r4 = [r3]

r5 = load_address r4

r6 = PyObject_Vectorcall(r2, r5, 1, 0)

keep_alive r3

r7 = unbox(int, r6)

return r7

[case testImport_toplevel]

import sys

import enum as enum2

import collections.abc

import collections.abc as abc2

_ = "filler"

import single

single.hello()

[file single.py]

def hello() -> None:

print("hello, world")

[out]

def __top_level__():

r0, r1 :: object

r2 :: bit

r3 :: str

r4 :: object

r5, r6, r7, r8 :: object_ptr

r9 :: object_ptr[4]

r10 :: c_ptr

r11 :: native_int[4]

r12 :: c_ptr

r13 :: object

r14 :: dict

r15, r16 :: str

r17 :: bit

r18 :: str

r19 :: dict

r20 :: str

r21 :: i32

r22 :: bit

r23 :: object_ptr

r24 :: object_ptr[1]

r25 :: c_ptr

r26 :: native_int[1]

r27 :: c_ptr

r28 :: object

r29 :: dict

r30, r31 :: str

r32 :: bit

r33 :: object

r34 :: str

r35, r36 :: object

L0:

r0 = builtins :: module

r1 = load_address _Py_NoneStruct

r2 = r0 != r1

if r2 goto L2 else goto L1 :: bool

L1:

r3 = 'builtins'

r4 = PyImport_Import(r3)

builtins = r4 :: module

L2:

r5 = load_address sys :: module

r6 = load_address enum :: module

r7 = load_address collections.abc :: module

r8 = load_address collections.abc :: module

r9 = [r5, r6, r7, r8]

r10 = load_address r9

r11 = [1, 2, 3, 4]

r12 = load_address r11

r13 = (('sys', 'sys', 'sys'), ('enum', 'enum', 'enum2'), ('collections.abc', 'collections', 'collections'), ('collections.abc', 'collections.abc', 'abc2'))

r14 = __main__.globals :: static

r15 = 'main'

r16 = '<module>'

r17 = CPyImport_ImportMany(r13, r10, r14, r15, r16, r12)

r18 = 'filler'

r19 = __main__.globals :: static

r20 = '_'

r21 = CPyDict_SetItem(r19, r20, r18)

r22 = r21 >= 0 :: signed

r23 = load_address single :: module

r24 = [r23]

r25 = load_address r24

r26 = [6]

r27 = load_address r26

r28 = (('single', 'single', 'single'),)

r29 = __main__.globals :: static

r30 = 'main'

r31 = '<module>'

r32 = CPyImport_ImportMany(r28, r25, r29, r30, r31, r27)

r33 = single :: module

r34 = 'hello'

r35 = CPyObject_GetAttr(r33, r34)

r36 = PyObject_Vectorcall(r35, 0, 0, 0)

return 1

[case testFromImport_toplevel]

from testmodule import g, h

from testmodule import h as two

def f(x: int) -> int:

return g(x) + h() + two()

[file testmodule.py]

def g(x: int) -> int:

return x + 1

def h() -> int:

return 2

[out]

def f(x):

x :: int

r0 :: dict

r1 :: str

r2, r3 :: object

r4 :: object[1]

r5 :: object_ptr

r6 :: object

r7 :: int

r8 :: dict

r9 :: str

r10, r11 :: object

r12, r13 :: int

r14 :: dict

r15 :: str

r16, r17 :: object

r18, r19 :: int

L0:

r0 = __main__.globals :: static

r1 = 'g'

r2 = CPyDict_GetItem(r0, r1)

r3 = box(int, x)

r4 = [r3]

r5 = load_address r4

r6 = PyObject_Vectorcall(r2, r5, 1, 0)

keep_alive r3

r7 = unbox(int, r6)

r8 = __main__.globals :: static

r9 = 'h'

r10 = CPyDict_GetItem(r8, r9)

r11 = PyObject_Vectorcall(r10, 0, 0, 0)

r12 = unbox(int, r11)

r13 = CPyTagged_Add(r7, r12)

r14 = __main__.globals :: static

r15 = 'two'

r16 = CPyDict_GetItem(r14, r15)

r17 = PyObject_Vectorcall(r16, 0, 0, 0)

r18 = unbox(int, r17)

r19 = CPyTagged_Add(r13, r18)

return r19

def __top_level__():

r0, r1 :: object

r2 :: bit

r3 :: str

r4, r5 :: object

r6 :: str

r7 :: dict

r8, r9, r10 :: object

r11 :: str

r12 :: dict

r13 :: object

L0:

r0 = builtins :: module

r1 = load_address _Py_NoneStruct

r2 = r0 != r1

if r2 goto L2 else goto L1 :: bool

L1:

r3 = 'builtins'

r4 = PyImport_Import(r3)

builtins = r4 :: module

L2:

r5 = ('g', 'h')

r6 = 'testmodule'

r7 = __main__.globals :: static

r8 = CPyImport_ImportFromMany(r6, r5, r5, r7)

testmodule = r8 :: module

r9 = ('h',)

r10 = ('two',)

r11 = 'testmodule'

r12 = __main__.globals :: static

r13 = CPyImport_ImportFromMany(r11, r9, r10, r12)

testmodule = r13 :: module

return 1

[case testPrintFullname]

import builtins

def f(x: int) -> None:

builtins.print(5)

[out]

def f(x):

x :: int

r0 :: object

r1 :: str

r2, r3 :: object

r4 :: object[1]

r5 :: object_ptr

r6 :: object

L0:

r0 = builtins :: module

r1 = 'print'

r2 = CPyObject_GetAttr(r0, r1)

r3 = object 5

r4 = [r3]

r5 = load_address r4

r6 = PyObject_Vectorcall(r2, r5, 1, 0)

keep_alive r3

return 1

[case testPrint]

import builtins

def f(x: int) -> None:

print(5)

[out]

def f(x):

x :: int

r0 :: object

r1 :: str

r2, r3 :: object

r4 :: object[1]

r5 :: object_ptr

r6 :: object

L0:

r0 = builtins :: module

r1 = 'print'

r2 = CPyObject_GetAttr(r0, r1)

r3 = object 5

r4 = [r3]

r5 = load_address r4

r6 = PyObject_Vectorcall(r2, r5, 1, 0)

keep_alive r3

return 1

[case testUnicodeLiteral]

def f() -> str:

x = "some string"

return "some other string"

[out]

def f():

r0, x, r1 :: str

L0:

r0 = 'some string'

x = r0

r1 = 'some other string'

return r1

[case testBytesLiteral]

def f() -> bytes:

x = b'\xf0'

return b'1234'

[out]

def f():

r0, x, r1 :: bytes

L0:

r0 = b'\xf0'

x = r0

r1 = b'1234'

return r1

[case testPyMethodCall1_64bit]

from typing import Any

def f(x: Any) -> int:

y: int = x.pop()

return x.pop()

[out]

def f(x):

x :: object

r0 :: str

r1 :: object[1]

r2 :: object_ptr

r3 :: object

r4, y :: int

r5 :: str

r6 :: object[1]

r7 :: object_ptr

r8 :: object

r9 :: int

L0:

r0 = 'pop'

r1 = [x]

r2 = load_address r1

r3 = PyObject_VectorcallMethod(r0, r2, 9223372036854775809, 0)

keep_alive x

r4 = unbox(int, r3)

y = r4

r5 = 'pop'

r6 = [x]

r7 = load_address r6

r8 = PyObject_VectorcallMethod(r5, r7, 9223372036854775809, 0)

keep_alive x

r9 = unbox(int, r8)

return r9

[case testObjectType]

def g(y: object) -> None:

g(y)

g([1])

g(None)

[out]

def g(y):

y :: object

r0 :: None

r1 :: list

r2 :: object

r3 :: ptr

r4 :: None

r5 :: object

r6 :: None

L0:

r0 = g(y)

r1 = PyList_New(1)

r2 = object 1

r3 = list_items r1

buf_init_item r3, 0, r2

keep_alive r1

r4 = g(r1)

r5 = box(None, 1)

r6 = g(r5)

return 1

[case testCoerceToObject1]

def g(y: object) -> object:

g(1)

a = [y]

a[0] = (1, 2)

y = True

return 3

[out]

def g(y):

y, r0, r1 :: object

r2 :: list

r3 :: ptr

a :: list

r4 :: tuple[int, int]

r5 :: object

r6 :: bit

r7, r8 :: object

L0:

r0 = object 1

r1 = g(r0)

r2 = PyList_New(1)

r3 = list_items r2

buf_init_item r3, 0, y

keep_alive r2

a = r2

r4 = (2, 4)

r5 = box(tuple[int, int], r4)

r6 = CPyList_SetItem(a, 0, r5)

r7 = box(bool, 1)

y = r7

r8 = object 3

return r8

[case testCoerceToObject2]

class A:

x: object

n: int

def f(a: A, o: object) -> None:

a.x = 1

o = a.n

[out]

def f(a, o):

a :: __main__.A

o, r0 :: object

r1 :: bool

r2 :: int

r3 :: object

L0:

r0 = object 1

a.x = r0; r1 = is_error

r2 = a.n

r3 = box(int, r2)

o = r3

return 1

[case testAssertType]

from typing import assert_type

def f(x: int) -> None:

y = assert_type(x, int)

[out]

def f(x):

x, y :: int

L0:

y = x

return 1

[case testDownCast]

from typing import cast, List, Tuple

class A: pass

def f(x: object) -> None:

n = cast(int, x)

b = cast(bool, x)

a = cast(A, x)

l = cast(List[int], x)

t = cast(Tuple[int, A], x)

[out]

def f(x):

x :: object

r0, n :: int

r1, b :: bool

r2, a :: __main__.A

r3, l :: list

r4, t :: tuple[int, __main__.A]

L0:

r0 = unbox(int, x)

n = r0

r1 = unbox(bool, x)

b = r1

r2 = cast(__main__.A, x)

a = r2

r3 = cast(list, x)

l = r3

r4 = unbox(tuple[int, __main__.A], x)

t = r4

return 1

[case testDownCastSpecialCases]

from typing import cast, Optional, Tuple

class A: pass

def f(o: Optional[A], n: int, t: Tuple[int, ...], tt: Tuple[int, int]) -> None:

a = cast(A, o)

m = cast(bool, n)

t = tt

[out]

def f(o, n, t, tt):

o :: union[__main__.A, None]

n :: int

t :: tuple

tt :: tuple[int, int]

r0, a :: __main__.A

r1 :: object

r2, m :: bool

r3 :: object

L0:

r0 = cast(__main__.A, o)

a = r0

r1 = box(int, n)

r2 = unbox(bool, r1)

m = r2

r3 = box(tuple[int, int], tt)

t = r3

return 1

[case testSuccessfulCast]

from typing import cast, Optional, Tuple, List, Dict

class A: pass

def f(o: object,

p: Optional[A],

n: int,

b: bool,

t: Tuple[int, ...],

s: Tuple[int, int],

a: A,

l: List[A],

d: Dict[int, str]) -> None:

o = cast(object, o)

p = cast(Optional[A], p)

n = cast(int, n)

b = cast(bool, b)

t = cast(Tuple[int, ...], t)

s = cast(Tuple[int, int], s)

o = cast(object, n)

a = cast(A, a)

l2 = cast(List[object], l)

d2 = cast(Dict[object, str], d)

[out]

def f(o, p, n, b, t, s, a, l, d):

o :: object

p :: union[__main__.A, None]

n :: int

b :: bool

t :: tuple

s :: tuple[int, int]

a :: __main__.A

l :: list

d :: dict

r0 :: object

l2 :: list

d2 :: dict

L0:

o = o

p = p

n = n

b = b

t = t

s = s

r0 = box(int, n)

o = r0

a = a

l2 = l

d2 = d

return 1

[case testGenericSetItem]

from typing import Any

def f(x: Any, y: Any, z: Any) -> None:

x[y] = z

[out]

def f(x, y, z):

x, y, z :: object

r0 :: i32

r1 :: bit

L0:

r0 = PyObject_SetItem(x, y, z)

r1 = r0 >= 0 :: signed

return 1