[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>()
+    }
+
+
+
+
+}
+