| -- Test cases for data flow analysis. | |
| [case testSimple_MaybeDefined] | |
| def f(a: int) -> None: | |
| x = 1 | |
| if x == a: | |
| y = 1 | |
| else: | |
| z = 1 | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0 :: short_int | |
| x :: int | |
| r1 :: bool | |
| r2 :: short_int | |
| y :: int | |
| r3 :: short_int | |
| z :: int | |
| r4 :: None | |
| L0: | |
| r0 = 1 | |
| x = r0 | |
| r1 = CPyTagged_IsEq(x, a) | |
| if r1 goto L1 else goto L2 :: bool | |
| L1: | |
| r2 = 1 | |
| y = r2 | |
| goto L3 | |
| L2: | |
| r3 = 1 | |
| z = r3 | |
| L3: | |
| r4 = None | |
| return r4 | |
| (0, 0) {a} {a} | |
| (0, 1) {a} {a, x} | |
| (0, 2) {a, x} {a, x} | |
| (0, 3) {a, x} {a, x} | |
| (1, 0) {a, x} {a, x} | |
| (1, 1) {a, x} {a, x, y} | |
| (1, 2) {a, x, y} {a, x, y} | |
| (2, 0) {a, x} {a, x} | |
| (2, 1) {a, x} {a, x, z} | |
| (2, 2) {a, x, z} {a, x, z} | |
| (3, 0) {a, x, y, z} {a, x, y, z} | |
| (3, 1) {a, x, y, z} {a, x, y, z} | |
| [case testSimple_Liveness] | |
| def f(a: int) -> int: | |
| x = 1 | |
| if x == 1: | |
| return a | |
| else: | |
| return x | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0 :: short_int | |
| x :: int | |
| r1 :: short_int | |
| r2 :: bool | |
| L0: | |
| r0 = 1 | |
| x = r0 | |
| r1 = 1 | |
| r2 = CPyTagged_IsEq(x, r1) | |
| if r2 goto L1 else goto L2 :: bool | |
| L1: | |
| return a | |
| L2: | |
| return x | |
| L3: | |
| unreachable | |
| (0, 0) {a} {a, r0} | |
| (0, 1) {a, r0} {a, x} | |
| (0, 2) {a, x} {a, r1, x} | |
| (0, 3) {a, r1, x} {a, r2, x} | |
| (0, 4) {a, r2, x} {a, x} | |
| (1, 0) {a} {} | |
| (2, 0) {x} {} | |
| (3, 0) {} {} | |
| [case testSpecial_Liveness] | |
| def f() -> int: | |
| x = 1 | |
| y = 1 | |
| x = 2 | |
| return x | |
| [out] | |
| def f(): | |
| r0 :: short_int | |
| x :: int | |
| r1 :: short_int | |
| y :: int | |
| r2 :: short_int | |
| L0: | |
| r0 = 1 | |
| x = r0 | |
| r1 = 1 | |
| y = r1 | |
| r2 = 2 | |
| x = r2 | |
| return x | |
| (0, 0) {} {r0} | |
| (0, 1) {r0} {} | |
| (0, 2) {} {r1} | |
| (0, 3) {r1} {} | |
| (0, 4) {} {r2} | |
| (0, 5) {r2} {x} | |
| (0, 6) {x} {} | |
| [case testSpecial2_Liveness] | |
| def f(a: int) -> int: | |
| a = 1 | |
| a = 2 | |
| a = 3 | |
| return a | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0, r1, r2 :: short_int | |
| L0: | |
| r0 = 1 | |
| a = r0 | |
| r1 = 2 | |
| a = r1 | |
| r2 = 3 | |
| a = r2 | |
| return a | |
| (0, 0) {} {r0} | |
| (0, 1) {r0} {} | |
| (0, 2) {} {r1} | |
| (0, 3) {r1} {} | |
| (0, 4) {} {r2} | |
| (0, 5) {r2} {a} | |
| (0, 6) {a} {} | |
| [case testSimple_MustDefined] | |
| def f(a: int) -> None: | |
| if a == 1: | |
| y = 1 | |
| x = 2 | |
| else: | |
| x = 2 | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0 :: short_int | |
| r1 :: bool | |
| r2 :: short_int | |
| y :: int | |
| r3 :: short_int | |
| x :: int | |
| r4 :: short_int | |
| r5 :: None | |
| L0: | |
| r0 = 1 | |
| r1 = CPyTagged_IsEq(a, r0) | |
| if r1 goto L1 else goto L2 :: bool | |
| L1: | |
| r2 = 1 | |
| y = r2 | |
| r3 = 2 | |
| x = r3 | |
| goto L3 | |
| L2: | |
| r4 = 2 | |
| x = r4 | |
| L3: | |
| r5 = None | |
| return r5 | |
| (0, 0) {a} {a} | |
| (0, 1) {a} {a} | |
| (0, 2) {a} {a} | |
| (1, 0) {a} {a} | |
| (1, 1) {a} {a, y} | |
| (1, 2) {a, y} {a, y} | |
| (1, 3) {a, y} {a, x, y} | |
| (1, 4) {a, x, y} {a, x, y} | |
| (2, 0) {a} {a} | |
| (2, 1) {a} {a, x} | |
| (2, 2) {a, x} {a, x} | |
| (3, 0) {a, x} {a, x} | |
| (3, 1) {a, x} {a, x} | |
| [case testTwoArgs_MustDefined] | |
| def f(x: int, y: int) -> int: | |
| return x | |
| [out] | |
| def f(x, y): | |
| x, y :: int | |
| L0: | |
| return x | |
| (0, 0) {x, y} {x, y} | |
| [case testLoop_MustDefined] | |
| def f(n: int) -> None: | |
| while n < 5: | |
| n = n + 1 | |
| m = n | |
| [out] | |
| def f(n): | |
| n :: int | |
| r0 :: short_int | |
| r1 :: bool | |
| r2 :: short_int | |
| r3, m :: int | |
| r4 :: None | |
| L0: | |
| L1: | |
| r0 = 5 | |
| r1 = CPyTagged_IsLt(n, r0) | |
| if r1 goto L2 else goto L3 :: bool | |
| L2: | |
| r2 = 1 | |
| r3 = CPyTagged_Add(n, r2) | |
| n = r3 | |
| m = n | |
| goto L1 | |
| L3: | |
| r4 = None | |
| return r4 | |
| (0, 0) {n} {n} | |
| (1, 0) {n} {n} | |
| (1, 1) {n} {n} | |
| (1, 2) {n} {n} | |
| (2, 0) {n} {n} | |
| (2, 1) {n} {n} | |
| (2, 2) {n} {n} | |
| (2, 3) {n} {m, n} | |
| (2, 4) {m, n} {m, n} | |
| (3, 0) {n} {n} | |
| (3, 1) {n} {n} | |
| [case testMultiPass_Liveness] | |
| def f(n: int) -> None: | |
| x = 1 | |
| y = 1 | |
| while n < 1: | |
| n = y | |
| while n < 2: | |
| n = 1 | |
| n = x | |
| [out] | |
| def f(n): | |
| n :: int | |
| r0 :: short_int | |
| x :: int | |
| r1 :: short_int | |
| y :: int | |
| r2 :: short_int | |
| r3 :: bool | |
| r4 :: short_int | |
| r5 :: bool | |
| r6 :: short_int | |
| r7 :: None | |
| L0: | |
| r0 = 1 | |
| x = r0 | |
| r1 = 1 | |
| y = r1 | |
| L1: | |
| r2 = 1 | |
| r3 = CPyTagged_IsLt(n, r2) | |
| if r3 goto L2 else goto L6 :: bool | |
| L2: | |
| n = y | |
| L3: | |
| r4 = 2 | |
| r5 = CPyTagged_IsLt(n, r4) | |
| if r5 goto L4 else goto L5 :: bool | |
| L4: | |
| r6 = 1 | |
| n = r6 | |
| n = x | |
| goto L3 | |
| L5: | |
| goto L1 | |
| L6: | |
| r7 = None | |
| return r7 | |
| (0, 0) {n} {n, r0} | |
| (0, 1) {n, r0} {n, x} | |
| (0, 2) {n, x} {n, r1, x} | |
| (0, 3) {n, r1, x} {n, x, y} | |
| (0, 4) {n, x, y} {n, x, y} | |
| (1, 0) {n, x, y} {n, r2, x, y} | |
| (1, 1) {n, r2, x, y} {r3, x, y} | |
| (1, 2) {r3, x, y} {x, y} | |
| (2, 0) {x, y} {n, x, y} | |
| (2, 1) {n, x, y} {n, x, y} | |
| (3, 0) {n, x, y} {n, r4, x, y} | |
| (3, 1) {n, r4, x, y} {n, r5, x, y} | |
| (3, 2) {n, r5, x, y} {n, x, y} | |
| (4, 0) {x, y} {r6, x, y} | |
| (4, 1) {r6, x, y} {x, y} | |
| (4, 2) {x, y} {n, x, y} | |
| (4, 3) {n, x, y} {n, x, y} | |
| (5, 0) {n, x, y} {n, x, y} | |
| (6, 0) {} {r7} | |
| (6, 1) {r7} {} | |
| [case testCall_Liveness] | |
| def f(x: int) -> int: | |
| a = f(1) | |
| return f(a) + a | |
| [out] | |
| def f(x): | |
| x :: int | |
| r0 :: short_int | |
| r1, a, r2, r3, r4 :: int | |
| L0: | |
| r0 = 1 | |
| r1 = f(r0) | |
| if is_error(r1) goto L3 (error at f:2) else goto L1 | |
| L1: | |
| a = r1 | |
| r2 = f(a) | |
| if is_error(r2) goto L3 (error at f:3) else goto L2 | |
| L2: | |
| r3 = CPyTagged_Add(r2, a) | |
| return r3 | |
| L3: | |
| r4 = <error> :: int | |
| return r4 | |
| (0, 0) {} {r0} | |
| (0, 1) {r0} {r1} | |
| (0, 2) {r1} {r1} | |
| (1, 0) {r1} {a} | |
| (1, 1) {a} {a, r2} | |
| (1, 2) {a, r2} {a, r2} | |
| (2, 0) {a, r2} {r3} | |
| (2, 1) {r3} {} | |
| (3, 0) {} {r4} | |
| (3, 1) {r4} {} | |
| [case testLoop_MaybeDefined] | |
| def f(a: int) -> None: | |
| while a < a: | |
| while a < a: | |
| y = a | |
| x = a | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0, r1 :: bool | |
| y, x :: int | |
| r2 :: None | |
| L0: | |
| L1: | |
| r0 = CPyTagged_IsLt(a, a) | |
| if r0 goto L2 else goto L6 :: bool | |
| L2: | |
| L3: | |
| r1 = CPyTagged_IsLt(a, a) | |
| if r1 goto L4 else goto L5 :: bool | |
| L4: | |
| y = a | |
| goto L3 | |
| L5: | |
| x = a | |
| goto L1 | |
| L6: | |
| r2 = None | |
| return r2 | |
| (0, 0) {a} {a} | |
| (1, 0) {a, x, y} {a, x, y} | |
| (1, 1) {a, x, y} {a, x, y} | |
| (2, 0) {a, x, y} {a, x, y} | |
| (3, 0) {a, x, y} {a, x, y} | |
| (3, 1) {a, x, y} {a, x, y} | |
| (4, 0) {a, x, y} {a, x, y} | |
| (4, 1) {a, x, y} {a, x, y} | |
| (5, 0) {a, x, y} {a, x, y} | |
| (5, 1) {a, x, y} {a, x, y} | |
| (6, 0) {a, x, y} {a, x, y} | |
| (6, 1) {a, x, y} {a, x, y} | |
| [case testTrivial_BorrowedArgument] | |
| def f(a: int, b: int) -> int: | |
| return b | |
| [out] | |
| def f(a, b): | |
| a, b :: int | |
| L0: | |
| return b | |
| (0, 0) {a, b} {a, b} | |
| [case testSimple_BorrowedArgument] | |
| def f(a: int) -> int: | |
| b = a | |
| a = 1 | |
| return a | |
| [out] | |
| def f(a): | |
| a, b :: int | |
| r0 :: short_int | |
| L0: | |
| b = a | |
| r0 = 1 | |
| a = r0 | |
| return a | |
| (0, 0) {a} {a} | |
| (0, 1) {a} {a} | |
| (0, 2) {a} {} | |
| (0, 3) {} {} | |
| [case testConditional_BorrowedArgument] | |
| def f(a: int) -> int: | |
| if a == a: | |
| x = 2 | |
| a = 1 | |
| else: | |
| x = 1 | |
| return x | |
| [out] | |
| def f(a): | |
| a :: int | |
| r0 :: bool | |
| r1 :: short_int | |
| x :: int | |
| r2, r3 :: short_int | |
| L0: | |
| r0 = CPyTagged_IsEq(a, a) | |
| if r0 goto L1 else goto L2 :: bool | |
| L1: | |
| r1 = 2 | |
| x = r1 | |
| r2 = 1 | |
| a = r2 | |
| goto L3 | |
| L2: | |
| r3 = 1 | |
| x = r3 | |
| L3: | |
| return x | |
| (0, 0) {a} {a} | |
| (0, 1) {a} {a} | |
| (1, 0) {a} {a} | |
| (1, 1) {a} {a} | |
| (1, 2) {a} {a} | |
| (1, 3) {a} {} | |
| (1, 4) {} {} | |
| (2, 0) {a} {a} | |
| (2, 1) {a} {a} | |
| (2, 2) {a} {a} | |
| (3, 0) {} {} | |
| [case testLoop_BorrowedArgument] | |
| 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 :: int | |
| r0 :: short_int | |
| sum :: int | |
| r1 :: short_int | |
| i :: int | |
| r2 :: bool | |
| r3 :: int | |
| r4 :: short_int | |
| r5 :: int | |
| L0: | |
| r0 = 0 | |
| sum = r0 | |
| r1 = 0 | |
| i = r1 | |
| L1: | |
| r2 = CPyTagged_IsLe(i, a) | |
| if r2 goto L2 else goto L3 :: bool | |
| L2: | |
| r3 = CPyTagged_Add(sum, i) | |
| sum = r3 | |
| r4 = 1 | |
| r5 = CPyTagged_Add(i, r4) | |
| i = r5 | |
| goto L1 | |
| L3: | |
| return sum | |
| (0, 0) {a} {a} | |
| (0, 1) {a} {a} | |
| (0, 2) {a} {a} | |
| (0, 3) {a} {a} | |
| (0, 4) {a} {a} | |
| (1, 0) {a} {a} | |
| (1, 1) {a} {a} | |
| (2, 0) {a} {a} | |
| (2, 1) {a} {a} | |
| (2, 2) {a} {a} | |
| (2, 3) {a} {a} | |
| (2, 4) {a} {a} | |
| (2, 5) {a} {a} | |
| (3, 0) {a} {a} | |
| [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 testExceptUndefined_Liveness] | |
| def lol(x: object) -> int: | |
| try: | |
| st = id(x) | |
| except Exception: | |
| return -1 | |
| return st + 1 | |
| [out] | |
| def lol(x): | |
| x :: object | |
| r0, st :: int | |
| r1 :: tuple[object, object, object] | |
| r2 :: object | |
| r3 :: str | |
| r4 :: object | |
| r5 :: bool | |
| r6 :: short_int | |
| r7 :: int | |
| r8, r9 :: bool | |
| r10 :: short_int | |
| r11, r12 :: int | |
| L0: | |
| L1: | |
| r0 = CPyTagged_Id(x) | |
| st = r0 | |
| goto L10 | |
| L2: | |
| r1 = error_catch | |
| r2 = builtins :: module | |
| r3 = unicode_1 :: static ('Exception') | |
| r4 = getattr r2, r3 | |
| if is_error(r4) goto L8 (error at lol:4) else goto L3 | |
| L3: | |
| r5 = exc_matches r4 | |
| if r5 goto L4 else goto L5 :: bool | |
| L4: | |
| r6 = 1 | |
| r7 = CPyTagged_Negate(r6) | |
| restore_exc_info r1 | |
| return r7 | |
| L5: | |
| reraise_exc; r8 = 0 | |
| if not r8 goto L8 else goto L6 :: bool | |
| L6: | |
| unreachable | |
| L7: | |
| restore_exc_info r1 | |
| goto L10 | |
| L8: | |
| restore_exc_info r1 | |
| r9 = keep_propagating | |
| if not r9 goto L11 else goto L9 :: bool | |
| L9: | |
| unreachable | |
| L10: | |
| r10 = 1 | |
| r11 = CPyTagged_Add(st, r10) | |
| return r11 | |
| L11: | |
| r12 = <error> :: int | |
| return r12 | |
| (0, 0) {x} {x} | |
| (1, 0) {x} {r0} | |
| (1, 1) {r0} {st} | |
| (1, 2) {st} {st} | |
| (2, 0) {} {r1} | |
| (2, 1) {r1} {r1, r2} | |
| (2, 2) {r1, r2} {r1, r2, r3} | |
| (2, 3) {r1, r2, r3} {r1, r4} | |
| (2, 4) {r1, r4} {r1, r4} | |
| (3, 0) {r1, r4} {r1, r5} | |
| (3, 1) {r1, r5} {r1} | |
| (4, 0) {r1} {r1, r6} | |
| (4, 1) {r1, r6} {r1, r7} | |
| (4, 2) {r1, r7} {r7} | |
| (4, 3) {r7} {} | |
| (5, 0) {r1} {r1, r8} | |
| (5, 1) {r1, r8} {r1} | |
| (6, 0) {} {} | |
| (7, 0) {r1, st} {st} | |
| (7, 1) {st} {st} | |
| (8, 0) {r1} {} | |
| (8, 1) {} {r9} | |
| (8, 2) {r9} {} | |
| (9, 0) {} {} | |
| (10, 0) {st} {r10, st} | |
| (10, 1) {r10, st} {r11} | |
| (10, 2) {r11} {} | |
| (11, 0) {} {r12} | |
| (11, 1) {r12} {} | |