-- Test cases for copy propagation optimization.  This also tests IR transforms in general,
-- as copy propagation was the first IR transform that was implemented.

[case testCopyPropagationSimple]
def g() -> int:
    return 1

def f() -> int:
    y = g()
    return y
[out]
def g():
L0:
    return 2
def f():
    r0 :: int
L0:
    r0 = g()
    return r0

[case testCopyPropagationChain]
def f(x: int) -> int:
    y = x
    z = y
    return z
[out]
def f(x):
    x :: int
L0:
    return x

[case testCopyPropagationChainPartial]
def f(x: int) -> int:
    y = x
    z = y
    x = 2
    return z
[out]
def f(x):
    x, y :: int
L0:
    y = x
    x = 4
    return y

[case testCopyPropagationChainBad]
def f(x: int) -> int:
    y = x
    z = y
    y = 2
    return z
[out]
def f(x):
    x, y, z :: int
L0:
    y = x
    z = y
    y = 4
    return z

[case testCopyPropagationMutatedSource1]
def f(x: int) -> int:
    y = x
    x = 1
    return y
[out]
def f(x):
    x, y :: int
L0:
    y = x
    x = 2
    return y

[case testCopyPropagationMutatedSource2]
def f() -> int:
    z = 1
    y = z
    z = 2
    return y
[out]
def f():
    z, y :: int
L0:
    z = 2
    y = z
    z = 4
    return y

[case testCopyPropagationTooComplex]
def f(b: bool, x: int) -> int:
    if b:
        y = x
        return y
    else:
        y = 1
        return y
[out]
def f(b, x):
    b :: bool
    x, y :: int
L0:
    if b goto L1 else goto L2 :: bool
L1:
    y = x
    return y
L2:
    y = 2
    return y

[case testCopyPropagationArg]
def f(x: int) -> int:
    x = 2
    return x
[out]
def f(x):
    x :: int
L0:
    x = 4
    return x

[case testCopyPropagationPartiallyDefined1]
def f(b: bool) -> int:
    if b:
        x = 1
    y = x
    return y
[out]
def f(b):
    b :: bool
    r0, x :: int
    r1 :: bool
    y :: int
L0:
    r0 = <error> :: int
    x = r0
    if b goto L1 else goto L2 :: bool
L1:
    x = 2
L2:
    if is_error(x) goto L3 else goto L4
L3:
    r1 = raise UnboundLocalError('local variable "x" referenced before assignment')
    unreachable
L4:
    y = x
    return y

-- The remaining test cases test basic IRTransform functionality and are not
-- all needed for testing copy propagation as such.

[case testIRTransformBranch]
from mypy_extensions import i64

def f(x: bool) -> int:
    y = x
    if y:
        return 1
    else:
        return 2
[out]
def f(x):
    x :: bool
L0:
    if x goto L1 else goto L2 :: bool
L1:
    return 2
L2:
    return 4

[case testIRTransformAssignment]
def f(b: bool, x: int) -> int:
    y = x
    if b:
        return y
    else:
        return 1
[out]
def f(b, x):
    b :: bool
    x :: int
L0:
    if b goto L1 else goto L2 :: bool
L1:
    return x
L2:
    return 2

[case testIRTransformRegisterOps1]
from __future__ import annotations
from typing import cast

class C:
    a: int

    def m(self, x: int) -> None: pass

def get_attr(x: C) -> int:
    y = x
    return y.a

def set_attr(x: C) -> None:
    y = x
    y.a = 1

def tuple_get(x: tuple[int, int]) -> int:
    y = x
    return y[0]

def tuple_set(x: int, xx: int) -> tuple[int, int]:
    y = x
    z = xx
    return y, z

def call(x: int) -> int:
    y = x
    return call(y)

def method_call(c: C, x: int) -> None:
    y = x
    c.m(y)

def cast_op(x: object) -> str:
    y = x
    return cast(str, y)

def box(x: int) -> object:
    y = x
    return y

def unbox(x: object) -> int:
    y = x
    return cast(int, y)

def call_c(x: list[str]) -> None:
    y = x
    y.append("x")

def keep_alive(x: C) -> int:
    y = x
    return y.a + 1
[out]
def C.m(self, x):
    self :: __main__.C
    x :: int
L0:
    return 1
def get_attr(x):
    x :: __main__.C
    r0 :: int
L0:
    r0 = x.a
    return r0
def set_attr(x):
    x :: __main__.C
    r0 :: bool
L0:
    x.a = 2; r0 = is_error
    return 1
def tuple_get(x):
    x :: tuple[int, int]
    r0 :: int
L0:
    r0 = x[0]
    return r0
def tuple_set(x, xx):
    x, xx :: int
    r0 :: tuple[int, int]
L0:
    r0 = (x, xx)
    return r0
def call(x):
    x, r0 :: int
L0:
    r0 = call(x)
    return r0
def method_call(c, x):
    c :: __main__.C
    x :: int
    r0 :: None
L0:
    r0 = c.m(x)
    return 1
def cast_op(x):
    x :: object
    r0 :: str
L0:
    r0 = cast(str, x)
    return r0
def box(x):
    x :: int
    r0 :: object
L0:
    r0 = box(int, x)
    return r0
def unbox(x):
    x :: object
    r0 :: int
L0:
    r0 = unbox(int, x)
    return r0
def call_c(x):
    x :: list
    r0 :: str
    r1 :: i32
    r2 :: bit
L0:
    r0 = 'x'
    r1 = PyList_Append(x, r0)
    r2 = r1 >= 0 :: signed
    return 1
def keep_alive(x):
    x :: __main__.C
    r0, r1 :: int
L0:
    r0 = borrow x.a
    r1 = CPyTagged_Add(r0, 2)
    keep_alive x
    return r1

[case testIRTransformRegisterOps2]
from mypy_extensions import i32, i64

def truncate(x: i64) -> i32:
    y = x
    return i32(y)

def extend(x: i32) -> i64:
    y = x
    return i64(y)

def int_op(x: i64, xx: i64) -> i64:
    y = x
    z = xx
    return y + z

def comparison_op(x: i64, xx: i64) -> bool:
    y = x
    z = xx
    return y == z

def float_op(x: float, xx: float) -> float:
    y = x
    z = xx
    return y + z

def float_neg(x: float) -> float:
    y = x
    return -y

def float_comparison_op(x: float, xx: float) -> bool:
    y = x
    z = xx
    return y == z
[out]
def truncate(x):
    x :: i64
    r0 :: i32
L0:
    r0 = truncate x: i64 to i32
    return r0
def extend(x):
    x :: i32
    r0 :: i64
L0:
    r0 = extend signed x: i32 to i64
    return r0
def int_op(x, xx):
    x, xx, r0 :: i64
L0:
    r0 = x + xx
    return r0
def comparison_op(x, xx):
    x, xx :: i64
    r0 :: bit
L0:
    r0 = x == xx
    return r0
def float_op(x, xx):
    x, xx, r0 :: float
L0:
    r0 = x + xx
    return r0
def float_neg(x):
    x, r0 :: float
L0:
    r0 = -x
    return r0
def float_comparison_op(x, xx):
    x, xx :: float
    r0 :: bit
L0:
    r0 = x == xx
    return r0

-- Note that transforms of these ops aren't tested here:
-- * LoadMem
-- * SetMem
-- * GetElementPtr
-- * LoadAddress
-- * Unborrow