[IR] add testdata for dumpKotlinLike

compiler/testData/ir/irText/classes/abstractMembers.kt.txt

@@ -0,0 +1,34 @@
+abstract class AbstractClass {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  abstract fun abstractFun() 
+  abstract val abstractVal: Int
+    abstract get
+
+  abstract var abstractVar: Int
+    abstract get
+    abstract set
+
+
+
+
+}
+
+interface Interface {
+  abstract fun abstractFun() 
+  abstract val abstractVal: Int
+    abstract get
+
+  abstract var abstractVar: Int
+    abstract get
+    abstract set
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/annotationClasses.kt.txt

@@ -0,0 +1,44 @@
+annotation class Test1 : Annotation {
+  constructor(x: Int) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+annotation class Test2 : Annotation {
+  constructor(x: Int = 0) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+annotation class Test3 : Annotation {
+  constructor(x: Test1) /* primary */ 
+  val x: Test1
+    field = x
+    get
+
+
+
+
+}
+
+annotation class Test4 : Annotation {
+  constructor(vararg xs: Int) /* primary */ 
+  val xs: IntArray
+    field = xs
+    get
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.kt.txt

@@ -0,0 +1,54 @@
+open class Base {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+
+
+
+}
+
+class Test1 : Base {
+  constructor(xx: Int, yy: Int) /* primary */ {
+    { //BLOCK
+      TODO("IrDelegatingConstructorCall")
+    }
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Test2 : Base {
+  constructor(xx: Int, yy: Int) {
+    { //BLOCK
+      TODO("IrDelegatingConstructorCall")
+    }
+        /* InstanceInitializerCall */
+
+  }
+
+  constructor(xxx: Int, yyy: Int, a: Any) {
+    { //BLOCK
+      TODO("IrDelegatingConstructorCall")
+    }
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/classMembers.kt.txt

@@ -0,0 +1,93 @@
+class C {
+  constructor(x: Int, y: Int, z: Int = 1) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val y: Int
+    field = y
+    get
+
+  var z: Int
+    field = z
+    get
+    set
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+  val property: Int
+    field = 0
+    get
+
+  val propertyWithGet: Int
+    get(): Int {
+      return 42
+    }
+
+  var propertyWithGetAndSet: Int
+    get(): Int {
+      return <this>.<get-z>()
+    }
+    set(value: Int) {
+      <this>.<set-z>(<set-?> = value)
+    }
+
+  fun function() {
+    println(message = "1")
+  }
+
+  fun Int.memberExtensionFunction() {
+    println(message = "2")
+  }
+
+  class NestedClass {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    fun function() {
+      println(message = "3")
+    }
+
+    fun Int.memberExtensionFunction() {
+      println(message = "4")
+    }
+
+
+
+
+  }
+
+  interface NestedInterface {
+    abstract fun foo() 
+    fun bar() {
+      return <this>.foo()
+    }
+
+
+
+
+  }
+
+  companion object Companion {
+    private constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/classes.kt.txt

@@ -0,0 +1,57 @@
+class TestClass {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+interface TestInterface {
+
+
+
+}
+
+object TestObject {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+annotation class TestAnnotationClass : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+enum class TestEnumClass : Enum<TestEnumClass> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<TestEnumClass> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnumClass /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/classes/companionObject.kt.txt

@@ -0,0 +1,48 @@
+class Test1 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  companion object Companion {
+    private constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+
+class Test2 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  companion object Named {
+    private constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/dataClassWithArrayMembers.kt.txt

@@ -0,0 +1,253 @@
+data class Test1 {
+  constructor(stringArray: Array<String>, charArray: CharArray, booleanArray: BooleanArray, byteArray: ByteArray, shortArray: ShortArray, intArray: IntArray, longArray: LongArray, floatArray: FloatArray, doubleArray: DoubleArray) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val stringArray: Array<String>
+    field = stringArray
+    get
+
+  val charArray: CharArray
+    field = charArray
+    get
+
+  val booleanArray: BooleanArray
+    field = booleanArray
+    get
+
+  val byteArray: ByteArray
+    field = byteArray
+    get
+
+  val shortArray: ShortArray
+    field = shortArray
+    get
+
+  val intArray: IntArray
+    field = intArray
+    get
+
+  val longArray: LongArray
+    field = longArray
+    get
+
+  val floatArray: FloatArray
+    field = floatArray
+    get
+
+  val doubleArray: DoubleArray
+    field = doubleArray
+    get
+
+  operator fun component1(): Array<String> {
+    return #stringArray
+  }
+
+  operator fun component2(): CharArray {
+    return #charArray
+  }
+
+  operator fun component3(): BooleanArray {
+    return #booleanArray
+  }
+
+  operator fun component4(): ByteArray {
+    return #byteArray
+  }
+
+  operator fun component5(): ShortArray {
+    return #shortArray
+  }
+
+  operator fun component6(): IntArray {
+    return #intArray
+  }
+
+  operator fun component7(): LongArray {
+    return #longArray
+  }
+
+  operator fun component8(): FloatArray {
+    return #floatArray
+  }
+
+  operator fun component9(): DoubleArray {
+    return #doubleArray
+  }
+
+  fun copy(stringArray: Array<String> = #stringArray, charArray: CharArray = #charArray, booleanArray: BooleanArray = #booleanArray, byteArray: ByteArray = #byteArray, shortArray: ShortArray = #shortArray, intArray: IntArray = #intArray, longArray: LongArray = #longArray, floatArray: FloatArray = #floatArray, doubleArray: DoubleArray = #doubleArray): Test1 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test1(" + 
+"stringArray=" + 
+dataClassArrayMemberToString(arg0 = #stringArray) + 
+", " + 
+"charArray=" + 
+dataClassArrayMemberToString(arg0 = #charArray) + 
+", " + 
+"booleanArray=" + 
+dataClassArrayMemberToString(arg0 = #booleanArray) + 
+", " + 
+"byteArray=" + 
+dataClassArrayMemberToString(arg0 = #byteArray) + 
+", " + 
+"shortArray=" + 
+dataClassArrayMemberToString(arg0 = #shortArray) + 
+", " + 
+"intArray=" + 
+dataClassArrayMemberToString(arg0 = #intArray) + 
+", " + 
+"longArray=" + 
+dataClassArrayMemberToString(arg0 = #longArray) + 
+", " + 
+"floatArray=" + 
+dataClassArrayMemberToString(arg0 = #floatArray) + 
+", " + 
+"doubleArray=" + 
+dataClassArrayMemberToString(arg0 = #doubleArray) + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return dataClassArrayMemberHashCode(arg0 = #stringArray).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #charArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #booleanArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #byteArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #shortArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #intArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #longArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #floatArray)).times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = #doubleArray))
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test1 -> return false
+    }
+    val tmp0_other_with_cast: Test1 = other as Test1
+    when {
+      EQEQ(arg0 = #stringArray, arg1 = #stringArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #charArray, arg1 = #charArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #booleanArray, arg1 = #booleanArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #byteArray, arg1 = #byteArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #shortArray, arg1 = #shortArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #intArray, arg1 = #intArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #longArray, arg1 = #longArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #floatArray, arg1 = #floatArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #doubleArray, arg1 = #doubleArray).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test2<T : Any?> {
+  constructor(genericArray: Array<T>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val genericArray: Array<T>
+    field = genericArray
+    get
+
+  operator fun component1(): Array<T> {
+    return #genericArray
+  }
+
+  fun copy(genericArray: Array<T> = #genericArray): Test2<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test2(" + 
+"genericArray=" + 
+dataClassArrayMemberToString(arg0 = #genericArray) + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return dataClassArrayMemberHashCode(arg0 = #genericArray)
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test2<T> -> return false
+    }
+    val tmp0_other_with_cast: Test2<T> = other as Test2<T>
+    when {
+      EQEQ(arg0 = #genericArray, arg1 = #genericArray).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test3 {
+  constructor(anyArrayN: Array<Any>?) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val anyArrayN: Array<Any>?
+    field = anyArrayN
+    get
+
+  operator fun component1(): Array<Any>? {
+    return #anyArrayN
+  }
+
+  fun copy(anyArrayN: Array<Any>? = #anyArrayN): Test3 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test3(" + 
+"anyArrayN=" + 
+dataClassArrayMemberToString(arg0 = #anyArrayN) + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #anyArrayN, arg1 = null) -> 0
+      true -> dataClassArrayMemberHashCode(arg0 = #anyArrayN)
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test3 -> return false
+    }
+    val tmp0_other_with_cast: Test3 = other as Test3
+    when {
+      EQEQ(arg0 = #anyArrayN, arg1 = #anyArrayN).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/dataClasses.kt.txt

@@ -0,0 +1,217 @@
+data class Test1 {
+  constructor(x: Int, y: String, z: Any) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+  val z: Any
+    field = z
+    get
+
+  operator fun component1(): Int {
+    return #x
+  }
+
+  operator fun component2(): String {
+    return #y
+  }
+
+  operator fun component3(): Any {
+    return #z
+  }
+
+  fun copy(x: Int = #x, y: String = #y, z: Any = #z): Test1 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test1(" + 
+"x=" + 
+#x + 
+", " + 
+"y=" + 
+#y + 
+", " + 
+"z=" + 
+#z + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode().times(other = 31).plus(other = #y.hashCode()).times(other = 31).plus(other = #z.hashCode())
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test1 -> return false
+    }
+    val tmp0_other_with_cast: Test1 = other as Test1
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #y, arg1 = #y).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #z, arg1 = #z).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test2 {
+  constructor(x: Any?) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Any?
+    field = x
+    get
+
+  operator fun component1(): Any? {
+    return #x
+  }
+
+  fun copy(x: Any? = #x): Test2 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test2(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #x, arg1 = null) -> 0
+      true -> #x.hashCode()
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test2 -> return false
+    }
+    val tmp0_other_with_cast: Test2 = other as Test2
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test3 {
+  constructor(d: Double, dn: Double?, f: Float, df: Float?) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val d: Double
+    field = d
+    get
+
+  val dn: Double?
+    field = dn
+    get
+
+  val f: Float
+    field = f
+    get
+
+  val df: Float?
+    field = df
+    get
+
+  operator fun component1(): Double {
+    return #d
+  }
+
+  operator fun component2(): Double? {
+    return #dn
+  }
+
+  operator fun component3(): Float {
+    return #f
+  }
+
+  operator fun component4(): Float? {
+    return #df
+  }
+
+  fun copy(d: Double = #d, dn: Double? = #dn, f: Float = #f, df: Float? = #df): Test3 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test3(" + 
+"d=" + 
+#d + 
+", " + 
+"dn=" + 
+#dn + 
+", " + 
+"f=" + 
+#f + 
+", " + 
+"df=" + 
+#df + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #d.hashCode().times(other = 31).plus(other = when {
+      EQEQ(arg0 = #dn, arg1 = null) -> 0
+      true -> #dn.hashCode()
+    }).times(other = 31).plus(other = #f.hashCode()).times(other = 31).plus(other = when {
+      EQEQ(arg0 = #df, arg1 = null) -> 0
+      true -> #df.hashCode()
+    })
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test3 -> return false
+    }
+    val tmp0_other_with_cast: Test3 = other as Test3
+    when {
+      EQEQ(arg0 = #d, arg1 = #d).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #dn, arg1 = #dn).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #f, arg1 = #f).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #df, arg1 = #df).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/dataClassesGeneric.kt.txt

@@ -0,0 +1,187 @@
+data class Test1<T : Any?> {
+  constructor(x: T) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  operator fun component1(): T {
+    return #x
+  }
+
+  fun copy(x: T = #x): Test1<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test1(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #x, arg1 = null) -> 0
+      true -> #x.hashCode()
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test1<T> -> return false
+    }
+    val tmp0_other_with_cast: Test1<T> = other as Test1<T>
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test2<T : Number> {
+  constructor(x: T) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  operator fun component1(): T {
+    return #x
+  }
+
+  fun copy(x: T = #x): Test2<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test2(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test2<T> -> return false
+    }
+    val tmp0_other_with_cast: Test2<T> = other as Test2<T>
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test3<T : Any?> {
+  constructor(x: List<T>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: List<T>
+    field = x
+    get
+
+  operator fun component1(): List<T> {
+    return #x
+  }
+
+  fun copy(x: List<T> = #x): Test3<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test3(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test3<T> -> return false
+    }
+    val tmp0_other_with_cast: Test3<T> = other as Test3<T>
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class Test4 {
+  constructor(x: List<String>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: List<String>
+    field = x
+    get
+
+  operator fun component1(): List<String> {
+    return #x
+  }
+
+  fun copy(x: List<String> = #x): Test4 {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test4(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test4 -> return false
+    }
+    val tmp0_other_with_cast: Test4 = other as Test4
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/delegatedGenericImplementation.kt.txt

@@ -0,0 +1,79 @@
+interface IBase<A : Any?> {
+  abstract fun <B : Any?> foo(a: A, b: B) 
+  abstract val <C : Any?> C.id: Map<A, C>?
+    abstract get
+
+  abstract var <D : Any?> List<D>.x: D?
+    abstract get
+    abstract set
+
+
+
+
+}
+
+class Test1<E : Any?> : IBase<E> {
+  constructor(i: IBase<E>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: IBase<E> = i
+  override fun <B : Any?> foo(a: E, b: B) {
+    #$$delegate_0.foo<B>(a = a, b = b)
+  }
+
+  override val <C : Any?> C.id: Map<E, C>?
+    override get(): Map<E, C>? {
+      return #$$delegate_0.<get-id><C>($receiver = <this>)
+    }
+
+  override var <D : Any?> List<D>.x: D?
+    override get(): D? {
+      return #$$delegate_0.<get-x><D>($receiver = <this>)
+    }
+    override set(<set-?>: D?) {
+      #$$delegate_0.<set-x><D>($receiver = <this>, <set-?> = <set-?>)
+    }
+
+
+
+
+}
+
+class Test2 : IBase<String> {
+  constructor(j: IBase<String>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var j: IBase<String>
+    field = j
+    get
+    set
+
+  private /*final field*/ val $$delegate_0: IBase<String> = j
+  override fun <B : Any?> foo(a: String, b: B) {
+    #$$delegate_0.foo<B>(a = a, b = b)
+  }
+
+  override val <C : Any?> C.id: Map<String, C>?
+    override get(): Map<String, C>? {
+      return #$$delegate_0.<get-id><C>($receiver = <this>)
+    }
+
+  override var <D : Any?> List<D>.x: D?
+    override get(): D? {
+      return #$$delegate_0.<get-x><D>($receiver = <this>)
+    }
+    override set(<set-?>: D?) {
+      #$$delegate_0.<set-x><D>($receiver = <this>, <set-?> = <set-?>)
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/delegatedImplementation.kt.txt

@@ -0,0 +1,168 @@
+interface IBase {
+  abstract fun foo(x: Int, s: String) 
+  abstract fun bar(): Int 
+  abstract fun String.qux() 
+
+
+
+}
+
+object BaseImpl : IBase {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo(x: Int, s: String) {
+  }
+
+  override fun bar(): Int {
+    return 42
+  }
+
+  override fun String.qux() {
+  }
+
+
+
+
+}
+
+interface IOther {
+  abstract val x: String
+    abstract get
+
+  abstract var y: Int
+    abstract get
+    abstract set
+
+  abstract val Byte.z1: Int
+    abstract get
+
+  abstract var Byte.z2: Int
+    abstract get
+    abstract set
+
+
+
+
+}
+
+fun otherImpl(x0: String, y0: Int): IOther {
+  return { //BLOCK
+    local class <no name provided> : IOther {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+      override val x: String
+        field = x0
+        override get
+
+      override var y: Int
+        field = y0
+        override get
+        override set
+
+      override val Byte.z1: Int
+        override get(): Int {
+          return 1
+        }
+
+      override var Byte.z2: Int
+        override get(): Int {
+          return 2
+        }
+        override set(value: Int) {
+        }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }
+}
+
+class Test1 : IBase {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: BaseImpl = BaseImpl
+  override fun bar(): Int {
+    return #$$delegate_0.bar()
+  }
+
+  override fun foo(x: Int, s: String) {
+    #$$delegate_0.foo(x = x, s = s)
+  }
+
+  override fun String.qux() {
+    #$$delegate_0.qux($receiver = <this>)
+  }
+
+
+
+
+}
+
+class Test2 : IBase, IOther {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: BaseImpl = BaseImpl
+  override fun bar(): Int {
+    return #$$delegate_0.bar()
+  }
+
+  override fun foo(x: Int, s: String) {
+    #$$delegate_0.foo(x = x, s = s)
+  }
+
+  override fun String.qux() {
+    #$$delegate_0.qux($receiver = <this>)
+  }
+
+  private /*final field*/ val $$delegate_1: IOther = otherImpl(x0 = "", y0 = 42)
+  override val Byte.z1: Int
+    override get(): Int {
+      return #$$delegate_1.<get-z1>($receiver = <this>)
+    }
+
+  override val x: String
+    override get(): String {
+      return #$$delegate_1.<get-x>()
+    }
+
+  override var Byte.z2: Int
+    override get(): Int {
+      return #$$delegate_1.<get-z2>($receiver = <this>)
+    }
+    override set(<set-?>: Int) {
+      #$$delegate_1.<set-z2>($receiver = <this>, <set-?> = <set-?>)
+    }
+
+  override var y: Int
+    override get(): Int {
+      return #$$delegate_1.<get-y>()
+    }
+    override set(<set-?>: Int) {
+      #$$delegate_1.<set-y>(<set-?> = <set-?>)
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/delegatedImplementationWithExplicitOverride.kt.txt

@@ -0,0 +1,46 @@
+interface IFooBar {
+  abstract fun foo() 
+  abstract fun bar() 
+
+
+
+}
+
+object FooBarImpl : IFooBar {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo() {
+  }
+
+  override fun bar() {
+  }
+
+
+
+
+}
+
+class C : IFooBar {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: FooBarImpl = FooBarImpl
+  override fun foo() {
+    #$$delegate_0.foo()
+  }
+
+  override fun bar() {
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.kt.txt

@@ -0,0 +1,42 @@
+open class Cell<T : Any?> {
+  constructor(value: T) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+
+
+
+}
+
+typealias CT<T : Any?> = Cell<T>
+typealias CStr = Cell<String>
+class C1 : Cell<String> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class C2 : Cell<String> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/delegatingConstructorCallsInSecondaryConstructors.kt.txt

@@ -0,0 +1,34 @@
+open class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Test : Base {
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  constructor(xx: Int) {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  constructor(xx: Short) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/enum.kt.txt

@@ -0,0 +1,150 @@
+enum class TestEnum1 : Enum<TestEnum1> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class TestEnum2 : Enum<TestEnum2> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  TEST3 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestEnum2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum2 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+abstract enum class TestEnum3 : Enum<TestEnum3> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  TEST init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+
+
+
+
+
+
+
+  fun values(): Array<TestEnum3> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum3 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+abstract enum class TestEnum4 : Enum<TestEnum4> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+
+
+
+
+
+
+
+  fun values(): Array<TestEnum4> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum4 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class TestEnum5 : Enum<TestEnum5> {
+  private constructor(x: Int = 0) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  TEST3 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestEnum5> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum5 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+fun f(): Int {
+  return 1
+}
+
+enum class TestEnum6 : Enum<TestEnum6> {
+  private constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  TEST init = { //BLOCK
+    val tmp0_y: Int = f()
+    val tmp1_x: Int = f()
+    TODO("IrEnumConstructorCall")
+  }
+
+
+
+
+
+
+  fun values(): Array<TestEnum6> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum6 /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/classes/enumClassModality.kt.txt

@@ -0,0 +1,159 @@
+enum class TestFinalEnum1 : Enum<TestFinalEnum1> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestFinalEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestFinalEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class TestFinalEnum2 : Enum<TestFinalEnum2> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  X1 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestFinalEnum2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestFinalEnum2 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class TestFinalEnum3 : Enum<TestFinalEnum3> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")  fun doStuff() {
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<TestFinalEnum3> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestFinalEnum3 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class TestOpenEnum1 : Enum<TestOpenEnum1> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestOpenEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestOpenEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class TestOpenEnum2 : Enum<TestOpenEnum2> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")  open fun foo() {
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<TestOpenEnum2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestOpenEnum2 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+abstract enum class TestAbstractEnum1 : Enum<TestAbstractEnum1> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+
+
+
+
+
+
+
+  fun values(): Array<TestAbstractEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestAbstractEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+interface IFoo {
+  abstract fun foo() 
+
+
+
+}
+
+abstract enum class TestAbstractEnum2 : Enum<TestAbstractEnum2>, IFoo {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  X1 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+
+  fun values(): Array<TestAbstractEnum2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestAbstractEnum2 /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt.txt

@@ -0,0 +1,54 @@
+open enum class A : Enum<A> {
+  X init = TODO("IrEnumConstructorCall")  Y init = TODO("IrEnumConstructorCall")  Z init = TODO("IrEnumConstructorCall")  val prop1: String
+    get
+
+  val prop2: String
+    field = "const2"
+    get
+
+  var prop3: String
+    field = ""
+    get
+    set
+
+  private constructor(arg: String) {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+    #prop1 = arg
+  }
+
+  private constructor() {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+    #prop1 = "default"
+    <this>.<set-prop3>(<set-?> = "empty")
+  }
+
+  private constructor(x: Int) {
+    TODO("IrDelegatingConstructorCall")
+    <this>.<set-prop3>(<set-?> = "int")
+  }
+
+  open fun f(): String {
+    return <this>.<get-prop1>() + 
+"#" + 
+<this>.<get-prop2>() + 
+"#" + 
+<this>.<get-prop3>()
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<A> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): A /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt.txt

@@ -0,0 +1,85 @@
+enum class Test0 : Enum<Test0> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO init = TODO("IrEnumConstructorCall")  private constructor() {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<Test0> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Test0 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class Test1 : Enum<Test1> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO init = TODO("IrEnumConstructorCall")  ONE init = TODO("IrEnumConstructorCall")  private constructor() {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<Test1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Test1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+abstract enum class Test2 : Enum<Test2> {
+  private constructor(x: Int) /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO init = TODO("IrEnumConstructorCall")  ONE init = TODO("IrEnumConstructorCall")  private constructor() {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+  abstract fun foo() 
+
+
+
+
+
+
+
+  fun values(): Array<Test2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Test2 /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.kt.txt

@@ -0,0 +1,14 @@
+class Test : Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.kt.txt

@@ -0,0 +1,150 @@
+interface IFoo {
+  abstract fun foo(): String 
+
+
+
+}
+
+class K1 : JFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+}
+
+class K2 : JFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo(): String {
+    return <this>.foo() /*!! String */
+  }
+
+
+
+
+}
+
+class K3 : JUnrelatedFoo, IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+}
+
+class K4 : JUnrelatedFoo, IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo(): @FlexibleNullability String? {
+    return <this>.foo()
+  }
+
+
+
+
+}
+
+class TestJFoo : IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: JFoo = TODO("IrConstructorCall")
+  override fun foo(): String {
+    return #$$delegate_0.foo() /*!! String */
+  }
+
+
+
+
+}
+
+class TestK1 : IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: K1 = TODO("IrConstructorCall")
+  override fun foo(): String {
+    return #$$delegate_0.foo() /*!! String */
+  }
+
+
+
+
+}
+
+class TestK2 : IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: K2 = TODO("IrConstructorCall")
+  override fun foo(): String {
+    return #$$delegate_0.foo()
+  }
+
+
+
+
+}
+
+class TestK3 : IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: K3 = TODO("IrConstructorCall")
+  override fun foo(): String {
+    return #$$delegate_0.foo()
+  }
+
+
+
+
+}
+
+class TestK4 : IFoo {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: K4 = TODO("IrConstructorCall")
+  override fun foo(): String {
+    return #$$delegate_0.foo() /*!! String */
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/initBlock.kt.txt

@@ -0,0 +1,104 @@
+class Test1 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  init {
+    println()
+  }
+
+
+
+
+}
+
+class Test2 {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  init {
+    println()
+  }
+
+
+
+
+}
+
+class Test3 {
+  init {
+    println()
+  }
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Test4 {
+  init {
+    println(message = "1")
+  }
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  init {
+    println(message = "2")
+  }
+
+
+
+
+}
+
+class Test5 {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  init {
+    println(message = "1")
+  }
+
+  inner class TestInner {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    init {
+      println(message = "2")
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/initVal.kt.txt

@@ -0,0 +1,51 @@
+class TestInitValFromParameter {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+class TestInitValInClass {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = 0
+    get
+
+
+
+
+}
+
+class TestInitValInInitBlock {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    get
+
+  init {
+    #x = 0
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/initValInLambda.kt.txt

@@ -0,0 +1,22 @@
+class TestInitValInLambdaCalledOnce {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    get
+
+  init {
+    run<Int, Unit>($receiver = 1, block =     local fun Int.<anonymous>() {
+      #x = 0
+    }
+)
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/initVar.kt.txt

@@ -0,0 +1,114 @@
+class TestInitVarFromParameter {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var x: Int
+    field = x
+    get
+    set
+
+
+
+
+}
+
+class TestInitVarInClass {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var x: Int
+    field = 0
+    get
+    set
+
+
+
+
+}
+
+class TestInitVarInInitBlock {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var x: Int
+    get
+    set
+
+  init {
+    <this>.<set-x>(<set-?> = 0)
+  }
+
+
+
+
+}
+
+class TestInitVarWithCustomSetter {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var x: Int
+    field = 0
+    get
+    set(value: Int) {
+      #x = value
+    }
+
+
+
+
+}
+
+class TestInitVarWithCustomSetterWithExplicitCtor {
+  var x: Int
+    get
+    set(value: Int) {
+      #x = value
+    }
+
+  init {
+    <this>.<set-x>(value = 0)
+  }
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestInitVarWithCustomSetterInCtor {
+  var x: Int
+    get
+    set(value: Int) {
+      #x = value
+    }
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+    <this>.<set-x>(value = 42)
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/inlineClass.kt.txt

@@ -0,0 +1,35 @@
+inline class Test {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  override fun toString(): String {
+    return "Test(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is Test -> return false
+    }
+    val tmp0_other_with_cast: Test = other as Test
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.kt.txt

@@ -0,0 +1,66 @@
+class C<T : Any?> {
+  constructor(t: T) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val t: T
+    field = t
+    get
+
+  override fun hashCode(): Int {
+    return <this>.<get-t>() as Int
+  }
+
+
+
+}
+
+inline class IC<TT : Any?> {
+  constructor(c: C<TT>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val c: C<TT>
+    field = c
+    get
+
+  fun foo(): Int {
+    return <this>.<get-c>().hashCode()
+  }
+
+  override fun toString(): String {
+    return "IC(" + 
+"c=" + 
+#c + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #c.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is IC<TT> -> return false
+    }
+    val tmp0_other_with_cast: IC<TT> = other as IC<TT>
+    when {
+      EQEQ(arg0 = #c, arg1 = #c).not() -> return false
+    }
+    return true
+  }
+
+}
+
+fun box(): String {
+  val ic: IC<Int> = TODO("IrConstructorCall")
+  when {
+    EQEQ(arg0 = ic.foo(), arg1 = 42).not() -> return "FAIL"
+  }
+  return "OK"
+}
+

compiler/testData/ir/irText/classes/innerClass.kt.txt

@@ -0,0 +1,36 @@
+class Outer {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  open inner class TestInnerClass {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+  inner class DerivedInnerClass : TestInnerClass {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/innerClassWithDelegatingConstructor.kt.txt

@@ -0,0 +1,32 @@
+class Outer {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  inner class Inner {
+    constructor(x: Int) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val x: Int
+      field = x
+      get
+
+    constructor() {
+      TODO("IrDelegatingConstructorCall")
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/kt31649.kt.txt

@@ -0,0 +1,87 @@
+data class TestData {
+  constructor(nn: Nothing?) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val nn: Nothing?
+    field = nn
+    get
+
+  operator fun component1(): Nothing? {
+    return #nn
+  }
+
+  fun copy(nn: Nothing? = #nn): TestData {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "TestData(" + 
+"nn=" + 
+#nn + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #nn, arg1 = null) -> 0
+      true -> #nn.hashCode()
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is TestData -> return false
+    }
+    val tmp0_other_with_cast: TestData = other as TestData
+    when {
+      EQEQ(arg0 = #nn, arg1 = #nn).not() -> return false
+    }
+    return true
+  }
+
+}
+
+inline class TestInline {
+  constructor(nn: Nothing?) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val nn: Nothing?
+    field = nn
+    get
+
+  override fun toString(): String {
+    return "TestInline(" + 
+"nn=" + 
+#nn + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #nn, arg1 = null) -> 0
+      true -> #nn.hashCode()
+    }
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is TestInline -> return false
+    }
+    val tmp0_other_with_cast: TestInline = other as TestInline
+    when {
+      EQEQ(arg0 = #nn, arg1 = #nn).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.kt.txt

@@ -0,0 +1,110 @@
+data class A {
+  constructor(runA: @ExtensionFunctionType Function2<A, String, Unit> =   local fun A.<anonymous>(it: String) {
+    return Unit
+  }
+) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val runA: @ExtensionFunctionType Function2<A, String, Unit>
+    field = runA
+    get
+
+  operator fun component1(): @ExtensionFunctionType Function2<A, String, Unit> {
+    return #runA
+  }
+
+  fun copy(runA: @ExtensionFunctionType Function2<A, String, Unit> = #runA): A {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "A(" + 
+"runA=" + 
+#runA + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #runA.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is A -> return false
+    }
+    val tmp0_other_with_cast: A = other as A
+    when {
+      EQEQ(arg0 = #runA, arg1 = #runA).not() -> return false
+    }
+    return true
+  }
+
+}
+
+data class B {
+  constructor(x: Any = { //BLOCK
+    local class <no name provided> {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Any
+    field = x
+    get
+
+  operator fun component1(): Any {
+    return #x
+  }
+
+  fun copy(x: Any = #x): B {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "B(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is B -> return false
+    }
+    val tmp0_other_with_cast: B = other as B
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/classes/localClasses.kt.txt

@@ -0,0 +1,20 @@
+fun outer() {
+  local class LocalClass {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    fun foo() {
+    }
+
+
+
+
+  }
+
+
+  TODO("IrConstructorCall").foo()
+}
+

compiler/testData/ir/irText/classes/objectLiteralExpressions.kt.txt

@@ -0,0 +1,120 @@
+interface IFoo {
+  abstract fun foo() 
+
+
+
+}
+
+val test1: Any
+  field = { //BLOCK
+    local class <no name provided> {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }
+  get
+
+val test2: IFoo
+  field = { //BLOCK
+    local class <no name provided> : IFoo {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+      override fun foo() {
+        println(message = "foo")
+      }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }
+  get
+
+class Outer {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  abstract inner class Inner : IFoo {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+
+  }
+
+  fun test3(): Inner {
+    return { //BLOCK
+      local class <no name provided> : Inner {
+        constructor() /* primary */ {
+          TODO("IrDelegatingConstructorCall")
+                    /* InstanceInitializerCall */
+
+        }
+
+        override fun foo() {
+          println(message = "foo")
+        }
+
+
+
+
+      }
+
+
+      TODO("IrConstructorCall")
+    }
+  }
+
+
+
+
+}
+
+fun Outer.test4(): Inner {
+  return { //BLOCK
+    local class <no name provided> : Inner {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+      override fun foo() {
+        println(message = "foo")
+      }
+
+
+
+
+    }
+
+
+    TODO("IrConstructorCall")
+  }
+}
+

compiler/testData/ir/irText/classes/objectWithInitializers.kt.txt

@@ -0,0 +1,35 @@
+abstract class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+object Test : Base {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = 1
+    get
+
+  val y: Int
+    get
+
+  init {
+    #y = <this>.<get-x>()
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/outerClassAccess.kt.txt

@@ -0,0 +1,52 @@
+class Outer {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun foo() {
+  }
+
+  inner class Inner {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    fun test() {
+      <this>.foo()
+    }
+
+    inner class Inner2 {
+      constructor() /* primary */ {
+        TODO("IrDelegatingConstructorCall")
+                /* InstanceInitializerCall */
+
+      }
+
+      fun test2() {
+        <this>.test()
+        <this>.foo()
+      }
+
+      fun Outer.test3() {
+        <this>.foo()
+      }
+
+
+
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/primaryConstructor.kt.txt

@@ -0,0 +1,63 @@
+class Test1 {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+
+
+
+}
+
+class Test2 {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val y: Int
+    field = y
+    get
+
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+class Test3 {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val y: Int
+    field = y
+    get
+
+  val x: Int
+    get
+
+  init {
+    #x = x
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/primaryConstructorWithSuperConstructorCall.kt.txt

@@ -0,0 +1,60 @@
+open class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestImplicitPrimaryConstructor : Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestExplicitPrimaryConstructor : Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestWithDelegatingConstructor : Base {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  constructor(x: Int) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/qualifiedSuperCalls.kt.txt

@@ -0,0 +1,50 @@
+interface ILeft {
+  fun foo() {
+  }
+
+  val bar: Int
+    get(): Int {
+      return 1
+    }
+
+
+
+
+}
+
+interface IRight {
+  fun foo() {
+  }
+
+  val bar: Int
+    get(): Int {
+      return 2
+    }
+
+
+
+
+}
+
+class CBoth : ILeft, IRight {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo() {
+    <this>.foo()
+    <this>.foo()
+  }
+
+  override val bar: Int
+    override get(): Int {
+      return <this>.<get-bar>().plus(other = <this>.<get-bar>())
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/sealedClasses.kt.txt

@@ -0,0 +1,60 @@
+sealed class Expr {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  class Const : Expr {
+    constructor(number: Double) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val number: Double
+      field = number
+      get
+
+
+
+
+  }
+
+  class Sum : Expr {
+    constructor(e1: Expr, e2: Expr) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val e1: Expr
+      field = e1
+      get
+
+    val e2: Expr
+      field = e2
+      get
+
+
+
+
+  }
+
+  object NotANumber : Expr {
+    private constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/secondaryConstructorWithInitializersFromClassBody.kt.txt

@@ -0,0 +1,57 @@
+open class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestProperty : Base {
+  val x: Int
+    field = 0
+    get
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class TestInitBlock : Base {
+  val x: Int
+    get
+
+  init {
+    #x = 0
+  }
+
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  constructor(z: Any) {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  constructor(y: Int) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/secondaryConstructors.kt.txt

@@ -0,0 +1,16 @@
+class C {
+  constructor() {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+  constructor(x: Int) {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/superCalls.kt.txt

@@ -0,0 +1,43 @@
+open class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  open fun foo() {
+  }
+
+  open val bar: String
+    field = ""
+    open get
+
+  override fun hashCode(): Int {
+    return <this>.hashCode()
+  }
+
+
+
+}
+
+class Derived : Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo() {
+    <this>.foo()
+  }
+
+  override val bar: String
+    override get(): String {
+      return <this>.<get-bar>()
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/classes/superCallsComposed.kt.txt

@@ -0,0 +1,50 @@
+open class Base {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  open fun foo() {
+  }
+
+  open val bar: String
+    field = ""
+    open get
+
+
+
+
+}
+
+interface BaseI {
+  abstract fun foo() 
+  abstract val bar: String
+    abstract get
+
+
+
+
+}
+
+class Derived : Base, BaseI {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo() {
+    <this>.foo()
+  }
+
+  override val bar: String
+    override get(): String {
+      return <this>.<get-bar>()
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/annotationsInAnnotationArguments.kt.txt

@@ -0,0 +1,38 @@
+annotation class A1 : Annotation {
+  constructor(x: Int) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+annotation class A2 : Annotation {
+  constructor(a: A1) /* primary */ 
+  val a: A1
+    field = a
+    get
+
+
+
+
+}
+
+annotation class AA : Annotation {
+  constructor(xs: Array<A1>) /* primary */ 
+  val xs: Array<A1>
+    field = xs
+    get
+
+
+
+
+}
+
+@A2(...)
+@AA(...)
+fun test() {
+}
+

compiler/testData/ir/irText/declarations/annotations/annotationsWithDefaultParameterValues.kt.txt

@@ -0,0 +1,35 @@
+annotation class A : Annotation {
+  constructor(x: String = "", y: Int = 42) /* primary */ 
+  val x: String
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+
+
+
+}
+
+@A(...)
+fun test1() {
+}
+
+@A(...)
+fun test2() {
+}
+
+@A(...)
+fun test3() {
+}
+
+@A(...)
+fun test4() {
+}
+
+@A(...)
+fun test5() {
+}
+

compiler/testData/ir/irText/declarations/annotations/annotationsWithVarargParameters.kt.txt

@@ -0,0 +1,23 @@
+annotation class A : Annotation {
+  constructor(vararg xs: String) /* primary */ 
+  val xs: Array<out String>
+    field = xs
+    get
+
+
+
+
+}
+
+@A(...)
+fun test1() {
+}
+
+@A(...)
+fun test2() {
+}
+
+@A(...)
+fun test3() {
+}
+

compiler/testData/ir/irText/declarations/annotations/arrayInAnnotationArguments.kt.txt

@@ -0,0 +1,32 @@
+annotation class TestAnnWithIntArray : Annotation {
+  constructor(x: IntArray) /* primary */ 
+  val x: IntArray
+    field = x
+    get
+
+
+
+
+}
+
+annotation class TestAnnWithStringArray : Annotation {
+  constructor(x: Array<String>) /* primary */ 
+  val x: Array<String>
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnnWithIntArray(...)
+@TestAnnWithStringArray(...)
+fun test1() {
+}
+
+@TestAnnWithIntArray(...)
+@TestAnnWithStringArray(...)
+fun test2() {
+}
+

compiler/testData/ir/irText/declarations/annotations/classLiteralInAnnotation.kt.txt

@@ -0,0 +1,27 @@
+annotation class A : Annotation {
+  constructor(klass: KClass<*>) /* primary */ 
+  val klass: KClass<*>
+    field = klass
+    get
+
+
+
+
+}
+
+class C {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+@A(...)
+fun test1() {
+}
+

compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt.txt

@@ -0,0 +1,98 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnn(...)
+class TestClass {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+@TestAnn(...)
+interface TestInterface {
+
+
+
+}
+
+@TestAnn(...)
+object TestObject {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  @TestAnn(...)
+  companion object TestCompanion {
+    private constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+
+@TestAnn(...)
+enum class TestEnum : Enum<TestEnum> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+
+
+
+
+  fun values(): Array<TestEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+@TestAnn(...)
+annotation class TestAnnotation : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/constExpressionsInAnnotationArguments.kt.txt

@@ -0,0 +1,23 @@
+const val ONE: Int
+  field = 1
+  get
+
+annotation class A : Annotation {
+  constructor(x: Int) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+@A(...)
+fun test1() {
+}
+
+@A(...)
+fun test2() {
+}
+

compiler/testData/ir/irText/declarations/annotations/constructorsWithAnnotations.kt.txt

@@ -0,0 +1,29 @@
+annotation class TestAnn : Annotation {
+  constructor(x: Int) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+class TestClass {
+  @TestAnn(...)
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  @TestAnn(...)
+  constructor(x: Int) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/delegateFieldWithAnnotations.kt.txt

@@ -0,0 +1,16 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+val test1: Int /* by */ 
+  field = lazy<Int>(initializer =   local fun <anonymous>(): Int {
+    return 42
+  }
+)
+  get(): Int {
+    return getValue<Int>($receiver = #test1$delegate, thisRef = null, property = ::test1)
+  }
+

compiler/testData/ir/irText/declarations/annotations/delegatedPropertyAccessorsWithAnnotations.kt.txt

@@ -0,0 +1,54 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+class Cell {
+  constructor(value: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var value: Int
+    field = value
+    get
+    set
+
+  operator fun getValue(thisRef: Any?, kProp: Any?): Int {
+    return <this>.<get-value>()
+  }
+
+  operator fun setValue(thisRef: Any?, kProp: Any?, newValue: Int) {
+    <this>.<set-value>(<set-?> = newValue)
+  }
+
+
+
+
+}
+
+val test1: Int /* by */ 
+  field = TODO("IrConstructorCall")
+  @A(...)
+  get(): Int {
+    return #test1$delegate.getValue(thisRef = null, kProp = ::test1)
+  }
+
+var test2: Int /* by */ 
+  field = TODO("IrConstructorCall")
+  @A(...)
+  get(): Int {
+    return #test2$delegate.getValue(thisRef = null, kProp = ::test2)
+  }
+  @A(...)
+  set(<set-?>: Int) {
+    return #test2$delegate.setValue(thisRef = null, kProp = ::test2, newValue = <set-?>)
+  }
+

compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt.txt

@@ -0,0 +1,33 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+open enum class TestEnum : Enum<TestEnum> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  @TestAnn(...)
+  ENTRY1 init = TODO("IrEnumConstructorCall")  @TestAnn(...)
+  ENTRY2 init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<TestEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt.txt

@@ -0,0 +1,35 @@
+enum class En : Enum<En> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  A init = TODO("IrEnumConstructorCall")  B init = TODO("IrEnumConstructorCall")  C init = TODO("IrEnumConstructorCall")  D init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): En /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+annotation class TestAnn : Annotation {
+  constructor(x: En) /* primary */ 
+  val x: En
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnn(...)
+fun test1() {
+}
+

compiler/testData/ir/irText/declarations/annotations/fieldsWithAnnotations.kt.txt

@@ -0,0 +1,20 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+val testVal: String
+  field = "a val"
+  get
+
+var testVar: String
+  field = "a var"
+  get
+  set
+

compiler/testData/ir/irText/declarations/annotations/fileAnnotations.kt.txt

@@ -0,0 +1,15 @@
+@file:A(...)
+package test
+
+@Target(...)
+annotation class A : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/functionsWithAnnotations.kt.txt

@@ -0,0 +1,15 @@
+annotation class TestAnn : Annotation {
+  constructor(x: Int) /* primary */ 
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnn(...)
+fun testSimpleFunction() {
+}
+

compiler/testData/ir/irText/declarations/annotations/javaAnnotation.kt.txt

@@ -0,0 +1,12 @@
+@JavaAnn(...)
+fun test1() {
+}
+
+@JavaAnn(...)
+fun test2() {
+}
+
+@JavaAnn(...)
+fun test3() {
+}
+

compiler/testData/ir/irText/declarations/annotations/localDelegatedPropertiesWithAnnotations.kt.txt

@@ -0,0 +1,25 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+fun foo(m: Map<String, Int>) {
+  @A(...)
+  val test: Int
+    val test$delegate: Lazy<Int> = lazy<Int>(initializer =     local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    local get(): Int {
+      return getValue<Int>($receiver = test$delegate, thisRef = null, property = ::test)
+    }
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/multipleAnnotationsInSquareBrackets.kt.txt

@@ -0,0 +1,27 @@
+annotation class A1 : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+annotation class A2 : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+annotation class A3 : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+@A1
+@A2
+@A3
+fun test() {
+}
+

compiler/testData/ir/irText/declarations/annotations/primaryConstructorParameterWithAnnotations.kt.txt

@@ -0,0 +1,23 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+class Test {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/propertiesWithAnnotations.kt.txt

@@ -0,0 +1,16 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnn(...)
+val testVal: String
+  field = ""
+  get
+

compiler/testData/ir/irText/declarations/annotations/propertyAccessorsFromClassHeaderWithAnnotations.kt.txt

@@ -0,0 +1,35 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+class C {
+  constructor(x: Int, y: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    @A(...)
+    get
+
+  var y: Int
+    field = y
+    @A(...)
+    get
+    @A(...)
+    set
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/propertyAccessorsWithAnnotations.kt.txt

@@ -0,0 +1,38 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+val test1: String
+  @TestAnn(...)
+  get(): String {
+    return ""
+  }
+
+var test2: String
+  @TestAnn(...)
+  get(): String {
+    return ""
+  }
+  @TestAnn(...)
+  set(value: String) {
+  }
+
+val test3: String
+  field = ""
+  @TestAnn(...)
+  get
+
+var test4: String
+  field = ""
+  @TestAnn(...)
+  get
+  @TestAnn(...)
+  set
+

compiler/testData/ir/irText/declarations/annotations/propertySetterParameterWithAnnotations.kt.txt

@@ -0,0 +1,29 @@
+annotation class AnnParam : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+var p: Int
+  field = 0
+  get
+  set
+
+class C {
+  constructor(p: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  var p: Int
+    field = p
+    get
+    set
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/receiverParameterWithAnnotations.kt.txt

@@ -0,0 +1,37 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+class A {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun String.f(): String {
+    return ""
+  }
+
+  val String?.p: String
+    get(): String {
+      return ""
+    }
+
+
+
+
+}
+
+fun String?.topLevelF(): String {
+  return ""
+}
+
+val String.topLevelP: String
+  get(): String {
+    return ""
+  }
+

compiler/testData/ir/irText/declarations/annotations/spreadOperatorInAnnotationArguments.kt.txt

@@ -0,0 +1,15 @@
+annotation class A : Annotation {
+  constructor(vararg xs: String) /* primary */ 
+  val xs: Array<out String>
+    field = xs
+    get
+
+
+
+
+}
+
+@A(...)
+fun test() {
+}
+

compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.kt.txt

@@ -0,0 +1,14 @@
+@Target(...)
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+@TestAnn(...)
+typealias TestTypeAlias = String

compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.kt.txt

@@ -0,0 +1,11 @@
+@Target(...)
+annotation class Anno : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+fun <@Anno T : Any?> foo() {
+}
+

compiler/testData/ir/irText/declarations/annotations/valueParametersWithAnnotations.kt.txt

@@ -0,0 +1,30 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+fun testFun(x: Int) {
+}
+
+class TestClassConstructor1 {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val xx: Int
+    field = x
+    get
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/annotations/varargsInAnnotationArguments.kt.txt

@@ -0,0 +1,45 @@
+annotation class A1 : Annotation {
+  constructor(vararg xs: Int) /* primary */ 
+  val xs: IntArray
+    field = xs
+    get
+
+
+
+
+}
+
+annotation class A2 : Annotation {
+  constructor(vararg xs: String) /* primary */ 
+  val xs: Array<out String>
+    field = xs
+    get
+
+
+
+
+}
+
+annotation class AA : Annotation {
+  constructor(vararg xs: A1) /* primary */ 
+  val xs: Array<out A1>
+    field = xs
+    get
+
+
+
+
+}
+
+@A1(...)
+@A2(...)
+@AA(...)
+fun test1() {
+}
+
+@A1(...)
+@A2(...)
+@AA(...)
+fun test2() {
+}
+

compiler/testData/ir/irText/declarations/annotations/variablesWithAnnotations.kt.txt

@@ -0,0 +1,18 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */ 
+  val x: String
+    field = x
+    get
+
+
+
+
+}
+
+fun foo() {
+  @TestAnn(...)
+  val testVal: String = "testVal"
+  @TestAnn(...)
+  var testVar: String = "testVar"
+}
+

compiler/testData/ir/irText/declarations/catchParameterInTopLevelProperty.kt.txt

@@ -0,0 +1,8 @@
+val test: Unit
+  field = try { //BLOCK
+  }
+  catch (...) { //BLOCK
+  }
+
+  get
+

compiler/testData/ir/irText/declarations/classLevelProperties.kt.txt

@@ -0,0 +1,60 @@
+class C {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val test1: Int
+    field = 0
+    get
+
+  val test2: Int
+    get(): Int {
+      return 0
+    }
+
+  var test3: Int
+    field = 0
+    get
+    set
+
+  var test4: Int
+    field = 1
+    get
+    set(value: Int) {
+      #test4 = value
+    }
+
+  var test5: Int
+    field = 1
+    get
+    private set
+
+  val test6: Int
+    field = 1
+    get
+
+  val test7: Int /* by */ 
+    field = lazy<Int>(initializer =     local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    get(): Int {
+      return getValue<Int>($receiver = #test7$delegate, thisRef = <this>, property = ::test7)
+    }
+
+  var test8: Int /* by */ 
+    field = hashMapOf<String, Int>()
+    get(): Int {
+      return getValue<Int, Int>($receiver = #test8$delegate, thisRef = <this>, property = ::test8)
+    }
+    set(<set-?>: Int) {
+      return setValue<Int>($receiver = #test8$delegate, thisRef = <this>, property = ::test8, value = <set-?>)
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/constValInitializers.kt.txt

@@ -0,0 +1,28 @@
+const val I0: Int
+  field = 0
+  get
+
+const val I1: Int
+  field = 1
+  get
+
+const val I2: Int
+  field = 2
+  get
+
+const val STR1: String
+  field = "String1"
+  get
+
+const val STR2: String
+  field = "String2"
+  get
+
+const val STR3: String
+  field = "String1String2"
+  get
+
+const val STR4: String
+  field = "String1String2"
+  get
+

compiler/testData/ir/irText/declarations/defaultArguments.kt.txt

@@ -0,0 +1,7 @@
+fun test1(x: Int, y: Int = 0, z: String = "abc") {
+  local fun local(xx: Int = x, yy: Int = y, zz: String = z) {
+  }
+
+
+}
+

compiler/testData/ir/irText/declarations/delegatedProperties.kt.txt

@@ -0,0 +1,52 @@
+val test1: Int /* by */ 
+  field = lazy<Int>(initializer =   local fun <anonymous>(): Int {
+    return 42
+  }
+)
+  get(): Int {
+    return getValue<Int>($receiver = #test1$delegate, thisRef = null, property = ::test1)
+  }
+
+class C {
+  constructor(map: MutableMap<String, Any>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val map: MutableMap<String, Any>
+    field = map
+    get
+
+  val test2: Int /* by */ 
+    field = lazy<Int>(initializer =     local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    get(): Int {
+      return getValue<Int>($receiver = #test2$delegate, thisRef = <this>, property = ::test2)
+    }
+
+  var test3: Any /* by */ 
+    field = <this>.<get-map>()
+    get(): Any {
+      return getValue<Any, Any>($receiver = #test3$delegate, thisRef = <this>, property = ::test3)
+    }
+    set(<set-?>: Any) {
+      return setValue<Any>($receiver = #test3$delegate, thisRef = <this>, property = ::test3, value = <set-?>)
+    }
+
+
+
+
+}
+
+var test4: Any /* by */ 
+  field = hashMapOf<String, Any>()
+  get(): Any {
+    return getValue<Any, Any>($receiver = #test4$delegate, thisRef = null, property = ::test4)
+  }
+  set(<set-?>: Any) {
+    return setValue<Any>($receiver = #test4$delegate, thisRef = null, property = ::test4, value = <set-?>)
+  }
+

compiler/testData/ir/irText/declarations/deprecatedProperty.kt.txt

@@ -0,0 +1,67 @@
+@Deprecated(...)
+val testVal: Int
+  field = 1
+  get
+
+@Deprecated(...)
+var testVar: Int
+  field = 1
+  get
+  set
+
+@Deprecated(...)
+val testValWithExplicitDefaultGet: Int
+  field = 1
+  get
+
+@Deprecated(...)
+val testValWithExplicitGet: Int
+  get(): Int {
+    return 1
+  }
+
+@Deprecated(...)
+var testVarWithExplicitDefaultGet: Int
+  field = 1
+  get
+  set
+
+@Deprecated(...)
+var testVarWithExplicitDefaultSet: Int
+  field = 1
+  get
+  set
+
+@Deprecated(...)
+var testVarWithExplicitDefaultGetSet: Int
+  field = 1
+  get
+  set
+
+@Deprecated(...)
+var testVarWithExplicitGetSet: Int
+  get(): Int {
+    return 1
+  }
+  set(v: Int) {
+  }
+
+@Deprecated(...)
+lateinit var testLateinitVar: Any
+  get
+  set
+
+@Deprecated(...)
+val Any.testExtVal: Int
+  get(): Int {
+    return 1
+  }
+
+@Deprecated(...)
+var Any.textExtVar: Int
+  get(): Int {
+    return 1
+  }
+  set(v: Int) {
+  }
+

compiler/testData/ir/irText/declarations/extensionProperties.kt.txt

@@ -0,0 +1,36 @@
+val String.test1: Int
+  get(): Int {
+    return 42
+  }
+
+var String.test2: Int
+  get(): Int {
+    return 42
+  }
+  set(value: Int) {
+  }
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val String.test3: Int
+    get(): Int {
+      return 42
+    }
+
+  var String.test4: Int
+    get(): Int {
+      return 42
+    }
+    set(value: Int) {
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/fakeOverrides.kt.txt

@@ -0,0 +1,48 @@
+interface IFooStr {
+  abstract fun foo(x: String) 
+
+
+
+}
+
+interface IBar {
+  abstract val bar: Int
+    abstract get
+
+
+
+
+}
+
+abstract class CFoo<T : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun foo(x: T) {
+  }
+
+
+
+
+}
+
+class Test1 : CFoo<String>, IFooStr, IBar {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override val bar: Int
+    field = 42
+    override get
+
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/fileWithAnnotations.kt.txt

@@ -0,0 +1,9 @@
+@file:JvmName(...)
+
+fun foo() {
+}
+
+val bar: Int
+  field = 42
+  get
+

compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.kt.txt

@@ -0,0 +1 @@
+typealias Bar<T : Any?> = Function1<T, String>

compiler/testData/ir/irText/declarations/genericDelegatedProperty.kt.txt

@@ -0,0 +1,40 @@
+class C<T : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+object Delegate {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  operator fun getValue(thisRef: Any?, kProp: Any?): Int {
+    return 42
+  }
+
+  operator fun setValue(thisRef: Any?, kProp: Any?, newValue: Int) {
+  }
+
+
+
+
+}
+
+var <T : Any?> C<T>.genericDelegatedProperty: Int /* by */ 
+  field = Delegate
+  get(): Int {
+    return #genericDelegatedProperty$delegate.getValue(thisRef = <this>, kProp = ::genericDelegatedProperty)
+  }
+  set(<set-?>: Int) {
+    return #genericDelegatedProperty$delegate.setValue(thisRef = <this>, kProp = ::genericDelegatedProperty, newValue = <set-?>)
+  }
+

compiler/testData/ir/irText/declarations/interfaceProperties.kt.txt

@@ -0,0 +1,25 @@
+interface C {
+  abstract val test1: Int
+    abstract get
+
+  val test2: Int
+    get(): Int {
+      return 0
+    }
+
+  abstract var test3: Int
+    abstract get
+    abstract set
+
+  var test4: Int
+    get(): Int {
+      return 0
+    }
+    set(value: Int) {
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/kt27005.kt.txt

@@ -0,0 +1,12 @@
+suspend fun foo() {
+  return baz<Unit>()
+}
+
+suspend fun bar(): Any {
+  return baz<Any>()
+}
+
+suspend fun <T : Any?> baz(): T {
+  TODO()
+}
+

compiler/testData/ir/irText/declarations/kt29833.kt.txt

@@ -0,0 +1,22 @@
+package interop
+
+object Definitions {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  const val KT_CONSTANT: String
+    field = "constant"
+    get
+
+  val ktValue: String
+    field = #CONSTANT
+    get
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/kt35550.kt.txt

@@ -0,0 +1,29 @@
+interface I {
+  val <T : Any?> T.id: T
+    get(): T {
+      return <this>
+    }
+
+
+
+
+}
+
+class A : I {
+  constructor(i: I) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: I = i
+  override val <T : Any?> T.id: T
+    override get(): T {
+      return #$$delegate_0.<get-id><T>($receiver = <this>)
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/localClassWithOverrides.kt.txt

@@ -0,0 +1,49 @@
+fun outer() {
+  local abstract class ALocal {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    abstract fun afun() 
+    abstract val aval: Int
+      abstract get
+
+    abstract var avar: Int
+      abstract get
+      abstract set
+
+
+
+
+  }
+
+
+  local class Local : ALocal {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun afun() {
+    }
+
+    override val aval: Int
+      field = 1
+      override get
+
+    override var avar: Int
+      field = 2
+      override get
+      override set
+
+
+
+
+  }
+
+
+}
+

compiler/testData/ir/irText/declarations/localDelegatedProperties.kt.txt

@@ -0,0 +1,34 @@
+fun test1() {
+  val x: Int
+    val x$delegate: Lazy<Int> = lazy<Int>(initializer =     local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    local get(): Int {
+      return getValue<Int>($receiver = x$delegate, thisRef = null, property = ::x)
+    }
+
+
+  println(message = <get-x>())
+}
+
+fun test2() {
+  var x: Int
+    val x$delegate: HashMap<String, Int> = hashMapOf<String, Int>()
+    local get(): Int {
+      return getValue<Int, Int>($receiver = x$delegate, thisRef = null, property = ::x)
+    }
+    local set(value: Int) {
+      return setValue<Int>($receiver = x$delegate, thisRef = null, property = ::x, value = value)
+    }
+
+
+  <set-x>(value = 0)
+  { //BLOCK
+    val tmp0: Int = <get-x>()
+    <set-x>(value = tmp0.inc())
+    tmp0
+  } /*~> Unit */
+  <set-x>(value = <get-x>().plus(other = 1))
+}
+

compiler/testData/ir/irText/declarations/localVarInDoWhile.kt.txt

@@ -0,0 +1,8 @@
+fun foo() {
+  { //BLOCK
+    do// COMPOSITE {
+    val x: Int = 42
+    // }    while (EQEQ(arg0 = x, arg1 = 42).not())
+  }
+}
+

compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.kt.txt

@@ -0,0 +1,48 @@
+expect abstract class A {
+  protected expect constructor() /* primary */ 
+  expect abstract fun foo() 
+
+
+
+}
+
+expect open class B : A {
+  expect constructor(i: Int) /* primary */ 
+  expect override fun foo() 
+  expect open fun bar(s: String) 
+
+
+
+}
+
+abstract class A {
+  protected constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  abstract fun foo() 
+
+
+
+}
+
+open class B : A {
+  constructor(i: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  override fun foo() {
+  }
+
+  open fun bar(s: String) {
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt.txt

@@ -0,0 +1,36 @@
+expect enum class MyEnum : Enum<MyEnum> {
+  FOO
+  BAR
+
+
+
+
+
+
+
+  fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): MyEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+enum class MyEnum : Enum<MyEnum> {
+  private constructor() /* primary */ {
+    TODO("IrEnumConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  FOO init = TODO("IrEnumConstructorCall")  BAR init = TODO("IrEnumConstructorCall")  BAZ init = TODO("IrEnumConstructorCall")
+
+
+
+
+
+
+  fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): MyEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
+

compiler/testData/ir/irText/declarations/multiplatform/expectedSealedClass.kt.txt

@@ -0,0 +1,38 @@
+expect sealed class Ops {
+  private expect constructor() /* primary */ 
+
+
+
+}
+
+expect class Add : Ops {
+  expect constructor() /* primary */ 
+
+
+
+}
+
+sealed class Ops {
+  private constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+
+class Add : Ops {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/packageLevelProperties.kt.txt

@@ -0,0 +1,48 @@
+val test1: Int
+  field = 0
+  get
+
+val test2: Int
+  get(): Int {
+    return 0
+  }
+
+var test3: Int
+  field = 0
+  get
+  set
+
+var test4: Int
+  field = 1
+  get
+  set(value: Int) {
+    #test4 = value
+  }
+
+var test5: Int
+  field = 1
+  get
+  private set
+
+val test6: Int
+  field = 1
+  get
+
+val test7: Int /* by */ 
+  field = lazy<Int>(initializer =   local fun <anonymous>(): Int {
+    return 42
+  }
+)
+  get(): Int {
+    return getValue<Int>($receiver = #test7$delegate, thisRef = null, property = ::test7)
+  }
+
+var test8: Int /* by */ 
+  field = hashMapOf<String, Int>()
+  get(): Int {
+    return getValue<Int, Int>($receiver = #test8$delegate, thisRef = null, property = ::test8)
+  }
+  set(<set-?>: Int) {
+    return setValue<Int>($receiver = #test8$delegate, thisRef = null, property = ::test8, value = <set-?>)
+  }
+

compiler/testData/ir/irText/declarations/parameters/class.kt.txt

@@ -0,0 +1,48 @@
+interface TestInterface<T : Any?> {
+  interface TestNestedInterface<TT : Any?> {
+
+
+
+  }
+
+
+
+
+}
+
+class Test<T0 : Any?> {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  class TestNested<T1 : Any?> {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+  inner class TestInner<T2 : Any?> {
+    constructor() /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+
+
+
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/constructor.kt.txt

@@ -0,0 +1,96 @@
+class Test1<T1 : Any?, T2 : Any?> {
+  constructor(x: T1, y: T2) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T1
+    field = x
+    get
+
+  val y: T2
+    field = y
+    get
+
+
+
+
+}
+
+class Test2 {
+  constructor(x: Int, y: String) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val y: String
+    field = y
+    get
+
+  inner class TestInner<Z : Any?> {
+    constructor(z: Z) /* primary */ {
+      TODO("IrDelegatingConstructorCall")
+            /* InstanceInitializerCall */
+
+    }
+
+    val z: Z
+      field = z
+      get
+
+    constructor(z: Z, i: Int) {
+      TODO("IrDelegatingConstructorCall")
+    }
+
+
+
+
+  }
+
+
+
+
+}
+
+class Test3 {
+  constructor(x: Int, y: String = "") /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+
+
+
+}
+
+class Test4<T : Any?> {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  constructor(x: Int, y: Int = 42) {
+    TODO("IrDelegatingConstructorCall")
+  }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/dataClassMembers.kt.txt

@@ -0,0 +1,63 @@
+data class Test<T : Any?> {
+  constructor(x: T, y: String = "") /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+  operator fun component1(): T {
+    return #x
+  }
+
+  operator fun component2(): String {
+    return #y
+  }
+
+  fun copy(x: T = #x, y: String = #y): Test<T> {
+    return TODO("IrConstructorCall")
+  }
+
+  override fun toString(): String {
+    return "Test(" + 
+"x=" + 
+#x + 
+", " + 
+"y=" + 
+#y + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = #x, arg1 = null) -> 0
+      true -> #x.hashCode()
+    }.times(other = 31).plus(other = #y.hashCode())
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Test<T> -> return false
+    }
+    val tmp0_other_with_cast: Test<T> = other as Test<T>
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = #y, arg1 = #y).not() -> return false
+    }
+    return true
+  }
+
+}
+

compiler/testData/ir/irText/declarations/parameters/defaultPropertyAccessors.kt.txt

@@ -0,0 +1,51 @@
+val test1: Int
+  field = 42
+  get
+
+var test2: Int
+  field = 42
+  get
+  set
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val testMember1: Int
+    field = 42
+    get
+
+  var testMember2: Int
+    field = 42
+    get
+    set
+
+
+
+
+}
+
+class InPrimaryCtor<T : Any?> {
+  constructor(testInPrimaryCtor1: T, testInPrimaryCtor2: Int = 42) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val testInPrimaryCtor1: T
+    field = testInPrimaryCtor1
+    get
+
+  var testInPrimaryCtor2: Int
+    field = testInPrimaryCtor2
+    get
+    set
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/delegatedMembers.kt.txt

@@ -0,0 +1,37 @@
+interface IBase<T : Any?> {
+  abstract fun foo(x: Int) 
+  abstract val bar: Int
+    abstract get
+
+  abstract fun <X : Any?> qux(t: T, x: X) 
+
+
+
+}
+
+class Test<TT : Any?> : IBase<TT> {
+  constructor(impl: IBase<TT>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: IBase<TT> = impl
+  override fun <X : Any?> qux(t: TT, x: X) {
+    #$$delegate_0.qux<X>(t = t, x = x)
+  }
+
+  override fun foo(x: Int) {
+    #$$delegate_0.foo(x = x)
+  }
+
+  override val bar: Int
+    override get(): Int {
+      return #$$delegate_0.<get-bar>()
+    }
+
+
+
+
+}
+

compiler/testData/ir/irText/declarations/parameters/fun.kt.txt

@@ -0,0 +1,30 @@
+fun <T : Any?> test1(i: Int, j: T) {
+}
+
+fun test2(i: Int = 0, j: String = "") {
+}
+
+fun test3(vararg args: String) {
+}
+
+fun String.textExt1(i: Int, j: String) {
+}
+
+class Host {
+  constructor() /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  fun String.testMembetExt1(i: Int, j: String) {
+  }
+
+  fun <T : Any?> String.testMembetExt2(i: Int, j: T) {
+  }
+
+
+
+
+}
+