== TestFunctionLiteral ==
class TestFunctionLiteral {
    val sum: (Int)->Int = { x: Int ->
        sum(x - 1) + x
    }
}
---------------------
L0:
  1 <START>                                                  INIT: in: {} out: {}
    v(val sum: (Int)->Int = { x: Int -> sum(x - 1) + x })    INIT: in: {} out: {}
    mark({ x: Int -> sum(x - 1) + x })                       INIT: in: {} out: {}
    jmp?(L2)
    d({ x: Int -> sum(x - 1) + x })                          INIT: in: {} out: {}
L2 [after local declaration]:
    r({ x: Int -> sum(x - 1) + x }) -> <v0>
    w(sum|<v0>)                                              INIT: in: {} out: {}
L1:
    <END>                                                    INIT: in: {} out: {}
error:
    <ERROR>
sink:
    <SINK>                                                                           USE: in: {} out: {}
=====================
== anonymous_0 ==
{ x: Int ->
        sum(x - 1) + x
    }
---------------------
L3:
  2 <START>                                          INIT: in: {} out: {}
    v(x: Int)                                        INIT: in: {} out: {}
    magic[FAKE_INITIALIZER](x: Int) -> <v0>          INIT: in: {} out: {}
    w(x|<v0>)                                        INIT: in: {} out: {}
  3 mark(sum(x - 1) + x)                             INIT: in: {} out: {}
    magic[IMPLICIT_RECEIVER](sum) -> <v1>
    r(sum|<v1>) -> <v2>
    r(x) -> <v3>
    r(1) -> <v4>
    mark(x - 1)
    call(x - 1, minus|<v3>, <v4>) -> <v5>
    mark(sum(x - 1))
    call(sum(x - 1), invoke|<v2>, <v5>) -> <v6>
    r(x) -> <v7>
    mark(sum(x - 1) + x)
    call(sum(x - 1) + x, plus|<v6>, <v7>) -> <v8>
  2 ret(*|<v8>) L4
L4:
    <END>
error:
    <ERROR>
sink:
    <SINK>                                                                   USE: in: {} out: {}
=====================
== A ==
open class A(val a: A)
---------------------
L0:
  1 <START>                                      INIT: in: {} out: {}
    v(val a: A)                                  INIT: in: {} out: {}
    magic[FAKE_INITIALIZER](val a: A) -> <v0>    INIT: in: {} out: {}
    w(a|<v0>)                                    INIT: in: {} out: {}
L1:
    <END>                                        INIT: in: {} out: {}
error:
    <ERROR>
sink:
    <SINK>                                                               USE: in: {} out: {}
=====================
== TestObjectLiteral ==
class TestObjectLiteral {
    val obj: A = object: A(obj) {
        init {
            val x = obj
        }
        fun foo() {
            val y = obj
        }
    }
}
---------------------
L0:
  1 <START>                                                                              INIT: in: {} out: {}
    v(val obj: A = object: A(obj) { init { val x = obj } fun foo() { val y = obj } })    INIT: in: {} out: {}
    mark(object: A(obj) { init { val x = obj } fun foo() { val y = obj } })              INIT: in: {} out: {}
    magic[IMPLICIT_RECEIVER](obj) -> <v0>
    r(obj|<v0>) -> <v1>
    mark(A(obj))
    call(A(obj), <init>|<v1>) -> <v2>
  2 mark({ val x = obj })
    v(val x = obj)                                                                       INIT: in: {} out: {}
    magic[IMPLICIT_RECEIVER](obj) -> <v3>                                                INIT: in: {} out: {}
    r(obj|<v3>) -> <v4>
    w(x|<v4>)                                                                            INIT: in: {} out: {}
  1 jmp?(L2)                                                                             INIT: in: {} out: {}
    d(fun foo() { val y = obj })                                                         INIT: in: {} out: {}
L2 [after local declaration]:
    r(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) -> <v5>
    w(obj|<v5>)                                                                          INIT: in: {} out: {}
L1:
    <END>                                                                                INIT: in: {} out: {}
error:
    <ERROR>
sink:
    <SINK>                                                                                                       USE: in: {} out: {}
=====================
== foo ==
fun foo() {
            val y = obj
        }
---------------------
L3:
  2 <START>                                  INIT: in: {} out: {}
  3 mark({ val y = obj })
    v(val y = obj)                           INIT: in: {} out: {}
    magic[IMPLICIT_RECEIVER](obj) -> <v0>    INIT: in: {} out: {}
    r(obj|<v0>) -> <v1>
    w(y|<v1>)                                INIT: in: {} out: {}
L4:
  2 <END>                                    INIT: in: {} out: {}
error:
    <ERROR>
sink:
    <SINK>                                                           USE: in: {} out: {}
=====================
== TestOther ==
class TestOther {
    val x: Int = x + 1
}
---------------------
L0:
  1 <START>                                 INIT: in: {} out: {}
    v(val x: Int = x + 1)                   INIT: in: {} out: {}
    magic[IMPLICIT_RECEIVER](x) -> <v0>     INIT: in: {} out: {}
    r(x|<v0>) -> <v1>
    r(1) -> <v2>
    mark(x + 1)
    call(x + 1, plus|<v1>, <v2>) -> <v3>
    w(x|<v3>)                               INIT: in: {} out: {}
L1:
    <END>                                   INIT: in: {} out: {}
error:
    <ERROR>
sink:
    <SINK>                                                          USE: in: {} out: {}
=====================