| == Direction == |
| enum class Direction { |
| NORTH, SOUTH, WEST, EAST |
| } |
| --------------------- |
| L0: |
| 1 <START> INIT: in: {} out: {} |
| v(NORTH,) INIT: in: {} out: {NORTH=D} |
| magic[FAKE_INITIALIZER](NORTH,) -> <v0> INIT: in: {NORTH=D} out: {NORTH=D} |
| w(NORTH|<v0>) INIT: in: {NORTH=D} out: {NORTH=ID} |
| v(SOUTH,) INIT: in: {NORTH=ID} out: {NORTH=ID, SOUTH=D} |
| magic[FAKE_INITIALIZER](SOUTH,) -> <v1> INIT: in: {NORTH=ID, SOUTH=D} out: {NORTH=ID, SOUTH=D} |
| w(SOUTH|<v1>) INIT: in: {NORTH=ID, SOUTH=D} out: {NORTH=ID, SOUTH=ID} |
| v(WEST,) INIT: in: {NORTH=ID, SOUTH=ID} out: {NORTH=ID, SOUTH=ID, WEST=D} |
| magic[FAKE_INITIALIZER](WEST,) -> <v2> INIT: in: {NORTH=ID, SOUTH=ID, WEST=D} out: {NORTH=ID, SOUTH=ID, WEST=D} |
| w(WEST|<v2>) INIT: in: {NORTH=ID, SOUTH=ID, WEST=D} out: {NORTH=ID, SOUTH=ID, WEST=ID} |
| v(EAST) INIT: in: {NORTH=ID, SOUTH=ID, WEST=ID} out: {EAST=D, NORTH=ID, SOUTH=ID, WEST=ID} |
| magic[FAKE_INITIALIZER](EAST) -> <v3> INIT: in: {EAST=D, NORTH=ID, SOUTH=ID, WEST=ID} out: {EAST=D, NORTH=ID, SOUTH=ID, WEST=ID} |
| w(EAST|<v3>) INIT: in: {EAST=D, NORTH=ID, SOUTH=ID, WEST=ID} out: {EAST=ID, NORTH=ID, SOUTH=ID, WEST=ID} |
| L1: |
| <END> INIT: in: {EAST=ID, NORTH=ID, SOUTH=ID, WEST=ID} out: {EAST=ID, NORTH=ID, SOUTH=ID, WEST=ID} |
| error: |
| <ERROR> INIT: in: {} out: {} |
| sink: |
| <SINK> INIT: in: {EAST=I?, NORTH=I?, SOUTH=I?, WEST=I?} out: {EAST=I?, NORTH=I?, SOUTH=I?, WEST=I?} USE: in: {} out: {} |
| ===================== |
| == foo == |
| fun foo(dir: Direction): Int { |
| val res: Int |
| when (dir) { |
| Direction.NORTH -> res = 1 |
| Direction.SOUTH -> res = 2 |
| Direction.WEST -> res = 3 |
| Direction.EAST -> res = 4 |
| } |
| return res |
| } |
| --------------------- |
| L0: |
| 1 <START> INIT: in: {} out: {} |
| v(dir: Direction) INIT: in: {} out: {} |
| magic[FAKE_INITIALIZER](dir: Direction) -> <v0> INIT: in: {} out: {} |
| w(dir|<v0>) INIT: in: {} out: {} USE: in: {} out: {} |
| 2 mark({ val res: Int when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 } return res }) INIT: in: {} out: {} |
| v(val res: Int) INIT: in: {} out: {res=D} |
| mark(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) INIT: in: {res=D} out: {res=D} |
| r(dir) -> <v1> |
| mark(Direction.NORTH -> res = 1) |
| mark(Direction.NORTH) |
| mark(Direction.NORTH) |
| r(NORTH) -> <v2> |
| magic[EQUALS_IN_WHEN_CONDITION](Direction.NORTH|<v1>, <v2>) -> <v3> |
| jmp?(L4|<v3>) USE: in: {res=READ} out: {res=READ} |
| L3 ['when' entry body]: |
| r(1) -> <v4> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} |
| w(res|<v4>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ} |
| jmp(L2) INIT: in: {res=ID} out: {res=ID} |
| L4 [next 'when' entry]: |
| mark(Direction.SOUTH -> res = 2) INIT: in: {res=D} out: {res=D} |
| mark(Direction.SOUTH) |
| mark(Direction.SOUTH) |
| r(SOUTH) -> <v5> |
| magic[EQUALS_IN_WHEN_CONDITION](Direction.SOUTH|<v1>, <v5>) -> <v6> |
| jmp?(L6|<v6>) USE: in: {res=READ} out: {res=READ} |
| L5 ['when' entry body]: |
| r(2) -> <v7> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} |
| w(res|<v7>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ} |
| jmp(L2) INIT: in: {res=ID} out: {res=ID} |
| L6 [next 'when' entry]: |
| mark(Direction.WEST -> res = 3) INIT: in: {res=D} out: {res=D} |
| mark(Direction.WEST) |
| mark(Direction.WEST) |
| r(WEST) -> <v8> |
| magic[EQUALS_IN_WHEN_CONDITION](Direction.WEST|<v1>, <v8>) -> <v9> |
| jmp?(L8|<v9>) USE: in: {res=READ} out: {res=READ} |
| L7 ['when' entry body]: |
| r(3) -> <v10> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} |
| w(res|<v10>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ} |
| jmp(L2) INIT: in: {res=ID} out: {res=ID} |
| L8 [next 'when' entry]: |
| mark(Direction.EAST -> res = 4) INIT: in: {res=D} out: {res=D} |
| mark(Direction.EAST) |
| mark(Direction.EAST) |
| r(EAST) -> <v11> |
| magic[EQUALS_IN_WHEN_CONDITION](Direction.EAST|<v1>, <v11>) -> <v12> |
| jmp?(L10|<v12>) USE: in: {res=READ} out: {res=READ} |
| L9 ['when' entry body]: |
| r(4) -> <v13> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} |
| w(res|<v13>) INIT: in: {res=D} out: {res=ID} USE: in: {res=READ} out: {res=WRITTEN_AFTER_READ} |
| jmp(L2) INIT: in: {res=ID} out: {res=ID} |
| L10 [next 'when' entry]: |
| magic[EXHAUSTIVE_WHEN_ELSE](when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) -> <v14> INIT: in: {res=D} out: {res=IED} |
| L2 [after 'when' expression]: |
| merge(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }|!<v15>, !<v16>, !<v17>, !<v18>) -> <v19> INIT: in: {res=ID} out: {res=ID} USE: in: {res=READ} out: {res=READ} |
| r(res) -> <v20> USE: in: {} out: {res=READ} |
| ret(*|<v20>) L1 |
| L1: |
| 1 <END> INIT: in: {} out: {} |
| error: |
| <ERROR> |
| sink: |
| <SINK> USE: in: {} out: {} |
| ===================== |
