863 lines
20 KiB
Plaintext
863 lines
20 KiB
Plaintext
[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
|
|
|