== t1 == fun t1() { try { 1 } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 } finally { 2 } }) mark(try { 1 } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 })] 3 mark({ 1 }) r(1) -> 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L3)] jmp(L3) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L4 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L5 [finish finally]: 2 jmp(error) NEXT:[] L3 [skipFinallyToErrorBlock]: L6 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L3)] r(2) -> 2 merge(try { 1 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t2 == fun t2() { try { 1 if (2 > 3) { return } } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 if (2 > 3) { return } } finally { 2 } }) mark(try { 1 if (2 > 3) { return } } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return } })] 3 mark({ 1 if (2 > 3) { return } }) r(1) -> mark(if (2 > 3) { return }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L3|) NEXT:[read (Unit), mark({ return })] 4 mark({ return }) jmp?(L2) NEXT:[mark({ 2 }), mark({ 2 })] L4 [start finally]: 5 mark({ 2 }) r(2) -> L5 [finish finally]: 4 ret L1 NEXT:[] - 3 jmp(L6) NEXT:[merge(if (2 > 3) { return }|!) -> ] PREV:[] L3 [else branch]: read (Unit) PREV:[jf(L3|)] L6 ['if' expression result]: merge(if (2 > 3) { return }|!) -> 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L7)] jmp(L7) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: 5 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2), jmp?(L2)] r(2) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 5 mark({ 2 }) PREV:[jmp(L7)] r(2) -> 2 merge(try { 1 if (2 > 3) { return } } finally { 2 }|) -> L1: 1 NEXT:[] PREV:[ret L1, merge(try { 1 if (2 > 3) { return } } finally { 2 }|) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t3 == fun t3() { try { 1 l@{ -> if (2 > 3) { return@l } } } finally { 2 } } --------------------- L0: 1 2 mark({ try { 1 l@{ -> if (2 > 3) { return@l } } } finally { 2 } }) mark(try { 1 l@{ -> if (2 > 3) { return@l } } } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ 1 l@{ -> if (2 > 3) { return@l } } })] 3 mark({ 1 l@{ -> if (2 > 3) { return@l } } }) r(1) -> mark(l@{ -> if (2 > 3) { return@l } }) mark({ -> if (2 > 3) { return@l } }) jmp?(L3) NEXT:[r({ -> if (2 > 3) { return@l } }) -> , d({ -> if (2 > 3) { return@l } })] d({ -> if (2 > 3) { return@l } }) NEXT:[] L3 [after local declaration]: r({ -> if (2 > 3) { return@l } }) -> PREV:[jmp?(L3)] 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L8)] jmp(L8) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L9 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L10 [finish finally]: 2 jmp(error) NEXT:[] L8 [skipFinallyToErrorBlock]: L11 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L8)] r(2) -> 2 merge(try { 1 l@{ -> if (2 > 3) { return@l } } } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, , d({ -> if (2 > 3) { return@l } })] ===================== == anonymous_0 == { -> if (2 > 3) { return@l } } --------------------- L4: 4 5 mark(if (2 > 3) { return@l }) mark(if (2 > 3) { return@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L6|) NEXT:[read (Unit), mark({ return@l })] 6 mark({ return@l }) ret L5 NEXT:[] - 5 jmp(L7) NEXT:[merge(if (2 > 3) { return@l }|!) -> ] PREV:[] L6 [else branch]: read (Unit) PREV:[jf(L6|)] L7 ['if' expression result]: merge(if (2 > 3) { return@l }|!) -> L5: 4 NEXT:[] PREV:[ret L5, merge(if (2 > 3) { return@l }|!) -> ] error: PREV:[] sink: PREV:[, ] ===================== == t4 == fun t4() { l@{ -> try { 1 if (2 > 3) { return@l } } finally { 2 } } } --------------------- L0: 1 2 mark({ l@{ -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }) mark(l@{ -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) mark({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) jmp?(L2) NEXT:[r({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> , d({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } })] d({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) NEXT:[] L2 [after local declaration]: r({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } }) -> PREV:[jmp?(L2)] L1: 1 NEXT:[] error: PREV:[] sink: PREV:[, , d({ -> try { 1 if (2 > 3) { return@l } } finally { 2 } })] ===================== == anonymous_1 == { -> try { 1 if (2 > 3) { return@l } } finally { 2 } } --------------------- L3: 3 4 mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) mark(try { 1 if (2 > 3) { return@l } } finally { 2 }) jmp?(L5) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { return@l } })] 5 mark({ 1 if (2 > 3) { return@l } }) r(1) -> mark(if (2 > 3) { return@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L6|) NEXT:[read (Unit), mark({ return@l })] 6 mark({ return@l }) jmp?(L5) NEXT:[mark({ 2 }), mark({ 2 })] L7 [start finally]: 7 mark({ 2 }) r(2) -> L8 [finish finally]: 6 ret L4 NEXT:[] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { return@l }|!) -> ] PREV:[] L6 [else branch]: read (Unit) PREV:[jf(L6|)] L9 ['if' expression result]: merge(if (2 > 3) { return@l }|!) -> 4 jmp?(L5) NEXT:[mark({ 2 }), jmp(L10)] jmp(L10) NEXT:[mark({ 2 })] L5 [onExceptionToFinallyBlock]: 7 mark({ 2 }) PREV:[jmp?(L5), jmp?(L5), jmp?(L5)] r(2) -> 4 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: 7 mark({ 2 }) PREV:[jmp(L10)] r(2) -> 4 merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|) -> L4: 3 NEXT:[] PREV:[ret L4, merge(try { 1 if (2 > 3) { return@l } } finally { 2 }|) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t5 == fun t5() { l@ while(true) { try { 1 if (2 > 3) { break@l } } finally { 2 } } } --------------------- L0: 1 2 mark({ l@ while(true) { try { 1 if (2 > 3) { break@l } } finally { 2 } } }) mark(l@ while(true) { try { 1 if (2 > 3) { break@l } } finally { 2 } }) L2 [loop entry point]: L6 [condition entry point]: r(true) -> PREV:[mark(l@ while(true) { try { 1 if (2 > 3) { break@l } } finally { 2 } }), jmp(L2)] mark(while(true) { try { 1 if (2 > 3) { break@l } } finally { 2 } }) magic[VALUE_CONSUMER](true|) -> L4 [body entry point]: 3 mark({ try { 1 if (2 > 3) { break@l } } finally { 2 } }) mark(try { 1 if (2 > 3) { break@l } } finally { 2 }) jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { break@l } })] 4 mark({ 1 if (2 > 3) { break@l } }) r(1) -> mark(if (2 > 3) { break@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ break@l })] 5 mark({ break@l }) jmp?(L7) NEXT:[mark({ 2 }), mark({ 2 })] L9 [start finally]: 6 mark({ 2 }) r(2) -> L10 [finish finally]: 5 jmp(L3) NEXT:[read (Unit)] - 4 jmp(L11) NEXT:[merge(if (2 > 3) { break@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L11 ['if' expression result]: merge(if (2 > 3) { break@l }|!) -> 3 jmp?(L7) NEXT:[mark({ 2 }), jmp(L12)] jmp(L12) NEXT:[mark({ 2 })] L7 [onExceptionToFinallyBlock]: 6 mark({ 2 }) PREV:[jmp?(L7), jmp?(L7), jmp?(L7)] r(2) -> 3 jmp(error) NEXT:[] L12 [skipFinallyToErrorBlock]: 6 mark({ 2 }) PREV:[jmp(L12)] r(2) -> 3 merge(try { 1 if (2 > 3) { break@l } } finally { 2 }|) -> 2 jmp(L2) NEXT:[r(true) -> ] L3 [loop exit point]: L5 [body exit point]: read (Unit) PREV:[jmp(L3)] L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t6 == fun t6() { try { l@ while(true) { 1 if (2 > 3) { break@l } } 5 } finally { 2 } } --------------------- L0: 1 2 mark({ try { l@ while(true) { 1 if (2 > 3) { break@l } } 5 } finally { 2 } }) mark(try { l@ while(true) { 1 if (2 > 3) { break@l } } 5 } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ l@ while(true) { 1 if (2 > 3) { break@l } } 5 })] 3 mark({ l@ while(true) { 1 if (2 > 3) { break@l } } 5 }) mark(l@ while(true) { 1 if (2 > 3) { break@l } }) L3 [loop entry point]: L7 [condition entry point]: r(true) -> PREV:[mark(l@ while(true) { 1 if (2 > 3) { break@l } }), jmp(L3)] mark(while(true) { 1 if (2 > 3) { break@l } }) magic[VALUE_CONSUMER](true|) -> L5 [body entry point]: 4 mark({ 1 if (2 > 3) { break@l } }) r(1) -> mark(if (2 > 3) { break@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ break@l })] 5 mark({ break@l }) jmp(L4) NEXT:[read (Unit)] - 4 jmp(L9) NEXT:[merge(if (2 > 3) { break@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L9 ['if' expression result]: merge(if (2 > 3) { break@l }|!) -> 3 jmp(L3) NEXT:[r(true) -> ] L4 [loop exit point]: L6 [body exit point]: read (Unit) PREV:[jmp(L4)] r(5) -> 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L10)] jmp(L10) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L11 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L12 [finish finally]: 2 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: L13 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L10)] r(2) -> 2 merge(try { l@ while(true) { 1 if (2 > 3) { break@l } } 5 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t7 == fun t7() { try { l@ while(true) { 1 if (2 > 3) { break@l } } } finally { 2 } } --------------------- L0: 1 2 mark({ try { l@ while(true) { 1 if (2 > 3) { break@l } } } finally { 2 } }) mark(try { l@ while(true) { 1 if (2 > 3) { break@l } } } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ l@ while(true) { 1 if (2 > 3) { break@l } } })] 3 mark({ l@ while(true) { 1 if (2 > 3) { break@l } } }) mark(l@ while(true) { 1 if (2 > 3) { break@l } }) L3 [loop entry point]: L7 [condition entry point]: r(true) -> PREV:[mark(l@ while(true) { 1 if (2 > 3) { break@l } }), jmp(L3)] mark(while(true) { 1 if (2 > 3) { break@l } }) magic[VALUE_CONSUMER](true|) -> L5 [body entry point]: 4 mark({ 1 if (2 > 3) { break@l } }) r(1) -> mark(if (2 > 3) { break@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ break@l })] 5 mark({ break@l }) jmp(L4) NEXT:[read (Unit)] - 4 jmp(L9) NEXT:[merge(if (2 > 3) { break@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L9 ['if' expression result]: merge(if (2 > 3) { break@l }|!) -> 3 jmp(L3) NEXT:[r(true) -> ] L4 [loop exit point]: L6 [body exit point]: read (Unit) PREV:[jmp(L4)] 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L10)] jmp(L10) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L11 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L12 [finish finally]: 2 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: L13 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L10)] r(2) -> 2 merge(try { l@ while(true) { 1 if (2 > 3) { break@l } } } finally { 2 }|!) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t8 == fun t8(a : Int) { l@ for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ l@ for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } } }) mark(l@ for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } }) 3 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> mark(1..a) call(1..a, iterator|) -> v(i) L2 [loop entry point]: L6 [condition entry point]: mark(1..a) PREV:[v(i), jmp(L6), jmp(L2)] call(1..a, hasNext) -> jmp?(L3) NEXT:[read (Unit), mark(1..a)] mark(1..a) call(1..a, next) -> magic[LOOP_RANGE_ITERATION](1..a|) -> w(i|) mark(for (i in 1..a) { try { 1 if (2 > 3) { continue@l } } finally { 2 } }) L4 [body entry point]: 4 mark({ try { 1 if (2 > 3) { continue@l } } finally { 2 } }) mark(try { 1 if (2 > 3) { continue@l } } finally { 2 }) jmp?(L7) NEXT:[mark({ 2 }), mark({ 1 if (2 > 3) { continue@l } })] 5 mark({ 1 if (2 > 3) { continue@l } }) r(1) -> mark(if (2 > 3) { continue@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ continue@l })] 6 mark({ continue@l }) jmp?(L7) NEXT:[mark({ 2 }), mark({ 2 })] L9 [start finally]: 7 mark({ 2 }) r(2) -> L10 [finish finally]: 6 jmp(L6) NEXT:[mark(1..a)] - 5 jmp(L11) NEXT:[merge(if (2 > 3) { continue@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L11 ['if' expression result]: merge(if (2 > 3) { continue@l }|!) -> 4 jmp?(L7) NEXT:[mark({ 2 }), jmp(L12)] jmp(L12) NEXT:[mark({ 2 })] L7 [onExceptionToFinallyBlock]: 7 mark({ 2 }) PREV:[jmp?(L7), jmp?(L7), jmp?(L7)] r(2) -> 4 jmp(error) NEXT:[] L12 [skipFinallyToErrorBlock]: 7 mark({ 2 }) PREV:[jmp(L12)] r(2) -> 4 merge(try { 1 if (2 > 3) { continue@l } } finally { 2 }|) -> 3 jmp(L2) NEXT:[mark(1..a)] L3 [loop exit point]: L5 [body exit point]: read (Unit) PREV:[jmp?(L3)] L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t9 == fun t9(a : Int) { try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 } }) mark(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 })] 3 mark({ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 }) mark(l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } }) 4 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> mark(1..a) call(1..a, iterator|) -> v(i) L3 [loop entry point]: L7 [condition entry point]: mark(1..a) PREV:[v(i), jmp(L7), jmp(L3)] call(1..a, hasNext) -> jmp?(L4) NEXT:[read (Unit), mark(1..a)] mark(1..a) call(1..a, next) -> magic[LOOP_RANGE_ITERATION](1..a|) -> w(i|) mark(for (i in 1..a) { 1 if (2 > 3) { continue@l } }) L5 [body entry point]: 5 mark({ 1 if (2 > 3) { continue@l } }) r(1) -> mark(if (2 > 3) { continue@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ continue@l })] 6 mark({ continue@l }) jmp(L7) NEXT:[mark(1..a)] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L9 ['if' expression result]: merge(if (2 > 3) { continue@l }|!) -> 4 jmp(L3) NEXT:[mark(1..a)] L4 [loop exit point]: L6 [body exit point]: read (Unit) PREV:[jmp?(L4)] 3 r(5) -> 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L10)] jmp(L10) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L11 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L12 [finish finally]: 2 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: L13 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L10)] r(2) -> 2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } 5 } finally { 2 }|) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t10 == fun t10(a : Int) { try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 } } --------------------- L0: 1 v(a : Int) magic[FAKE_INITIALIZER](a : Int) -> w(a|) 2 mark({ try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 } }) mark(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 }) jmp?(L2) NEXT:[mark({ 2 }), mark({ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } })] 3 mark({ l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } }) mark(l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } }) 4 r(1) -> r(a) -> mark(1..a) call(1..a, rangeTo|, ) -> mark(1..a) call(1..a, iterator|) -> v(i) L3 [loop entry point]: L7 [condition entry point]: mark(1..a) PREV:[v(i), jmp(L7), jmp(L3)] call(1..a, hasNext) -> jmp?(L4) NEXT:[read (Unit), mark(1..a)] mark(1..a) call(1..a, next) -> magic[LOOP_RANGE_ITERATION](1..a|) -> w(i|) mark(for (i in 1..a) { 1 if (2 > 3) { continue@l } }) L5 [body entry point]: 5 mark({ 1 if (2 > 3) { continue@l } }) r(1) -> mark(if (2 > 3) { continue@l }) r(2) -> r(3) -> mark(2 > 3) call(2 > 3, compareTo|, ) -> jf(L8|) NEXT:[read (Unit), mark({ continue@l })] 6 mark({ continue@l }) jmp(L7) NEXT:[mark(1..a)] - 5 jmp(L9) NEXT:[merge(if (2 > 3) { continue@l }|!) -> ] PREV:[] L8 [else branch]: read (Unit) PREV:[jf(L8|)] L9 ['if' expression result]: merge(if (2 > 3) { continue@l }|!) -> 4 jmp(L3) NEXT:[mark(1..a)] L4 [loop exit point]: L6 [body exit point]: read (Unit) PREV:[jmp?(L4)] 2 jmp?(L2) NEXT:[mark({ 2 }), jmp(L10)] jmp(L10) NEXT:[mark({ 2 })] L2 [onExceptionToFinallyBlock]: L11 [start finally]: 3 mark({ 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> L12 [finish finally]: 2 jmp(error) NEXT:[] L10 [skipFinallyToErrorBlock]: L13 [copy of L2, onExceptionToFinallyBlock]: 3 mark({ 2 }) PREV:[jmp(L10)] r(2) -> 2 merge(try { l@ for (i in 1..a) { 1 if (2 > 3) { continue@l } } } finally { 2 }|!) -> L1: 1 NEXT:[] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t11 == fun t11() { try { return 1 } finally { return 2 } } --------------------- L0: 1 2 mark({ try { return 1 } finally { return 2 } }) mark(try { return 1 } finally { return 2 }) jmp?(L2) NEXT:[mark({ return 2 }), mark({ return 1 })] 3 mark({ return 1 }) jmp?(L2) NEXT:[mark({ return 2 }), r(1) -> ] r(1) -> L3 [start finally]: 4 mark({ return 2 }) r(2) -> ret(*|) L1 NEXT:[] L4 [finish finally]: - 3 ret(*|) L1 NEXT:[] PREV:[] - 2 jmp?(L2) NEXT:[mark({ return 2 }), jmp(L5)] PREV:[] - jmp(L5) NEXT:[mark({ return 2 })] PREV:[] L2 [onExceptionToFinallyBlock]: 4 mark({ return 2 }) PREV:[jmp?(L2), jmp?(L2)] r(2) -> ret(*|) L1 NEXT:[] - 2 jmp(error) NEXT:[] PREV:[] L5 [skipFinallyToErrorBlock]: - 4 mark({ return 2 }) PREV:[] - r(2) -> PREV:[] - ret(*|) L1 NEXT:[] PREV:[] - 2 merge(try { return 1 } finally { return 2 }|!) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1, ret(*|) L1] error: PREV:[] sink: PREV:[, ] ===================== == t12 == fun t12() : Int { try { return 1 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } finally { doSmth(3) } }) mark(try { return 1 } finally { doSmth(3) }) jmp?(L2) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) jmp?(L2) NEXT:[mark({ doSmth(3) }), r(1) -> ] r(1) -> L3 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L4 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp?(L2) NEXT:[mark({ doSmth(3) }), jmp(L5)] PREV:[] - jmp(L5) NEXT:[mark({ doSmth(3) })] PREV:[] L2 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L2), jmp?(L2)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L5 [skipFinallyToErrorBlock]: - 4 mark({ doSmth(3) }) PREV:[] - r(3) -> PREV:[] - mark(doSmth(3)) PREV:[] - call(doSmth(3), doSmth|) -> PREV:[] - 2 merge(try { return 1 } finally { doSmth(3) }|!) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t13 == fun t13() : Int { try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), r(1) -> ] r(1) -> L4 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L5 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] PREV:[] - jmp?(L3) NEXT:[mark({ doSmth(3) }), jmp(L6)] PREV:[] - jmp(L6) NEXT:[jmp(L7)] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2), jmp?(L2)] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ doSmth(2) }) r(2) -> mark(doSmth(2)) call(doSmth(2), doSmth|) -> 3 jmp(L6) L6 [afterCatches]: 2 jmp(L7) NEXT:[mark({ doSmth(3) })] L3 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L3), jmp?(L3)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 4 mark({ doSmth(3) }) PREV:[jmp(L7)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }|!, ) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }|!, ) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t14 == fun t14() : Int { try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), mark({ return 1 })] 3 mark({ return 1 }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), r(1) -> ] r(1) -> ret(*|) L1 NEXT:[] - 2 jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp(L3)] PREV:[] - jmp(L3) NEXT:[merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> ] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2), jmp?(L2)] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ doSmth(2) }) r(2) -> mark(doSmth(2)) call(doSmth(2), doSmth|) -> 3 jmp(L3) L3 [afterCatches]: 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }|!, ) -> ] error: PREV:[] sink: PREV:[, ] ===================== == t15 == fun t15() : Int { try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) mark(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ return 1 })] 3 mark({ return 1 }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), r(1) -> ] r(1) -> L4 [start finally]: 4 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L5 [finish finally]: 3 ret(*|) L1 NEXT:[] - 2 jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] PREV:[] - jmp?(L3) NEXT:[mark({ doSmth(3) }), jmp(L6)] PREV:[] - jmp(L6) NEXT:[jmp(L7)] PREV:[] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2), jmp?(L2)] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ return 2 }) r(2) -> mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> ret(*|) L1 NEXT:[] - 3 jmp(L6) PREV:[] L6 [afterCatches]: - 2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[] L3 [onExceptionToFinallyBlock]: 4 mark({ doSmth(3) }) PREV:[jmp?(L3), jmp?(L3)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: - 4 mark({ doSmth(3) }) PREV:[] - r(3) -> PREV:[] - mark(doSmth(3)) PREV:[] - call(doSmth(3), doSmth|) -> PREV:[] - 2 merge(try { return 1 } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|!, !) -> PREV:[] L1: 1 NEXT:[] PREV:[ret(*|) L1, ret(*|) L1] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == t16 == fun t16() : Int { try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } } --------------------- L0: 1 2 mark({ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }) mark(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }) jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), mark({ doSmth(1) })] 3 mark({ doSmth(1) }) r(1) -> mark(doSmth(1)) call(doSmth(1), doSmth|) -> 2 jmp?(L2) NEXT:[v(e: UnsupportedOperationException), jmp?(L3)] jmp?(L3) NEXT:[mark({ doSmth(3) }), jmp(L4)] jmp(L4) NEXT:[jmp(L7)] L2 [onException]: 3 v(e: UnsupportedOperationException) PREV:[jmp?(L2), jmp?(L2)] magic[FAKE_INITIALIZER](e: UnsupportedOperationException) -> w(e|) 4 mark({ return 2 }) r(2) -> L5 [start finally]: 5 mark({ doSmth(3) }) r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> L6 [finish finally]: 4 ret(*|) L1 NEXT:[] - 3 jmp(L4) PREV:[] L4 [afterCatches]: 2 jmp(L7) NEXT:[mark({ doSmth(3) })] PREV:[jmp(L4)] L3 [onExceptionToFinallyBlock]: 5 mark({ doSmth(3) }) PREV:[jmp?(L3), jmp?(L3)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 jmp(error) NEXT:[] L7 [skipFinallyToErrorBlock]: 5 mark({ doSmth(3) }) PREV:[jmp(L7)] r(3) -> mark(doSmth(3)) call(doSmth(3), doSmth|) -> 2 merge(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|, !) -> L1: 1 NEXT:[] PREV:[ret(*|) L1, merge(try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }|, !) -> ] error: PREV:[jmp(error)] sink: PREV:[, ] ===================== == doSmth == fun doSmth(i: Int) { } --------------------- L0: 1 v(i: Int) magic[FAKE_INITIALIZER](i: Int) -> w(i|) 2 mark({ }) read (Unit) L1: 1 NEXT:[] error: PREV:[] sink: PREV:[, ] =====================