Add tests for element -> pseudo-value mapping

compiler/testData/cfg-variables/basic/IfWithUninitialized.values

@@ -0,0 +1,28 @@
+== foo ==
+fun foo() {
+    val b: Boolean
+    if (1 < 2) {
+        use(b)
+    }
+    else {
+        b = true
+    }
+}
+---------------------
+1                                                            <v0>   NEW()          
+<                                                            <v2>   NEW(<v0>, <v1>)
+2                                                            <v1>   NEW()          
+1 < 2                                                        <v2>   COPY           
+use                                                          <v4>   NEW(<v3>)      
+b                                                            <v3>   NEW()          
+use(b)                                                       <v4>   COPY           
+{ use(b) }                                                   <v4>   COPY           
+true                                                         <v5>   NEW()          
+if (1 < 2) { use(b) } else { b = true }                      <v4>   COPY           
+{ val b: Boolean if (1 < 2) { use(b) } else { b = true } }   <v4>   COPY           
+=====================
+== use ==
+fun use(vararg a: Any?) = a
+---------------------
+a   <v1>   NEW()
+=====================

compiler/testData/cfg-variables/basic/InitializedNotDeclared.values

@@ -0,0 +1,10 @@
+== A ==
+class A {
+    {
+        x = 1
+    }
+    val x: Int
+}
+---------------------
+1   <v0>   NEW()
+=====================

compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.values

@@ -0,0 +1,32 @@
+== foo ==
+fun foo() {
+    val a = 1
+    val f = { (x: Int) ->
+        val y = x + a
+        use(a)
+    }
+}
+---------------------
+1                                      <v0>   NEW()
+{ (x: Int) -> val y = x + a use(a) }   <v1>   NEW()
+=====================
+== anonymous_0 ==
+{ (x: Int) ->
+        val y = x + a
+        use(a)
+    }
+---------------------
+x                      <v1>   NEW()
++                      <v3>   NEW(<v1>, <v2>)
+a                      <v2>   NEW()          
+x + a                  <v3>   COPY           
+use                    <v5>   NEW(<v4>)      
+a                      <v4>   NEW()          
+use(a)                 <v5>   COPY           
+val y = x + a use(a)   <v5>   COPY           
+=====================
+== use ==
+fun use(vararg a: Any?) = a
+---------------------
+a   <v1>   NEW()
+=====================

compiler/testData/cfg-variables/basic/VariablesInitialization.values

@@ -0,0 +1,34 @@
+== foo ==
+fun foo() {
+    val a = 1
+    val b: Int
+    b = 2
+    42
+}
+---------------------
+1                                   <v0>   NEW()
+2                                   <v1>   NEW()
+42                                  <v2>   NEW()
+{ val a = 1 val b: Int b = 2 42 }   <v2>   COPY 
+=====================
+== bar ==
+fun bar(foo: Foo) {
+    foo.c
+    foo.c = 2
+    42
+}
+---------------------
+foo                      <v1>   NEW()
+c                        <v2>   NEW(<v1>)
+foo.c                    <v2>   COPY     
+foo                      <v4>   NEW()    
+2                        <v3>   NEW()    
+42                       <v5>   NEW()    
+{ foo.c foo.c = 2 42 }   <v5>   COPY     
+=====================
+== Foo ==
+trait Foo {
+    var c: Int
+}
+---------------------
+=====================

compiler/testData/cfg-variables/basic/VariablesUsage.values

@@ -0,0 +1,31 @@
+== foo ==
+fun foo() {
+    var a = 1
+    use(a)
+    a = 2
+    use(a)
+}
+---------------------
+1                                   <v0>   NEW()    
+use                                 <v2>   NEW(<v1>)
+a                                   <v1>   NEW()    
+use(a)                              <v2>   COPY     
+2                                   <v3>   NEW()    
+use                                 <v5>   NEW(<v4>)
+a                                   <v4>   NEW()    
+use(a)                              <v5>   COPY     
+{ var a = 1 use(a) a = 2 use(a) }   <v5>   COPY     
+=====================
+== bar ==
+fun bar() {
+    val b: Int
+    b = 3
+}
+---------------------
+3   <v0>   NEW()
+=====================
+== use ==
+fun use(a: Int) = a
+---------------------
+a   <v1>   NEW()
+=====================

compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values

@@ -0,0 +1,62 @@
+== TestFunctionLiteral ==
+class TestFunctionLiteral {
+    val sum: (Int)->Int = { (x: Int) ->
+        sum(x - 1) + x
+    }
+}
+---------------------
+{ (x: Int) -> sum(x - 1) + x }   <v0>   NEW()
+=====================
+== anonymous_0 ==
+{ (x: Int) ->
+        sum(x - 1) + x
+    }
+---------------------
+sum              <v5>   NEW(<v1>, <v4>)
+x                <v2>   NEW()          
+-                <v4>   NEW(<v2>, <v3>)
+1                <v3>   NEW()          
+x - 1            <v4>   COPY           
+sum(x - 1)       <v5>   COPY           
++                <v7>   NEW(<v5>, <v6>)
+x                <v6>   NEW()          
+sum(x - 1) + x   <v7>   COPY           
+sum(x - 1) + x   <v7>   COPY           
+=====================
+== A ==
+open class A(val a: A)
+---------------------
+=====================
+== TestObjectLiteral ==
+class TestObjectLiteral {
+    val obj: A = object: A(obj) {
+        {
+            val x = obj
+        }
+        fun foo() {
+            val y = obj
+        }
+    }
+}
+---------------------
+obj                                                            <v0>   NEW()
+obj                                                            <v1>   NEW()
+object: A(obj) { { val x = obj } fun foo() { val y = obj } }   <v2>   NEW()
+=====================
+== foo ==
+fun foo() {
+            val y = obj
+        }
+---------------------
+obj   <v0>   NEW()
+=====================
+== TestOther ==
+class TestOther {
+    val x: Int = x + 1
+}
+---------------------
+x       <v0>   NEW()          
++       <v2>   NEW(<v0>, <v1>)
+1       <v1>   NEW()          
+x + 1   <v2>   COPY           
+=====================

compiler/testData/cfg-variables/bugs/varInitializationInIf.values

@@ -0,0 +1,23 @@
+== foo ==
+fun foo() {
+    val b: Boolean
+    if (1 < 2) {
+        b = false
+    }
+    else {
+        b = true
+    }
+    use(b)
+}
+---------------------
+1                                                                      <v0>   NEW()          
+<                                                                      <v2>   NEW(<v0>, <v1>)
+2                                                                      <v1>   NEW()          
+1 < 2                                                                  <v2>   COPY           
+false                                                                  <v3>   NEW()          
+true                                                                   <v4>   NEW()          
+use                                                                    <v6>   NEW(<v5>)      
+b                                                                      <v5>   NEW()          
+use(b)                                                                 <v6>   COPY           
+{ val b: Boolean if (1 < 2) { b = false } else { b = true } use(b) }   <v6>   COPY           
+=====================

compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.values

@@ -0,0 +1,31 @@
+== foo ==
+fun foo(numbers: Collection<Int>) {
+    for (i in numbers) {
+        val b: Boolean
+        if (1 < 2) {
+            b = false
+        }
+        else {
+            b = true
+        }
+        use(b)
+        continue
+    }
+}
+---------------------
+numbers   <v1>   NEW()
+1         <v3>   NEW()
+<         <v5>   NEW(<v3>, <v4>)
+2         <v4>   NEW()
+1 < 2     <v5>   COPY
+false     <v6>   NEW()
+true      <v7>   NEW()
+use       <v9>   NEW(<v8>)
+b         <v8>   NEW()
+use(b)    <v9>   COPY
+=====================
+== use ==
+fun use(vararg a: Any?) = a
+---------------------
+a   <v1>   NEW()
+=====================

compiler/testData/cfg-variables/lexicalScopes/doWhileScope.values

@@ -0,0 +1,18 @@
+== foo ==
+fun foo() {
+    "before"
+    do {
+        var a = 2
+    } while (a > 0)
+    "after"
+}
+---------------------
+"before"                                              <v0>   NEW()          
+2                                                     <v1>   NEW()          
+a                                                     <v2>   NEW()          
+>                                                     <v4>   NEW(<v2>, <v3>)
+0                                                     <v3>   NEW()          
+a > 0                                                 <v4>   COPY           
+"after"                                               <v5>   NEW()          
+{ "before" do { var a = 2 } while (a > 0) "after" }   <v5>   COPY           
+=====================

compiler/testData/cfg-variables/lexicalScopes/forScope.values

@@ -0,0 +1,18 @@
+== foo ==
+fun foo() {
+    "before"
+    for (i in 1..10) {
+        val a = i
+    }
+    "after"
+}
+---------------------
+"before"                                              <v0>   NEW()          
+1                                                     <v1>   NEW()          
+..                                                    <v3>   NEW(<v1>, <v2>)
+10                                                    <v2>   NEW()          
+1..10                                                 <v3>   COPY
+i                                                     <v5>   NEW()          
+"after"                                               <v6>   NEW()          
+{ "before" for (i in 1..10) { val a = i } "after" }   <v6>   COPY           
+=====================

compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.values

@@ -0,0 +1,26 @@
+== foo ==
+fun foo() {
+    "before"
+    val b = 1
+    val f = { (x: Int) ->
+        val a = x + b
+    }
+    "after"
+}
+---------------------
+"before"                                                               <v0>   NEW()
+1                                                                      <v1>   NEW()
+{ (x: Int) -> val a = x + b }                                          <v2>   NEW()
+"after"                                                                <v3>   NEW()
+{ "before" val b = 1 val f = { (x: Int) -> val a = x + b } "after" }   <v3>   COPY 
+=====================
+== anonymous_0 ==
+{ (x: Int) ->
+        val a = x + b
+    }
+---------------------
+x       <v1>   NEW()
++       <v3>   NEW(<v1>, <v2>)
+b       <v2>   NEW()
+x + b   <v3>   COPY
+=====================

compiler/testData/cfg-variables/lexicalScopes/ifScope.values

@@ -0,0 +1,19 @@
+== foo ==
+fun foo() {
+    "before"
+    if (true) {
+        val a = 1
+    }
+    else {
+        val b = 2
+    }
+    "after"
+}
+---------------------
+"before"                                                          <v0>   NEW()
+true                                                              <v1>   NEW()
+1                                                                 <v2>   NEW()
+2                                                                 <v3>   NEW()
+"after"                                                           <v4>   NEW()
+{ "before" if (true) { val a = 1 } else { val b = 2 } "after" }   <v4>   COPY 
+=====================

compiler/testData/cfg-variables/lexicalScopes/localClass.values

@@ -0,0 +1,26 @@
+== foo ==
+fun foo() {
+    "before"
+    class A(val x: Int) {
+        {
+            val a = x
+        }
+        fun foo() {
+            val b = x
+        }
+    }
+    "after"
+}
+---------------------
+"before"                                                                             <v0>   NEW()
+x                                                                                    <v2>   NEW()
+"after"                                                                              <v3>   NEW()
+{ "before" class A(val x: Int) { { val a = x } fun foo() { val b = x } } "after" }   <v3>   COPY 
+=====================
+== foo ==
+fun foo() {
+            val b = x
+        }
+---------------------
+x   <v0>   NEW()
+=====================

compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.values

@@ -0,0 +1,25 @@
+== foo ==
+fun foo() {
+    "before"
+    val b = 1
+    fun local(x: Int) {
+        val a = x + b
+    }
+    "after"
+}
+---------------------
+"before"                                                             <v0>   NEW()
+1                                                                    <v1>   NEW()
+"after"                                                              <v2>   NEW()
+{ "before" val b = 1 fun local(x: Int) { val a = x + b } "after" }   <v2>   COPY 
+=====================
+== local ==
+fun local(x: Int) {
+        val a = x + b
+    }
+---------------------
+x       <v1>   NEW()
++       <v3>   NEW(<v1>, <v2>)
+b       <v2>   NEW()
+x + b   <v3>   COPY
+=====================

compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.values

