[case testNestedFunctions]

from typing import Callable

def a() -> Callable[[], object]:

def inner() -> object:

return None

return inner

def b() -> Callable[[], Callable[[], str]]:

def first() -> Callable[[], str]:

def second() -> str:

return 'b.first.second: nested function'

return second

return first

def c(num: float) -> Callable[[str], str]:

def inner(s: str) -> str:

return s + '!'

return inner

def d(num: float) -> str:

def inner(s: str) -> str:

return s + '?'

a = inner('one')

b = inner('two')

return a

def inner() -> str:

return 'inner: normal function'

def first() -> str:

return 'first: normal function'

def second() -> str:

return 'second: normal function'

[out]

def inner_a_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_a_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_a_obj

r0 :: __main__.a_env

r1, inner, r2 :: object

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = box(None, 1)

return r2

def a():

r0 :: __main__.a_env

r1 :: __main__.inner_a_obj

r2, r3 :: bool

r4 :: object

L0:

r0 = a_env()

r1 = inner_a_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.inner = r1; r3 = is_error

r4 = r0.inner

return r4

def second_b_first_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def second_b_first_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.second_b_first_obj

r0 :: __main__.first_b_env

r1 :: __main__.b_env

r2, second :: object

r3 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.__mypyc_env__

r2 = r0.second

second = r2

r3 = 'b.first.second: nested function'

return r3

def first_b_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def first_b_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.first_b_obj

r0 :: __main__.b_env

r1, first :: object

r2 :: __main__.first_b_env

r3 :: bool

r4 :: __main__.second_b_first_obj

r5, r6 :: bool

r7 :: object

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.first

first = r1

r2 = first_b_env()

r2.__mypyc_env__ = r0; r3 = is_error

r4 = second_b_first_obj()

r4.__mypyc_env__ = r2; r5 = is_error

r2.second = r4; r6 = is_error

r7 = r2.second

return r7

def b():

r0 :: __main__.b_env

r1 :: __main__.first_b_obj

r2, r3 :: bool

r4 :: object

L0:

r0 = b_env()

r1 = first_b_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.first = r1; r3 = is_error

r4 = r0.first

return r4

def inner_c_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_c_obj.__call__(__mypyc_self__, s):

__mypyc_self__ :: __main__.inner_c_obj

s :: str

r0 :: __main__.c_env

r1, inner :: object

r2, r3 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = '!'

r3 = PyUnicode_Concat(s, r2)

return r3

def c(num):

num :: float

r0 :: __main__.c_env

r1 :: __main__.inner_c_obj

r2, r3 :: bool

r4 :: object

L0:

r0 = c_env()

r1 = inner_c_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.inner = r1; r3 = is_error

r4 = r0.inner

return r4

def inner_d_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_d_obj.__call__(__mypyc_self__, s):

__mypyc_self__ :: __main__.inner_d_obj

s :: str

r0 :: __main__.d_env

r1, inner :: object

r2, r3 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = '?'

r3 = PyUnicode_Concat(s, r2)

return r3

def d(num):

num :: float

r0 :: __main__.d_env

r1 :: __main__.inner_d_obj

r2, r3 :: bool

r4 :: str

r5, r6 :: object

r7, a, r8 :: str

r9, r10 :: object

r11, b :: str

L0:

r0 = d_env()

r1 = inner_d_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.inner = r1; r3 = is_error

r4 = 'one'

r5 = r0.inner

r6 = PyObject_CallFunctionObjArgs(r5, r4, 0)

r7 = cast(str, r6)

a = r7

r8 = 'two'

r9 = r0.inner

r10 = PyObject_CallFunctionObjArgs(r9, r8, 0)

r11 = cast(str, r10)

b = r11

return a

def inner():

r0 :: str

L0:

r0 = 'inner: normal function'

return r0

def first():

r0 :: str

L0:

r0 = 'first: normal function'

return r0

