| == 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: {} |
| ===================== |