@@ -0,0 +1,21 @@
+== foo ==
+fun foo() {
+    "before"
+    val b = 1
+    fun local(x: Int) = x + b
+    "after"
+}
+---------------------
+"before"                                                   <v0>   NEW()
+1                                                          <v1>   NEW()
+"after"                                                    <v2>   NEW()
+{ "before" val b = 1 fun local(x: Int) = x + b "after" }   <v2>   COPY 
+=====================
+== local ==
+fun local(x: Int) = x + b
+---------------------
+x       <v1>   NEW()
++       <v3>   NEW(<v1>, <v2>)
+b       <v2>   NEW()
+x + b   <v3>   COPY
+=====================

compiler/testData/cfg-variables/lexicalScopes/localObject.values

@@ -0,0 +1,26 @@
+== foo ==
+fun foo() {
+    "before"
+    object A {
+        {
+            val a = 1
+        }
+        fun foo() {
+            val b = 2
+        }
+    }
+    "after"
+}
+---------------------
+"before"                                                                  <v0>   NEW()
+1                                                                         <v1>   NEW()
+"after"                                                                   <v2>   NEW()
+{ "before" object A { { val a = 1 } fun foo() { val b = 2 } } "after" }   <v2>   COPY 
+=====================
+== foo ==
+fun foo() {
+            val b = 2
+        }
+---------------------
+2   <v0>   NEW()
+=====================

compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.values

@@ -0,0 +1,27 @@
+== foo ==
+fun foo() {
+    "before"
+    val bar = object {
+        {
+            val x = 1
+        }
+        fun foo() {
+            val a = 2
+        }
+    }
+    "after"
+}
+---------------------
+"before"                                                                          <v0>   NEW()
+1                                                                                 <v1>   NEW()
+object { { val x = 1 } fun foo() { val a = 2 } }                                  <v2>   NEW()
+"after"                                                                           <v3>   NEW()
+{ "before" val bar = object { { val x = 1 } fun foo() { val a = 2 } } "after" }   <v3>   COPY 
+=====================
+== foo ==
+fun foo() {
+            val a = 2
+        }
+---------------------
+2   <v0>   NEW()
+=====================

compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.values

@@ -0,0 +1,28 @@
+== foo ==
+fun foo() {
+    class A {
+        var a : Int
+          get() {
+              return $a
+          }
+          set(v: Int) {
+              $a = v
+          }
+    }
+}
+---------------------
+=====================
+== get_a ==
+get() {
+              return $a
+          }
+---------------------
+$a   <v0>   NEW()
+=====================
+== set_a ==
+set(v: Int) {
+              $a = v
+          }
+---------------------
+v   <v1>   NEW()
+=====================

compiler/testData/cfg-variables/lexicalScopes/tryScope.values

@@ -0,0 +1,25 @@
+== foo ==
+fun foo() {
+    "before"
+    try {
+        foo()
+    }
+    catch (e: Exception) {
+        val a = e
+    }
+    finally {
+        val a = 1
+    }
+    "after"
+}
+---------------------
+"before"                                                                                      <v0>   NEW()
+foo                                                                                           <v1>   NEW()
+foo()                                                                                         <v1>   COPY 
+{ foo() }                                                                                     <v1>   COPY 
+e                                                                                             <v3>   NEW()
+1                                                                                             <v4>   NEW()
+try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 }                        <v1>   COPY 
+"after"                                                                                       <v5>   NEW()
+{ "before" try { foo() } catch (e: Exception) { val a = e } finally { val a = 1 } "after" }   <v5>   COPY 
+=====================

compiler/testData/cfg-variables/lexicalScopes/whileScope.values

@@ -0,0 +1,14 @@
+== foo ==
+fun foo() {
+    "before"
+    while (true) {
+        val a: Int
+    }
+    "after"
+}
+---------------------
+"before"                                           <v0>   NEW()
+true                                               <v1>   NEW()
+"after"                                            <v2>   NEW()
+{ "before" while (true) { val a: Int } "after" }   <v2>   COPY 
+=====================

compiler/testData/cfg/arrays/ArrayAccess.values

@@ -0,0 +1,31 @@
+== foo ==
+fun foo() {
+  val a = Array<Int>
+  3
+  a[10] = 4
+  2
+  a[10]
+  100
+  a[10] += 1
+}
+---------------------
+Array                                                       <v0>    NEW()                   
+Array<Int>                                                  <v0>    COPY                    
+3                                                           <v1>    NEW()                   
+a                                                           <v2>    NEW()                   
+10                                                          <v3>    NEW()                   
+4                                                           <v4>    NEW()                   
+a[10] = 4                                                   <v5>    NEW(<v2>, <v3>, <v4>)   
+2                                                           <v6>    NEW()                   
+a                                                           <v7>    NEW()                   
+10                                                          <v8>    NEW()                   
+a[10]                                                       <v9>    NEW(<v7>, <v8>)         
+100                                                         <v10>   NEW()                   
+a                                                           <v16>   NEW()                   
+10                                                          <v17>   NEW()                   
+a[10]                                                       <v13>   NEW(<v11>, <v12>)       
++=                                                          <v15>   NEW(<v13>, <v14>)       
+1                                                           <v14>   NEW()                   
+a[10] += 1                                                  <v18>   NEW(<v16>, <v17>, <v15>)
+{ val a = Array<Int> 3 a[10] = 4 2 a[10] 100 a[10] += 1 }   <v18>   COPY                    
+=====================

compiler/testData/cfg/arrays/ArrayOfFunctions.values

@@ -0,0 +1,12 @@
+== test ==
+fun test(array: Array<(Int)->Unit>) {
+    array[11](3)
+}
+---------------------
+array              <v1>   NEW()
+11                 <v2>   NEW()
+array[11]          <v5>   NEW(<v3>, <v4>)
+3                  <v4>   NEW()
+array[11](3)       <v5>   COPY
+{ array[11](3) }   <v5>   COPY
+=====================

compiler/testData/cfg/arrays/arrayAccessExpression.values

@@ -0,0 +1,23 @@
+== Ab ==
+abstract class Ab {
+    abstract fun getArray() : Array<Int>
+}
+---------------------
+=====================
+== getArray ==
+abstract fun getArray() : Array<Int>
+---------------------
+=====================
+== test ==
+fun test(ab: Ab) {
+    ab.getArray()[1]
+}
+---------------------
+ab                     <v1>   NEW()
+getArray               <v2>   NEW(<v1>)      
+getArray()             <v2>   COPY           
+ab.getArray()          <v2>   COPY           
+1                      <v3>   NEW()          
+ab.getArray()[1]       <v4>   NEW(<v2>, <v3>)
+{ ab.getArray()[1] }   <v4>   COPY           
+=====================

compiler/testData/cfg/arrays/arrayInc.values

@@ -0,0 +1,12 @@
+== foo ==
+fun foo(a: Array<Int>) {
+    a[0]++
+}
+---------------------
+a            <v5>   NEW()
+0            <v6>   NEW()
+a[0]         <v3>   NEW(<v1>, <v2>)
+++           <v4>   NEW(<v3>)
+a[0]++       <v7>   NEW(<v5>, <v6>, <v4>)
+{ a[0]++ }   <v7>   COPY
+=====================

compiler/testData/cfg/arrays/arraySet.values

@@ -0,0 +1,11 @@
+== foo ==
+fun foo(a: Array<Int>) {
+    a[1] = 2
+}
+---------------------
+a              <v1>   NEW()
+1              <v2>   NEW()
+2              <v3>   NEW()
+a[1] = 2       <v4>   NEW(<v1>, <v2>, <v3>)
+{ a[1] = 2 }   <v4>   COPY
+=====================

compiler/testData/cfg/arrays/arraySetPlusAssign.values

@@ -0,0 +1,13 @@
+== foo ==
+fun foo(a: Array<Int>) {
+    a[0] += 1
+}
+---------------------
+a               <v6>   NEW()
+0               <v7>   NEW()                
+a[0]            <v3>   NEW(<v1>, <v2>)      
++=              <v5>   NEW(<v3>, <v4>)      
+1               <v4>   NEW()                
+a[0] += 1       <v8>   NEW(<v6>, <v7>, <v5>)
+{ a[0] += 1 }   <v8>   COPY                 
+=====================

compiler/testData/cfg/basic/Basic.values

@@ -0,0 +1,73 @@
+== f ==
+fun f(a : Boolean) : Unit {
+    1
+    a
+    2.toLong()
+    foo(a, 3)
+    genfun<Any>()
+    flfun {1}
+    3.equals(4)
+
+    3 equals 4
+
+    1 + 2
+
+    a && true
+    a || false
+
+}
+---------------------
+1                                                                                                        <v1>    NEW()
+a                                                                                                        <v2>    NEW()            
+2                                                                                                        <v3>    NEW()            
+toLong                                                                                                   <v4>    NEW(<v3>)        
+toLong()                                                                                                 <v4>    COPY             
+2.toLong()                                                                                               <v4>    COPY             
+foo                                                                                                      <v7>    NEW(<v5>, <v6>)  
+a                                                                                                        <v5>    NEW()            
+3                                                                                                        <v6>    NEW()            
+foo(a, 3)                                                                                                <v7>    COPY             
+genfun                                                                                                   <v8>    NEW()            
+genfun<Any>()                                                                                            <v8>    COPY             
+flfun                                                                                                    <v10>   NEW(<v9>)        
+{1}                                                                                                      <v9>    NEW()            
+flfun {1}                                                                                                <v10>   COPY             
+3                                                                                                        <v11>   NEW()            
+equals                                                                                                   <v13>   NEW(<v11>, <v12>)
+4                                                                                                        <v12>   NEW()            
+equals(4)                                                                                                <v13>   COPY             
+3.equals(4)                                                                                              <v13>   COPY             
+3                                                                                                        <v14>   NEW()            
+equals                                                                                                   <v16>   NEW(<v14>, <v15>)
+4                                                                                                        <v15>   NEW()            
+3 equals 4                                                                                               <v16>   COPY             
+1                                                                                                        <v17>   NEW()            
++                                                                                                        <v19>   NEW(<v17>, <v18>)
+2                                                                                                        <v18>   NEW()            
+1 + 2                                                                                                    <v19>   COPY             
+a                                                                                                        <v20>   NEW()            
+true                                                                                                     <v21>   NEW()            
+a && true                                                                                                <v22>   NEW(<v20>, <v21>)
+a                                                                                                        <v23>   NEW()            
+false                                                                                                    <v24>   NEW()            
+a || false                                                                                               <v25>   NEW(<v23>, <v24>)
+{ 1 a 2.toLong() foo(a, 3) genfun<Any>() flfun {1} 3.equals(4) 3 equals 4 1 + 2 a && true a || false }   <v25>   COPY             
+=====================
+== anonymous_0 ==
+{1}
+---------------------
+1   <v0>   NEW()
+1   <v0>   COPY 
+=====================
+== foo ==
+fun foo(a : Boolean, b : Int) : Unit {}
+---------------------
+=====================
+== genfun ==
+fun genfun<T>() : Unit {}
+---------------------
+=====================
+== flfun ==
+fun flfun(f : () -> Any) : Unit {}
+---------------------
+=====================

compiler/testData/cfg/basic/EmptyFunction.values

@@ -0,0 +1,4 @@
+== empty ==
+fun empty() {}
+---------------------
+=====================

compiler/testData/cfg/basic/ShortFunction.values

@@ -0,0 +1,5 @@
+== short ==
+fun short() = 1
+---------------------
+1   <v0>   NEW()
+=====================

compiler/testData/cfg/bugs/jumpToOuterScope.values

@@ -0,0 +1,19 @@
+== foo ==
+fun foo(c: Collection<Int>) {
+    for (e in c) {
+        {
+            break
+        }
+    }
+}
+---------------------
+c               <v1>   NEW()
+{ break }       <v3>   NEW()
+{ { break } }   <v3>   COPY
+=====================
+== anonymous_0 ==
+{
+            break
+        }
+---------------------
+=====================

compiler/testData/cfg/controlStructures/Finally.values