def second():

r0 :: str

L0:

r0 = 'second: normal function'

return r0

[case testFreeVars]

from typing import Callable

def a(num: int) -> int:

def inner() -> int:

return num

return inner()

def b() -> int:

num = 3

def inner() -> int:

nonlocal num

num = 4

foo = 6

return num

return inner() + num

def c(flag: bool) -> str:

if flag:

def inner() -> str:

return 'f.inner: first definition'

else:

def inner() -> str:

return 'f.inner: second definition'

return inner()

[out]

def inner_a_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_a_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_a_obj

r0 :: __main__.a_env

r1, inner :: object

r2 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = r0.num

return r2

def a(num):

num :: int

r0 :: __main__.a_env

r1 :: bool

r2 :: __main__.inner_a_obj

r3, r4 :: bool

r5, r6 :: object

r7 :: int

L0:

r0 = a_env()

r0.num = num; r1 = is_error

r2 = inner_a_obj()

r2.__mypyc_env__ = r0; r3 = is_error

r0.inner = r2; r4 = is_error

r5 = r0.inner

r6 = PyObject_CallFunctionObjArgs(r5, 0)

r7 = unbox(int, r6)

return r7

def inner_b_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_b_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_b_obj

r0 :: __main__.b_env

r1, inner :: object

r2 :: bool

foo, r3 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r0.num = 8; r2 = is_error

foo = 12

r3 = r0.num

return r3

def b():

r0 :: __main__.b_env

r1 :: bool

r2 :: __main__.inner_b_obj

r3, r4 :: bool

r5, r6 :: object

r7, r8, r9 :: int

L0:

r0 = b_env()

r0.num = 6; r1 = is_error

r2 = inner_b_obj()

r2.__mypyc_env__ = r0; r3 = is_error

r0.inner = r2; r4 = is_error

r5 = r0.inner

r6 = PyObject_CallFunctionObjArgs(r5, 0)

r7 = unbox(int, r6)

r8 = r0.num

r9 = CPyTagged_Add(r7, r8)

return r9

def inner_c_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_c_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_c_obj

r0 :: __main__.c_env

r1, inner :: object

r2 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = 'f.inner: first definition'

return r2

def inner_c_obj_0.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_c_obj_0.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_c_obj_0

r0 :: __main__.c_env

r1, inner :: object

r2 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = 'f.inner: second definition'

return r2

def c(flag):

flag :: bool

r0 :: __main__.c_env

r1 :: __main__.inner_c_obj

r2, r3 :: bool

r4 :: __main__.inner_c_obj_0

r5, r6 :: bool

r7, r8 :: object

r9 :: str

L0:

r0 = c_env()

if flag goto L1 else goto L2 :: bool

L1:

r1 = inner_c_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.inner = r1; r3 = is_error

goto L3

L2:

r4 = inner_c_obj_0()

r4.__mypyc_env__ = r0; r5 = is_error

r0.inner = r4; r6 = is_error

L3:

r7 = r0.inner

r8 = PyObject_CallFunctionObjArgs(r7, 0)

r9 = cast(str, r8)

return r9

[case testSpecialNested]

def a() -> int:

x = 1

def b() -> int:

x += 1

def c() -> int:

return x

return c()

return b()

[out]

def c_a_b_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def c_a_b_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.c_a_b_obj

r0 :: __main__.b_a_env

r1 :: __main__.a_env

r2, c :: object

r3 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.__mypyc_env__

r2 = r0.c

c = r2

r3 = r1.x

return r3

def b_a_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def b_a_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.b_a_obj

r0 :: __main__.a_env

r1, b :: object

r2 :: __main__.b_a_env

r3 :: bool

r4, r5 :: int

r6 :: bool

r7 :: __main__.c_a_b_obj

r8, r9 :: bool

r10, r11 :: object

r12 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.b

b = r1

r2 = b_a_env()

