[IR] add new testdata after rebase

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

@@ -0,0 +1,58 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */ 
+
+
+
+}
+
+interface IFoo {
+  @Ann
+  abstract val testVal: String
+    abstract get
+
+  @Ann
+  abstract fun testFun() 
+  @Ann
+  abstract val String.testExtVal: String
+    abstract get
+
+  @Ann
+  abstract fun String.testExtFun() 
+
+
+
+}
+
+class DFoo : IFoo {
+  constructor(d: IFoo) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private /*final field*/ val $$delegate_0: IFoo = d
+  @Ann
+  override fun String.testExtFun() {
+    #$$delegate_0.testExtFun($receiver = <this>)
+  }
+
+  @Ann
+  override fun testFun() {
+    #$$delegate_0.testFun()
+  }
+
+  override val String.testExtVal: String
+    override get(): String {
+      return #$$delegate_0.<get-testExtVal>($receiver = <this>)
+    }
+
+  override val testVal: String
+    override get(): String {
+      return #$$delegate_0.<get-testVal>()
+    }
+
+
+
+
+}
+

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

@@ -0,0 +1,115 @@
+inline class IT {
+  constructor(x: Int) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  override fun toString(): String {
+    return "IT(" + 
+"x=" + 
+#x + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #x.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is IT -> return false
+    }
+    val tmp0_other_with_cast: IT = other as IT
+    when {
+      EQEQ(arg0 = #x, arg1 = #x).not() -> return false
+    }
+    return true
+  }
+
+}
+
+inline class InlineMutableSet : MutableSet<IT> {
+  constructor(ms: MutableSet<IT>) /* primary */ {
+    TODO("IrDelegatingConstructorCall")
+        /* InstanceInitializerCall */
+
+  }
+
+  private val ms: MutableSet<IT>
+    field = ms
+    private get
+
+  override val size: Int
+    override get(): Int {
+      return <this>.<get-ms>().<get-size>()
+    }
+
+  override operator fun contains(element: IT): Boolean {
+    return <this>.<get-ms>().contains(element = element)
+  }
+
+  override fun containsAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().containsAll(elements = elements)
+  }
+
+  override fun isEmpty(): Boolean {
+    return <this>.<get-ms>().isEmpty()
+  }
+
+  override fun add(element: IT): Boolean {
+    return <this>.<get-ms>().add(element = element)
+  }
+
+  override fun addAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().addAll(elements = elements)
+  }
+
+  override fun clear() {
+    <this>.<get-ms>().clear()
+  }
+
+  override operator fun iterator(): MutableIterator<IT> {
+    return <this>.<get-ms>().iterator()
+  }
+
+  override fun remove(element: IT): Boolean {
+    return <this>.<get-ms>().remove(element = element)
+  }
+
+  override fun removeAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().removeAll(elements = elements)
+  }
+
+  override fun retainAll(elements: Collection<IT>): Boolean {
+    return <this>.<get-ms>().retainAll(elements = elements)
+  }
+
+  override fun toString(): String {
+    return "InlineMutableSet(" + 
+"ms=" + 
+#ms + 
+")"
+  }
+
+  override fun hashCode(): Int {
+    return #ms.hashCode()
+  }
+
+  override operator fun equals(other: Any?): Boolean {
+    when {
+      other !is InlineMutableSet -> return false
+    }
+    val tmp0_other_with_cast: InlineMutableSet = other as InlineMutableSet
+    when {
+      EQEQ(arg0 = #ms, arg1 = #ms).not() -> return false
+    }
+    return true
+  }
+
+}
+