@@ -0,0 +1,388 @@
+== t1 ==
+fun t1() {
+  try {
+    1
+  } finally {
+    2
+  }
+}
+---------------------
+1                             <v0>   NEW()
+{ 1 }                         <v0>   COPY 
+2                             <v1>   NEW()
+{ 2 }                         <v1>   COPY 
+try { 1 } finally { 2 }       <v0>   COPY 
+{ try { 1 } finally { 2 } }   <v0>   COPY 
+=====================
+== t2 ==
+fun t2() {
+  try {
+    1
+    if (2 > 3) {
+      return
+    }
+  } finally {
+    2
+  }
+}
+---------------------
+1       <v0>   NEW()          
+2       <v1>   NEW()          
+>       <v3>   NEW(<v1>, <v2>)
+3       <v2>   NEW()          
+2 > 3   <v3>   COPY           
+2       <v4>   NEW()          
+{ 2 }   <v4>   COPY           
+=====================
+== t3 ==
+fun t3() {
+  try {
+    1
+    @l{ () ->
+        if (2 > 3) {
+          return@l
+        }
+    }
+  } finally {
+    2
+  }
+}
+---------------------
+1                                                                 <v0>   NEW()
+{ () -> if (2 > 3) { return@l } }                                 <v1>   NEW()
+@l{ () -> if (2 > 3) { return@l } }                               <v1>   COPY 
+{ 1 @l{ () -> if (2 > 3) { return@l } } }                         <v1>   COPY 
+2                                                                 <v2>   NEW()
+{ 2 }                                                             <v2>   COPY 
+try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 }       <v1>   COPY 
+{ try { 1 @l{ () -> if (2 > 3) { return@l } } } finally { 2 } }   <v1>   COPY 
+=====================
+== anonymous_0 ==
+{ () ->
+        if (2 > 3) {
+          return@l
+        }
+    }
+---------------------
+2       <v0>   NEW()          
+>       <v2>   NEW(<v0>, <v1>)
+3       <v1>   NEW()          
+2 > 3   <v2>   COPY           
+=====================
+== t4 ==
+fun t4() {
+  @l{ () ->
+    try {
+      1
+      if (2 > 3) {
+        return@l
+      }
+    } finally {
+      2
+    }
+  }
+}
+---------------------
+{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }         <v0>   NEW()
+@l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } }       <v0>   COPY 
+{ @l{ () -> try { 1 if (2 > 3) { return@l } } finally { 2 } } }   <v0>   COPY 
+=====================
+== anonymous_1 ==
+{ () ->
+    try {
+      1
+      if (2 > 3) {
+        return@l
+      }
+    } finally {
+      2
+    }
+  }
+---------------------
+1       <v0>   NEW()          
+2       <v1>   NEW()          
+>       <v3>   NEW(<v1>, <v2>)
+3       <v2>   NEW()          
+2 > 3   <v3>   COPY           
+2       <v4>   NEW()          
+{ 2 }   <v4>   COPY           
+=====================
+== t5 ==
+fun t5() {
+  @l while(true) {
+    try {
+      1
+      if (2 > 3) {
+        break @l
+      }
+    } finally {
+      2
+    }
+  }
+}
+---------------------
+true    <v0>   NEW()          
+1       <v1>   NEW()          
+2       <v2>   NEW()          
+>       <v4>   NEW(<v2>, <v3>)
+3       <v3>   NEW()          
+2 > 3   <v4>   COPY           
+2       <v5>   NEW()          
+{ 2 }   <v5>   COPY           
+=====================
+== t6 ==
+fun t6() {
+  try {
+    @l while(true) {
+        1
+        if (2 > 3) {
+          break @l
+        }
+      }
+      5
+  } finally {
+    2
+  }
+}
+---------------------
+true                                                                       <v0>   NEW()          
+1                                                                          <v1>   NEW()          
+2                                                                          <v2>   NEW()          
+>                                                                          <v4>   NEW(<v2>, <v3>)
+3                                                                          <v3>   NEW()          
+2 > 3                                                                      <v4>   COPY           
+5                                                                          <v5>   NEW()          
+{ @l while(true) { 1 if (2 > 3) { break @l } } 5 }                         <v5>   COPY           
+2                                                                          <v6>   NEW()          
+{ 2 }                                                                      <v6>   COPY           
+try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 }       <v5>   COPY           
+{ try { @l while(true) { 1 if (2 > 3) { break @l } } 5 } finally { 2 } }   <v5>   COPY           
+=====================
+== t7 ==
+fun t7() {
+  try {
+    @l while(true) {
+        1
+        if (2 > 3) {
+          break @l
+        }
+      }
+  } finally {
+    2
+  }
+}
+---------------------
+true    <v0>   NEW()          
+1       <v1>   NEW()          
+2       <v2>   NEW()          
+>       <v4>   NEW(<v2>, <v3>)
+3       <v3>   NEW()          
+2 > 3   <v4>   COPY           
+2       <v5>   NEW()          
+{ 2 }   <v5>   COPY           
+=====================
+== t8 ==
+fun t8(a : Int) {
+  @l for (i in 1..a) {
+    try {
+      1
+      if (2 > 3) {
+        continue @l
+      }
+    } finally {
+      2
+    }
+  }
+}
+---------------------
+1       <v1>   NEW()
+..      <v3>   NEW(<v1>, <v2>)
+a       <v2>   NEW()
+1..a    <v3>   COPY
+1       <v5>   NEW()
+2       <v6>   NEW()
+>       <v8>   NEW(<v6>, <v7>)
+3       <v7>   NEW()
+2 > 3   <v8>   COPY
+2       <v9>   NEW()
+{ 2 }   <v9>   COPY
+=====================
+== t9 ==
+fun t9(a : Int) {
+  try {
+    @l for (i in 1..a) {
+        1
+        if (2 > 3) {
+          continue @l
+        }
+      }
+      5
+  } finally {
+    2
+  }
+}
+---------------------
+1                                                                                 <v1>    NEW()
+..                                                                                <v3>    NEW(<v1>, <v2>)
+a                                                                                 <v2>    NEW()          
+1..a                                                                              <v3>    COPY
+1                                                                                 <v5>    NEW()          
+2                                                                                 <v6>    NEW()          
+>                                                                                 <v8>    NEW(<v6>, <v7>)
+3                                                                                 <v7>    NEW()          
+2 > 3                                                                             <v8>    COPY           
+5                                                                                 <v9>    NEW()          
+{ @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 }                         <v9>    COPY           
+2                                                                                 <v10>   NEW()          
+{ 2 }                                                                             <v10>   COPY           
+try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 }       <v9>    COPY           
+{ try { @l for (i in 1..a) { 1 if (2 > 3) { continue @l } } 5 } finally { 2 } }   <v9>    COPY           
+=====================
+== t10 ==
+fun t10(a : Int) {
+  try {
+    @l for (i in 1..a) {
+        1
+        if (2 > 3) {
+          continue @l
+        }
+      }
+  } finally {
+    2
+  }
+}
+---------------------
+1       <v1>   NEW()
+..      <v3>   NEW(<v1>, <v2>)
+a       <v2>   NEW()
+1..a    <v3>   COPY
+1       <v5>   NEW()
+2       <v6>   NEW()
+>       <v8>   NEW(<v6>, <v7>)
+3       <v7>   NEW()
+2 > 3   <v8>   COPY
+2       <v9>   NEW()
+{ 2 }   <v9>   COPY
+=====================
+== t11 ==
+fun t11() {
+  try {
+    return 1
+  }
+  finally {
+    return 2
+  }
+}
+---------------------
+1   <v0>   NEW()
+2   <v1>   NEW()
+=====================
+== t12 ==
+fun t12() : Int {
+    try {
+        return 1
+    }
+    finally {
+        doSmth(3)
+    }
+}
+---------------------
+1               <v0>   NEW()    
+doSmth          <v2>   NEW(<v1>)
+3               <v1>   NEW()    
+doSmth(3)       <v2>   COPY     
+{ doSmth(3) }   <v2>   COPY     
+=====================
+== t13 ==
+fun t13() : Int {
+    try {
+        return 1
+    }
+    catch (e: UnsupportedOperationException) {
+        doSmth(2)
+    }
+    finally {
+        doSmth(3)
+    }
+}
+---------------------
+1                                                                                                   <v0>   NEW()    
+doSmth                                                                                              <v5>   NEW(<v4>)
+2                                                                                                   <v4>   NEW()    
+doSmth(2)                                                                                           <v5>   COPY     
+{ doSmth(2) }                                                                                       <v5>   COPY     
+doSmth                                                                                              <v2>   NEW(<v1>)
+3                                                                                                   <v1>   NEW()    
+doSmth(3)                                                                                           <v2>   COPY     
+{ doSmth(3) }                                                                                       <v2>   COPY     
+try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) }       <v5>   COPY     
+{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } finally { doSmth(3) } }   <v5>   COPY     
+=====================
+== t14 ==
+fun t14() : Int {
+    try {
+        return 1
+    }
+    catch (e: UnsupportedOperationException) {
+        doSmth(2)
+    }
+}
+---------------------
+1                                                                             <v0>   NEW()    
+doSmth                                                                        <v3>   NEW(<v2>)
+2                                                                             <v2>   NEW()    
+doSmth(2)                                                                     <v3>   COPY     
+{ doSmth(2) }                                                                 <v3>   COPY     
+try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) }       <v3>   COPY     
+{ try { return 1 } catch (e: UnsupportedOperationException) { doSmth(2) } }   <v3>   COPY     
+=====================
+== t15 ==
+fun t15() : Int {
+    try {
+        return 1
+    }
+    catch (e: UnsupportedOperationException) {
+        return 2
+    }
+    finally {
+        doSmth(3)
+    }
+}
+---------------------
+1               <v0>   NEW()
+2               <v4>   NEW()
+doSmth          <v2>   NEW(<v1>)
+3               <v1>   NEW()
+doSmth(3)       <v2>   COPY
+{ doSmth(3) }   <v2>   COPY
+=====================
+== t16 ==
+fun t16() : Int {
+    try {
+        doSmth(1)
+    }
+    catch (e: UnsupportedOperationException) {
+        return 2
+    }
+    finally {
+        doSmth(3)
+    }
+}
+---------------------
+doSmth                                                                                              <v1>   NEW(<v0>)
+1                                                                                                   <v0>   NEW()    
+doSmth(1)                                                                                           <v1>   COPY     
+{ doSmth(1) }                                                                                       <v1>   COPY     
+2                                                                                                   <v3>   NEW()
+doSmth                                                                                              <v5>   NEW(<v4>)
+3                                                                                                   <v4>   NEW()    
+doSmth(3)                                                                                           <v5>   COPY     
+{ doSmth(3) }                                                                                       <v5>   COPY     
+try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) }       <v1>   COPY     
+{ try { doSmth(1) } catch (e: UnsupportedOperationException) { return 2 } finally { doSmth(3) } }   <v1>   COPY     
+=====================
+== doSmth ==
+fun doSmth(i: Int) {
+}
+---------------------
+=====================

compiler/testData/cfg/controlStructures/FinallyTestCopy.values