r2.__mypyc_env__ = r0; r3 = is_error

r4 = r0.x

r5 = CPyTagged_Add(r4, 2)

r0.x = r5; r6 = is_error

r7 = c_a_b_obj()

r7.__mypyc_env__ = r2; r8 = is_error

r2.c = r7; r9 = is_error

r10 = r2.c

r11 = PyObject_CallFunctionObjArgs(r10, 0)

r12 = unbox(int, r11)

return r12

def a():

r0 :: __main__.a_env

r1 :: bool

r2 :: __main__.b_a_obj

r3, r4 :: bool

r5, r6 :: object

r7 :: int

L0:

r0 = a_env()

r0.x = 2; r1 = is_error

r2 = b_a_obj()

r2.__mypyc_env__ = r0; r3 = is_error

r0.b = r2; r4 = is_error

r5 = r0.b

r6 = PyObject_CallFunctionObjArgs(r5, 0)

r7 = unbox(int, r6)

return r7

[case testNestedFunctionInsideStatements]

def f(flag: bool) -> str:

if flag:

def inner() -> str:

return 'f.inner: first definition'

else:

def inner() -> str:

return 'f.inner: second definition'

return inner()

[out]

def inner_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_f_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_f_obj

r0 :: __main__.f_env

r1, inner :: object

r2 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = 'f.inner: first definition'

return r2

def inner_f_obj_0.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def inner_f_obj_0.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.inner_f_obj_0

r0 :: __main__.f_env

r1, inner :: object

r2 :: str

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.inner

inner = r1

r2 = 'f.inner: second definition'

return r2

def f(flag):

flag :: bool

r0 :: __main__.f_env

r1 :: __main__.inner_f_obj

r2, r3 :: bool

r4 :: __main__.inner_f_obj_0

r5, r6 :: bool

r7, r8 :: object

r9 :: str

L0:

r0 = f_env()

if flag goto L1 else goto L2 :: bool

L1:

r1 = inner_f_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.inner = r1; r3 = is_error

goto L3

L2:

r4 = inner_f_obj_0()

r4.__mypyc_env__ = r0; r5 = is_error

r0.inner = r4; r6 = is_error

L3:

r7 = r0.inner

r8 = PyObject_CallFunctionObjArgs(r7, 0)

r9 = cast(str, r8)

return r9

[case testNestedFunctionsCallEachOther]

from typing import Callable, List

def f(a: int) -> int:

def foo() -> int:

return a + 1

def bar() -> int:

return foo()

def baz(n: int) -> int:

if n == 0:

return 0

return n + baz(n - 1)

return bar() + baz(a)

[out]

def foo_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def foo_f_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.foo_f_obj

r0 :: __main__.f_env

r1, foo :: object

r2, r3 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.foo

foo = r1

r2 = r0.a

r3 = CPyTagged_Add(r2, 2)

return r3

def bar_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def bar_f_obj.__call__(__mypyc_self__):

__mypyc_self__ :: __main__.bar_f_obj

r0 :: __main__.f_env

r1, bar, r2, r3 :: object

r4 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.bar

bar = r1

r2 = r0.foo

r3 = PyObject_CallFunctionObjArgs(r2, 0)

r4 = unbox(int, r3)

return r4

def baz_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def baz_f_obj.__call__(__mypyc_self__, n):

__mypyc_self__ :: __main__.baz_f_obj

n :: int

r0 :: __main__.f_env

r1, baz :: object

r2 :: bit

r3 :: int

r4, r5 :: object

r6, r7 :: int

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.baz

baz = r1

r2 = n == 0

if r2 goto L1 else goto L2 :: bool

L1:

return 0

L2:

r3 = CPyTagged_Subtract(n, 2)

r4 = box(int, r3)

r5 = PyObject_CallFunctionObjArgs(baz, r4, 0)

r6 = unbox(int, r5)

r7 = CPyTagged_Add(n, r6)

return r7

