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

Pseudocode: Add valued instructions and unbound values to AbstractPseudoValueTest

Browse Source
This commit is contained in:
Alexey Sedunov
2014-06-25 19:32:20 +04:00
parent 21be468e6c
commit f226d99d36
77 changed files with 897 additions and 777 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
+23 -16
View File
@@ -5,25 +5,28 @@ class TestFunctionLiteral {
}
}
---------------------
{ (x: Int) -> sum(x - 1) + x } <v0>: {<: (Int) -> Int} NEW()
{ (x: Int) -> sum(x - 1) + x } <v0>: {<: (Int) -> Int} NEW: r({ (x: Int) -> sum(x - 1) + x }) -> <v0>
=====================
== anonymous_0 ==
{ (x: Int) ->
sum(x - 1) + x
}
---------------------
sum <v2>: {<: (Int) -> Int} NEW(<v1>)
x <v3>: Int NEW()
1 <v4>: Int NEW()
x - 1 <v5>: Int NEW(<v3>, <v4>)
sum(x - 1) <v6>: Int NEW(<v2>, <v5>)
x <v7>: Int NEW()
sum(x - 1) + x <v8>: Int NEW(<v6>, <v7>)
sum(x - 1) + x <v8>: Int COPY
<v0>: Int NEW: magic(x: Int) -> <v0>
<v1>: TestFunctionLiteral NEW: magic(sum) -> <v1>
sum <v2>: {<: (Int) -> Int} NEW: r(sum|<v1>) -> <v2>
x <v3>: Int NEW: r(x) -> <v3>
1 <v4>: Int NEW: r(1) -> <v4>
x - 1 <v5>: Int NEW: call(-, minus|<v3>, <v4>) -> <v5>
sum(x - 1) <v6>: Int NEW: call(sum, invoke|<v2>, <v5>) -> <v6>
x <v7>: Int NEW: r(x) -> <v7>
sum(x - 1) + x <v8>: Int NEW: call(+, plus|<v6>, <v7>) -> <v8>
sum(x - 1) + x <v8>: Int COPY
=====================
== A ==
open class A(val a: A)
---------------------
<v0>: {<: A} NEW: magic(val a: A) -> <v0>
=====================
== TestObjectLiteral ==
class TestObjectLiteral {
@@ -37,23 +40,27 @@ class TestObjectLiteral {
}
}
---------------------
obj <v1>: * NEW(<v0>)
obj <v3>: {<: A} NEW(<v2>)
object: A(obj) { { val x = obj } fun foo() { val y = obj } } <v4>: {<: A} NEW()
<v0>: TestObjectLiteral NEW: magic(obj) -> <v0>
<v2>: TestObjectLiteral NEW: magic(obj) -> <v2>
obj <v1>: * NEW: r(obj|<v0>) -> <v1>
obj <v3>: {<: A} NEW: r(obj|<v2>) -> <v3>
object: A(obj) { { val x = obj } fun foo() { val y = obj } } <v4>: {<: A} NEW: r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v4>
=====================
== foo ==
fun foo() {
val y = obj
}
---------------------
obj <v1>: {<: A} NEW(<v0>)
<v0>: TestObjectLiteral NEW: magic(obj) -> <v0>
obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1>
=====================
== TestOther ==
class TestOther {
val x: Int = x + 1
}
---------------------
x <v1>: Int NEW(<v0>)
1 <v2>: Int NEW()
x + 1 <v3>: Int NEW(<v1>, <v2>)
<v0>: TestOther NEW: magic(x) -> <v0>
x <v1>: Int NEW: r(x|<v0>) -> <v1>
1 <v2>: Int NEW: r(1) -> <v2>
x + 1 <v3>: Int NEW: call(+, plus|<v1>, <v2>) -> <v3>
=====================
compiler/testData/cfg-variables/bugs/varInitializationInIf.values
+8 -8
View File
@@ -10,12 +10,12 @@ fun foo() {
use(b)
}
---------------------
1 <v0>: {<: Comparable<Int>} NEW()
2 <v1>: Int NEW()
1 < 2 <v2>: Boolean NEW(<v0>, <v1>)
false <v3>: Boolean NEW()
true <v4>: Boolean NEW()
b <v5>: * NEW()
use(b) <v6>: * NEW(<v5>)
{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) } <v6>: * COPY
1 <v0>: {<: Comparable<Int>} NEW: r(1) -> <v0>
2 <v1>: Int NEW: r(2) -> <v1>
1 < 2 <v2>: Boolean NEW: call(<, compareTo|<v0>, <v1>) -> <v2>
false <v3>: Boolean NEW: r(false) -> <v3>
true <v4>: Boolean NEW: r(true) -> <v4>
b <v5>: * NEW: r(b) -> <v5>
use(b) <v6>: * NEW: magic(use(b)|<v5>) -> <v6>
{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) } <v6>: * COPY
=====================
compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values
+12 -9
View File
@@ -13,17 +13,20 @@ fun foo(numbers: Collection<Int>) {
}
}
---------------------
numbers <v1>: {<: Iterable<Int>} NEW()
1 <v3>: {<: Comparable<Int>} NEW()
2 <v4>: Int NEW()
1 < 2 <v5>: Boolean NEW(<v3>, <v4>)
false <v6>: Boolean NEW()
true <v7>: Boolean NEW()
b <v8>: {<: Any?} NEW()
use(b) <v9>: * NEW(<v8>)
<v0>: {<: Collection<Int>} NEW: magic(numbers: Collection<Int>) -> <v0>
<v2>: Int NEW: magic(numbers|<v1>) -> <v2>
numbers <v1>: {<: Iterable<Int>} NEW: r(numbers) -> <v1>
1 <v3>: {<: Comparable<Int>} NEW: r(1) -> <v3>
2 <v4>: Int NEW: r(2) -> <v4>
1 < 2 <v5>: Boolean NEW: call(<, compareTo|<v3>, <v4>) -> <v5>
false <v6>: Boolean NEW: r(false) -> <v6>
true <v7>: Boolean NEW: r(true) -> <v7>
b <v8>: {<: Any?} NEW: r(b) -> <v8>
use(b) <v9>: * NEW: call(use, use|<v8>) -> <v9>
=====================
== use ==
fun use(vararg a: Any?) = a
---------------------
a <v1>: {<: Array<Any?>} NEW()
<v0>: {<: Array<Any?>} NEW: magic(vararg a: Any?) -> <v0>
a <v1>: {<: Array<Any?>} NEW: r(a) -> <v1>
=====================