@@ -0,0 +1,131 @@
+== doSmth ==
+fun doSmth() {}
+---------------------
+=====================
+== doSmth1 ==
+fun doSmth1() {}
+---------------------
+=====================
+== doSmth2 ==
+fun doSmth2() {}
+---------------------
+=====================
+== cond ==
+fun cond() {}
+---------------------
+=====================
+== testCopy1 ==
+fun testCopy1() : Int {
+    try {
+        doSmth()
+    }
+    catch (e: NullPointerException) {
+        doSmth1()
+    }
+    catch (e: Exception) {
+        doSmth2()
+    }
+    finally {
+        return 1
+    }
+}
+---------------------
+doSmth                                                                                                                       <v0>   NEW()                
+doSmth()                                                                                                                     <v0>   COPY                 
+{ doSmth() }                                                                                                                 <v0>   COPY                 
+doSmth1                                                                                                                      <v2>   NEW()
+doSmth1()                                                                                                                    <v2>   COPY                 
+{ doSmth1() }                                                                                                                <v2>   COPY                 
+doSmth2                                                                                                                      <v4>   NEW()
+doSmth2()                                                                                                                    <v4>   COPY                 
+{ doSmth2() }                                                                                                                <v4>   COPY                 
+1                                                                                                                            <v5>   NEW()                
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 }       <v6>   NEW(<v0>, <v2>, <v4>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { return 1 } }   <v6>   COPY                 
+=====================
+== testCopy2 ==
+fun testCopy2() {
+    while (cond()) {
+        try {
+            doSmth()
+        }
+        catch (e: NullPointerException) {
+            doSmth1()
+        }
+        catch (e: Exception) {
+            doSmth2()
+        }
+        finally {
+            if (cond()) return
+            else continue
+        }
+    }
+}
+---------------------
+cond                                                                                                                                                 <v0>   NEW()                
+cond()                                                                                                                                               <v0>   COPY                 
+doSmth                                                                                                                                               <v1>   NEW()                
+doSmth()                                                                                                                                             <v1>   COPY                 
+{ doSmth() }                                                                                                                                         <v1>   COPY                 
+doSmth1                                                                                                                                              <v3>   NEW()
+doSmth1()                                                                                                                                            <v3>   COPY                 
+{ doSmth1() }                                                                                                                                        <v3>   COPY                 
+doSmth2                                                                                                                                              <v5>   NEW()
+doSmth2()                                                                                                                                            <v5>   COPY                 
+{ doSmth2() }                                                                                                                                        <v5>   COPY                 
+cond                                                                                                                                                 <v6>   NEW()                
+cond()                                                                                                                                               <v6>   COPY                 
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue }       <v7>   NEW(<v1>, <v3>, <v5>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { if (cond()) return else continue } }   <v7>   COPY                 
+=====================
+== testCopy3 ==
+fun testCopy3() {
+    try {
+        doSmth()
+    }
+    catch (e: NullPointerException) {
+        doSmth1()
+    }
+    catch (e: Exception) {
+        doSmth2()
+    }
+    finally {
+        while (cond());
+    }
+}
+---------------------
+doSmth                                                                                                                              <v0>   NEW()                
+doSmth()                                                                                                                            <v0>   COPY                 
+{ doSmth() }                                                                                                                        <v0>   COPY                 
+doSmth1                                                                                                                             <v2>   NEW()
+doSmth1()                                                                                                                           <v2>   COPY                 
+{ doSmth1() }                                                                                                                       <v2>   COPY                 
+doSmth2                                                                                                                             <v4>   NEW()
+doSmth2()                                                                                                                           <v4>   COPY                 
+{ doSmth2() }                                                                                                                       <v4>   COPY                 
+cond                                                                                                                                <v5>   NEW()                
+cond()                                                                                                                              <v5>   COPY                 
+try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); }       <v6>   NEW(<v0>, <v2>, <v4>)
+{ try { doSmth() } catch (e: NullPointerException) { doSmth1() } catch (e: Exception) { doSmth2() } finally { while (cond()); } }   <v6>   COPY                 
+=====================
+== doTestCopy4 ==
+fun doTestCopy4(list: List<String>?) : Int {
+    try {
+        doSmth()
+    }
+    finally {
+        if(list != null) {
+        }
+    }
+}
+---------------------
+doSmth                                                  <v1>   NEW()
+doSmth()                                                <v1>   COPY           
+{ doSmth() }                                            <v1>   COPY           
+list                                                    <v2>   NEW()          
+!=                                                      <v4>   NEW(<v2>, <v3>)
+null                                                    <v3>   NEW()          
+list != null                                            <v4>   COPY           
+try { doSmth() } finally { if(list != null) { } }       <v1>   COPY           
+{ try { doSmth() } finally { if(list != null) { } } }   <v1>   COPY           
+=====================

compiler/testData/cfg/controlStructures/For.values

@@ -0,0 +1,20 @@
+== t1 ==
+fun t1() {
+    for (i in 1..2) {
+        doSmth(i)
+    }
+}
+---------------------
+1               <v0>   NEW()          
+..              <v2>   NEW(<v0>, <v1>)
+2               <v1>   NEW()          
+1..2            <v2>   COPY
+doSmth          <v5>   NEW(<v4>)      
+i               <v4>   NEW()          
+doSmth(i)       <v5>   COPY           
+{ doSmth(i) }   <v5>   COPY           
+=====================
+== doSmth ==
+fun doSmth(i: Int) {}
+---------------------
+=====================

compiler/testData/cfg/controlStructures/If.values

@@ -0,0 +1,55 @@
+== t1 ==
+fun t1(b: Boolean) {
+    var u: String
+    if (b) {
+        u = "s"
+    }
+    doSmth(u)
+
+    var r: String
+    if (b) {
+        r = "s"
+    }
+    else {
+        r = "t"
+    }
+    doSmth(r)
+}
+---------------------
+b                                                                                                            <v1>   NEW()
+"s"                                                                                                          <v2>   NEW()    
+doSmth                                                                                                       <v4>   NEW(<v3>)
+u                                                                                                            <v3>   NEW()    
+doSmth(u)                                                                                                    <v4>   COPY     
+b                                                                                                            <v5>   NEW()    
+"s"                                                                                                          <v6>   NEW()    
+"t"                                                                                                          <v7>   NEW()    
+doSmth                                                                                                       <v9>   NEW(<v8>)
+r                                                                                                            <v8>   NEW()    
+doSmth(r)                                                                                                    <v9>   COPY     
+{ var u: String if (b) { u = "s" } doSmth(u) var r: String if (b) { r = "s" } else { r = "t" } doSmth(r) }   <v9>   COPY     
+=====================
+== t2 ==
+fun t2(b: Boolean) {
+    val i = 3
+    if (b) {
+        return;
+    }
+    doSmth(i)
+    if (i is Int) {
+        return;
+    }
+}
+---------------------
+3           <v1>   NEW()
+b           <v2>   NEW()
+doSmth      <v4>   NEW(<v3>)
+i           <v3>   NEW()
+doSmth(i)   <v4>   COPY
+i           <v5>   NEW()
+i is Int    <v6>   NEW(<v5>)
+=====================
+== doSmth ==
+fun doSmth(s: String) {}
+---------------------
+=====================

compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.values

@@ -0,0 +1,25 @@
+== main ==
+fun main() {
+    while(0 > 1) {
+      2
+    }
+}
+---------------------
+0       <v0>   NEW()          
+>       <v2>   NEW(<v0>, <v1>)
+1       <v1>   NEW()          
+0 > 1   <v2>   COPY           
+2       <v3>   NEW()          
+{ 2 }   <v3>   COPY           
+=====================
+== dowhile ==
+fun dowhile() {
+    do {return}
+    while(0 > 1)
+}
+---------------------
+0       <v0>   NEW()          
+>       <v2>   NEW(<v0>, <v1>)
+1       <v1>   NEW()          
+0 > 1   <v2>   COPY           
+=====================

compiler/testData/cfg/controlStructures/returnsInWhen.values

@@ -0,0 +1,10 @@
+== illegalWhenBlock ==
+fun illegalWhenBlock(a: Any): Any {
+    when(a) {
+        is Int -> return a
+    }
+}
+---------------------
+a   <v1>   NEW()
+a   <v3>   NEW()
+=====================

compiler/testData/cfg/conventions/equals.values

@@ -0,0 +1,11 @@
+== foo ==
+fun foo(a: Int, b: Int) {
+    if (a == b) {
+    }
+}
+---------------------
+a        <v2>   NEW()
+==       <v4>   NEW(<v2>, <v3>)
+b        <v3>   NEW()          
+a == b   <v4>   COPY           
+=====================

compiler/testData/cfg/conventions/incrementAtTheEnd.values

@@ -0,0 +1,10 @@
+== foo ==
+fun foo() {
+    var i = 1
+    i++
+}
+---------------------
+1    <v0>   NEW()    
+i    <v1>   NEW()    
+++   <v2>   NEW(<v1>)
+=====================

compiler/testData/cfg/conventions/invoke.values

@@ -0,0 +1,9 @@
+== foo ==
+fun foo(f: () -> Unit) {
+    f()
+}
+---------------------
+f         <v2>   NEW(<v1>)
+f()       <v2>   COPY
+{ f() }   <v2>   COPY
+=====================

compiler/testData/cfg/conventions/notEqual.values

@@ -0,0 +1,10 @@
+== neq ==
+fun neq(a: Int, b: Int) {
+    if (a != b) {}
+}
+---------------------
+a        <v2>   NEW()
+!=       <v4>   NEW(<v2>, <v3>)
+b        <v3>   NEW()          
+a != b   <v4>   COPY           
+=====================

compiler/testData/cfg/deadCode/DeadCode.values

@@ -0,0 +1,12 @@
+== test ==
+fun test() {
+    throw Exception()
+    test()
+}
+---------------------
+Exception                      <v0>   NEW()
+Exception()                    <v0>   COPY 
+test                           <v1>   NEW()
+test()                         <v1>   COPY 
+{ throw Exception() test() }   <v1>   COPY 
+=====================

compiler/testData/cfg/deadCode/returnInElvis.values

@@ -0,0 +1,9 @@
+== foo ==
+fun foo() {
+    return ?: null
+}
+---------------------
+null                 <v0>   NEW()
+return ?: null       <v0>   COPY 
+{ return ?: null }   <v0>   COPY 
+=====================

compiler/testData/cfg/deadCode/stringTemplate.values

@@ -0,0 +1,11 @@
+== test ==
+fun test() {
+    "${throw Exception()} ${1}"
+}
+---------------------
+Exception                         <v0>   NEW()    
+Exception()                       <v0>   COPY     
+1                                 <v1>   NEW()    
+"${throw Exception()} ${1}"       <v2>   NEW(<v1>)
+{ "${throw Exception()} ${1}" }   <v2>   COPY     
+=====================

compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.values

@@ -0,0 +1,21 @@
+== AnonymousInitializers ==
+class AnonymousInitializers() {
+    val k = 34
+
+    val i: Int
+    {
+        $i = 12
+    }
+
+    val j: Int
+       get() = 20
+
+    {
+        $i = 13
+    }
+}
+---------------------
+34   <v0>   NEW()
+12   <v1>   NEW()
+13   <v2>   NEW()
+=====================

compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.values

@@ -0,0 +1,12 @@
+== foo ==
+fun foo() {
+    {}
+}
+---------------------
+{}       <v0>   NEW()
+{ {} }   <v0>   COPY 
+=====================
+== anonymous_0 ==
+{}
+---------------------
+=====================

compiler/testData/cfg/declarations/functions/FailFunction.values

@@ -0,0 +1,9 @@
+== fail ==
+fun fail() : Nothing {
+  throw java.lang.RuntimeException()
+}
+---------------------
+RuntimeException               <v0>   NEW()
+RuntimeException()             <v0>   COPY 
+java.lang.RuntimeException()   <v0>   COPY 
+=====================

compiler/testData/cfg/declarations/functions/typeParameter.values

@@ -0,0 +1,8 @@
+== foo ==
+fun <T> foo() {
+    T
+}
+---------------------
+T       <v0>   NEW()
+{ T }   <v0>   COPY 
+=====================

compiler/testData/cfg/declarations/local/LocalDeclarations.values