def f(a):

a :: int

r0 :: __main__.f_env

r1 :: bool

r2 :: __main__.foo_f_obj

r3, r4 :: bool

r5 :: __main__.bar_f_obj

r6, r7 :: bool

r8 :: __main__.baz_f_obj

r9, r10 :: bool

r11, r12 :: object

r13, r14 :: int

r15, r16, r17 :: object

r18, r19 :: int

L0:

r0 = f_env()

r0.a = a; r1 = is_error

r2 = foo_f_obj()

r2.__mypyc_env__ = r0; r3 = is_error

r0.foo = r2; r4 = is_error

r5 = bar_f_obj()

r5.__mypyc_env__ = r0; r6 = is_error

r0.bar = r5; r7 = is_error

r8 = baz_f_obj()

r8.__mypyc_env__ = r0; r9 = is_error

r0.baz = r8; r10 = is_error

r11 = r0.bar

r12 = PyObject_CallFunctionObjArgs(r11, 0)

r13 = unbox(int, r12)

r14 = r0.a

r15 = r0.baz

r16 = box(int, r14)

r17 = PyObject_CallFunctionObjArgs(r15, r16, 0)

r18 = unbox(int, r17)

r19 = CPyTagged_Add(r13, r18)

return r19

[case testLambdas]

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

s = lambda a, b: a + b

t = lambda a, b: s(a, b)

return t(x, y)

[out]

def __mypyc_lambda__0_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def __mypyc_lambda__0_f_obj.__call__(__mypyc_self__, a, b):

__mypyc_self__ :: __main__.__mypyc_lambda__0_f_obj

a, b :: object

r0 :: __main__.f_env

r1 :: object

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = PyNumber_Add(a, b)

return r1

def __mypyc_lambda__1_f_obj.__get__(__mypyc_self__, instance, owner):

__mypyc_self__, instance, owner, r0 :: object

r1 :: bit

r2 :: object

L0:

r0 = load_address _Py_NoneStruct

r1 = instance == r0

if r1 goto L1 else goto L2 :: bool

L1:

return __mypyc_self__

L2:

r2 = PyMethod_New(__mypyc_self__, instance)

return r2

def __mypyc_lambda__1_f_obj.__call__(__mypyc_self__, a, b):

__mypyc_self__ :: __main__.__mypyc_lambda__1_f_obj

a, b :: object

r0 :: __main__.f_env

r1, r2 :: object

L0:

r0 = __mypyc_self__.__mypyc_env__

r1 = r0.s

r2 = PyObject_CallFunctionObjArgs(r1, a, b, 0)

return r2

def f(x, y):

x, y :: int

r0 :: __main__.f_env

r1 :: __main__.__mypyc_lambda__0_f_obj

r2, r3 :: bool

r4 :: __main__.__mypyc_lambda__1_f_obj

r5 :: bool

t, r6, r7, r8 :: object

r9 :: None

L0:

r0 = f_env()

r1 = __mypyc_lambda__0_f_obj()

r1.__mypyc_env__ = r0; r2 = is_error

r0.s = r1; r3 = is_error

r4 = __mypyc_lambda__1_f_obj()

r4.__mypyc_env__ = r0; r5 = is_error

t = r4

r6 = box(int, x)

r7 = box(int, y)

r8 = PyObject_CallFunctionObjArgs(t, r6, r7, 0)

r9 = unbox(None, r8)

return r9

[case testRecursiveFunction]

from typing import Callable

def baz(n: int) -> int:

if n == 0:

return 0

return n + baz(n - 1)

[out]

def baz(n):

n :: int

r0 :: bit

r1, r2, r3 :: int

L0:

r0 = n == 0

if r0 goto L1 else goto L2 :: bool

L1:

return 0

L2:

r1 = CPyTagged_Subtract(n, 2)

r2 = baz(r1)

r3 = CPyTagged_Add(n, r2)

return r3