-- 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 = x == a :: int
    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 = x == r1 :: int
    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 = a == r0 :: int
    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 = n < r0 :: int
    if r1 goto L2 else goto L3 :: bool
L2:
    r2 = 1
    r3 = n + r2 :: int
    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 = n < r2 :: int
    if r3 goto L2 else goto L6 :: bool
L2:
    n = y
L3:
    r4 = 2
    r5 = n < r4 :: int
    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 = r2 + a :: int
    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 = a < a :: int
    if r0 goto L2 else goto L6 :: bool
L2:
L3:
    r1 = a < a :: int
    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 = a == a :: int
    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 = i <= a :: int
    if r2 goto L2 else goto L3 :: bool
L2:
    r3 = sum + i :: int
    sum = r3
    r4 = 1
    r5 = i + r4 :: int
    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 = id x :: object
    st = r0
    goto L10
L2:
    r1 = error_catch
    r2 = builtins.module :: static
    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 = -r6 :: int
    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 = st + r10 :: int
    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}                   {}