@@ -0,0 +1,137 @@
+== C ==
+class C() {
+    val a: Int = 1
+
+    class object {
+        val x : Int
+
+        {
+            $x = 1
+        }
+
+
+        fun foo() {
+            val b : Int = 1
+            doSmth(b)
+        }
+    }
+}
+---------------------
+1   <v0>   NEW()
+=====================
+== doSmth ==
+fun doSmth(i: Int) {}
+---------------------
+=====================
+== test1 ==
+fun test1() {
+    val a = object {
+        val x : Int
+        {
+            $x = 1
+        }
+    }
+}
+---------------------
+1                                   <v0>   NEW()
+object { val x : Int { $x = 1 } }   <v1>   NEW()
+=====================
+== O ==
+object O {
+    val x : Int
+    {
+        $x = 1
+    }
+}
+---------------------
+1   <v0>   NEW()
+=====================
+== test2 ==
+fun test2() {
+    val b = 1
+    val a = object {
+        val x = b
+    }
+}
+---------------------
+1                      <v0>   NEW()
+b                      <v1>   NEW()
+object { val x = b }   <v2>   NEW()
+=====================
+== test3 ==
+fun test3() {
+    val a = object {
+        val y : Int
+        fun inner_bar() {
+            y = 10
+        }
+    }
+}
+---------------------
+object { val y : Int fun inner_bar() { y = 10 } }   <v0>   NEW()
+=====================
+== inner_bar ==
+fun inner_bar() {
+            y = 10
+        }
+---------------------
+10   <v0>   NEW()
+=====================
+== test4 ==
+fun test4() {
+    val a = object {
+        val x : Int
+        val y : Int
+        {
+            $x = 1
+        }
+        fun ggg() {
+            y = 10
+        }
+    }
+}
+---------------------
+1                                                                    <v0>   NEW()
+object { val x : Int val y : Int { $x = 1 } fun ggg() { y = 10 } }   <v1>   NEW()
+=====================
+== ggg ==
+fun ggg() {
+            y = 10
+        }
+---------------------
+10   <v0>   NEW()
+=====================
+== test5 ==
+fun test5() {
+    val a = object {
+        var x = 1
+        {
+            $x = 2
+        }
+        fun foo() {
+            x = 3
+        }
+        fun bar() {
+            x = 4
+        }
+    }
+}
+---------------------
+1                                                                         <v0>   NEW()
+2                                                                         <v1>   NEW()
+object { var x = 1 { $x = 2 } fun foo() { x = 3 } fun bar() { x = 4 } }   <v2>   NEW()
+=====================
+== foo ==
+fun foo() {
+            x = 3
+        }
+---------------------
+3   <v0>   NEW()
+=====================
+== bar ==
+fun bar() {
+            x = 4
+        }
+---------------------
+4   <v0>   NEW()
+=====================

compiler/testData/cfg/declarations/local/ObjectExpression.values

@@ -0,0 +1,34 @@
+== A ==
+trait A {
+    fun foo() : Int
+}
+---------------------
+=====================
+== foo ==
+fun foo() : Int
+---------------------
+=====================
+== B ==
+class B : A {
+    override fun foo() = 10
+}
+---------------------
+=====================
+== foo ==
+override fun foo() = 10
+---------------------
+10   <v0>   NEW()
+=====================
+== foo ==
+fun foo(b: B) : Int {
+    val o = object : A by b {}
+    return o.foo()
+}
+---------------------
+b                    <v1>   NEW()
+object : A by b {}   <v2>   NEW()    
+o                    <v3>   NEW()    
+foo                  <v4>   NEW(<v3>)
+foo()                <v4>   COPY     
+o.foo()              <v4>   COPY     
+=====================

compiler/testData/cfg/declarations/local/localClass.values

@@ -0,0 +1,32 @@
+== f ==
+fun f() {
+    class LocalClass() {
+        fun f() {
+            val x = ""
+
+            fun loc() {
+                val x3 = ""
+            }
+        }
+    }
+}
+---------------------
+=====================
+== f ==
+fun f() {
+            val x = ""
+
+            fun loc() {
+                val x3 = ""
+            }
+        }
+---------------------
+""   <v0>   NEW()
+=====================
+== loc ==
+fun loc() {
+                val x3 = ""
+            }
+---------------------
+""   <v0>   NEW()
+=====================

compiler/testData/cfg/declarations/local/localProperty.values

@@ -0,0 +1,20 @@
+== foo ==
+fun foo() {
+    class B {
+        val a: Int
+            get() {
+                val b: Int
+                return b
+            }
+    }
+}
+---------------------
+=====================
+== get_a ==
+get() {
+                val b: Int
+                return b
+            }
+---------------------
+b   <v0>   NEW()
+=====================

compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.values

@@ -0,0 +1,28 @@
+== C ==
+class C {
+    fun component1() = 1
+    fun component2() = 2
+}
+---------------------
+=====================
+== component1 ==
+fun component1() = 1
+---------------------
+1   <v0>   NEW()
+=====================
+== component2 ==
+fun component2() = 2
+---------------------
+2   <v0>   NEW()
+=====================
+== test ==
+fun test(c: C) {
+    val (a, b) = c
+    val d = 1
+}
+---------------------
+a   <v2>   NEW(<v1>)
+b   <v3>   NEW(<v1>)
+c   <v1>   NEW()
+1   <v4>   NEW()
+=====================

compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.values

@@ -0,0 +1,10 @@
+== foo ==
+fun foo(x: Int) {
+    val (a, b) = x
+    a
+}
+---------------------
+x                      <v1>   NEW()
+a                      <v4>   NEW()
+{ val (a, b) = x a }   <v4>   COPY
+=====================

compiler/testData/cfg/declarations/properties/DelegatedProperty.values

@@ -0,0 +1,22 @@
+== Delegate ==
+class Delegate {
+    fun get(_this: Any, p: PropertyMetadata): Int = 0
+}
+---------------------
+=====================
+== get ==
+fun get(_this: Any, p: PropertyMetadata): Int = 0
+---------------------
+0   <v2>   NEW()
+=====================
+== a ==
+val a = Delegate()
+---------------------
+Delegate     <v0>   NEW()
+Delegate()   <v0>   COPY 
+=====================
+== b ==
+val b by a
+---------------------
+a   <v0>   NEW()
+=====================

compiler/testData/cfg/declarations/properties/backingFieldAccess.values

@@ -0,0 +1,13 @@
+== C ==
+class C {
+    val a: Int
+        get() = 1
+
+    {
+        $a
+    }
+}
+---------------------
+$a       <v0>   NEW()
+{ $a }   <v0>   COPY 
+=====================

compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.values

@@ -0,0 +1,17 @@
+== Bar ==
+abstract class Bar {
+    abstract var bar : String
+    fun foo() = "foo" + this.$bar
+}
+---------------------
+=====================
+== foo ==
+fun foo() = "foo" + this.$bar
+---------------------
+"foo"               <v0>   NEW()          
++                   <v3>   NEW(<v0>, <v2>)
+this                <v1>   NEW()          
+$bar                <v2>   NEW(<v1>)      
+this.$bar           <v2>   COPY           
+"foo" + this.$bar   <v3>   COPY           
+=====================

compiler/testData/cfg/expressions/Assignments.values

@@ -0,0 +1,47 @@
+== Test ==
+class Test {
+  var x : Int;
+}
+---------------------
+=====================
+== assignments ==
+fun assignments() : Unit {
+    var x = 1
+    x = 2
+    x += 2
+
+    x = if (true) 1 else 2
+
+    val y = true && false
+    val z = false && true
+
+    val t = Test();
+    t.x = 1
+    t.x += 1
+}
+---------------------
+1                    <v0>    NEW()            
+2                    <v1>    NEW()            
+x                    <v2>    NEW()            
++=                   <v4>    NEW(<v2>, <v3>)  
+2                    <v3>    NEW()            
+true                 <v5>    NEW()            
+1                    <v6>    NEW()            
+2                    <v7>    NEW()            
+if (true) 1 else 2   <v8>    NEW(<v6>, <v7>)  
+true                 <v9>    NEW()            
+false                <v10>   NEW()            
+true && false        <v11>   NEW(<v9>, <v10>) 
+false                <v12>   NEW()            
+true                 <v13>   NEW()            
+false && true        <v14>   NEW(<v12>, <v13>)
+Test                 <v15>   NEW()            
+Test()               <v15>   COPY             
+t                    <v17>   NEW()            
+1                    <v16>   NEW()            
+t                    <v22>   NEW()            
+x                    <v19>   NEW(<v18>)       
+t.x                  <v19>   COPY             
++=                   <v21>   NEW(<v19>, <v20>)
+1                    <v20>   NEW()            
+=====================

compiler/testData/cfg/expressions/LazyBooleans.values

@@ -0,0 +1,48 @@
+== lazyBooleans ==
+fun lazyBooleans(a : Boolean, b : Boolean) : Unit {
+    if (a) {
+      1
+    }
+    else {
+      2
+    }
+    3
+    if (a && b) 5 else 6
+    7
+    if (a || b) 8 else 9
+    10
+    if (a) 11
+    12
+    if (a) else 13
+    14
+}
+---------------------
+a                                                                                                             <v2>    NEW()
+1                                                                                                             <v3>    NEW()            
+{ 1 }                                                                                                         <v3>    COPY             
+2                                                                                                             <v4>    NEW()            
+{ 2 }                                                                                                         <v4>    COPY             
+if (a) { 1 } else { 2 }                                                                                       <v5>    NEW(<v3>, <v4>)  
+3                                                                                                             <v6>    NEW()            
+a                                                                                                             <v7>    NEW()            
+b                                                                                                             <v8>    NEW()            
+5                                                                                                             <v9>    NEW()            
+6                                                                                                             <v10>   NEW()            
+if (a && b) 5 else 6                                                                                          <v11>   NEW(<v9>, <v10>) 
+7                                                                                                             <v12>   NEW()            
+a                                                                                                             <v13>   NEW()            
+b                                                                                                             <v14>   NEW()            
+8                                                                                                             <v15>   NEW()            
+9                                                                                                             <v16>   NEW()            
+if (a || b) 8 else 9                                                                                          <v17>   NEW(<v15>, <v16>)
+10                                                                                                            <v18>   NEW()            
+a                                                                                                             <v19>   NEW()            
+11                                                                                                            <v20>   NEW()            
+if (a) 11                                                                                                     <v20>   COPY             
+12                                                                                                            <v21>   NEW()            
+a                                                                                                             <v22>   NEW()            
+13                                                                                                            <v23>   NEW()            
+if (a) else 13                                                                                                <v23>   COPY             
+14                                                                                                            <v24>   NEW()            
+{ if (a) { 1 } else { 2 } 3 if (a && b) 5 else 6 7 if (a || b) 8 else 9 10 if (a) 11 12 if (a) else 13 14 }   <v24>   COPY             
+=====================

compiler/testData/cfg/expressions/ReturnFromExpression.values

@@ -0,0 +1,10 @@
+== blockAndAndMismatch ==
+fun blockAndAndMismatch() : Boolean {
+  false || (return false)
+}
+---------------------
+false                         <v0>   NEW()    
+false                         <v1>   NEW()    
+false || (return false)       <v2>   NEW(<v0>)
+{ false || (return false) }   <v2>   COPY     
+=====================

compiler/testData/cfg/expressions/assignmentToThis.values

@@ -0,0 +1,7 @@
+== bar ==
+fun Int.bar(c: C) {
+    this = c
+}
+---------------------
+c   <v1>   NEW()
+=====================

compiler/testData/cfg/expressions/chainedQualifiedExpression.values

