diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt index 7acc068c07a..50c804c5f09 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt @@ -67,6 +67,9 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon fun getDeclaredVariables(pseudocode: Pseudocode, includeInsideLocalDeclarations: Boolean): Set = getAllDeclaredVariables(pseudocode, includeInsideLocalDeclarations).allVars + fun isVariableWithTrivialInitializer(variableDescriptor: VariableDescriptor) = + variableDescriptor in rootVariables.valsWithTrivialInitializer + private fun getAllDeclaredVariables(pseudocode: Pseudocode, includeInsideLocalDeclarations: Boolean): VariablesForDeclaration { if (!includeInsideLocalDeclarations) { return getUpperLevelDeclaredVariables(pseudocode) diff --git a/compiler/testData/cfg-variables/basic/ExhaustiveInitialization.instructions b/compiler/testData/cfg-variables/basic/ExhaustiveInitialization.instructions index 8dd64ec31c7..9bb7fb604e4 100644 --- a/compiler/testData/cfg-variables/basic/ExhaustiveInitialization.instructions +++ b/compiler/testData/cfg-variables/basic/ExhaustiveInitialization.instructions @@ -38,66 +38,66 @@ fun foo(dir: Direction): Int { --------------------- L0: 1 INIT: in: {} out: {} - v(dir: Direction) INIT: in: {} out: {dir=D} - magic[FAKE_INITIALIZER](dir: Direction) -> INIT: in: {dir=D} out: {dir=D} - w(dir|) INIT: in: {dir=D} out: {dir=ID} USE: in: {dir=READ} out: {dir=READ} - 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: {dir=ID} out: {dir=ID} - v(val res: Int) INIT: in: {dir=ID} out: {dir=ID, res=D} - mark(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) INIT: in: {dir=ID, res=D} out: {dir=ID, res=D} + v(dir: Direction) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](dir: Direction) -> INIT: in: {} out: {} + w(dir|) 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) -> mark(Direction.NORTH -> res = 1) mark(Direction.NORTH) mark(Direction.NORTH) r(NORTH) -> magic[EQUALS_IN_WHEN_CONDITION](Direction.NORTH|, ) -> - jmp?(L4|) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ} + jmp?(L4|) USE: in: {res=READ} out: {res=READ} L3 ['when' entry body]: - r(1) -> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - w(res|) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} + r(1) -> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} + w(res|) 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: {dir=ID, res=D} out: {dir=ID, res=D} + mark(Direction.SOUTH -> res = 2) INIT: in: {res=D} out: {res=D} mark(Direction.SOUTH) mark(Direction.SOUTH) r(SOUTH) -> magic[EQUALS_IN_WHEN_CONDITION](Direction.SOUTH|, ) -> - jmp?(L6|) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ} + jmp?(L6|) USE: in: {res=READ} out: {res=READ} L5 ['when' entry body]: - r(2) -> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - w(res|) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} + r(2) -> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} + w(res|) 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: {dir=ID, res=D} out: {dir=ID, res=D} + mark(Direction.WEST -> res = 3) INIT: in: {res=D} out: {res=D} mark(Direction.WEST) mark(Direction.WEST) r(WEST) -> magic[EQUALS_IN_WHEN_CONDITION](Direction.WEST|, ) -> - jmp?(L8|) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ} + jmp?(L8|) USE: in: {res=READ} out: {res=READ} L7 ['when' entry body]: - r(3) -> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - w(res|) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} + r(3) -> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} + w(res|) 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: {dir=ID, res=D} out: {dir=ID, res=D} + mark(Direction.EAST -> res = 4) INIT: in: {res=D} out: {res=D} mark(Direction.EAST) mark(Direction.EAST) r(EAST) -> magic[EQUALS_IN_WHEN_CONDITION](Direction.EAST|, ) -> - jmp?(L10|) USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ} + jmp?(L10|) USE: in: {res=READ} out: {res=READ} L9 ['when' entry body]: - r(4) -> USE: in: {dir=READ, res=WRITTEN_AFTER_READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - w(res|) INIT: in: {dir=ID, res=D} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=WRITTEN_AFTER_READ} - jmp(L2) INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} + r(4) -> USE: in: {res=WRITTEN_AFTER_READ} out: {res=WRITTEN_AFTER_READ} + w(res|) 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 }) -> INIT: in: {dir=ID, res=D} out: {dir=ID, res=IED} + magic[EXHAUSTIVE_WHEN_ELSE](when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }) -> 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 }|!, !, !, !) -> INIT: in: {dir=ID, res=ID} out: {dir=ID, res=ID} USE: in: {dir=READ, res=READ} out: {dir=READ, res=READ} - r(res) -> USE: in: {dir=READ} out: {dir=READ, res=READ} + merge(when (dir) { Direction.NORTH -> res = 1 Direction.SOUTH -> res = 2 Direction.WEST -> res = 3 Direction.EAST -> res = 4 }|!, !, !, !) -> INIT: in: {res=ID} out: {res=ID} USE: in: {res=READ} out: {res=READ} + r(res) -> USE: in: {} out: {res=READ} ret(*|) L1 L1: - 1 INIT: in: {dir=ID} out: {dir=ID} + 1 INIT: in: {} out: {} error: sink: - USE: in: {dir=READ} out: {dir=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions b/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions index beda1c7afb7..d4606e0ae29 100644 --- a/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions +++ b/compiler/testData/cfg-variables/basic/IfWithUninitialized.instructions @@ -42,15 +42,15 @@ fun use(vararg a: Any?) = a --------------------- L0: 1 INIT: in: {} out: {} - v(vararg a: Any?) INIT: in: {} out: {a=D} - magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - r(a) -> INIT: in: {a=ID} out: {a=ID} + v(vararg a: Any?) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + r(a) -> INIT: in: {} out: {} ret(*|) L1 L1: error: sink: - USE: in: {a=READ} out: {a=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions index 87f08e33434..3316e336849 100644 --- a/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions +++ b/compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.instructions @@ -10,22 +10,22 @@ fun foo() { L0: 1 INIT: in: {} out: {} 2 mark({ val a = 1 val f = { x: Int -> val y = x + a use(a) } }) - v(val a = 1) INIT: in: {} out: {a=D} - r(1) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - v(val f = { x: Int -> val y = x + a use(a) }) INIT: in: {a=ID} out: {a=ID, f=D} - mark({ x: Int -> val y = x + a use(a) }) INIT: in: {a=ID, f=D} out: {a=ID, f=D} + v(val a = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + v(val f = { x: Int -> val y = x + a use(a) }) INIT: in: {} out: {} + mark({ x: Int -> val y = x + a use(a) }) INIT: in: {} out: {} jmp?(L2) - d({ x: Int -> val y = x + a use(a) }) INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=D, x=ID, y=ID} + d({ x: Int -> val y = x + a use(a) }) INIT: in: {} out: {} L2 [after local declaration]: r({ x: Int -> val y = x + a use(a) }) -> - w(f|) INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=ID, x=ID, y=ID} + w(f|) INIT: in: {} out: {} L1: - 1 INIT: in: {a=ID, f=ID, x=ID, y=ID} out: {a=ID, f=ID, x=ID, y=ID} + 1 INIT: in: {} out: {} error: sink: - USE: in: {a=READ, x=READ} out: {a=READ, x=READ} + USE: in: {} out: {} ===================== == anonymous_0 == { x: Int -> @@ -34,18 +34,18 @@ sink: } --------------------- L3: - 3 INIT: in: {a=ID, f=D} out: {a=ID, f=D} - v(x: Int) INIT: in: {a=ID, f=D} out: {a=ID, f=D, x=D} - magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {a=ID, f=D, x=D} out: {a=ID, f=D, x=D} - w(x|) INIT: in: {a=ID, f=D, x=D} out: {a=ID, f=D, x=ID} - 4 mark(val y = x + a use(a)) INIT: in: {a=ID, f=D, x=ID} out: {a=ID, f=D, x=ID} - v(val y = x + a) INIT: in: {a=ID, f=D, x=ID} out: {a=ID, f=D, x=ID, y=D} - r(x) -> INIT: in: {a=ID, f=D, x=ID, y=D} out: {a=ID, f=D, x=ID, y=D} + 3 INIT: in: {} out: {} + v(x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 4 mark(val y = x + a use(a)) INIT: in: {} out: {} + v(val y = x + a) INIT: in: {} out: {} + r(x) -> INIT: in: {} out: {} r(a) -> mark(x + a) call(x + a, plus|, ) -> - w(y|) INIT: in: {a=ID, f=D, x=ID, y=D} out: {a=ID, f=D, x=ID, y=ID} - r(a) -> INIT: in: {a=ID, f=D, x=ID, y=ID} out: {a=ID, f=D, x=ID, y=ID} + w(y|) INIT: in: {} out: {} + r(a) -> INIT: in: {} out: {} mark(use(a)) call(use(a), use|) -> 3 ret(*|) L4 @@ -54,22 +54,22 @@ L4: error: sink: - USE: in: {a=READ, x=READ} out: {a=READ, x=READ} + USE: in: {} out: {} ===================== == use == fun use(vararg a: Any?) = a --------------------- L0: 1 INIT: in: {} out: {} - v(vararg a: Any?) INIT: in: {} out: {a=D} - magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - r(a) -> INIT: in: {a=ID} out: {a=ID} + v(vararg a: Any?) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + r(a) -> INIT: in: {} out: {} ret(*|) L1 L1: error: sink: - USE: in: {a=READ} out: {a=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/basic/UseUninitializedInLambda.instructions b/compiler/testData/cfg-variables/basic/UseUninitializedInLambda.instructions index 620d1e9dc27..aadd7c026d2 100644 --- a/compiler/testData/cfg-variables/basic/UseUninitializedInLambda.instructions +++ b/compiler/testData/cfg-variables/basic/UseUninitializedInLambda.instructions @@ -3,10 +3,10 @@ fun bar(f: () -> Unit) = f() --------------------- L0: 1 INIT: in: {} out: {} - v(f: () -> Unit) INIT: in: {} out: {f=D} - magic[FAKE_INITIALIZER](f: () -> Unit) -> INIT: in: {f=D} out: {f=D} - w(f|) INIT: in: {f=D} out: {f=ID} - r(f) -> INIT: in: {f=ID} out: {f=ID} + v(f: () -> Unit) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](f: () -> Unit) -> INIT: in: {} out: {} + w(f|) INIT: in: {} out: {} + r(f) -> INIT: in: {} out: {} mark(f()) call(f(), invoke|) -> ret(*|) L1 @@ -15,7 +15,7 @@ L1: error: sink: - USE: in: {f=READ} out: {f=READ} + USE: in: {} out: {} ===================== == foo == fun foo() { diff --git a/compiler/testData/cfg-variables/basic/VariablesInitialization.instructions b/compiler/testData/cfg-variables/basic/VariablesInitialization.instructions index 7ffbbe6a3e5..9d344f7e2dc 100644 --- a/compiler/testData/cfg-variables/basic/VariablesInitialization.instructions +++ b/compiler/testData/cfg-variables/basic/VariablesInitialization.instructions @@ -7,21 +7,21 @@ fun foo() { } --------------------- L0: - 1 INIT: in: {} out: {} USE: in: {} out: {} + 1 INIT: in: {} out: {} USE: in: {} out: {} 2 mark({ val a = 1 val b: Int b = 2 42 }) - v(val a = 1) INIT: in: {} out: {a=D} - r(1) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - v(val b: Int) INIT: in: {a=ID} out: {a=ID, b=D} - r(2) -> INIT: in: {a=ID, b=D} out: {a=ID, b=D} USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ} - w(b|) INIT: in: {a=ID, b=D} out: {a=ID, b=ID} USE: in: {} out: {b=ONLY_WRITTEN_NEVER_READ} - r(42) -> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID} + v(val a = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + v(val b: Int) INIT: in: {} out: {b=D} + r(2) -> INIT: in: {b=D} out: {b=D} USE: in: {b=ONLY_WRITTEN_NEVER_READ} out: {b=ONLY_WRITTEN_NEVER_READ} + w(b|) INIT: in: {b=D} out: {b=ID} USE: in: {} out: {b=ONLY_WRITTEN_NEVER_READ} + r(42) -> INIT: in: {b=ID} out: {b=ID} L1: - 1 INIT: in: {a=ID} out: {a=ID} + 1 INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == bar == fun bar(foo: Foo) { @@ -32,10 +32,10 @@ fun bar(foo: Foo) { --------------------- L0: 1 INIT: in: {} out: {} - v(foo: Foo) INIT: in: {} out: {foo=D} - magic[FAKE_INITIALIZER](foo: Foo) -> INIT: in: {foo=D} out: {foo=D} - w(foo|) INIT: in: {foo=D} out: {foo=ID} - 2 mark({ foo.c foo.c = 2 42 }) INIT: in: {foo=ID} out: {foo=ID} + v(foo: Foo) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](foo: Foo) -> INIT: in: {} out: {} + w(foo|) INIT: in: {} out: {} + 2 mark({ foo.c foo.c = 2 42 }) INIT: in: {} out: {} mark(foo.c) r(foo) -> r(c|) -> @@ -48,7 +48,7 @@ L1: error: sink: - USE: in: {foo=READ} out: {foo=READ} + USE: in: {} out: {} ===================== == Foo == interface Foo { @@ -57,11 +57,11 @@ interface Foo { --------------------- L0: 1 INIT: in: {} out: {} - v(var c: Int) INIT: in: {} out: {c=D} + v(var c: Int) INIT: in: {} out: {} L1: - INIT: in: {c=D} out: {c=D} + INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/basic/VariablesUsage.instructions b/compiler/testData/cfg-variables/basic/VariablesUsage.instructions index faae6aef3d4..120ab47ef92 100644 --- a/compiler/testData/cfg-variables/basic/VariablesUsage.instructions +++ b/compiler/testData/cfg-variables/basic/VariablesUsage.instructions @@ -51,15 +51,15 @@ fun use(a: Int) = a --------------------- L0: 1 INIT: in: {} out: {} - v(a: Int) INIT: in: {} out: {a=D} - magic[FAKE_INITIALIZER](a: Int) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - r(a) -> INIT: in: {a=ID} out: {a=ID} + v(a: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](a: Int) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + r(a) -> INIT: in: {} out: {} ret(*|) L1 L1: error: sink: - USE: in: {a=READ} out: {a=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/kt10243.instructions b/compiler/testData/cfg-variables/bugs/kt10243.instructions index 17044411ec6..f350f845553 100644 --- a/compiler/testData/cfg-variables/bugs/kt10243.instructions +++ b/compiler/testData/cfg-variables/bugs/kt10243.instructions @@ -25,10 +25,10 @@ fun foo(f: Boolean) { --------------------- L0: 1 INIT: in: {} out: {} - v(f: Boolean) INIT: in: {} out: {f=D} - magic[FAKE_INITIALIZER](f: Boolean) -> INIT: in: {f=D} out: {f=D} - w(f|) 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) -> INIT: in: {} out: {} + w(f|) 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: sink: - USE: in: {f=READ} out: {f=READ} + USE: in: {} out: {} ===================== == bar == fun bar() {} --------------------- L8: - 4 INIT: in: {f=ID} out: {f=ID} + 4 INIT: in: {} out: {} 5 mark({}) read (Unit) L9: @@ -79,13 +79,13 @@ L9: error: sink: - USE: in: {f=READ} out: {f=READ} + USE: in: {} out: {} ===================== == bar == fun bar() {} --------------------- L2 [copy of L8, null]: - 4 INIT: in: {f=ID} out: {f=ID} + 4 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]: L1 [copy of sink, null]: - USE: in: {f=READ} out: {f=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/kt4764.instructions b/compiler/testData/cfg-variables/bugs/kt4764.instructions index 90955a7ed90..cca1dbf8cb7 100644 --- a/compiler/testData/cfg-variables/bugs/kt4764.instructions +++ b/compiler/testData/cfg-variables/bugs/kt4764.instructions @@ -39,7 +39,7 @@ L4 [start finally]: 5 mark({}) read (Unit) L5 [finish finally]: - 4 ret(*|) L1 USE: in: {} out: {} + 4 ret(*|) 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) -> - jf(L8|) USE: in: {} out: {} + jf(L8|) 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) -> INIT: in: {foo=D} out: {foo=D} w(foo|) 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") -> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ} - w(foo|) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ} + r("test") -> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ} + w(foo|) 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) -> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID} - w(e|) 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) -> INIT: in: {foo=ID} out: {foo=ID} + w(e|) INIT: in: {foo=ID} out: {foo=ID} + 8 mark({ return "fail" }) INIT: in: {foo=ID} out: {foo=ID} jmp?(L2) mark("fail") r("fail") -> L12 [start finally]: - 9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ} - r(foo) -> USE: in: {} out: {foo=READ} + 9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ} + r(foo) -> USE: in: {} out: {foo=READ} mark(println(foo)) magic[UNRESOLVED_CALL](println(foo)|, !) -> L13 [finish finally]: - 5 mark({}) INIT: in: {e=ID} out: {e=ID} + 5 mark({}) INIT: in: {} out: {} read (Unit) - 8 ret(*|) L1 USE: in: {} out: {} + 8 ret(*|) 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) -> USE: in: {} out: {foo=READ} + 9 mark({ println(foo) // Variable 'foo' must be initialized }) USE: in: {foo=READ} out: {foo=READ} + r(foo) -> USE: in: {} out: {foo=READ} mark(println(foo)) magic[UNRESOLVED_CALL](println(foo)|, !) -> - 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) -> 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) -> USE: in: {} out: {foo=READ} mark(println(foo)) magic[UNRESOLVED_CALL](println(foo)|, !) -> 6 merge(try { foo = "test" } catch (e: Exception) { return "fail" } finally { println(foo) // Variable 'foo' must be initialized }|!, !) -> - 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") -> mark({}) read (Unit) - ret(*|) L1 USE: in: {} out: {} + ret(*|) 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" }|!) -> L6 ['if' expression result]: @@ -133,5 +133,5 @@ L1: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/kt5469.instructions b/compiler/testData/cfg-variables/bugs/kt5469.instructions index 6b5d5fd7807..2bffc859dba 100644 --- a/compiler/testData/cfg-variables/bugs/kt5469.instructions +++ b/compiler/testData/cfg-variables/bugs/kt5469.instructions @@ -10,38 +10,38 @@ fun f() { } --------------------- L0: - 1 INIT: in: {} out: {} USE: in: {} out: {} + 1 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) -> INIT: in: {foo=D} out: {foo=D} w(foo|) 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) -> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ} - w(foo|) USE: in: {foo=READ} out: {foo=WRITTEN_AFTER_READ} + r(2) -> USE: in: {foo=WRITTEN_AFTER_READ} out: {foo=WRITTEN_AFTER_READ} + w(foo|) 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(), ) -> - throw (throw RuntimeException()|) USE: in: {} out: {} + throw (throw RuntimeException()|) 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) -> INIT: in: {e=D, foo=ID} out: {e=D, foo=ID} - w(e|) 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) -> USE: in: {} out: {foo=READ} + 3 v(e: Throwable) INIT: in: {foo=ID} out: {foo=ID} + magic[FAKE_INITIALIZER](e: Throwable) -> INIT: in: {foo=ID} out: {foo=ID} + w(e|) 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) -> USE: in: {} out: {foo=READ} mark(println(foo)) magic[UNRESOLVED_CALL](println(foo)|, !) -> 3 jmp(L3) L3 [afterCatches]: 2 merge(try { foo = 2 throw RuntimeException() } catch (e: Throwable) { println(foo) }|!, ) -> L1: - 1 INIT: in: {e=ID} out: {e=ID} + 1 INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions b/compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions index 29e878038e6..72611e50337 100644 --- a/compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions +++ b/compiler/testData/cfg-variables/bugs/localObjectInConstructor.instructions @@ -3,17 +3,17 @@ fun println(obj: Any?) {} --------------------- L0: 1 INIT: in: {} out: {} - v(obj: Any?) INIT: in: {} out: {obj=D} - magic[FAKE_INITIALIZER](obj: Any?) -> INIT: in: {obj=D} out: {obj=D} - w(obj|) 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?) -> INIT: in: {} out: {} + w(obj|) INIT: in: {} out: {} + 2 mark({}) INIT: in: {} out: {} read (Unit) L1: 1 error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == Demo0 == class Demo0 { @@ -28,22 +28,22 @@ class Demo0 { --------------------- L0: 1 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 } }) -> - w(some|) INIT: in: {some=D} out: {some=ID} - v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D} - r(true) -> INIT: in: {some=ID, state=D} out: {some=ID, state=D} - w(state|) INIT: in: {some=ID, state=D} out: {some=ID, state=ID} + w(some|) INIT: in: {} out: {} + v(private var state: Boolean = true) INIT: in: {} out: {state=D} + r(true) -> INIT: in: {state=D} out: {state=D} + w(state|) INIT: in: {state=D} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == foo == fun foo() { @@ -51,10 +51,10 @@ fun foo() { } --------------------- L3: - 2 INIT: in: {some=D} out: {some=D} + 2 INIT: in: {} out: {} 3 mark({ println(state) // Ok }) - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: @@ -62,7 +62,7 @@ L4: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == Demo1 == class Demo1 { @@ -80,22 +80,22 @@ class Demo1 { --------------------- L0: 1 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 } }) -> INIT: in: {some=D} out: {some=D} - w(some|) INIT: in: {some=D} out: {some=ID} - v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D} - r(true) -> INIT: in: {some=ID, state=D} out: {some=ID, state=D} - w(state|) INIT: in: {some=ID, state=D} out: {some=ID, state=ID} + r(object { fun foo() { if (state) state = true println(state) // must be initialized } }) -> INIT: in: {} out: {} + w(some|) INIT: in: {} out: {} + v(private var state: Boolean = true) INIT: in: {} out: {state=D} + r(true) -> INIT: in: {state=D} out: {state=D} + w(state|) INIT: in: {state=D} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == foo == fun foo() { @@ -106,30 +106,30 @@ fun foo() { } --------------------- L3: - 2 INIT: in: {some=D} out: {some=D} + 2 INIT: in: {} out: {} 3 mark({ if (state) state = true println(state) // must be initialized }) mark(if (state) state = true) magic[IMPLICIT_RECEIVER](state) -> r(state|) -> - jf(L5|) USE: in: {state=READ} out: {state=READ} + jf(L5|) USE: in: {state=READ} out: {state=READ} magic[IMPLICIT_RECEIVER](state) -> - r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) 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) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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|!) -> INIT: in: {some=D, state=I} out: {some=D, state=I} - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + merge(if (state) state = true|!) -> INIT: in: {state=I} out: {state=I} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: 2 error: - INIT: in: {some=D} out: {some=D} + INIT: in: {} out: {} sink: - INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {} + INIT: in: {state=I} out: {state=I} USE: in: {} out: {} ===================== == Demo1A == class Demo1A { @@ -207,22 +207,22 @@ class Demo2 { --------------------- L0: 1 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 } }) -> INIT: in: {some=D} out: {some=D} - w(some|) INIT: in: {some=D} out: {some=ID} - v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D} - r(true) -> INIT: in: {some=ID, state=D} out: {some=ID, state=D} - w(state|) 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 } }) -> INIT: in: {} out: {} + w(some|) INIT: in: {} out: {} + v(private var state: Boolean = true) INIT: in: {} out: {state=D} + r(true) -> INIT: in: {state=D} out: {state=D} + w(state|) INIT: in: {state=D} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == foo == fun foo() { @@ -235,32 +235,32 @@ fun foo() { } --------------------- L3: - 2 INIT: in: {some=D} out: {some=D} + 2 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) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=READ} jf(L5|) magic[IMPLICIT_RECEIVER](state) -> - r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) 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) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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) -> INIT: in: {some=D} out: {some=D} - r(false) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) INIT: in: {some=D} out: {some=D, state=I} USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ} + magic[IMPLICIT_RECEIVER](state) -> INIT: in: {} out: {} + r(false) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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|!, !) -> INIT: in: {some=D, state=I} out: {some=D, state=I} - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + merge(if (state) state = true else state = false|!, !) -> INIT: in: {state=I} out: {state=I} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: 2 error: - INIT: in: {some=D} out: {some=D} + INIT: in: {} out: {} sink: - INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {} + INIT: in: {state=I} out: {state=I} USE: in: {} out: {} ===================== == Demo3 == class Demo3 { @@ -276,25 +276,25 @@ class Demo3 { --------------------- L0: 1 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 }) -> 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 }) -> 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 }) -> mark(run { if (state) state = true println(state) // OK }) call(run { if (state) state = true println(state) // OK }, run|, ) -> - w(some|) INIT: in: {some=D} out: {some=ID} - v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D} - r(true) -> INIT: in: {some=ID, state=D} out: {some=ID, state=D} - w(state|) INIT: in: {some=ID, state=D} out: {some=ID, state=ID} + w(some|) INIT: in: {} out: {} + v(private var state: Boolean = true) INIT: in: {} out: {state=D} + r(true) -> INIT: in: {state=D} out: {state=D} + w(state|) INIT: in: {state=D} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == anonymous_0 == { @@ -305,22 +305,22 @@ sink: } --------------------- L3: - 2 INIT: in: {some=D} out: {some=D} + 2 INIT: in: {} out: {} 3 mark(if (state) state = true println(state) // OK) mark(if (state) state = true) magic[IMPLICIT_RECEIVER](state) -> r(state|) -> - jf(L5|) USE: in: {state=READ} out: {state=READ} + jf(L5|) USE: in: {state=READ} out: {state=READ} magic[IMPLICIT_RECEIVER](state) -> - r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ} + r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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|!) -> - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: @@ -328,17 +328,17 @@ L4: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == exec == fun exec(f: () -> T): T = f() --------------------- L0: 1 INIT: in: {} out: {} - v(f: () -> T) INIT: in: {} out: {f=D} - magic[FAKE_INITIALIZER](f: () -> T) -> INIT: in: {f=D} out: {f=D} - w(f|) INIT: in: {f=D} out: {f=ID} - r(f) -> INIT: in: {f=ID} out: {f=ID} + v(f: () -> T) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](f: () -> T) -> INIT: in: {} out: {} + w(f|) INIT: in: {} out: {} + r(f) -> INIT: in: {} out: {} mark(f()) call(f(), invoke|) -> ret(*|) L1 @@ -347,7 +347,7 @@ L1: error: sink: - USE: in: {f=READ} out: {f=READ} + USE: in: {} out: {} ===================== == Demo4 == class Demo4 { @@ -363,24 +363,24 @@ class Demo4 { --------------------- L0: 1 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 }) -> INIT: in: {some=D} out: {some=D} + r({ if (state) state = true println(state) // must be initialized }) -> 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|) -> - w(some|) INIT: in: {some=D} out: {some=ID} - v(private var state: Boolean = true) INIT: in: {some=ID} out: {some=ID, state=D} - r(true) -> INIT: in: {some=ID, state=D} out: {some=ID, state=D} - w(state|) INIT: in: {some=ID, state=D} out: {some=ID, state=ID} + w(some|) INIT: in: {} out: {} + v(private var state: Boolean = true) INIT: in: {} out: {state=D} + r(true) -> INIT: in: {state=D} out: {state=D} + w(state|) INIT: in: {state=D} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == anonymous_1 == { @@ -391,30 +391,30 @@ sink: } --------------------- L3: - 2 INIT: in: {some=D} out: {some=D} + 2 INIT: in: {} out: {} 3 mark(if (state) state = true println(state) // must be initialized) mark(if (state) state = true) magic[IMPLICIT_RECEIVER](state) -> r(state|) -> - jf(L5|) USE: in: {state=READ} out: {state=READ} + jf(L5|) USE: in: {state=READ} out: {state=READ} magic[IMPLICIT_RECEIVER](state) -> - r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) 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) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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|!) -> INIT: in: {some=D, state=I} out: {some=D, state=I} - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + merge(if (state) state = true|!) -> INIT: in: {state=I} out: {state=I} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: 2 error: - INIT: in: {some=D} out: {some=D} + INIT: in: {} out: {} sink: - INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {} + 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) -> INIT: in: {state=D} out: {state=D} w(state|) 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 } }) -> INIT: in: {some=D, state=ID} out: {some=D, state=ID} - w(some|) INIT: in: {some=D, state=ID} out: {some=ID, state=ID} + r(object { fun foo() { if (state) state = true println(state) // OK } }) -> INIT: in: {state=ID} out: {state=ID} + w(some|) INIT: in: {state=ID} out: {state=ID} L1: - INIT: in: {some=ID, state=ID} out: {some=ID, state=ID} + INIT: in: {state=ID} out: {state=ID} error: - INIT: in: {some=ID} out: {some=ID} + INIT: in: {} out: {} sink: - INIT: in: {some=ID, state=I?} out: {some=ID, state=I?} USE: in: {} out: {} + INIT: in: {state=I?} out: {state=I?} USE: in: {} out: {} ===================== == foo == fun foo() { @@ -458,28 +458,28 @@ fun foo() { } --------------------- L3: - 2 INIT: in: {some=D, state=ID} out: {some=D, state=ID} + 2 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) -> r(state|) -> - jf(L5|) USE: in: {state=READ} out: {state=READ} + jf(L5|) USE: in: {state=READ} out: {state=READ} magic[IMPLICIT_RECEIVER](state) -> - r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} - w(state|, ) USE: in: {state=READ} out: {state=WRITTEN_AFTER_READ} + r(true) -> USE: in: {state=WRITTEN_AFTER_READ} out: {state=WRITTEN_AFTER_READ} + w(state|, ) 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|!) -> - magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} - r(state|) -> USE: in: {} out: {state=READ} + magic[IMPLICIT_RECEIVER](state) -> USE: in: {state=READ} out: {state=READ} + r(state|) -> USE: in: {} out: {state=READ} mark(println(state)) call(println(state), println|) -> L4: 2 error: - INIT: in: {some=D} out: {some=D} + INIT: in: {} out: {} sink: - INIT: in: {some=D, state=I} out: {some=D, state=I} USE: in: {} out: {} + INIT: in: {state=I} out: {state=I} USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions index 290a82da3e3..bbac4a9a2a7 100644 --- a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions +++ b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions @@ -7,19 +7,19 @@ class TestFunctionLiteral { --------------------- L0: 1 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 }) -> - w(sum|) INIT: in: {sum=D, x=ID} out: {sum=ID, x=ID} + w(sum|) INIT: in: {} out: {} L1: - INIT: in: {sum=ID, x=ID} out: {sum=ID, x=ID} + INIT: in: {} out: {} error: sink: - USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ} + USE: in: {} out: {} ===================== == anonymous_0 == { x: Int -> @@ -27,11 +27,11 @@ sink: } --------------------- L3: - 2 INIT: in: {sum=D} out: {sum=D} - v(x: Int) INIT: in: {sum=D} out: {sum=D, x=D} - magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {sum=D, x=D} out: {sum=D, x=D} - w(x|) 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 INIT: in: {} out: {} + v(x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 3 mark(sum(x - 1) + x) INIT: in: {} out: {} magic[IMPLICIT_RECEIVER](sum) -> r(sum|) -> r(x) -> @@ -49,22 +49,22 @@ L4: error: sink: - USE: in: {sum=READ, x=READ} out: {sum=READ, x=READ} + USE: in: {} out: {} ===================== == A == open class A(val a: A) --------------------- L0: 1 INIT: in: {} out: {} - v(val a: A) INIT: in: {} out: {a=D} - magic[FAKE_INITIALIZER](val a: A) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} + v(val a: A) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](val a: A) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} L1: - INIT: in: {a=ID} out: {a=ID} + INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == TestObjectLiteral == class TestObjectLiteral { @@ -80,28 +80,28 @@ class TestObjectLiteral { --------------------- L0: 1 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) -> r(obj|) -> mark(A(obj)) call(A(obj), |) -> 2 mark({ val x = obj }) - v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D} - magic[IMPLICIT_RECEIVER](obj) -> INIT: in: {obj=D, x=D} out: {obj=D, x=D} + v(val x = obj) INIT: in: {} out: {} + magic[IMPLICIT_RECEIVER](obj) -> INIT: in: {} out: {} r(obj|) -> - w(x|) 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|) 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 } }) -> - w(obj|) INIT: in: {obj=D, x=ID, y=ID} out: {obj=ID, x=ID, y=ID} + w(obj|) INIT: in: {} out: {} L1: - INIT: in: {obj=ID, x=ID, y=ID} out: {obj=ID, x=ID, y=ID} + INIT: in: {} out: {} error: sink: - USE: in: {obj=READ} out: {obj=READ} + USE: in: {} out: {} ===================== == foo == fun foo() { @@ -109,18 +109,18 @@ fun foo() { } --------------------- L3: - 2 INIT: in: {obj=D, x=ID} out: {obj=D, x=ID} + 2 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) -> 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) -> INIT: in: {} out: {} r(obj|) -> - w(y|) INIT: in: {obj=D, x=ID, y=D} out: {obj=D, x=ID, y=ID} + w(y|) INIT: in: {} out: {} L4: - 2 INIT: in: {obj=D, x=ID, y=ID} out: {obj=D, x=ID, y=ID} + 2 INIT: in: {} out: {} error: sink: - USE: in: {obj=READ} out: {obj=READ} + USE: in: {} out: {} ===================== == TestOther == class TestOther { @@ -129,17 +129,17 @@ class TestOther { --------------------- L0: 1 INIT: in: {} out: {} - v(val x: Int = x + 1) INIT: in: {} out: {x=D} - magic[IMPLICIT_RECEIVER](x) -> INIT: in: {x=D} out: {x=D} + v(val x: Int = x + 1) INIT: in: {} out: {} + magic[IMPLICIT_RECEIVER](x) -> INIT: in: {} out: {} r(x|) -> r(1) -> mark(x + 1) call(x + 1, plus|, ) -> - w(x|) INIT: in: {x=D} out: {x=ID} + w(x|) INIT: in: {} out: {} L1: - INIT: in: {x=ID} out: {x=ID} + INIT: in: {} out: {} error: sink: - USE: in: {x=READ} out: {x=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions index d5bd6fcf516..90cc8f2a78b 100644 --- a/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions +++ b/compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.instructions @@ -15,72 +15,72 @@ fun foo(numbers: Collection) { --------------------- L0: 1 INIT: in: {} out: {} - v(numbers: Collection) INIT: in: {} out: {numbers=D} - magic[FAKE_INITIALIZER](numbers: Collection) -> INIT: in: {numbers=D} out: {numbers=D} - w(numbers|) 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) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](numbers: Collection) -> INIT: in: {} out: {} + w(numbers|) 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) -> mark(numbers) call(numbers, iterator|) -> - 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) -> jmp?(L3) mark(numbers) call(numbers, next) -> magic[LOOP_RANGE_ITERATION](numbers|) -> - w(i|) 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|) 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) -> r(2) -> mark(1 < 2) call(1 < 2, compareTo|, ) -> jf(L7|) 5 mark({ b = false }) - r(false) -> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ} - w(b|) 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) -> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} + w(b|) 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) -> USE: in: {b=WRITTEN_AFTER_READ, numbers=READ} out: {b=WRITTEN_AFTER_READ, numbers=READ} - w(b|) 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) -> USE: in: {b=WRITTEN_AFTER_READ} out: {b=WRITTEN_AFTER_READ} + w(b|) 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 }|!, !) -> 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) -> USE: in: {numbers=READ} out: {b=READ, numbers=READ} + 4 merge(if (1 < 2) { b = false } else { b = true }|!, !) -> INIT: in: {b=ID} out: {b=ID} USE: in: {b=READ} out: {b=READ} + r(b) -> USE: in: {} out: {b=READ} mark(use(b)) call(use(b), use|) -> - 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 error: sink: - USE: in: {numbers=READ} out: {numbers=READ} + USE: in: {} out: {} ===================== == use == fun use(vararg a: Any?) = a --------------------- L0: 1 INIT: in: {} out: {} - v(vararg a: Any?) INIT: in: {} out: {a=D} - magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - r(a) -> INIT: in: {a=ID} out: {a=ID} + v(vararg a: Any?) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](vararg a: Any?) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + r(a) -> INIT: in: {} out: {} ret(*|) L1 L1: error: sink: - USE: in: {a=READ} out: {a=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions index b35b6d17eec..d82f2aac219 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/forScope.instructions @@ -18,23 +18,23 @@ L0: call(1..10, rangeTo|, ) -> mark(1..10) call(1..10, iterator|) -> - v(i) INIT: in: {} out: {i=D} + v(i) INIT: in: {} out: {} L2 [loop entry point]: L6 [condition entry point]: - mark(1..10) INIT: in: {i=D} out: {i=D} + mark(1..10) INIT: in: {} out: {} call(1..10, hasNext) -> jmp?(L3) mark(1..10) call(1..10, next) -> magic[LOOP_RANGE_ITERATION](1..10|) -> - w(i|) INIT: in: {i=D} out: {i=ID} - mark(for (i in 1..10) { val a = i }) INIT: in: {i=ID} out: {i=ID} + w(i|) INIT: in: {} out: {} + mark(for (i in 1..10) { val a = i }) INIT: in: {} out: {} L4 [body entry point]: 4 mark({ val a = i }) - v(val a = i) INIT: in: {i=ID} out: {a=D, i=ID} - r(i) -> INIT: in: {a=D, i=ID} out: {a=D, i=ID} - w(a|) INIT: in: {a=D, i=ID} out: {a=ID, i=ID} - 3 jmp(L2) INIT: in: {a=ID, i=ID} out: {a=ID, i=ID} + v(val a = i) INIT: in: {} out: {} + r(i) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + 3 jmp(L2) INIT: in: {} out: {} L3 [loop exit point]: L5 [body exit point]: read (Unit) @@ -45,5 +45,5 @@ L1: error: sink: - USE: in: {i=READ} out: {i=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions index a2f2b273c00..cf296215eb8 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.instructions @@ -13,24 +13,24 @@ L0: 2 mark({ "before" val b = 1 val f = { x: Int -> val a = x + b } "after" }) mark("before") r("before") -> - v(val b = 1) INIT: in: {} out: {b=D} - r(1) -> INIT: in: {b=D} out: {b=D} - w(b|) INIT: in: {b=D} out: {b=ID} - v(val f = { x: Int -> val a = x + b }) INIT: in: {b=ID} out: {b=ID, f=D} - mark({ x: Int -> val a = x + b }) INIT: in: {b=ID, f=D} out: {b=ID, f=D} + v(val b = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(b|) INIT: in: {} out: {} + v(val f = { x: Int -> val a = x + b }) INIT: in: {} out: {} + mark({ x: Int -> val a = x + b }) INIT: in: {} out: {} jmp?(L2) - d({ x: Int -> val a = x + b }) INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID} + d({ x: Int -> val a = x + b }) INIT: in: {} out: {} L2 [after local declaration]: r({ x: Int -> val a = x + b }) -> - w(f|) INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=ID, x=ID} - mark("after") INIT: in: {a=ID, b=ID, f=ID, x=ID} out: {a=ID, b=ID, f=ID, x=ID} + w(f|) INIT: in: {} out: {} + mark("after") INIT: in: {} out: {} r("after") -> L1: 1 error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== == anonymous_0 == { x: Int -> @@ -38,21 +38,21 @@ sink: } --------------------- L3: - 3 INIT: in: {b=ID, f=D} out: {b=ID, f=D} - v(x: Int) INIT: in: {b=ID, f=D} out: {b=ID, f=D, x=D} - magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {b=ID, f=D, x=D} out: {b=ID, f=D, x=D} - w(x|) INIT: in: {b=ID, f=D, x=D} out: {b=ID, f=D, x=ID} - 4 mark(val a = x + b) INIT: in: {b=ID, f=D, x=ID} out: {b=ID, f=D, x=ID} - v(val a = x + b) INIT: in: {b=ID, f=D, x=ID} out: {a=D, b=ID, f=D, x=ID} - r(x) -> INIT: in: {a=D, b=ID, f=D, x=ID} out: {a=D, b=ID, f=D, x=ID} + 3 INIT: in: {} out: {} + v(x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 4 mark(val a = x + b) INIT: in: {} out: {} + v(val a = x + b) INIT: in: {} out: {} + r(x) -> INIT: in: {} out: {} r(b) -> mark(x + b) call(x + b, plus|, ) -> - w(a|) INIT: in: {a=D, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID} + w(a|) INIT: in: {} out: {} L4: - 3 INIT: in: {a=ID, b=ID, f=D, x=ID} out: {a=ID, b=ID, f=D, x=ID} + 3 INIT: in: {} out: {} error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions index dc8eab83f12..b8680fc8589 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/ifScope.instructions @@ -19,17 +19,17 @@ L0: r(true) -> jf(L2|) 3 mark({ val a = 1 }) - v(val a = 1) INIT: in: {} out: {a=D} - r(1) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - 2 jmp(L3) INIT: in: {a=ID} out: {a=ID} + v(val a = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + 2 jmp(L3) INIT: in: {} out: {} L2 [else branch]: 3 mark({ val b = 2 }) - v(val b = 2) INIT: in: {a=ID} out: {a=ID, b=D} - r(2) -> INIT: in: {a=ID, b=D} out: {a=ID, b=D} - w(b|) INIT: in: {a=ID, b=D} out: {a=ID, b=ID} + v(val b = 2) INIT: in: {} out: {} + r(2) -> INIT: in: {} out: {} + w(b|) INIT: in: {} out: {} L3 ['if' expression result]: - 2 merge(if (true) { val a = 1 } else { val b = 2 }|!, !) -> INIT: in: {a=ID, b=ID} out: {a=ID, b=ID} + 2 merge(if (true) { val a = 1 } else { val b = 2 }|!, !) -> INIT: in: {} out: {} mark("after") r("after") -> L1: @@ -37,5 +37,5 @@ L1: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/localClass.instructions b/compiler/testData/cfg-variables/lexicalScopes/localClass.instructions index 19bc56d1c05..e4568fcd064 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/localClass.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/localClass.instructions @@ -18,16 +18,16 @@ L0: mark("before") r("before") -> jmp?(L2) - v(val x: Int) INIT: in: {} out: {x=D} - magic[FAKE_INITIALIZER](val x: Int) -> INIT: in: {x=D} out: {x=D} - w(x|) INIT: in: {x=D} out: {x=ID} - 3 mark({ val a = x }) INIT: in: {x=ID} out: {x=ID} - v(val a = x) INIT: in: {x=ID} out: {a=D, x=ID} - magic[IMPLICIT_RECEIVER](x) -> INIT: in: {a=D, x=ID} out: {a=D, x=ID} + v(val x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](val x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 3 mark({ val a = x }) INIT: in: {} out: {} + v(val a = x) INIT: in: {} out: {} + magic[IMPLICIT_RECEIVER](x) -> INIT: in: {} out: {} r(x|) -> - w(a|) INIT: in: {a=D, x=ID} out: {a=ID, x=ID} - 2 jmp?(L3) INIT: in: {a=ID, x=ID} out: {a=ID, x=ID} - d(fun foo() { val b = x }) INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID} + w(a|) INIT: in: {} out: {} + 2 jmp?(L3) INIT: in: {} out: {} + d(fun foo() { val b = x }) INIT: in: {} out: {} L2 [after local class]: L3 [after local declaration]: mark("after") @@ -37,7 +37,7 @@ L1: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == foo == fun foo() { @@ -45,16 +45,16 @@ fun foo() { } --------------------- L4: - 3 INIT: in: {a=ID, x=ID} out: {a=ID, x=ID} + 3 INIT: in: {} out: {} 4 mark({ val b = x }) - v(val b = x) INIT: in: {a=ID, x=ID} out: {a=ID, b=D, x=ID} - magic[IMPLICIT_RECEIVER](x) -> INIT: in: {a=ID, b=D, x=ID} out: {a=ID, b=D, x=ID} + v(val b = x) INIT: in: {} out: {} + magic[IMPLICIT_RECEIVER](x) -> INIT: in: {} out: {} r(x|) -> - w(b|) INIT: in: {a=ID, b=D, x=ID} out: {a=ID, b=ID, x=ID} + w(b|) INIT: in: {} out: {} L5: - 3 INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID} + 3 INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions index 8985d98c48e..14a16c62a41 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.instructions @@ -13,11 +13,11 @@ L0: 2 mark({ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" }) mark("before") r("before") -> - v(val b = 1) INIT: in: {} out: {b=D} - r(1) -> INIT: in: {b=D} out: {b=D} - w(b|) INIT: in: {b=D} out: {b=ID} - jmp?(L2) INIT: in: {b=ID} out: {b=ID} - d(fun local(x: Int) { val a = x + b }) INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID} + v(val b = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(b|) INIT: in: {} out: {} + jmp?(L2) INIT: in: {} out: {} + d(fun local(x: Int) { val a = x + b }) INIT: in: {} out: {} L2 [after local declaration]: mark("after") r("after") -> @@ -26,7 +26,7 @@ L1: error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== == local == fun local(x: Int) { @@ -34,21 +34,21 @@ fun local(x: Int) { } --------------------- L3: - 3 INIT: in: {b=ID} out: {b=ID} - v(x: Int) INIT: in: {b=ID} out: {b=ID, x=D} - magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {b=ID, x=D} out: {b=ID, x=D} - w(x|) INIT: in: {b=ID, x=D} out: {b=ID, x=ID} - 4 mark({ val a = x + b }) INIT: in: {b=ID, x=ID} out: {b=ID, x=ID} - v(val a = x + b) INIT: in: {b=ID, x=ID} out: {a=D, b=ID, x=ID} - r(x) -> INIT: in: {a=D, b=ID, x=ID} out: {a=D, b=ID, x=ID} + 3 INIT: in: {} out: {} + v(x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 4 mark({ val a = x + b }) INIT: in: {} out: {} + v(val a = x + b) INIT: in: {} out: {} + r(x) -> INIT: in: {} out: {} r(b) -> mark(x + b) call(x + b, plus|, ) -> - w(a|) INIT: in: {a=D, b=ID, x=ID} out: {a=ID, b=ID, x=ID} + w(a|) INIT: in: {} out: {} L4: - 3 INIT: in: {a=ID, b=ID, x=ID} out: {a=ID, b=ID, x=ID} + 3 INIT: in: {} out: {} error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions index 41024162bf8..8110cefbaf0 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.instructions @@ -11,11 +11,11 @@ L0: 2 mark({ "before" val b = 1 fun local(x: Int) = x + b "after" }) mark("before") r("before") -> - v(val b = 1) INIT: in: {} out: {b=D} - r(1) -> INIT: in: {b=D} out: {b=D} - w(b|) INIT: in: {b=D} out: {b=ID} - jmp?(L2) INIT: in: {b=ID} out: {b=ID} - d(fun local(x: Int) = x + b) INIT: in: {b=ID, x=ID} out: {b=ID, x=ID} + v(val b = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(b|) INIT: in: {} out: {} + jmp?(L2) INIT: in: {} out: {} + d(fun local(x: Int) = x + b) INIT: in: {} out: {} L2 [after local declaration]: mark("after") r("after") -> @@ -24,17 +24,17 @@ L1: error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== == local == fun local(x: Int) = x + b --------------------- L3: - 3 INIT: in: {b=ID} out: {b=ID} - v(x: Int) INIT: in: {b=ID} out: {b=ID, x=D} - magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {b=ID, x=D} out: {b=ID, x=D} - w(x|) INIT: in: {b=ID, x=D} out: {b=ID, x=ID} - r(x) -> INIT: in: {b=ID, x=ID} out: {b=ID, x=ID} + 3 INIT: in: {} out: {} + v(x: Int) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](x: Int) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + r(x) -> INIT: in: {} out: {} r(b) -> mark(x + b) call(x + b, plus|, ) -> @@ -44,5 +44,5 @@ L4: error: sink: - USE: in: {b=READ, x=READ} out: {b=READ, x=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/localObject.instructions b/compiler/testData/cfg-variables/lexicalScopes/localObject.instructions index 3be2504c57f..9d654cdedeb 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/localObject.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/localObject.instructions @@ -19,11 +19,11 @@ L0: r("before") -> jmp?(L2) 3 mark({ val a = 1 }) - v(val a = 1) INIT: in: {} out: {a=D} - r(1) -> INIT: in: {a=D} out: {a=D} - w(a|) INIT: in: {a=D} out: {a=ID} - 2 jmp?(L3) INIT: in: {a=ID} out: {a=ID} - d(fun foo() { val b = 2 }) INIT: in: {a=ID, b=ID} out: {a=ID, b=ID} + v(val a = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + 2 jmp?(L3) INIT: in: {} out: {} + d(fun foo() { val b = 2 }) INIT: in: {} out: {} L2 [after local class]: L3 [after local declaration]: mark("after") @@ -33,7 +33,7 @@ L1: error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == foo == fun foo() { @@ -41,15 +41,15 @@ fun foo() { } --------------------- L4: - 3 INIT: in: {a=ID} out: {a=ID} + 3 INIT: in: {} out: {} 4 mark({ val b = 2 }) - v(val b = 2) INIT: in: {a=ID} out: {a=ID, b=D} - r(2) -> INIT: in: {a=ID, b=D} out: {a=ID, b=D} - w(b|) INIT: in: {a=ID, b=D} out: {a=ID, b=ID} + v(val b = 2) INIT: in: {} out: {} + r(2) -> INIT: in: {} out: {} + w(b|) INIT: in: {} out: {} L5: - 3 INIT: in: {a=ID, b=ID} out: {a=ID, b=ID} + 3 INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions index 0b801e86894..3d6ce75fad7 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.instructions @@ -17,25 +17,25 @@ L0: 2 mark({ "before" val bar = object { init { val x = 1 } fun foo() { val a = 2 } } "after" }) mark("before") r("before") -> - v(val bar = object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {bar=D} - mark(object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {bar=D} out: {bar=D} + v(val bar = object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {} + mark(object { init { val x = 1 } fun foo() { val a = 2 } }) INIT: in: {} out: {} 3 mark({ val x = 1 }) - v(val x = 1) INIT: in: {bar=D} out: {bar=D, x=D} - r(1) -> INIT: in: {bar=D, x=D} out: {bar=D, x=D} - w(x|) INIT: in: {bar=D, x=D} out: {bar=D, x=ID} - 2 jmp?(L2) INIT: in: {bar=D, x=ID} out: {bar=D, x=ID} - d(fun foo() { val a = 2 }) INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=D, x=ID} + v(val x = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(x|) INIT: in: {} out: {} + 2 jmp?(L2) INIT: in: {} out: {} + d(fun foo() { val a = 2 }) INIT: in: {} out: {} L2 [after local declaration]: r(object { init { val x = 1 } fun foo() { val a = 2 } }) -> - w(bar|) INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=ID, x=ID} - mark("after") INIT: in: {a=ID, bar=ID, x=ID} out: {a=ID, bar=ID, x=ID} + w(bar|) INIT: in: {} out: {} + mark("after") INIT: in: {} out: {} r("after") -> L1: 1 error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== == foo == fun foo() { @@ -43,15 +43,15 @@ fun foo() { } --------------------- L3: - 3 INIT: in: {bar=D, x=ID} out: {bar=D, x=ID} + 3 INIT: in: {} out: {} 4 mark({ val a = 2 }) - v(val a = 2) INIT: in: {bar=D, x=ID} out: {a=D, bar=D, x=ID} - r(2) -> INIT: in: {a=D, bar=D, x=ID} out: {a=D, bar=D, x=ID} - w(a|) INIT: in: {a=D, bar=D, x=ID} out: {a=ID, bar=D, x=ID} + v(val a = 2) INIT: in: {} out: {} + r(2) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} L4: - 3 INIT: in: {a=ID, bar=D, x=ID} out: {a=ID, bar=D, x=ID} + 3 INIT: in: {} out: {} error: sink: - USE: in: {} out: {} + USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions index abe4cd0ad49..249f2d881f6 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.instructions @@ -20,15 +20,15 @@ L0: d(get() { return field }) INIT: in: {a=I?} out: {a=I?} L3 [after local declaration]: jmp?(L6) INIT: in: {a=D} out: {a=D} - d(set(v: Int) { field = v }) INIT: in: {a=I?, v=ID} out: {a=I?, v=ID} + d(set(v: Int) { field = v }) INIT: in: {a=I?} out: {a=I?} L1: L2 [after local class]: L6 [after local declaration]: - 1 INIT: in: {v=ID} out: {v=ID} + 1 INIT: in: {} out: {} error: sink: - USE: in: {v=READ} out: {v=READ} + USE: in: {} out: {} ===================== == get_a == get() { @@ -45,7 +45,7 @@ L5: error: INIT: in: {} out: {} sink: - INIT: in: {a=I?} out: {a=I?} USE: in: {v=READ} out: {v=READ} + INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {} ===================== == set_a == set(v: Int) { @@ -54,16 +54,16 @@ set(v: Int) { --------------------- L7: 3 INIT: in: {a=D} out: {a=D} - v(v: Int) INIT: in: {a=D} out: {a=D, v=D} - magic[FAKE_INITIALIZER](v: Int) -> INIT: in: {a=D, v=D} out: {a=D, v=D} - w(v|) INIT: in: {a=D, v=D} out: {a=D, v=ID} - 4 mark({ field = v }) INIT: in: {a=D, v=ID} out: {a=D, v=ID} + v(v: Int) INIT: in: {a=D} out: {a=D} + magic[FAKE_INITIALIZER](v: Int) -> INIT: in: {a=D} out: {a=D} + w(v|) INIT: in: {a=D} out: {a=D} + 4 mark({ field = v }) INIT: in: {a=D} out: {a=D} r(v) -> w(field|) L8: 3 error: - INIT: in: {v=ID} out: {v=ID} + INIT: in: {} out: {} sink: - INIT: in: {a=I?, v=ID} out: {a=I?, v=ID} USE: in: {v=READ} out: {v=READ} + INIT: in: {a=I?} out: {a=I?} USE: in: {} out: {} ===================== diff --git a/compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions b/compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions index 7d0840b0d0f..ac9e198e8b6 100644 --- a/compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions +++ b/compiler/testData/cfg-variables/lexicalScopes/tryScope.instructions @@ -28,24 +28,24 @@ L0: jmp?(L3) jmp(L4) L2 [onException]: - 3 v(e: Exception) INIT: in: {} out: {e=D} - magic[FAKE_INITIALIZER](e: Exception) -> INIT: in: {e=D} out: {e=D} - w(e|) INIT: in: {e=D} out: {e=ID} - 4 mark({ val a = e }) INIT: in: {e=ID} out: {e=ID} - v(val a = e) INIT: in: {e=ID} out: {a=D, e=ID} - r(e) -> INIT: in: {a=D, e=ID} out: {a=D, e=ID} - w(a|) INIT: in: {a=D, e=ID} out: {a=ID, e=ID} - 3 jmp(L4) INIT: in: {a=ID, e=ID} out: {a=ID, e=ID} + 3 v(e: Exception) INIT: in: {} out: {} + magic[FAKE_INITIALIZER](e: Exception) -> INIT: in: {} out: {} + w(e|) INIT: in: {} out: {} + 4 mark({ val a = e }) INIT: in: {} out: {} + v(val a = e) INIT: in: {} out: {} + r(e) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} + 3 jmp(L4) INIT: in: {} out: {} L4 [afterCatches]: 2 jmp(L5) L3 [onExceptionToFinallyBlock]: L6 [start finally]: 3 mark({ val a = 1 }) - v(val a = 1) INIT: in: {a=ID, e=ID} out: {a=D, a=ID, e=ID} - r(1) -> INIT: in: {a=D, a=ID, e=ID} out: {a=D, a=ID, e=ID} - w(a|) INIT: in: {a=D, a=ID, e=ID} out: {a=ID, a=ID, e=ID} + v(val a = 1) INIT: in: {} out: {} + r(1) -> INIT: in: {} out: {} + w(a|) INIT: in: {} out: {} L7 [finish finally]: - 2 jmp(error) INIT: in: {a=ID, a=ID, e=ID} out: {a=ID, a=ID, e=ID} + 2 jmp(error) INIT: in: {} out: {} L5 [skipFinallyToErrorBlock]: L8 [copy of L3, onExceptionToFinallyBlock]: 3 mark({ val a = 1 }) @@ -60,5 +60,5 @@ L1: error: sink: - USE: in: {e=READ} out: {e=READ} + USE: in: {} out: {} ===================== diff --git a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java index 83e808752b8..58380e00b6e 100644 --- a/compiler/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java +++ b/compiler/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java @@ -45,7 +45,8 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { pseudocodeVariablesData.getVariableUseStatusData(); String initPrefix = " INIT:"; String usePrefix = " USE:"; - int initializersColumnWidth = countDataColumnWidth(initPrefix, pseudocode.getInstructionsIncludingDeadCode(), variableInitializers); + int initializersColumnWidth = countDataColumnWidth(initPrefix, pseudocode.getInstructionsIncludingDeadCode(), variableInitializers, + pseudocodeVariablesData); dumpInstructions(pseudocode, out, (instruction, next, prev) -> { StringBuilder result = new StringBuilder(); @@ -53,14 +54,14 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { Edges previousInitializersEdges = variableInitializers.get(prev); String initializersData = ""; if (initializersEdges != null && !initializersEdges.equals(previousInitializersEdges)) { - initializersData = dumpEdgesData(initPrefix, initializersEdges); + initializersData = dumpEdgesData(initPrefix, initializersEdges, pseudocodeVariablesData); } result.append(String.format("%1$-" + initializersColumnWidth + "s", initializersData)); Edges> useStatusEdges = useStatusData.get(instruction); Edges> nextUseStatusEdges = useStatusData.get(next); if (useStatusEdges != null && !useStatusEdges.equals(nextUseStatusEdges)) { - result.append(dumpEdgesData(usePrefix, useStatusEdges)); + result.append(dumpEdgesData(usePrefix, useStatusEdges, pseudocodeVariablesData)); } return result.toString(); }); @@ -69,13 +70,14 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { private static int countDataColumnWidth( @NotNull String prefix, @NotNull List instructions, - @NotNull Map> data + @NotNull Map> data, + @NotNull PseudocodeVariablesData variablesData ) { int maxWidth = 0; for (Instruction instruction : instructions) { Edges edges = data.get(instruction); if (edges == null) continue; - int length = dumpEdgesData(prefix, edges).length(); + int length = dumpEdgesData(prefix, edges, variablesData).length(); if (maxWidth < length) { maxWidth = length; } @@ -85,17 +87,27 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { } @NotNull - private static > String dumpEdgesData(String prefix, @NotNull Edges edges) { + private static > String dumpEdgesData( + String prefix, + @NotNull Edges edges, + @NotNull PseudocodeVariablesData variablesData + ) { return prefix + - " in: " + renderVariableMap(edges.getIncoming().asMap()) + - " out: " + renderVariableMap(edges.getOutgoing().asMap()); + " in: " + renderVariableMap(edges.getIncoming().asMap(), variablesData) + + " out: " + renderVariableMap(edges.getOutgoing().asMap(), variablesData); } - private static String renderVariableMap(javaslang.collection.Map map) { + private static String renderVariableMap( + javaslang.collection.Map map, + PseudocodeVariablesData variablesData + ) { List result = Lists.newArrayList(); for (Tuple2 entry : map) { VariableDescriptor variable = entry._1; S state = entry._2; + + if (variablesData.isVariableWithTrivialInitializer(variable)) continue; + result.add(variable.getName() + "=" + state); } Collections.sort(result);