azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Do not render trivial variables in DataFlow tests

Browse Source 
The reason is that while there are optimizations for them
definition of their state is both rather simple and may be
confusing in testData
This commit is contained in:
Denis Zharkov
2017-09-29 16:42:41 +03:00
parent 477aeef90c
commit edbf360852
24 changed files with 479 additions and 464 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg-variables/bugs/kt10243.instructions
Vendored
+9 -9
View File
@@ -25,10 +25,10 @@ fun foo(f: Boolean) {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(f: Boolean) INIT: in: {} out: {f=D}
magic[FAKE_INITIALIZER](f: Boolean) -> <v0> INIT: in: {f=D} out: {f=D}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
2 mark({ try { if (f) { x = 0 } } finally { fun bar() {} } }) INIT: in: {f=ID} out: {f=ID}
v(f: Boolean) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](f: Boolean) -> <v0> INIT: in: {} out: {}
w(f|<v0>) INIT: in: {} out: {}
2 mark({ try { if (f) { x = 0 } } finally { fun bar() {} } }) INIT: in: {} out: {}
mark(try { if (f) { x = 0 } } finally { fun bar() {} })
jmp?(L2)
3 mark({ if (f) { x = 0 } })
@@ -65,13 +65,13 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== bar ==
fun bar() {}
---------------------
L8:
4 <START> INIT: in: {f=ID} out: {f=ID}
4 <START> INIT: in: {} out: {}
5 mark({})
read (Unit)
L9:
@@ -79,13 +79,13 @@ L9:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== bar ==
fun bar() {}
---------------------
L2 [copy of L8, null]:
4 <START> INIT: in: {f=ID} out: {f=ID}
4 <START> INIT: in: {} out: {}
5 mark({})
read (Unit)
L3 [copy of L9, null]:
@@ -93,5 +93,5 @@ L3 [copy of L9, null]:
L0 [copy of error, null]:
<ERROR>
L1 [copy of sink, null]:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/kt4764.instructions
Vendored
+24 -24
View File
@@ -39,7 +39,7 @@ L4 [start finally]:
5 mark({})
read (Unit)
L5 [finish finally]:
4 ret(*|<v1>) L1 USE: in: {} out: {}
4 ret(*|<v1>) L1 USE: in: {} out: {}
- 3 jmp(L6)
L3 [else branch]:
4 mark({ if (false) { if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" } }) INIT: in: {} out: {}
@@ -49,56 +49,56 @@ L3 [else branch]:
5 mark({ if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" })
mark(if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } })
r(false) -> <v4>
jf(L8|<v4>) USE: in: {} out: {}
jf(L8|<v4>) USE: in: {} out: {}
6 mark({ var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } })
v(var foo: String? = null) INIT: in: {} out: {foo=D}
r(null) -> <v5> INIT: in: {foo=D} out: {foo=D}
w(foo|<v5>) INIT: in: {foo=D} out: {foo=ID}
mark(try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L9)
jmp?(L10) USE: in: {foo=READ} out: {foo=READ}
jmp?(L10) USE: in: {foo=READ} out: {foo=READ}
7 mark({ foo = "test" })
mark("test")
r("test") -> <v6> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v6>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
r("test") -> <v6> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v6>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
6 jmp?(L9)
jmp?(L10)
jmp(L11)
L9 [onException]:
7 v(e: Exception) INIT: in: {foo=ID} out: {e=D, foo=ID}
magic[FAKE_INITIALIZER](e: Exception) -> <v8> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID}
w(e|<v8>) INIT: in: {e=D, foo=ID} out: {e=ID, foo=ID}
8 mark({ return "fail" }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID}
7 v(e: Exception) INIT: in: {foo=ID} out: {foo=ID}
magic[FAKE_INITIALIZER](e: Exception) -> <v8> INIT: in: {foo=ID} out: {foo=ID}
w(e|<v8>) INIT: in: {foo=ID} out: {foo=ID}
8 mark({ return "fail" }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L2)
mark("fail")
r("fail") -> <v9>
L12 [start finally]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
L13 [finish finally]:
5 mark({}) INIT: in: {e=ID} out: {e=ID}
5 mark({}) INIT: in: {} out: {}
read (Unit)
8 ret(*|<v9>) L1 USE: in: {} out: {}
8 ret(*|<v9>) L1 USE: in: {} out: {}
- 7 jmp(L11)
L11 [afterCatches]:
6 jmp(L14) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID}
6 jmp(L14) INIT: in: {foo=ID} out: {foo=ID}
L10 [onExceptionToFinallyBlock]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
5 mark({}) INIT: in: {e=ID} out: {e=ID}
5 mark({}) INIT: in: {} out: {}
read (Unit)
6 jmp(error) USE: in: {} out: {}
6 jmp(error) USE: in: {} out: {}
L14 [skipFinallyToErrorBlock]:
9 mark({ println(foo) // Variable 'foo' must be initialized }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
9 mark({ println(foo) // Variable 'foo' must be initialized }) INIT: in: {foo=ID} out: {foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v10> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v10>, !<v11>) -> <v12>
6 merge(try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized }|!<v7>, !<v13>) -> <v14>
5 jmp(L15) INIT: in: {e=ID} out: {e=ID}
5 jmp(L15) INIT: in: {} out: {}
L8 [else branch]:
read (Unit)
L15 ['if' expression result]:
@@ -108,10 +108,10 @@ L15 ['if' expression result]:
r("fail") -> <v16>
mark({})
read (Unit)
ret(*|<v16>) L1 USE: in: {} out: {}
ret(*|<v16>) L1 USE: in: {} out: {}
- 4 jmp(L16)
L7 [else branch]:
read (Unit) INIT: in: {e=ID} out: {e=ID}
read (Unit) INIT: in: {} out: {}
L16 ['if' expression result]:
merge(if (false) { if (false) { var foo: String? = null try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized } } return "fail" }|!<v17>) -> <v18>
L6 ['if' expression result]:
@@ -133,5 +133,5 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/kt5469.instructions
Vendored
+13 -13
View File
@@ -10,38 +10,38 @@ fun f() {
}
---------------------
L0:
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
1 <START> INIT: in: {} out: {} USE: in: {} out: {}
2 mark({ var foo = 1 try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) } })
v(var foo = 1) INIT: in: {} out: {foo=D}
r(1) -> <v0> INIT: in: {foo=D} out: {foo=D}
w(foo|<v0>) INIT: in: {foo=D} out: {foo=ID}
mark(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }) INIT: in: {foo=ID} out: {foo=ID}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
3 mark({ foo = 2 throw RuntimeException() })
r(2) -> <v1> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v1>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
r(2) -> <v1> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ}
w(foo|<v1>) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ}
mark(throw RuntimeException())
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
jmp?(L2) USE: in: {foo=READ} out: {foo=READ}
mark(RuntimeException())
call(RuntimeException(), <init>) -> <v2>
throw (throw RuntimeException()|<v2>) USE: in: {} out: {}
throw (throw RuntimeException()|<v2>) USE: in: {} out: {}
- 2 jmp?(L2)
- jmp(L3)
L2 [onException]:
3 v(e: Throwable) INIT: in: {foo=ID} out: {e=D, foo=ID}
magic[FAKE_INITIALIZER](e: Throwable) -> <v4> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID}
w(e|<v4>) INIT: in: {e=D, foo=ID} out: {e=ID, foo=ID}
4 mark({ println(foo) }) INIT: in: {e=ID, foo=ID} out: {e=ID, foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v5> USE: in: {} out: {foo=READ}
3 v(e: Throwable) INIT: in: {foo=ID} out: {foo=ID}
magic[FAKE_INITIALIZER](e: Throwable) -> <v4> INIT: in: {foo=ID} out: {foo=ID}
w(e|<v4>) INIT: in: {foo=ID} out: {foo=ID}
4 mark({ println(foo) }) INIT: in: {foo=ID} out: {foo=ID} USE: in: {foo=READ} out: {foo=READ}
r(foo) -> <v5> USE: in: {} out: {foo=READ}
mark(println(foo))
magic[UNRESOLVED_CALL](println(foo)|<v5>, !<v6>) -> <v7>
3 jmp(L3)
L3 [afterCatches]:
2 merge(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }|!<v3>, <v7>) -> <v8>
L1:
1 <END> INIT: in: {e=ID} out: {e=ID}
1 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions
Vendored
+126 -126
View File
@@ -3,17 +3,17 @@ fun println(obj: Any?) {}
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(obj: Any?) INIT: in: {} out: {obj=D}
magic[FAKE_INITIALIZER](obj: Any?) -> <v0> INIT: in: {obj=D} out: {obj=D}
w(obj|<v0>) INIT: in: {obj=D} out: {obj=ID}
2 mark({}) INIT: in: {obj=ID} out: {obj=ID}
v(obj: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](obj: Any?) -> <v0> INIT: in: {} out: {}
w(obj|<v0>) INIT: in: {} out: {}
2 mark({}) INIT: in: {} out: {}
read (Unit)
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo0 ==
class Demo0 {
@@ -28,22 +28,22 @@ class Demo0 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { println(state) // Ok } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {}
mark(object { fun foo() { println(state) // Ok } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { println(state) // Ok }) USE: in: {state=READ} out: {state=READ}
d(fun foo() { println(state) // Ok }) USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { println(state) // Ok } }) -> <v0>
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -51,10 +51,10 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ println(state) // Ok })
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v1>) -> <v2>
L4:
@@ -62,7 +62,7 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== Demo1 ==
class Demo1 {
@@ -80,22 +80,22 @@ class Demo1 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {}
mark(object { fun foo() { if (state) state = true println(state) // must be initialized } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // must be initialized }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true println(state) // must be initialized }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true println(state) // must be initialized } }) -> <v0> INIT: in: {some=D} out: {some=D}
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true println(state) // must be initialized } }) -> <v0> INIT: in: {} out: {}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -106,30 +106,30 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ if (state) state = true println(state) // must be initialized })
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
read (Unit) INIT: in: {} out: {}
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo1A ==
class Demo1A {
@@ -207,22 +207,22 @@ class Demo2 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {some=D}
mark(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {some=D} out: {some=D}
v(private val some = object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {}
mark(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) INIT: in: {} out: {}
jmp?(L2)
d(fun foo() { if (state) state = true else state = false println(state) // OK }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true else state = false println(state) // OK }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) -> <v0> INIT: in: {some=D} out: {some=D}
w(some|<v0>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v1> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v1>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true else state = false println(state) // OK } }) -> <v0> INIT: in: {} out: {}
w(some|<v0>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v1> INIT: in: {state=D} out: {state=D}
w(state|<v1>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -235,32 +235,32 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark({ if (state) state = true else state = false println(state) // OK })
mark(if (state) state = true else state = false)
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v0> USE: in: {state=READ} out: {state=READ}
r(state|<v0>) -> <v1> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ}
jf(L5|<v1>)
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L5 [else branch]:
magic[IMPLICIT_RECEIVER](state) -> <v4> INIT: in: {some=D} out: {some=D}
r(false) -> <v5> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v4>, <v5>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
magic[IMPLICIT_RECEIVER](state) -> <v4> INIT: in: {} out: {}
r(false) -> <v5> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v4>, <v5>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
L6 ['if' expression result]:
merge(if (state) state = true else state = false|!<v6>, !<v7>) -> <v8> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v9> USE: in: {state=READ} out: {state=READ}
r(state|<v9>) -> <v10> USE: in: {} out: {state=READ}
merge(if (state) state = true else state = false|!<v6>, !<v7>) -> <v8> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v9> USE: in: {state=READ} out: {state=READ}
r(state|<v9>) -> <v10> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v10>) -> <v11>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo3 ==
class Demo3 {
@@ -276,25 +276,25 @@ class Demo3 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = run { if (state) state = true println(state) // OK }) INIT: in: {} out: {some=D}
magic[IMPLICIT_RECEIVER](run { if (state) state = true println(state) // OK }) -> <v0> INIT: in: {some=D} out: {some=D}
v(private val some = run { if (state) state = true println(state) // OK }) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](run { if (state) state = true println(state) // OK }) -> <v0> INIT: in: {} out: {}
mark({ if (state) state = true println(state) // OK })
jmp?(L2)
d({ if (state) state = true println(state) // OK }) USE: in: {state=READ} out: {state=READ}
d({ if (state) state = true println(state) // OK }) USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r({ if (state) state = true println(state) // OK }) -> <v1>
mark(run { if (state) state = true println(state) // OK })
call(run { if (state) state = true println(state) // OK }, run|<v0>, <v1>) -> <v2>
w(some|<v2>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v3> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v3>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v2>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v3> INIT: in: {state=D} out: {state=D}
w(state|<v3>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== anonymous_0 ==
{
@@ -305,22 +305,22 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark(if (state) state = true println(state) // OK)
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6)
L5 [else branch]:
read (Unit)
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5>
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
@@ -328,17 +328,17 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== exec ==
fun <T> exec(f: () -> T): T = f()
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(f: () -> T) INIT: in: {} out: {f=D}
magic[FAKE_INITIALIZER](f: () -> T) -> <v0> INIT: in: {f=D} out: {f=D}
w(f|<v0>) INIT: in: {f=D} out: {f=ID}
r(f) -> <v1> INIT: in: {f=ID} out: {f=ID}
v(f: () -> T) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](f: () -> T) -> <v0> INIT: in: {} out: {}
w(f|<v0>) INIT: in: {} out: {}
r(f) -> <v1> INIT: in: {} out: {}
mark(f())
call(f(), invoke|<v1>) -> <v2>
ret(*|<v2>) L1
@@ -347,7 +347,7 @@ L1:
error:
<ERROR>
sink:
<SINK> USE: in: {f=READ} out: {f=READ}
<SINK> USE: in: {} out: {}
=====================
== Demo4 ==
class Demo4 {
@@ -363,24 +363,24 @@ class Demo4 {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(private val some = exec { if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {some=D}
mark({ if (state) state = true println(state) // must be initialized }) INIT: in: {some=D} out: {some=D}
v(private val some = exec { if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {}
mark({ if (state) state = true println(state) // must be initialized }) INIT: in: {} out: {}
jmp?(L2)
d({ if (state) state = true println(state) // must be initialized }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d({ if (state) state = true println(state) // must be initialized }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r({ if (state) state = true println(state) // must be initialized }) -> <v0> INIT: in: {some=D} out: {some=D}
r({ if (state) state = true println(state) // must be initialized }) -> <v0> INIT: in: {} out: {}
mark(exec { if (state) state = true println(state) // must be initialized })
call(exec { if (state) state = true println(state) // must be initialized }, exec|<v0>) -> <v1>
w(some|<v1>) INIT: in: {some=D} out: {some=ID}
v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D}
r(true) -> <v2> INIT: in: {some=ID, state=D} out: {some=ID, state=D}
w(state|<v2>) INIT: in: {some=ID, state=D} out: {some=ID, state=ID}
w(some|<v1>) INIT: in: {} out: {}
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v2> INIT: in: {state=D} out: {state=D}
w(state|<v2>) INIT: in: {state=D} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== anonymous_1 ==
{
@@ -391,30 +391,30 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {some=D} out: {some=D}
2 <START> INIT: in: {} out: {}
3 mark(if (state) state = true println(state) // must be initialized)
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {some=D, state=I} out: {some=D, state=I}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) INIT: in: {} out: {state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6) INIT: in: {state=I} out: {state=I}
L5 [else branch]:
read (Unit) INIT: in: {some=D} out: {some=D}
read (Unit) INIT: in: {} out: {}
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {some=D, state=I} out: {some=D, state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
merge(if (state) state = true|!<v4>) -> <v5> INIT: in: {state=I} out: {state=I}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
== Demo5 ==
class Demo5 {
@@ -435,19 +435,19 @@ L0:
v(private var state: Boolean = true) INIT: in: {} out: {state=D}
r(true) -> <v0> INIT: in: {state=D} out: {state=D}
w(state|<v0>) INIT: in: {state=D} out: {state=ID}
v(private val some = object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {some=D, state=ID}
mark(object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {some=D, state=ID} out: {some=D, state=ID}
v(private val some = object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {state=ID}
mark(object { fun foo() { if (state) state = true println(state) // OK } }) INIT: in: {state=ID} out: {state=ID}
jmp?(L2)
d(fun foo() { if (state) state = true println(state) // OK }) INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {state=READ} out: {state=READ}
d(fun foo() { if (state) state = true println(state) // OK }) INIT: in: {state=I} out: {state=I} USE: in: {state=READ} out: {state=READ}
L2 [after local declaration]:
r(object { fun foo() { if (state) state = true println(state) // OK } }) -> <v1> INIT: in: {some=D, state=ID} out: {some=D, state=ID}
w(some|<v1>) INIT: in: {some=D, state=ID} out: {some=ID, state=ID}
r(object { fun foo() { if (state) state = true println(state) // OK } }) -> <v1> INIT: in: {state=ID} out: {state=ID}
w(some|<v1>) INIT: in: {state=ID} out: {state=ID}
L1:
<END> INIT: in: {some=ID, state=ID} out: {some=ID, state=ID}
<END> INIT: in: {state=ID} out: {state=ID}
error:
<ERROR> INIT: in: {some=ID} out: {some=ID}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {}
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -458,28 +458,28 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {some=D, state=ID} out: {some=D, state=ID}
2 <START> INIT: in: {state=ID} out: {state=ID}
3 mark({ if (state) state = true println(state) // OK })
mark(if (state) state = true)
magic[IMPLICIT_RECEIVER](state) -> <v0>
r(state|<v0>) -> <v1>
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
jf(L5|<v1>) USE: in: {state=READ} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v2>
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
r(true) -> <v3> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ}
w(state|<v2>, <v3>) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ}
jmp(L6)
L5 [else branch]:
read (Unit)
L6 ['if' expression result]:
merge(if (state) state = true|!<v4>) -> <v5>
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
magic[IMPLICIT_RECEIVER](state) -> <v6> USE: in: {state=READ} out: {state=READ}
r(state|<v6>) -> <v7> USE: in: {} out: {state=READ}
mark(println(state))
call(println(state), println|<v7>) -> <v8>
L4:
2 <END>
error:
<ERROR> INIT: in: {some=D} out: {some=D}
<ERROR> INIT: in: {} out: {}
sink:
<SINK> INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {}
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
Vendored
+38 -38
View File
@@ -7,19 +7,19 @@ class TestFunctionLiteral {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val sum: (Int)->Int = { x: Int -> sum(x - 1) + x }) INIT: in: {} out: {sum=D}
mark({ x: Int -> sum(x - 1) + x }) INIT: in: {sum=D} out: {sum=D}
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: {sum=D, x=ID} out: {sum=D, x=ID}
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: {sum=D, x=ID} out: {sum=ID, x=ID}
w(sum|<v0>) INIT: in: {} out: {}
L1:
<END> INIT: in: {sum=ID, x=ID} out: {sum=ID, x=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== anonymous_0 ==
{ x: Int ->
@@ -27,11 +27,11 @@ sink:
}
---------------------
L3:
2 <START> INIT: in: {sum=D} out: {sum=D}
v(x: Int) INIT: in: {sum=D} out: {sum=D, x=D}
magic[FAKE_INITIALIZER](x: Int) -> <v0> INIT: in: {sum=D, x=D} out: {sum=D, x=D}
w(x|<v0>) INIT: in: {sum=D, x=D} out: {sum=D, x=ID}
3 mark(sum(x - 1) + x) INIT: in: {sum=D, x=ID} out: {sum=D, x=ID}
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>
@@ -49,22 +49,22 @@ L4:
error:
<ERROR>
sink:
<SINK> USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ}
<SINK> USE: in: {} out: {}
=====================
== A ==
open class A(val a: A)
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val a: A) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](val a: A) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
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: {a=ID} out: {a=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {} out: {}
<SINK> USE: in: {} out: {}
=====================
== TestObjectLiteral ==
class TestObjectLiteral {
@@ -80,28 +80,28 @@ class TestObjectLiteral {
---------------------
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: {obj=D}
mark(object: A(obj) { init { val x = obj } fun foo() { val y = obj } }) INIT: in: {obj=D} out: {obj=D}
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: {obj=D} out: {obj=D, x=D}
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
v(val x = obj) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](obj) -> <v3> INIT: in: {} out: {}
r(obj|<v3>) -> <v4>
w(x|<v4>) INIT: in: {obj=D, x=D} out: {obj=D, x=ID}
1 jmp?(L2) INIT: in: {obj=D, x=ID} out: {obj=D, x=ID}
d(fun foo() { val y = obj }) INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID}
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: {obj=D, x=ID, y=ID} out: {obj=ID, x=ID, y=ID}
w(obj|<v5>) INIT: in: {} out: {}
L1:
<END> INIT: in: {obj=ID, x=ID, y=ID} out: {obj=ID, x=ID, y=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {obj=READ} out: {obj=READ}
<SINK> USE: in: {} out: {}
=====================
== foo ==
fun foo() {
@@ -109,18 +109,18 @@ fun foo() {
}
---------------------
L3:
2 <START> INIT: in: {obj=D, x=ID} out: {obj=D, x=ID}
2 <START> INIT: in: {} out: {}
3 mark({ val y = obj })
v(val y = obj) INIT: in: {obj=D, x=ID} out: {obj=D, x=ID, y=D}
magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=D}
v(val y = obj) INIT: in: {} out: {}
magic[IMPLICIT_RECEIVER](obj) -> <v0> INIT: in: {} out: {}
r(obj|<v0>) -> <v1>
w(y|<v1>) INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=ID}
w(y|<v1>) INIT: in: {} out: {}
L4:
2 <END> INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID}
2 <END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {obj=READ} out: {obj=READ}
<SINK> USE: in: {} out: {}
=====================
== TestOther ==
class TestOther {
@@ -129,17 +129,17 @@ class TestOther {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(val x: Int = x + 1) INIT: in: {} out: {x=D}
magic[IMPLICIT_RECEIVER](x) -> <v0> INIT: in: {x=D} out: {x=D}
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: {x=D} out: {x=ID}
w(x|<v3>) INIT: in: {} out: {}
L1:
<END> INIT: in: {x=ID} out: {x=ID}
<END> INIT: in: {} out: {}
error:
<ERROR>
sink:
<SINK> USE: in: {x=READ} out: {x=READ}
<SINK> USE: in: {} out: {}
=====================
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions
Vendored
+26 -26
View File
@@ -15,72 +15,72 @@ fun foo(numbers: Collection<Int>) {
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(numbers: Collection<Int>) INIT: in: {} out: {numbers=D}
magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0> INIT: in: {numbers=D} out: {numbers=D}
w(numbers|<v0>) INIT: in: {numbers=D} out: {numbers=ID}
2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {numbers=ID} out: {numbers=ID}
v(numbers: Collection<Int>) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](numbers: Collection<Int>) -> <v0> INIT: in: {} out: {}
w(numbers|<v0>) INIT: in: {} out: {}
2 mark({ for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue } }) INIT: in: {} out: {}
3 r(numbers) -> <v1>
mark(numbers)
call(numbers, iterator|<v1>) -> <v2>
v(i) INIT: in: {numbers=ID} out: {i=D, numbers=ID}
v(i) INIT: in: {} out: {}
L2 [loop entry point]:
L6 [condition entry point]:
mark(numbers) INIT: in: {i=D, numbers=ID} out: {i=D, numbers=ID}
mark(numbers) INIT: in: {} out: {}
call(numbers, hasNext) -> <v3>
jmp?(L3)
mark(numbers)
call(numbers, next) -> <v4>
magic[LOOP_RANGE_ITERATION](numbers|<v4>) -> <v5>
w(i|<v5>) INIT: in: {i=D, numbers=ID} out: {i=ID, numbers=ID}
mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue }) INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID} USE: in: {numbers=READ} out: {numbers=READ}
w(i|<v5>) INIT: in: {} out: {}
mark(for (i in numbers) { val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue }) INIT: in: {} out: {} USE: in: {} out: {}
L4 [body entry point]:
4 mark({ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) continue })
v(val b: Boolean) INIT: in: {i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
mark(if (1 < 2) { b = false } else { b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
v(val b: Boolean) INIT: in: {} out: {b=D}
mark(if (1 < 2) { b = false } else { b = true }) INIT: in: {b=D} out: {b=D}
r(1) -> <v6>
r(2) -> <v7>
mark(1 < 2)
call(1 < 2, compareTo|<v6>, <v7>) -> <v8>
jf(L7|<v8>)
5 mark({ b = false })
r(false) -> <v9> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
w(b|<v9>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
4 jmp(L8) INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=READ, numbers=READ}
r(false) -> <v9> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v9>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
4 jmp(L8) INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ}
L7 [else branch]:
5 mark({ b = true }) INIT: in: {b=D, i=ID, numbers=ID} out: {b=D, i=ID, numbers=ID}
r(true) -> <v11> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
w(b|<v11>) INIT: in: {b=D, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ}
5 mark({ b = true }) INIT: in: {b=D} out: {b=D}
r(true) -> <v11> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ}
w(b|<v11>) INIT: in: {b=D} out: {b=ID} USE: in: {b=READ} out: {b=WRITTEN_AFTER_READ}
L8 ['if' expression result]:
4 merge(if (1 < 2) { b = false } else { b = true }|!<v10>, !<v12>) -> <v13> INIT: in: {b=ID, i=ID, numbers=ID} out: {b=ID, i=ID, numbers=ID} USE: in: {b=READ, numbers=READ} out: {b=READ, numbers=READ}
r(b) -> <v14> USE: in: {numbers=READ} out: {b=READ, numbers=READ}
4 merge(if (1 < 2) { b = false } else { b = true }|!<v10>, !<v12>) -> <v13> INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ}
r(b) -> <v14> USE: in: {} out: {b=READ}
mark(use(b))
call(use(b), use|<v14>) -> <v15>
jmp(L6) USE: in: {numbers=READ} out: {numbers=READ}
jmp(L6) USE: in: {} out: {}
- 3 jmp(L2)
L3 [loop exit point]:
L5 [body exit point]:
read (Unit) INIT: in: {i=ID, numbers=ID} out: {i=ID, numbers=ID}
read (Unit) INIT: in: {} out: {}
L1:
1 <END>
error:
<ERROR>
sink:
<SINK> USE: in: {numbers=READ} out: {numbers=READ}
<SINK> USE: in: {} out: {}
=====================
== use ==
fun use(vararg a: Any?) = a
---------------------
L0:
1 <START> INIT: in: {} out: {}
v(vararg a: Any?) INIT: in: {} out: {a=D}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {a=D} out: {a=D}
w(a|<v0>) INIT: in: {a=D} out: {a=ID}
r(a) -> <v1> INIT: in: {a=ID} out: {a=ID}
v(vararg a: Any?) INIT: in: {} out: {}
magic[FAKE_INITIALIZER](vararg a: Any?) -> <v0> INIT: in: {} out: {}
w(a|<v0>) INIT: in: {} out: {}
r(a) -> <v1> INIT: in: {} out: {}
ret(*|<v1>) L1
L1:
<END>
error:
<ERROR>
sink:
<SINK> USE: in: {a=READ} out: {a=READ}
<SINK> USE: in: {} out: {}
=====================