@@ -0,0 +1,337 @@
+== JetToken ==
+class JetToken
+---------------------
+=====================
+== JetKeywordCompletionContributor ==
+public open class JetKeywordCompletionContributor() {
+    {
+        val inTopLevel = 1.0
+
+        BunchKeywordRegister()
+                .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+
+                .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)
+                .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)
+                .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)
+                .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)
+
+                .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+                .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)
+
+                .add(IMPORT_KEYWORD, inTopLevel)
+                .add(PACKAGE_KEYWORD, inTopLevel)
+
+                .add(OVERRIDE_KEYWORD, inTopLevel)
+
+                .add(IN_KEYWORD, inTopLevel, inTopLevel)
+
+                .add(OUT_KEYWORD, inTopLevel)
+
+                .add(OBJECT_KEYWORD, unresolvedCode)
+
+                .registerAll()
+    }
+
+    private inner class BunchKeywordRegister() {
+        fun add(keyword= JetToken(), vararg filters: Double): BunchKeywordRegister {
+        }
+
+        fun registerAll() {
+        }
+    }
+}
+---------------------
+1.0                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v0>     NEW()                                        
+BunchKeywordRegister                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v1>     NEW()                                        
+BunchKeywordRegister()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v1>     COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v6>     NEW(<v1>, <v2>, <v3>, <v4>, <v5>)            
+ABSTRACT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v2>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v3>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v4>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v5>     NEW()                                        
+add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v6>     COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v6>     COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v11>    NEW(<v6>, <v7>, <v8>, <v9>, <v10>)           
+FINAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v7>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v8>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v9>     NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v10>    NEW()                                        
+add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v11>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v11>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v16>    NEW(<v11>, <v12>, <v13>, <v14>, <v15>)       
+OPEN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v12>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v13>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v14>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v15>    NEW()                                        
+add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v16>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v16>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v22>    NEW(<v16>, <v17>, <v18>, <v19>, <v20>, <v21>)
+INTERNAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v17>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v18>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v19>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v20>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v21>    NEW()                                        
+add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v22>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v22>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v28>    NEW(<v22>, <v23>, <v24>, <v25>, <v26>, <v27>)
+PRIVATE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v23>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v24>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v25>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v26>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v27>    NEW()                                        
+add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v28>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v28>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v34>    NEW(<v28>, <v29>, <v30>, <v31>, <v32>, <v33>)
+PROTECTED_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v29>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v30>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v31>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v32>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v33>    NEW()                                        
+add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v34>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v34>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v40>    NEW(<v34>, <v35>, <v36>, <v37>, <v38>, <v39>)
+PUBLIC_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v35>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v36>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v37>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v38>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v39>    NEW()                                        
+add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v40>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v40>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v45>    NEW(<v40>, <v41>, <v42>, <v43>, <v44>)       
+CLASS_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v41>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v42>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v43>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v44>    NEW()                                        
+add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v45>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 <v45>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v50>    NEW(<v45>, <v46>, <v47>, <v48>, <v49>)       
+ENUM_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v46>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v47>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v48>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v49>    NEW()                                        
+add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v50>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          <v50>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v55>    NEW(<v50>, <v51>, <v52>, <v53>, <v54>)       
+FUN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v51>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v52>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v53>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v54>    NEW()                                        
+add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v55>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v55>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v60>    NEW(<v55>, <v56>, <v57>, <v58>, <v59>)       
+GET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v56>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v57>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v58>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v59>    NEW()                                        
+add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v60>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v60>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v65>    NEW(<v60>, <v61>, <v62>, <v63>, <v64>)       
+SET_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v61>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v62>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v63>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v64>    NEW()                                        
+add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v65>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v65>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v70>    NEW(<v65>, <v66>, <v67>, <v68>, <v69>)       
+TRAIT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v66>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v67>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v68>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v69>    NEW()                                        
+add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             <v70>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                <v70>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v75>    NEW(<v70>, <v71>, <v72>, <v73>, <v74>)       
+VAL_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v71>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v72>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v73>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v74>    NEW()                                        
+add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v75>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                          <v75>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v80>    NEW(<v75>, <v76>, <v77>, <v78>, <v79>)       
+VAR_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v76>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v77>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v78>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v79>    NEW()                                        
+add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               <v80>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                    <v80>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v85>    NEW(<v80>, <v81>, <v82>, <v83>, <v84>)       
+TYPE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v81>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v82>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v83>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v84>    NEW()                                        
+add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              <v85>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                             <v85>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v88>    NEW(<v85>, <v86>, <v87>)                     
+IMPORT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v86>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v87>    NEW()                                        
+add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v88>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel)                                                                                                                                                                                                                            <v88>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v91>    NEW(<v88>, <v89>, <v90>)                     
+PACKAGE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    <v89>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v90>    NEW()                                        
+add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v91>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel)                                                                                                                                                                                          <v91>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v94>    NEW(<v91>, <v92>, <v93>)                     
+OVERRIDE_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   <v92>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v93>    NEW()                                        
+add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  <v94>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel)                                                                                                                                                       <v94>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v98>    NEW(<v94>, <v95>, <v96>, <v97>)              
+IN_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v95>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v96>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v97>    NEW()                                        
+add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            <v98>    COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel)                                                                                                              <v98>    COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v101>   NEW(<v98>, <v99>, <v100>)                    
+OUT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v99>    NEW()                                        
+inTopLevel                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         <v100>   NEW()                                        
+add(OUT_KEYWORD, inTopLevel)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       <v101>   COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel)                                                                                <v101>   COPY                                         
+add                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v104>   NEW(<v101>, <v102>, <v103>)                  
+OBJECT_KEYWORD                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v102>   NEW()                                        
+unresolvedCode                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     <v103>   NEW()                                        
+add(OBJECT_KEYWORD, unresolvedCode)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <v104>   COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode)                                           <v104>   COPY                                         
+registerAll                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <v105>   NEW(<v104>)                                  
+registerAll()                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      <v105>   COPY                                         
+BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll()                            <v105>   COPY                                         
+{ val inTopLevel = 1.0 BunchKeywordRegister() .add(ABSTRACT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FINAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(OPEN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(INTERNAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PRIVATE_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PROTECTED_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(PUBLIC_KEYWORD, inTopLevel, inTopLevel, inTopLevel, inTopLevel) .add(CLASS_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(ENUM_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(FUN_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(GET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(SET_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TRAIT_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAL_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(VAR_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(TYPE_KEYWORD, inTopLevel, inTopLevel, inTopLevel) .add(IMPORT_KEYWORD, inTopLevel) .add(PACKAGE_KEYWORD, inTopLevel) .add(OVERRIDE_KEYWORD, inTopLevel) .add(IN_KEYWORD, inTopLevel, inTopLevel) .add(OUT_KEYWORD, inTopLevel) .add(OBJECT_KEYWORD, unresolvedCode) .registerAll() }   <v105>   COPY                                         
+=====================
+== ABSTRACT_KEYWORD ==
+val ABSTRACT_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== FINAL_KEYWORD ==
+val FINAL_KEYWORD OPEN_KEYWORD = JetToken()
+---------------------
+=====================
+== OPEN_KEYWORD ==
+val OPEN_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== INTERNAL_KEYWORD ==
+val INTERNAL_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== PRIVATE_KEYWORD ==
+val PRIVATE_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== PROTECTED_KEYWORD ==
+val PROTECTED_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== PUBLIC_KEYWORD ==
+val PUBLIC_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== CLASS_KEYWORD ==
+val CLASS_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== ENUM_KEYWORD ==
+val ENUM_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== FUN_KEYWORD ==
+val FUN_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== GET_KEYWORD ==
+val GET_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== SET_KEYWORD ==
+val SET_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== TRAIT_KEYWORD ==
+val TRAIT_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== VAL_KEYWORD ==
+val VAL_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== VAR_KEYWORD ==
+val VAR_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== TYPE_KEYWORD ==
+val TYPE_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== IMPORT_KEYWORD ==
+val IMPORT_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== PACKAGE_KEYWORD ==
+val PACKAGE_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== OVERRIDE_KEYWORD ==
+val OVERRIDE_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== IN_KEYWORD ==
+val IN_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== OUT_KEYWORD ==
+val OUT_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================
+== OBJECT_KEYWORD ==
+val OBJECT_KEYWORD = JetToken()
+---------------------
+JetToken     <v0>   NEW()
+JetToken()   <v0>   COPY 
+=====================

compiler/testData/cfg/expressions/expressionAsFunction.values

@@ -0,0 +1,10 @@
+== invoke ==
+fun invoke(f: () -> Unit) {
+    (f)()
+}
+---------------------
+f           <v1>   NEW()
+(f)         <v2>   NEW(<v1>)
+(f)()       <v2>   COPY
+{ (f)() }   <v2>   COPY
+=====================

compiler/testData/cfg/expressions/nothingExpr.values

@@ -0,0 +1,25 @@
+== doSomething ==
+fun Any?.doSomething() {}
+---------------------
+=====================
+== bar ==
+fun bar(): Nothing = throw Exception()
+---------------------
+Exception     <v0>   NEW()
+Exception()   <v0>   COPY 
+=====================
+== foo ==
+fun foo() {
+    null!!.doSomething()
+    bar().doSomething
+}
+---------------------
+null                                         <v0>   NEW()    
+null!!                                       <v1>   NEW(<v0>)
+doSomething                                  <v2>   NEW(<v1>)
+doSomething()                                <v2>   COPY     
+null!!.doSomething()                         <v2>   COPY     
+doSomething                                  <v3>   NEW()    
+bar().doSomething                            <v3>   COPY     
+{ null!!.doSomething() bar().doSomething }   <v3>   COPY     
+=====================

compiler/testData/cfg/expressions/propertySafeCall.values

@@ -0,0 +1,10 @@
+== test ==
+fun test(s: String?) {
+    s?.length
+}
+---------------------
+s               <v1>   NEW()
+length          <v2>   NEW(<v1>)
+s?.length       <v2>   COPY     
+{ s?.length }   <v2>   COPY     
+=====================

compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.values

@@ -0,0 +1,9 @@
+== foo ==
+fun foo(s: String) {
+    s.
+}
+---------------------
+s        <v1>   NEW()
+s.       <v2>   NEW(<v1>)
+{ s. }   <v2>   COPY
+=====================

compiler/testData/cfg/expressions/thisExpression.values

@@ -0,0 +1,9 @@
+== foo ==
+fun Function0<Unit>.foo() {
+    this()
+}
+---------------------
+this         <v0>   NEW()
+this()       <v0>   COPY 
+{ this() }   <v0>   COPY 
+=====================

compiler/testData/cfg/expressions/unresolvedCall.values

@@ -0,0 +1,11 @@
+== test ==
+fun test(a: Any) {
+    a.foo()
+}
+---------------------
+a             <v1>   NEW()
+foo           <v2>   NEW(<v1>)
+foo()         <v2>   COPY     
+a.foo()       <v2>   COPY     
+{ a.foo() }   <v2>   COPY     
+=====================

compiler/testData/cfg/expressions/unresolvedProperty.values

@@ -0,0 +1,10 @@
+== test ==
+fun test(a: Any) {
+    a.foo
+}
+---------------------
+a           <v1>   NEW()
+foo         <v2>   NEW(<v1>)
+a.foo       <v2>   COPY     
+{ a.foo }   <v2>   COPY     
+=====================

compiler/testData/cfg/expressions/unusedExpressionSimpleName.values

@@ -0,0 +1,8 @@
+== main ==
+fun main(arg : Array<String>) {
+    a
+}
+---------------------
+a       <v1>   NEW()
+{ a }   <v1>   COPY
+=====================

compiler/testData/cfg/tailCalls/finally.values

@@ -0,0 +1,13 @@
+== test ==
+tailRecursive fun test() : Int {
+    try {
+        // do nothing
+    } finally {
+        test()
+    }
+}
+---------------------
+test         <v0>   NEW()
+test()       <v0>   COPY 
+{ test() }   <v0>   COPY 
+=====================

compiler/testData/cfg/tailCalls/finallyWithReturn.values

@@ -0,0 +1,12 @@
+== test ==
+tailRecursive fun test() : Int {
+    try {
+        // do nothing
+    } finally {
+        return test()
+    }
+}
+---------------------
+test     <v0>   NEW()
+test()   <v0>   COPY 
+=====================

compiler/testData/cfg/tailCalls/sum.values

@@ -0,0 +1,25 @@
+== sum ==
+tailRecursive fun sum(x: Long, sum: Long): Long {
+    if (x == 0.toLong()) return sum
+    return sum(x - 1, sum + x)
+}
+---------------------
+x                     <v2>    NEW()
+==                    <v5>    NEW(<v2>, <v4>)  
+0                     <v3>    NEW()            
+toLong                <v4>    NEW(<v3>)        
+toLong()              <v4>    COPY             
+0.toLong()            <v4>    COPY             
+x == 0.toLong()       <v5>    COPY             
+sum                   <v6>    NEW()            
+sum                   <v13>   NEW(<v9>, <v12>) 
+x                     <v7>    NEW()            
+-                     <v9>    NEW(<v7>, <v8>)  
+1                     <v8>    NEW()            
+x - 1                 <v9>    COPY             
+sum                   <v10>   NEW()            
++                     <v12>   NEW(<v10>, <v11>)
+x                     <v11>   NEW()            
+sum + x               <v12>   COPY             
+sum(x - 1, sum + x)   <v13>   COPY             
+=====================

compiler/testData/cfg/tailCalls/try.values

@@ -0,0 +1,12 @@
+== foo ==
+tailRecursive fun foo() {
+    try {
+        return foo()
+    }
+    catch (e: Throwable) {
+    }
+}
+---------------------
+foo     <v0>   NEW()
+foo()   <v0>   COPY
+=====================

compiler/testData/cfg/tailCalls/tryCatchFinally.values

@@ -0,0 +1,23 @@
+== test ==
+fun test() : Unit {
+    try {
+        test()
+    } catch (any : Exception) {
+        test()
+    } finally {
+        test()
+    }
+}
+---------------------
+test                                                                       <v0>   NEW()          
+test()                                                                     <v0>   COPY           
+{ test() }                                                                 <v0>   COPY           
+test                                                                       <v2>   NEW()
+test()                                                                     <v2>   COPY           
+{ test() }                                                                 <v2>   COPY           
+test                                                                       <v3>   NEW()          
+test()                                                                     <v3>   COPY           
+{ test() }                                                                 <v3>   COPY           
+try { test() } catch (any : Exception) { test() } finally { test() }       <v4>   NEW(<v0>, <v2>)
+{ try { test() } catch (any : Exception) { test() } finally { test() } }   <v4>   COPY           
+=====================

compiler/tests/org/jetbrains/jet/cfg/AbstractPseudoValueTest.kt

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.cfg
+
+import org.jetbrains.jet.lang.cfg.pseudocode.PseudoValue
+import org.jetbrains.jet.lang.cfg.pseudocode.PseudocodeImpl
+import org.jetbrains.jet.lang.psi.JetElement
+import org.jetbrains.jet.lang.psi.JetTreeVisitorVoid
+import org.jetbrains.jet.lang.resolve.BindingContext
+import java.util.*
+
+public abstract class AbstractPseudoValueTest : AbstractPseudocodeTest() {
+    override fun dumpInstructions(pseudocode: PseudocodeImpl, out: StringBuilder, bindingContext: BindingContext) {
+        fun getElementToValueMap(pseudocode: PseudocodeImpl): Map<JetElement, PseudoValue> {
+            val elementToValues = LinkedHashMap<JetElement, PseudoValue>()
+            pseudocode.getCorrespondingElement().accept(object : JetTreeVisitorVoid() {
+                override fun visitJetElement(element: JetElement) {
+                    super.visitJetElement(element)
+
+                    val value = pseudocode.getElementValue(element)
+                    if (value != null) {
+                        elementToValues.put(element, value)
+                    }
+                }
+            })
+            return elementToValues
+        }
+
+        fun maxLength(strings: Iterable<String>): Int = strings.map { it.length }.max() ?: 0
+
+        fun elementText(element: JetElement): String = element.getText()!!.replaceAll("\\s+", " ")
+
+        fun valueDescription(element: JetElement, value: PseudoValue): String {
+            return if (value.element != element) "COPY" else "NEW${value.createdAt.getInputValues().makeString(", ", "(", ")")}"
+        }
+
+        val elementToValues = getElementToValueMap(pseudocode)
+        if (elementToValues.isEmpty()) return
+
+        val elementColumnWidth = elementToValues.keySet().map { elementText(it).length() }.max()!!
+        val valueColumnWidth = elementToValues.values().map { it.debugName.length() }.max()!!
+        val valueDescColumnWidth = elementToValues.entrySet().map { valueDescription(it.key, it.value).length }.max()!!
+
+        for ((element, value) in elementToValues.entrySet()) {
+            out
+                    .append("%1$-${elementColumnWidth}s".format(elementText(element)))
+                    .append("   ")
+                    .append("%1$-${valueColumnWidth}s".format(value.debugName))
+                    .append("   ")
+                    .append("%1$-${valueDescColumnWidth}s".format(valueDescription(element, value)))
+                    .append("\n")
+        }
+    }
+
+    override fun getDataFileExtension(): String? = "values"
+}

compiler/tests/org/jetbrains/jet/cfg/AbstractPseudocodeTest.java

@@ -119,10 +119,14 @@ public abstract class AbstractPseudocodeTest extends KotlinTestWithEnvironment {
             checkPseudocode((PseudocodeImpl) pseudocode);
         }
 
-        File expectedInstructionsFile = JetTestUtils.replaceExtension(file, "instructions");
+        File expectedInstructionsFile = JetTestUtils.replaceExtension(file, getDataFileExtension());
         JetTestUtils.assertEqualsToFile(expectedInstructionsFile, instructionDump.toString());
     }
 
+    protected String getDataFileExtension() {
+        return "instructions";
+    }
+
     protected void checkPseudocode(PseudocodeImpl pseudocode) {
     }
 

compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java

@@ -0,0 +1,607 @@
+/*
+ * Copyright 2010-2014 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.jet.cfg;
+
+import junit.framework.Assert;
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+import java.io.File;
+import java.util.regex.Pattern;
+import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.test.InnerTestClasses;
+import org.jetbrains.jet.test.TestMetadata;
+
+import org.jetbrains.jet.cfg.AbstractPseudoValueTest;
+
+/** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@InnerTestClasses({PseudoValueTestGenerated.Cfg.class, PseudoValueTestGenerated.Cfg_variables.class})
+public class PseudoValueTestGenerated extends AbstractPseudoValueTest {
+    @TestMetadata("compiler/testData/cfg")
+    @InnerTestClasses({Cfg.Arrays.class, Cfg.Basic.class, Cfg.Bugs.class, Cfg.ControlStructures.class, Cfg.Conventions.class, Cfg.DeadCode.class, Cfg.Declarations.class, Cfg.Expressions.class, Cfg.TailCalls.class})
+    public static class Cfg extends AbstractPseudoValueTest {
+        public void testAllFilesPresentInCfg() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("compiler/testData/cfg/arrays")
+        public static class Arrays extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInArrays() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/arrays"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("ArrayAccess.kt")
+            public void testArrayAccess() throws Exception {
+                doTest("compiler/testData/cfg/arrays/ArrayAccess.kt");
+            }
+            
+            @TestMetadata("arrayAccessExpression.kt")
+            public void testArrayAccessExpression() throws Exception {
+                doTest("compiler/testData/cfg/arrays/arrayAccessExpression.kt");
+            }
+            
+            @TestMetadata("arrayInc.kt")
+            public void testArrayInc() throws Exception {
+                doTest("compiler/testData/cfg/arrays/arrayInc.kt");
+            }
+            
+            @TestMetadata("ArrayOfFunctions.kt")
+            public void testArrayOfFunctions() throws Exception {
+                doTest("compiler/testData/cfg/arrays/ArrayOfFunctions.kt");
+            }
+            
+            @TestMetadata("arraySet.kt")
+            public void testArraySet() throws Exception {
+                doTest("compiler/testData/cfg/arrays/arraySet.kt");
+            }
+            
+            @TestMetadata("arraySetPlusAssign.kt")
+            public void testArraySetPlusAssign() throws Exception {
+                doTest("compiler/testData/cfg/arrays/arraySetPlusAssign.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/basic")
+        public static class Basic extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInBasic() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/basic"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("Basic.kt")
+            public void testBasic() throws Exception {
+                doTest("compiler/testData/cfg/basic/Basic.kt");
+            }
+            
+            @TestMetadata("EmptyFunction.kt")
+            public void testEmptyFunction() throws Exception {
+                doTest("compiler/testData/cfg/basic/EmptyFunction.kt");
+            }
+            
+            @TestMetadata("ShortFunction.kt")
+            public void testShortFunction() throws Exception {
+                doTest("compiler/testData/cfg/basic/ShortFunction.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/bugs")
+        public static class Bugs extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInBugs() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/bugs"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("jumpToOuterScope.kt")
+            public void testJumpToOuterScope() throws Exception {
+                doTest("compiler/testData/cfg/bugs/jumpToOuterScope.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/controlStructures")
+        public static class ControlStructures extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInControlStructures() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/controlStructures"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("Finally.kt")
+            public void testFinally() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/Finally.kt");
+            }
+            
+            @TestMetadata("FinallyTestCopy.kt")
+            public void testFinallyTestCopy() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/FinallyTestCopy.kt");
+            }
+            
+            @TestMetadata("For.kt")
+            public void testFor() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/For.kt");
+            }
+            
+            @TestMetadata("If.kt")
+            public void testIf() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/If.kt");
+            }
+            
+            @TestMetadata("OnlyWhileInFunctionBody.kt")
+            public void testOnlyWhileInFunctionBody() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/OnlyWhileInFunctionBody.kt");
+            }
+            
+            @TestMetadata("returnsInWhen.kt")
+            public void testReturnsInWhen() throws Exception {
+                doTest("compiler/testData/cfg/controlStructures/returnsInWhen.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/conventions")
+        public static class Conventions extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInConventions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/conventions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("equals.kt")
+            public void testEquals() throws Exception {
+                doTest("compiler/testData/cfg/conventions/equals.kt");
+            }
+            
+            @TestMetadata("incrementAtTheEnd.kt")
+            public void testIncrementAtTheEnd() throws Exception {
+                doTest("compiler/testData/cfg/conventions/incrementAtTheEnd.kt");
+            }
+            
+            @TestMetadata("invoke.kt")
+            public void testInvoke() throws Exception {
+                doTest("compiler/testData/cfg/conventions/invoke.kt");
+            }
+            
+            @TestMetadata("notEqual.kt")
+            public void testNotEqual() throws Exception {
+                doTest("compiler/testData/cfg/conventions/notEqual.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/deadCode")
+        public static class DeadCode extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInDeadCode() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/deadCode"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("DeadCode.kt")
+            public void testDeadCode() throws Exception {
+                doTest("compiler/testData/cfg/deadCode/DeadCode.kt");
+            }
+            
+            @TestMetadata("returnInElvis.kt")
+            public void testReturnInElvis() throws Exception {
+                doTest("compiler/testData/cfg/deadCode/returnInElvis.kt");
+            }
+            
+            @TestMetadata("stringTemplate.kt")
+            public void testStringTemplate() throws Exception {
+                doTest("compiler/testData/cfg/deadCode/stringTemplate.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/declarations")
+        @InnerTestClasses({Declarations.ClassesAndObjects.class, Declarations.FunctionLiterals.class, Declarations.Functions.class, Declarations.Local.class, Declarations.MultiDeclaration.class, Declarations.Properties.class})
+        public static class Declarations extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInDeclarations() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/classesAndObjects")
+            public static class ClassesAndObjects extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInClassesAndObjects() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/classesAndObjects"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("AnonymousInitializers.kt")
+                public void testAnonymousInitializers() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.kt");
+                }
+                
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/functionLiterals")
+            public static class FunctionLiterals extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInFunctionLiterals() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/functionLiterals"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("unusedFunctionLiteral.kt")
+                public void testUnusedFunctionLiteral() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/functionLiterals/unusedFunctionLiteral.kt");
+                }
+                
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/functions")
+            public static class Functions extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInFunctions() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/functions"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("FailFunction.kt")
+                public void testFailFunction() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/functions/FailFunction.kt");
+                }
+                
+                @TestMetadata("typeParameter.kt")
+                public void testTypeParameter() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/functions/typeParameter.kt");
+                }
+                
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/local")
+            public static class Local extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInLocal() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/local"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("localClass.kt")
+                public void testLocalClass() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/local/localClass.kt");
+                }
+                
+                @TestMetadata("LocalDeclarations.kt")
+                public void testLocalDeclarations() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/local/LocalDeclarations.kt");
+                }
+                
+                @TestMetadata("localProperty.kt")
+                public void testLocalProperty() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/local/localProperty.kt");
+                }
+                
+                @TestMetadata("ObjectExpression.kt")
+                public void testObjectExpression() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/local/ObjectExpression.kt");
+                }
+                
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/multiDeclaration")
+            public static class MultiDeclaration extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInMultiDeclaration() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/multiDeclaration"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("MultiDecl.kt")
+                public void testMultiDecl() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/multiDeclaration/MultiDecl.kt");
+                }
+                
+                @TestMetadata("multiDeclarationWithError.kt")
+                public void testMultiDeclarationWithError() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/multiDeclaration/multiDeclarationWithError.kt");
+                }
+                
+            }
+            
+            @TestMetadata("compiler/testData/cfg/declarations/properties")
+            public static class Properties extends AbstractPseudoValueTest {
+                public void testAllFilesPresentInProperties() throws Exception {
+                    JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/declarations/properties"), Pattern.compile("^(.+)\\.kt$"), true);
+                }
+                
+                @TestMetadata("backingFieldAccess.kt")
+                public void testBackingFieldAccess() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/properties/backingFieldAccess.kt");
+                }
+                
+                @TestMetadata("backingFieldQualifiedWithThis.kt")
+                public void testBackingFieldQualifiedWithThis() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/properties/backingFieldQualifiedWithThis.kt");
+                }
+                
+                @TestMetadata("DelegatedProperty.kt")
+                public void testDelegatedProperty() throws Exception {
+                    doTest("compiler/testData/cfg/declarations/properties/DelegatedProperty.kt");
+                }
+                
+            }
+            
+            public static Test innerSuite() {
+                TestSuite suite = new TestSuite("Declarations");
+                suite.addTestSuite(Declarations.class);
+                suite.addTestSuite(ClassesAndObjects.class);
+                suite.addTestSuite(FunctionLiterals.class);
+                suite.addTestSuite(Functions.class);
+                suite.addTestSuite(Local.class);
+                suite.addTestSuite(MultiDeclaration.class);
+                suite.addTestSuite(Properties.class);
+                return suite;
+            }
+        }
+        
+        @TestMetadata("compiler/testData/cfg/expressions")
+        public static class Expressions extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInExpressions() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/expressions"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("assignmentToThis.kt")
+            public void testAssignmentToThis() throws Exception {
+                doTest("compiler/testData/cfg/expressions/assignmentToThis.kt");
+            }
+            
+            @TestMetadata("Assignments.kt")
+            public void testAssignments() throws Exception {
+                doTest("compiler/testData/cfg/expressions/Assignments.kt");
+            }
+            
+            @TestMetadata("chainedQualifiedExpression.kt")
+            public void testChainedQualifiedExpression() throws Exception {
+                doTest("compiler/testData/cfg/expressions/chainedQualifiedExpression.kt");
+            }
+            
+            @TestMetadata("expressionAsFunction.kt")
+            public void testExpressionAsFunction() throws Exception {
+                doTest("compiler/testData/cfg/expressions/expressionAsFunction.kt");
+            }
+            
+            @TestMetadata("LazyBooleans.kt")
+            public void testLazyBooleans() throws Exception {
+                doTest("compiler/testData/cfg/expressions/LazyBooleans.kt");
+            }
+            
+            @TestMetadata("nothingExpr.kt")
+            public void testNothingExpr() throws Exception {
+                doTest("compiler/testData/cfg/expressions/nothingExpr.kt");
+            }
+            
+            @TestMetadata("propertySafeCall.kt")
+            public void testPropertySafeCall() throws Exception {
+                doTest("compiler/testData/cfg/expressions/propertySafeCall.kt");
+            }
+            
+            @TestMetadata("qualifiedExpressionWithoutSelector.kt")
+            public void testQualifiedExpressionWithoutSelector() throws Exception {
+                doTest("compiler/testData/cfg/expressions/qualifiedExpressionWithoutSelector.kt");
+            }
+            
+            @TestMetadata("ReturnFromExpression.kt")
+            public void testReturnFromExpression() throws Exception {
+                doTest("compiler/testData/cfg/expressions/ReturnFromExpression.kt");
+            }
+            
+            @TestMetadata("thisExpression.kt")
+            public void testThisExpression() throws Exception {
+                doTest("compiler/testData/cfg/expressions/thisExpression.kt");
+            }
+            
+            @TestMetadata("unresolvedCall.kt")
+            public void testUnresolvedCall() throws Exception {
+                doTest("compiler/testData/cfg/expressions/unresolvedCall.kt");
+            }
+            
+            @TestMetadata("unresolvedProperty.kt")
+            public void testUnresolvedProperty() throws Exception {
+                doTest("compiler/testData/cfg/expressions/unresolvedProperty.kt");
+            }
+            
+            @TestMetadata("unusedExpressionSimpleName.kt")
+            public void testUnusedExpressionSimpleName() throws Exception {
+                doTest("compiler/testData/cfg/expressions/unusedExpressionSimpleName.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg/tailCalls")
+        public static class TailCalls extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInTailCalls() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg/tailCalls"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("finally.kt")
+            public void testFinally() throws Exception {
+                doTest("compiler/testData/cfg/tailCalls/finally.kt");
+            }
+            
+            @TestMetadata("finallyWithReturn.kt")
+            public void testFinallyWithReturn() throws Exception {
+                doTest("compiler/testData/cfg/tailCalls/finallyWithReturn.kt");
+            }
+            
+            @TestMetadata("sum.kt")
+            public void testSum() throws Exception {
+                doTest("compiler/testData/cfg/tailCalls/sum.kt");
+            }
+            
+            @TestMetadata("try.kt")
+            public void testTry() throws Exception {
+                doTest("compiler/testData/cfg/tailCalls/try.kt");
+            }
+            
+            @TestMetadata("tryCatchFinally.kt")
+            public void testTryCatchFinally() throws Exception {
+                doTest("compiler/testData/cfg/tailCalls/tryCatchFinally.kt");
+            }
+            
+        }
+        
+        public static Test innerSuite() {
+            TestSuite suite = new TestSuite("Cfg");
+            suite.addTestSuite(Cfg.class);
+            suite.addTestSuite(Arrays.class);
+            suite.addTestSuite(Basic.class);
+            suite.addTestSuite(Bugs.class);
+            suite.addTestSuite(ControlStructures.class);
+            suite.addTestSuite(Conventions.class);
+            suite.addTestSuite(DeadCode.class);
+            suite.addTest(Declarations.innerSuite());
+            suite.addTestSuite(Expressions.class);
+            suite.addTestSuite(TailCalls.class);
+            return suite;
+        }
+    }
+    
+    @TestMetadata("compiler/testData/cfg-variables")
+    @InnerTestClasses({Cfg_variables.Basic.class, Cfg_variables.Bugs.class, Cfg_variables.LexicalScopes.class})
+    public static class Cfg_variables extends AbstractPseudoValueTest {
+        public void testAllFilesPresentInCfg_variables() throws Exception {
+            JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg-variables"), Pattern.compile("^(.+)\\.kt$"), true);
+        }
+        
+        @TestMetadata("compiler/testData/cfg-variables/basic")
+        public static class Basic extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInBasic() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg-variables/basic"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("IfWithUninitialized.kt")
+            public void testIfWithUninitialized() throws Exception {
+                doTest("compiler/testData/cfg-variables/basic/IfWithUninitialized.kt");
+            }
+            
+            @TestMetadata("InitializedNotDeclared.kt")
+            public void testInitializedNotDeclared() throws Exception {
+                doTest("compiler/testData/cfg-variables/basic/InitializedNotDeclared.kt");
+            }
+            
+            @TestMetadata("UsageInFunctionLiteral.kt")
+            public void testUsageInFunctionLiteral() throws Exception {
+                doTest("compiler/testData/cfg-variables/basic/UsageInFunctionLiteral.kt");
+            }
+            
+            @TestMetadata("VariablesInitialization.kt")
+            public void testVariablesInitialization() throws Exception {
+                doTest("compiler/testData/cfg-variables/basic/VariablesInitialization.kt");
+            }
+            
+            @TestMetadata("VariablesUsage.kt")
+            public void testVariablesUsage() throws Exception {
+                doTest("compiler/testData/cfg-variables/basic/VariablesUsage.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg-variables/bugs")
+        public static class Bugs extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInBugs() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg-variables/bugs"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("referenceToPropertyInitializer.kt")
+            public void testReferenceToPropertyInitializer() throws Exception {
+                doTest("compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.kt");
+            }
+            
+            @TestMetadata("varInitializationInIf.kt")
+            public void testVarInitializationInIf() throws Exception {
+                doTest("compiler/testData/cfg-variables/bugs/varInitializationInIf.kt");
+            }
+            
+            @TestMetadata("varInitializationInIfInCycle.kt")
+            public void testVarInitializationInIfInCycle() throws Exception {
+                doTest("compiler/testData/cfg-variables/bugs/varInitializationInIfInCycle.kt");
+            }
+            
+        }
+        
+        @TestMetadata("compiler/testData/cfg-variables/lexicalScopes")
+        public static class LexicalScopes extends AbstractPseudoValueTest {
+            public void testAllFilesPresentInLexicalScopes() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), "org.jetbrains.jet.generators.tests.TestsPackage", new File("compiler/testData/cfg-variables/lexicalScopes"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("doWhileScope.kt")
+            public void testDoWhileScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/doWhileScope.kt");
+            }
+            
+            @TestMetadata("forScope.kt")
+            public void testForScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/forScope.kt");
+            }
+            
+            @TestMetadata("functionLiteralScope.kt")
+            public void testFunctionLiteralScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/functionLiteralScope.kt");
+            }
+            
+            @TestMetadata("ifScope.kt")
+            public void testIfScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/ifScope.kt");
+            }
+            
+            @TestMetadata("localClass.kt")
+            public void testLocalClass() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/localClass.kt");
+            }
+            
+            @TestMetadata("localFunctionScope.kt")
+            public void testLocalFunctionScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/localFunctionScope.kt");
+            }
+            
+            @TestMetadata("localFunctionScopeWithoutBody.kt")
+            public void testLocalFunctionScopeWithoutBody() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/localFunctionScopeWithoutBody.kt");
+            }
+            
+            @TestMetadata("localObject.kt")
+            public void testLocalObject() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/localObject.kt");
+            }
+            
+            @TestMetadata("objectLiteralScope.kt")
+            public void testObjectLiteralScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/objectLiteralScope.kt");
+            }
+            
+            @TestMetadata("propertyAccessorScope.kt")
+            public void testPropertyAccessorScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/propertyAccessorScope.kt");
+            }
+            
+            @TestMetadata("tryScope.kt")
+            public void testTryScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/tryScope.kt");
+            }
+            
+            @TestMetadata("whileScope.kt")
+            public void testWhileScope() throws Exception {
+                doTest("compiler/testData/cfg-variables/lexicalScopes/whileScope.kt");
+            }
+            
+        }
+        
+        public static Test innerSuite() {
+            TestSuite suite = new TestSuite("Cfg_variables");
+            suite.addTestSuite(Cfg_variables.class);
+            suite.addTestSuite(Basic.class);
+            suite.addTestSuite(Bugs.class);
+            suite.addTestSuite(LexicalScopes.class);
+            return suite;
+        }
+    }
+    
+    public static Test suite() {
+        TestSuite suite = new TestSuite("PseudoValueTestGenerated");
+        suite.addTest(Cfg.innerSuite());
+        suite.addTest(Cfg_variables.innerSuite());
+        return suite;
+    }
+}

generators/src/org/jetbrains/jet/generators/tests/GenerateTests.kt

@@ -112,6 +112,7 @@ import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentCompletion
 import org.jetbrains.jet.plugin.debugger.evaluate.AbstractCodeFragmentHighlightingTest
 import org.jetbrains.jet.plugin.stubs.AbstractLazyResolveByStubTest
 import org.jetbrains.jet.plugin.stubs.AbstractMultiFileHighlightingTest
+import org.jetbrains.jet.cfg.AbstractPseudoValueTest
 import org.jetbrains.jet.plugin.structureView.AbstractKotlinFileStructureTest
 
 fun main(args: Array<String>) {
@@ -247,6 +248,11 @@ fun main(args: Array<String>) {
             model("cfg-variables")
         }
 
+        testClass(javaClass<AbstractPseudoValueTest>()) {
+            model("cfg")
+            model("cfg-variables")
+        }
+
         testClass(javaClass<AbstractAnnotationParameterTest>()) {
             model("resolveAnnotations/parameters")
         }