Dmitry Savvinov
5cb949ad7f
In 1.3, due to changes in language, testdata for some tests can be different from 1.2 We want to simlultaneously test both versions, so instead of fixing language version in such tests, we split them into two: one with fixed 1.2, another with fixed 1.3
506 lines
25 KiB
Plaintext
Vendored
506 lines
25 KiB
Plaintext
Vendored
== println ==
|
|
fun println(obj: Any?) {}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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: {}
|
|
=====================
|
|
== Demo0 ==
|
|
class Demo0 {
|
|
private val some = object {
|
|
fun foo() {
|
|
println(state) // Ok
|
|
}
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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}
|
|
L2 [after local declaration]:
|
|
r(object { fun foo() { println(state) // Ok } }) -> <v0>
|
|
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: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== foo ==
|
|
fun foo() {
|
|
println(state) // Ok
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
mark(println(state))
|
|
call(println(state), println|<v1>) -> <v2>
|
|
L4:
|
|
2 <END>
|
|
error:
|
|
<ERROR>
|
|
sink:
|
|
<SINK> USE: in: {} out: {}
|
|
=====================
|
|
== Demo1 ==
|
|
class Demo1 {
|
|
private val some = object {
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // must be initialized
|
|
}
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
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: {}
|
|
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: {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: {} 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: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== foo ==
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // must be initialized
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
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: {} 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: {} out: {}
|
|
L6 ['if' expression result]:
|
|
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: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
|
|
=====================
|
|
== Demo1A ==
|
|
class Demo1A {
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // Ok
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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}
|
|
L1:
|
|
<END> INIT: in: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== foo ==
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // Ok
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
2 mark({ if (state) state = true println(state) // Ok })
|
|
mark(if (state) state = true)
|
|
magic[IMPLICIT_RECEIVER](state) -> <v0>
|
|
r(state|<v0>) -> <v1>
|
|
jf(L2|<v1>)
|
|
magic[IMPLICIT_RECEIVER](state) -> <v2>
|
|
r(true) -> <v3>
|
|
w(state|<v2>, <v3>)
|
|
jmp(L3)
|
|
L2 [else branch]:
|
|
read (Unit)
|
|
L3 ['if' expression result]:
|
|
merge(if (state) state = true|!<v4>) -> <v5>
|
|
magic[IMPLICIT_RECEIVER](state) -> <v6>
|
|
r(state|<v6>) -> <v7>
|
|
mark(println(state))
|
|
call(println(state), println|<v7>) -> <v8>
|
|
L1:
|
|
1 <END>
|
|
error:
|
|
<ERROR>
|
|
sink:
|
|
<SINK> USE: in: {} out: {}
|
|
=====================
|
|
== Demo2 ==
|
|
class Demo2 {
|
|
private val some = object {
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
else
|
|
state = false
|
|
|
|
println(state) // OK
|
|
}
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
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: {}
|
|
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: {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: {} 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: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== foo ==
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
else
|
|
state = false
|
|
|
|
println(state) // OK
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
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: {} 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: {} 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: {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: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
|
|
=====================
|
|
== Demo3 ==
|
|
class Demo3 {
|
|
private val some = run {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // OK
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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}
|
|
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: {} 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: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== anonymous_0 ==
|
|
{
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // OK
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
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}
|
|
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}
|
|
mark(println(state))
|
|
call(println(state), println|<v7>) -> <v8>
|
|
L4:
|
|
2 <END>
|
|
error:
|
|
<ERROR>
|
|
sink:
|
|
<SINK> USE: in: {} out: {}
|
|
=====================
|
|
== run ==
|
|
fun <T, R> T.run(f: T.() -> R) = f()
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
v(f: T.() -> R) INIT: in: {} out: {}
|
|
magic[FAKE_INITIALIZER](f: T.() -> R) -> <v0> INIT: in: {} out: {}
|
|
w(f|<v0>) INIT: in: {} out: {}
|
|
r(f) -> <v1> INIT: in: {} out: {}
|
|
magic[IMPLICIT_RECEIVER](f()) -> <v2>
|
|
mark(f())
|
|
call(f(), invoke|<v1>, <v2>) -> <v3>
|
|
ret(*|<v3>) L1
|
|
L1:
|
|
<END>
|
|
error:
|
|
<ERROR>
|
|
sink:
|
|
<SINK> USE: in: {} out: {}
|
|
=====================
|
|
== exec ==
|
|
fun <T> exec(f: () -> T): T = f()
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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
|
|
L1:
|
|
<END>
|
|
error:
|
|
<ERROR>
|
|
sink:
|
|
<SINK> USE: in: {} out: {}
|
|
=====================
|
|
== Demo4 ==
|
|
class Demo4 {
|
|
private val some = exec {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // must be initialized
|
|
}
|
|
|
|
private var state: Boolean = true
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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: {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: {} 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: {} 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: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== anonymous_1 ==
|
|
{
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // must be initialized
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
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: {} 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: {} out: {}
|
|
L6 ['if' expression result]:
|
|
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: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
|
|
=====================
|
|
== Demo5 ==
|
|
class Demo5 {
|
|
private var state: Boolean = true
|
|
|
|
private val some = object {
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // OK
|
|
}
|
|
}
|
|
}
|
|
---------------------
|
|
L0:
|
|
1 <START> INIT: in: {} out: {}
|
|
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: {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: {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: {state=ID} out: {state=ID}
|
|
w(some|<v1>) INIT: in: {state=ID} out: {state=ID}
|
|
L1:
|
|
<END> INIT: in: {state=ID} out: {state=ID}
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {}
|
|
=====================
|
|
== foo ==
|
|
fun foo() {
|
|
if (state)
|
|
state = true
|
|
|
|
println(state) // OK
|
|
}
|
|
---------------------
|
|
L3:
|
|
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}
|
|
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}
|
|
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}
|
|
mark(println(state))
|
|
call(println(state), println|<v7>) -> <v8>
|
|
L4:
|
|
2 <END>
|
|
error:
|
|
<ERROR> INIT: in: {} out: {}
|
|
sink:
|
|
<SINK> INIT: in: {state=I} out: {state=I} USE: in: {} out: {}
|
|
=====================
|