| [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 = load_global CPyStatic_unicode_3 :: static ('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 = load_global CPyStatic_unicode_4 :: static ('!') |
| 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 = load_global CPyStatic_unicode_5 :: static ('?') |
| 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 = load_global CPyStatic_unicode_6 :: static ('one') |
| r5 = r0.inner |
| r6 = PyObject_CallFunctionObjArgs(r5, r4, 0) |
| r7 = cast(str, r6) |
| a = r7 |
| r8 = load_global CPyStatic_unicode_7 :: static ('two') |
| r9 = r0.inner |
| r10 = PyObject_CallFunctionObjArgs(r9, r8, 0) |
| r11 = cast(str, r10) |
| b = r11 |
| return a |
| def inner(): |
| r0 :: str |
| L0: |
| r0 = load_global CPyStatic_unicode_8 :: static ('inner: normal function') |
| return r0 |
| def first(): |
| r0 :: str |
| L0: |
| r0 = load_global CPyStatic_unicode_9 :: static ('first: normal function') |
| return r0 |
| def second(): |
| r0 :: str |
| L0: |
| r0 = load_global CPyStatic_unicode_10 :: static ('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 = load_global CPyStatic_unicode_3 :: static ('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 = load_global CPyStatic_unicode_4 :: static ('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 = load_global CPyStatic_unicode_1 :: static ('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 = load_global CPyStatic_unicode_2 :: static ('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 |
| |
