diff --git a/compiler/testData/ir/irText/classes/annotationClasses.fir.kt.txt b/compiler/testData/ir/irText/classes/annotationClasses.fir.kt.txt
new file mode 100644
index 00000000000..d6e3ed1c3ef
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/annotationClasses.fir.kt.txt
@@ -0,0 +1,31 @@
+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
+
+}
diff --git a/compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..feb8a4114e0
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/argumentReorderingInDelegatingConstructorCall.fir.kt.txt
@@ -0,0 +1,44 @@
+open class Base {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+}
+
+class Test1 : Base {
+  constructor(xx: Int, yy: Int) /* primary */ {
+    { // BLOCK
+      super/*Base*/(x = xx, y = yy)
+    }
+    /* <init>() */
+
+  }
+
+}
+
+class Test2 : Base {
+  constructor(xx: Int, yy: Int) {
+    { // BLOCK
+      super/*Base*/(x = xx, y = yy)
+    }
+    /* <init>() */
+
+  }
+
+  constructor(xxx: Int, yyy: Int, a: Any) {
+    { // BLOCK
+      this/*Test2*/(xx = xxx, yy = yyy)
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/classes.fir.kt.txt b/compiler/testData/ir/irText/classes/classes.fir.kt.txt
new file mode 100644
index 00000000000..f414e52079e
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/classes.fir.kt.txt
@@ -0,0 +1,39 @@
+class TestClass {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+interface TestInterface {
+
+}
+
+object TestObject {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+annotation class TestAnnotationClass : Annotation {
+  constructor() /* primary */
+
+}
+
+enum class TestEnumClass : Enum<TestEnumClass> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestEnumClass>()
+    /* <init>() */
+
+  }
+
+  fun values(): Array<TestEnumClass> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnumClass /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/classes/cloneable.fir.kt.txt b/compiler/testData/ir/irText/classes/cloneable.fir.kt.txt
new file mode 100644
index 00000000000..d5d61aabac7
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/cloneable.fir.kt.txt
@@ -0,0 +1,34 @@
+class A : Cloneable {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+interface I : Cloneable {
+
+}
+
+class C : I {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class OC : I {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  protected override fun clone(): OC {
+    return OC()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/dataClassWithArrayMembers.fir.kt.txt b/compiler/testData/ir/irText/classes/dataClassWithArrayMembers.fir.kt.txt
new file mode 100644
index 00000000000..065d0ceeae6
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/dataClassWithArrayMembers.fir.kt.txt
@@ -0,0 +1,228 @@
+data class Test1 {
+  constructor(stringArray: Array<String>, charArray: CharArray, booleanArray: BooleanArray, byteArray: ByteArray, shortArray: ShortArray, intArray: IntArray, longArray: LongArray, floatArray: FloatArray, doubleArray: DoubleArray) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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
+
+  fun component1(): Array<String> {
+    return <this>.#stringArray
+  }
+
+  fun component2(): CharArray {
+    return <this>.#charArray
+  }
+
+  fun component3(): BooleanArray {
+    return <this>.#booleanArray
+  }
+
+  fun component4(): ByteArray {
+    return <this>.#byteArray
+  }
+
+  fun component5(): ShortArray {
+    return <this>.#shortArray
+  }
+
+  fun component6(): IntArray {
+    return <this>.#intArray
+  }
+
+  fun component7(): LongArray {
+    return <this>.#longArray
+  }
+
+  fun component8(): FloatArray {
+    return <this>.#floatArray
+  }
+
+  fun component9(): DoubleArray {
+    return <this>.#doubleArray
+  }
+
+  fun copy(stringArray: Array<String> = <this>.#stringArray, charArray: CharArray = <this>.#charArray, booleanArray: BooleanArray = <this>.#booleanArray, byteArray: ByteArray = <this>.#byteArray, shortArray: ShortArray = <this>.#shortArray, intArray: IntArray = <this>.#intArray, longArray: LongArray = <this>.#longArray, floatArray: FloatArray = <this>.#floatArray, doubleArray: DoubleArray = <this>.#doubleArray): Test1 {
+    return Test1(stringArray = stringArray, charArray = charArray, booleanArray = booleanArray, byteArray = byteArray, shortArray = shortArray, intArray = intArray, longArray = longArray, floatArray = floatArray, doubleArray = doubleArray)
+  }
+
+  override 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 = <this>.#stringArray, arg1 = tmp0_other_with_cast.#stringArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#charArray, arg1 = tmp0_other_with_cast.#charArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#booleanArray, arg1 = tmp0_other_with_cast.#booleanArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#byteArray, arg1 = tmp0_other_with_cast.#byteArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#shortArray, arg1 = tmp0_other_with_cast.#shortArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#intArray, arg1 = tmp0_other_with_cast.#intArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#longArray, arg1 = tmp0_other_with_cast.#longArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#floatArray, arg1 = tmp0_other_with_cast.#floatArray).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#doubleArray, arg1 = tmp0_other_with_cast.#doubleArray).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = dataClassArrayMemberHashCode(arg0 = <this>.#stringArray)
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#charArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#booleanArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#byteArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#shortArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#intArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#longArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#floatArray))
+    result = result.times(other = 31).plus(other = dataClassArrayMemberHashCode(arg0 = <this>.#doubleArray))
+    return result
+  }
+
+  override fun toString(): String {
+    return "Test1(" + "stringArray=" + dataClassArrayMemberToString(arg0 = <this>.#stringArray) + ", " + "charArray=" + dataClassArrayMemberToString(arg0 = <this>.#charArray) + ", " + "booleanArray=" + dataClassArrayMemberToString(arg0 = <this>.#booleanArray) + ", " + "byteArray=" + dataClassArrayMemberToString(arg0 = <this>.#byteArray) + ", " + "shortArray=" + dataClassArrayMemberToString(arg0 = <this>.#shortArray) + ", " + "intArray=" + dataClassArrayMemberToString(arg0 = <this>.#intArray) + ", " + "longArray=" + dataClassArrayMemberToString(arg0 = <this>.#longArray) + ", " + "floatArray=" + dataClassArrayMemberToString(arg0 = <this>.#floatArray) + ", " + "doubleArray=" + dataClassArrayMemberToString(arg0 = <this>.#doubleArray) + ")"
+  }
+
+}
+
+data class Test2<T : Any?> {
+  constructor(genericArray: Array<T>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val genericArray: Array<T>
+    field = genericArray
+    get
+
+  fun component1(): Array<T> {
+    return <this>.#genericArray
+  }
+
+  fun copy(genericArray: Array<T> = <this>.#genericArray): Test2<T> {
+    return Test2<Any>(genericArray = genericArray)
+  }
+
+  override 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 = <this>.#genericArray, arg1 = tmp0_other_with_cast.#genericArray).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return dataClassArrayMemberHashCode(arg0 = <this>.#genericArray)
+  }
+
+  override fun toString(): String {
+    return "Test2(" + "genericArray=" + dataClassArrayMemberToString(arg0 = <this>.#genericArray) + ")"
+  }
+
+}
+
+data class Test3 {
+  constructor(anyArrayN: Array<Any>?) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val anyArrayN: Array<Any>?
+    field = anyArrayN
+    get
+
+  fun component1(): Array<Any>? {
+    return <this>.#anyArrayN
+  }
+
+  fun copy(anyArrayN: Array<Any>? = <this>.#anyArrayN): Test3 {
+    return Test3(anyArrayN = anyArrayN)
+  }
+
+  override 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 = <this>.#anyArrayN, arg1 = tmp0_other_with_cast.#anyArrayN).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#anyArrayN, arg1 = null) -> 0
+      else -> dataClassArrayMemberHashCode(arg0 = <this>.#anyArrayN)
+    }
+  }
+
+  override fun toString(): String {
+    return "Test3(" + "anyArrayN=" + dataClassArrayMemberToString(arg0 = <this>.#anyArrayN) + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/dataClasses.fir.kt.txt b/compiler/testData/ir/irText/classes/dataClasses.fir.kt.txt
new file mode 100644
index 00000000000..9203bc4657f
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/dataClasses.fir.kt.txt
@@ -0,0 +1,199 @@
+data class Test1 {
+  constructor(x: Int, y: String, z: Any) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+  val z: Any
+    field = z
+    get
+
+  fun component1(): Int {
+    return <this>.#x
+  }
+
+  fun component2(): String {
+    return <this>.#y
+  }
+
+  fun component3(): Any {
+    return <this>.#z
+  }
+
+  fun copy(x: Int = <this>.#x, y: String = <this>.#y, z: Any = <this>.#z): Test1 {
+    return Test1(x = x, y = y, z = z)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#y, arg1 = tmp0_other_with_cast.#y).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#z, arg1 = tmp0_other_with_cast.#z).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = <this>.#x.hashCode()
+    result = result.times(other = 31).plus(other = <this>.#y.hashCode())
+    result = result.times(other = 31).plus(other = <this>.#z.hashCode())
+    return result
+  }
+
+  override fun toString(): String {
+    return "Test1(" + "x=" + <this>.#x + ", " + "y=" + <this>.#y + ", " + "z=" + <this>.#z + ")"
+  }
+
+}
+
+data class Test2 {
+  constructor(x: Any?) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Any?
+    field = x
+    get
+
+  fun component1(): Any? {
+    return <this>.#x
+  }
+
+  fun copy(x: Any? = <this>.#x): Test2 {
+    return Test2(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#x, arg1 = null) -> 0
+      else -> <this>.#x.hashCode()
+    }
+  }
+
+  override fun toString(): String {
+    return "Test2(" + "x=" + <this>.#x + ")"
+  }
+
+}
+
+data class Test3 {
+  constructor(d: Double, dn: Double?, f: Float, df: Float?) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val d: Double
+    field = d
+    get
+
+  val dn: Double?
+    field = dn
+    get
+
+  val f: Float
+    field = f
+    get
+
+  val df: Float?
+    field = df
+    get
+
+  fun component1(): Double {
+    return <this>.#d
+  }
+
+  fun component2(): Double? {
+    return <this>.#dn
+  }
+
+  fun component3(): Float {
+    return <this>.#f
+  }
+
+  fun component4(): Float? {
+    return <this>.#df
+  }
+
+  fun copy(d: Double = <this>.#d, dn: Double? = <this>.#dn, f: Float = <this>.#f, df: Float? = <this>.#df): Test3 {
+    return Test3(d = d, dn = dn, f = f, df = df)
+  }
+
+  override 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 = <this>.#d, arg1 = tmp0_other_with_cast.#d).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#dn, arg1 = tmp0_other_with_cast.#dn).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#f, arg1 = tmp0_other_with_cast.#f).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#df, arg1 = tmp0_other_with_cast.#df).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = <this>.#d.hashCode()
+    result = result.times(other = 31).plus(other = when {
+      EQEQ(arg0 = <this>.#dn, arg1 = null) -> 0
+      else -> <this>.#dn.hashCode()
+    })
+    result = result.times(other = 31).plus(other = <this>.#f.hashCode())
+    result = result.times(other = 31).plus(other = when {
+      EQEQ(arg0 = <this>.#df, arg1 = null) -> 0
+      else -> <this>.#df.hashCode()
+    })
+    return result
+  }
+
+  override fun toString(): String {
+    return "Test3(" + "d=" + <this>.#d + ", " + "dn=" + <this>.#dn + ", " + "f=" + <this>.#f + ", " + "df=" + <this>.#df + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/dataClassesGeneric.fir.kt.txt b/compiler/testData/ir/irText/classes/dataClassesGeneric.fir.kt.txt
new file mode 100644
index 00000000000..d932e4fc785
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/dataClassesGeneric.fir.kt.txt
@@ -0,0 +1,174 @@
+data class Test1<T : Any?> {
+  constructor(x: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  fun component1(): T {
+    return <this>.#x
+  }
+
+  fun copy(x: T = <this>.#x): Test1<T> {
+    return Test1<Any>(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#x, arg1 = null) -> 0
+      else -> <this>.#x.hashCode()
+    }
+  }
+
+  override fun toString(): String {
+    return "Test1(" + "x=" + <this>.#x + ")"
+  }
+
+}
+
+data class Test2<T : Number> {
+  constructor(x: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  fun component1(): T {
+    return <this>.#x
+  }
+
+  fun copy(x: T = <this>.#x): Test2<T> {
+    return Test2<Any>(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "Test2(" + "x=" + <this>.#x + ")"
+  }
+
+}
+
+data class Test3<T : Any?> {
+  constructor(x: List<T>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: List<T>
+    field = x
+    get
+
+  fun component1(): List<T> {
+    return <this>.#x
+  }
+
+  fun copy(x: List<T> = <this>.#x): Test3<T> {
+    return Test3<Any>(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "Test3(" + "x=" + <this>.#x + ")"
+  }
+
+}
+
+data class Test4 {
+  constructor(x: List<String>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: List<String>
+    field = x
+    get
+
+  fun component1(): List<String> {
+    return <this>.#x
+  }
+
+  fun copy(x: List<String> = <this>.#x): Test4 {
+    return Test4(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "Test4(" + "x=" + <this>.#x + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatedGenericImplementation.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatedGenericImplementation.fir.kt.txt
new file mode 100644
index 00000000000..12ed623bf64
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatedGenericImplementation.fir.kt.txt
@@ -0,0 +1,73 @@
+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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = i
+  }
+
+  override fun <B : Any?> foo(a: E, b: B) {
+    <this>.#<$$delegate_0>.foo</* null */>(a = a, b = b)
+  }
+
+  override val <C : Any?> C.id: Map<E, C>?
+    override get(): Map<E, C>? {
+      return (<this>.#<$$delegate_0>, <this>).<get-id></* null */>()
+    }
+
+  override var <D : Any?> List<D>.x: D?
+    override get(): D? {
+      return (<this>.#<$$delegate_0>, <this>).<get-x></* null */>()
+    }
+    override set(<set-?>: D?) {
+      (<this>.#<$$delegate_0>, <this>).<set-x></* null */>(<set-?> = <set-?>)
+    }
+
+  local /*final field*/ val <$$delegate_0>: IBase<E>
+
+}
+
+class Test2 : IBase<String> {
+  constructor(j: IBase<String>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = j
+  }
+
+  var j: IBase<String>
+    field = j
+    get
+    set
+
+  override fun <B : Any?> foo(a: String, b: B) {
+    <this>.#<$$delegate_0>.foo</* null */>(a = a, b = b)
+  }
+
+  override val <C : Any?> C.id: Map<String, C>?
+    override get(): Map<String, C>? {
+      return (<this>.#<$$delegate_0>, <this>).<get-id></* null */>()
+    }
+
+  override var <D : Any?> List<D>.x: D?
+    override get(): D? {
+      return (<this>.#<$$delegate_0>, <this>).<get-x></* null */>()
+    }
+    override set(<set-?>: D?) {
+      (<this>.#<$$delegate_0>, <this>).<set-x></* null */>(<set-?> = <set-?>)
+    }
+
+  local /*final field*/ val <$$delegate_0>: IBase<String>
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatedImplementation.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatedImplementation.fir.kt.txt
new file mode 100644
index 00000000000..ef0e829ad86
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatedImplementation.fir.kt.txt
@@ -0,0 +1,154 @@
+interface IBase {
+  abstract fun foo(x: Int, s: String)
+  abstract fun bar(): Int
+  abstract fun String.qux()
+
+}
+
+object BaseImpl : IBase {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      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) {
+        }
+
+    }
+
+    <no name provided>()
+  }
+}
+
+class Test1 : IBase {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = BaseImpl
+  }
+
+  override fun foo(x: Int, s: String) {
+    <this>.#<$$delegate_0>.foo(x = x, s = s)
+  }
+
+  override fun bar(): Int {
+    return <this>.#<$$delegate_0>.bar()
+  }
+
+  override fun String.qux() {
+    (<this>.#<$$delegate_0>, <this>).qux()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IBase
+
+}
+
+class Test2 : IBase, IOther {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = BaseImpl
+    <this>.#<$$delegate_1> = otherImpl(x0 = "", y0 = 42)
+  }
+
+  override fun foo(x: Int, s: String) {
+    <this>.#<$$delegate_0>.foo(x = x, s = s)
+  }
+
+  override fun bar(): Int {
+    return <this>.#<$$delegate_0>.bar()
+  }
+
+  override fun String.qux() {
+    (<this>.#<$$delegate_0>, <this>).qux()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IBase
+  override val x: String
+    override get(): String {
+      return <this>.#<$$delegate_1>.<get-x>()
+    }
+
+  override var y: Int
+    override get(): Int {
+      return <this>.#<$$delegate_1>.<get-y>()
+    }
+    override set(<set-?>: Int) {
+      <this>.#<$$delegate_1>.<set-y>(<set-?> = <set-?>)
+    }
+
+  override val Byte.z1: Int
+    override get(): Int {
+      return (<this>.#<$$delegate_1>, <this>).<get-z1>()
+    }
+
+  override var Byte.z2: Int
+    override get(): Int {
+      return (<this>.#<$$delegate_1>, <this>).<get-z2>()
+    }
+    override set(<set-?>: Int) {
+      (<this>.#<$$delegate_1>, <this>).<set-z2>(<set-?> = <set-?>)
+    }
+
+  local /*final field*/ val <$$delegate_1>: IOther
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatedImplementationOfJavaInterface.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatedImplementationOfJavaInterface.fir.kt.txt
new file mode 100644
index 00000000000..8bf95831780
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatedImplementationOfJavaInterface.fir.kt.txt
@@ -0,0 +1,39 @@
+class Test : J {
+  constructor(j: J) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = j
+  }
+
+  private val j: J
+    field = j
+    private get
+
+  override fun takeNotNull(x: @EnhancedNullability String) {
+    <this>.#<$$delegate_0>.takeNotNull(x = x)
+  }
+
+  override fun takeNullable(x: @FlexibleNullability String?) {
+    <this>.#<$$delegate_0>.takeNullable(x = x)
+  }
+
+  override fun takeFlexible(x: String?) {
+    <this>.#<$$delegate_0>.takeFlexible(x = x)
+  }
+
+  override fun returnNotNull(): @EnhancedNullability String {
+    return <this>.#<$$delegate_0>.returnNotNull()
+  }
+
+  override fun returnNullable(): @FlexibleNullability String? {
+    return <this>.#<$$delegate_0>.returnNullable()
+  }
+
+  override fun returnsFlexible(): String? {
+    return <this>.#<$$delegate_0>.returnsFlexible()
+  }
+
+  local /*final field*/ val <$$delegate_0>: J
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatedImplementationWithExplicitOverride.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatedImplementationWithExplicitOverride.fir.kt.txt
new file mode 100644
index 00000000000..fba073af5c8
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatedImplementationWithExplicitOverride.fir.kt.txt
@@ -0,0 +1,39 @@
+interface IFooBar {
+  abstract fun foo()
+  abstract fun bar()
+
+}
+
+object FooBarImpl : IFooBar {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override fun foo() {
+  }
+
+  override fun bar() {
+  }
+
+}
+
+class C : IFooBar {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = FooBarImpl
+  }
+
+  override fun bar() {
+  }
+
+  override fun foo() {
+    <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFooBar
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.fir.kt.txt
new file mode 100644
index 00000000000..3fce7ec5c13
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.fir.kt.txt
@@ -0,0 +1,32 @@
+typealias CT<T : Any?> = Cell<T>
+typealias CStr = Cell<String>
+open class Cell<T : Any?> {
+  constructor(value: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+}
+
+class C1 : Cell<String> {
+  constructor() /* primary */ {
+    super/*Cell*/<String>(value = "O")
+    /* <init>() */
+
+  }
+
+}
+
+class C2 : Cell<String> {
+  constructor() /* primary */ {
+    super/*Cell*/<String>(value = "K")
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/delegatingConstructorCallsInSecondaryConstructors.fir.kt.txt b/compiler/testData/ir/irText/classes/delegatingConstructorCallsInSecondaryConstructors.fir.kt.txt
new file mode 100644
index 00000000000..4aa34fe4a53
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/delegatingConstructorCallsInSecondaryConstructors.fir.kt.txt
@@ -0,0 +1,27 @@
+open class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Test : Base {
+  constructor() {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  constructor(xx: Int) {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  constructor(xx: Short) {
+    this/*Test*/()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/enum.fir.kt.txt b/compiler/testData/ir/irText/classes/enum.fir.kt.txt
new file mode 100644
index 00000000000..f162b559184
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/enum.fir.kt.txt
@@ -0,0 +1,174 @@
+enum class TestEnum1 : Enum<TestEnum1> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestEnum1>()
+    /* <init>() */
+
+  }
+
+  TEST1 = TestEnum1()
+
+  TEST2 = TestEnum1()
+
+  fun values(): Array<TestEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class TestEnum2 : Enum<TestEnum2> {
+  private constructor(x: Int) /* primary */ {
+    super/*Enum*/<TestEnum2>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 = TestEnum2(x = 1)
+
+  TEST2 = TestEnum2(x = 2)
+
+  TEST3 = TestEnum2(x = 3)
+
+  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 */ {
+    super/*Enum*/<TestEnum3>()
+    /* <init>() */
+
+  }
+
+  TEST = TEST()
+  private enum entry class TEST : TestEnum3 {
+    private constructor() /* primary */ {
+      super/*TestEnum3*/()
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+      println(message = "Hello, world!")
+    }
+
+  }
+
+  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 */ {
+    super/*Enum*/<TestEnum4>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 = TEST1()
+  private enum entry class TEST1 : TestEnum4 {
+    private constructor() /* primary */ {
+      super/*TestEnum4*/(x = 1)
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+      println(message = TestEnum4.TEST1)
+    }
+
+  }
+
+  TEST2 = TEST2()
+  private enum entry class TEST2 : TestEnum4 {
+    private constructor() /* primary */ {
+      super/*TestEnum4*/(x = 2)
+      /* <init>() */
+
+    }
+
+    val z: Int
+      get
+
+    init {
+      <this>.#z = <this>.<get-x>()
+    }
+
+    override fun foo() {
+      println(message = TestEnum4.TEST2)
+    }
+
+  }
+
+  abstract fun foo()
+  fun values(): Array<TestEnum4> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum4 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class TestEnum5 : Enum<TestEnum5> {
+  private constructor(x: Int = 0) /* primary */ {
+    super/*Enum*/<TestEnum5>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  TEST1 = TestEnum5()
+
+  TEST2 = TestEnum5()
+
+  TEST3 = TestEnum5(x = 0)
+
+  fun values(): Array<TestEnum5> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum5 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+fun f(): Int {
+  return 1
+}
+
+open enum class TestEnum6 : Enum<TestEnum6> {
+  private constructor(x: Int, y: Int) /* primary */ {
+    super/*Enum*/<TestEnum6>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  TEST = { // BLOCK
+    val tmp0_y: Int = f()
+    val tmp1_x: Int = f()
+    TestEnum6(x = tmp1_x, y = tmp0_y)
+  }
+
+  fun values(): Array<TestEnum6> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum6 /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/classes/enumClassModality.fir.kt.txt b/compiler/testData/ir/irText/classes/enumClassModality.fir.kt.txt
new file mode 100644
index 00000000000..d8342c49ad4
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/enumClassModality.fir.kt.txt
@@ -0,0 +1,165 @@
+enum class TestFinalEnum1 : Enum<TestFinalEnum1> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestFinalEnum1>()
+    /* <init>() */
+
+  }
+
+  X1 = TestFinalEnum1()
+
+  fun values(): Array<TestFinalEnum1> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestFinalEnum1 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class TestFinalEnum2 : Enum<TestFinalEnum2> {
+  private constructor(x: Int) /* primary */ {
+    super/*Enum*/<TestFinalEnum2>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  X1 = TestFinalEnum2(x = 1)
+
+  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 */ {
+    super/*Enum*/<TestFinalEnum3>()
+    /* <init>() */
+
+  }
+
+  X1 = TestFinalEnum3()
+
+  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 */ {
+    super/*Enum*/<TestOpenEnum1>()
+    /* <init>() */
+
+  }
+
+  X1 = X1()
+  private enum entry class X1 : TestOpenEnum1 {
+    private constructor() /* primary */ {
+      super/*TestOpenEnum1*/()
+      /* <init>() */
+
+    }
+
+    override fun toString(): String {
+      return "X1"
+    }
+
+  }
+
+  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 */ {
+    super/*Enum*/<TestOpenEnum2>()
+    /* <init>() */
+
+  }
+
+  X1 = X1()
+  private enum entry class X1 : TestOpenEnum2 {
+    private constructor() /* primary */ {
+      super/*TestOpenEnum2*/()
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
+
+  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 */ {
+    super/*Enum*/<TestAbstractEnum1>()
+    /* <init>() */
+
+  }
+
+  X1 = X1()
+  private enum entry class X1 : TestAbstractEnum1 {
+    private constructor() /* primary */ {
+      super/*TestAbstractEnum1*/()
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
+
+  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()
+
+}
+
+open enum class TestAbstractEnum2 : IFoo, Enum<TestAbstractEnum2> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestAbstractEnum2>()
+    /* <init>() */
+
+  }
+
+  X1 = X1()
+  private enum entry class X1 : TestAbstractEnum2 {
+    private constructor() /* primary */ {
+      super/*TestAbstractEnum2*/()
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
+
+  fun values(): Array<TestAbstractEnum2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestAbstractEnum2 /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/classes/enumWithMultipleCtors.fir.kt.txt b/compiler/testData/ir/irText/classes/enumWithMultipleCtors.fir.kt.txt
new file mode 100644
index 00000000000..461e99bf1b0
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/enumWithMultipleCtors.fir.kt.txt
@@ -0,0 +1,60 @@
+open enum class A : Enum<A> {
+  X = A(arg = "asd")
+
+  Y = Y()
+  private enum entry class Y : A {
+    private constructor() /* primary */ {
+      super/*A*/()
+      /* <init>() */
+
+    }
+
+    override fun f(): String {
+      return super.f().plus(other = "#Y")
+    }
+
+  }
+
+  Z = A(x = 5)
+
+  val prop1: String
+    get
+
+  val prop2: String
+    field = "const2"
+    get
+
+  var prop3: String
+    field = ""
+    get
+    set
+
+  private constructor(arg: String) {
+    super/*Enum*/<A>()
+    /* <init>() */
+
+    <this>.#prop1 = arg
+  }
+
+  private constructor() {
+    super/*Enum*/<A>()
+    /* <init>() */
+
+    <this>.#prop1 = "default"
+    <this>.<set-prop3>(<set-?> = "empty")
+  }
+
+  private constructor(x: Int) {
+    this/*A*/(arg = x.toString())
+    <this>.<set-prop3>(<set-?> = "int")
+  }
+
+  open fun f(): String {
+    return <this>.<get-prop1>().toString() + "#" + <this>.<get-prop2>().toString() + "#" + <this>.<get-prop3>().toString()
+  }
+
+  fun values(): Array<A> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): A /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.fir.kt.txt b/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.fir.kt.txt
new file mode 100644
index 00000000000..e9f1098f803
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.fir.kt.txt
@@ -0,0 +1,97 @@
+open enum class Test0 : Enum<Test0> {
+  private constructor(x: Int) /* primary */ {
+    super/*Enum*/<Test0>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO = Test0()
+
+  private constructor() {
+    this/*Test0*/(x = 0)
+  }
+
+  fun values(): Array<Test0> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Test0 /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+open enum class Test1 : Enum<Test1> {
+  private constructor(x: Int) /* primary */ {
+    super/*Enum*/<Test1>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO = Test1()
+
+  ONE = Test1(x = 1)
+
+  private constructor() {
+    this/*Test1*/(x = 0)
+  }
+
+  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 */ {
+    super/*Enum*/<Test2>()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  ZERO = ZERO()
+  private enum entry class ZERO : Test2 {
+    private constructor() /* primary */ {
+      super/*Test2*/()
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+      println(message = "ZERO")
+    }
+
+  }
+
+  ONE = ONE()
+  private enum entry class ONE : Test2 {
+    private constructor() /* primary */ {
+      super/*Test2*/(x = 1)
+      /* <init>() */
+
+    }
+
+    override fun foo() {
+      println(message = "ONE")
+    }
+
+  }
+
+  private constructor() {
+    this/*Test2*/(x = 0)
+  }
+
+  abstract fun foo()
+  fun values(): Array<Test2> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Test2 /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.fir.kt.txt b/compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.fir.kt.txt
new file mode 100644
index 00000000000..f4f44ae84e1
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/fakeOverridesForJavaStaticMembers.fir.kt.txt
@@ -0,0 +1,8 @@
+class Test : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.fir.kt.txt b/compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.fir.kt.txt
new file mode 100644
index 00000000000..8ae6aea8d38
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/implicitNotNullOnDelegatedImplementation.fir.kt.txt
@@ -0,0 +1,128 @@
+interface IFoo {
+  abstract fun foo(): String
+
+}
+
+class K1 : JFoo {
+  constructor() /* primary */ {
+    super/*JFoo*/()
+    /* <init>() */
+
+  }
+
+}
+
+class K2 : JFoo {
+  constructor() /* primary */ {
+    super/*JFoo*/()
+    /* <init>() */
+
+  }
+
+  override fun foo(): @FlexibleNullability String {
+    return super.foo()
+  }
+
+}
+
+class K3 : JUnrelatedFoo, IFoo {
+  constructor() /* primary */ {
+    super/*JUnrelatedFoo*/()
+    /* <init>() */
+
+  }
+
+}
+
+class K4 : JUnrelatedFoo, IFoo {
+  constructor() /* primary */ {
+    super/*JUnrelatedFoo*/()
+    /* <init>() */
+
+  }
+
+  override fun foo(): String? {
+    return super.foo()
+  }
+
+}
+
+class TestJFoo : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = JFoo()
+  }
+
+  override fun foo(): String {
+    return <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
+
+class TestK1 : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = K1()
+  }
+
+  override fun foo(): String {
+    return <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
+
+class TestK2 : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = K2()
+  }
+
+  override fun foo(): String {
+    return <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
+
+class TestK3 : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = K3()
+  }
+
+  override fun foo(): String {
+    return <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
+
+class TestK4 : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = K4()
+  }
+
+  override fun foo(): String {
+    return <this>.#<$$delegate_0>.foo()
+  }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
diff --git a/compiler/testData/ir/irText/classes/initValInLambda.fir.kt.txt b/compiler/testData/ir/irText/classes/initValInLambda.fir.kt.txt
new file mode 100644
index 00000000000..727822427ed
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/initValInLambda.fir.kt.txt
@@ -0,0 +1,18 @@
+class TestInitValInLambdaCalledOnce {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    get
+
+  init {
+    1.run<Int, Unit>(block = local fun Int.<anonymous>() {
+      <this>.#x = 0
+    }
+)
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/inlineClass.fir.kt.txt b/compiler/testData/ir/irText/classes/inlineClass.fir.kt.txt
new file mode 100644
index 00000000000..f606fd6ab9f
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/inlineClass.fir.kt.txt
@@ -0,0 +1,31 @@
+inline class Test {
+  constructor(x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  override fun equals(other: Any?): Boolean {
+    when {
+      other !is Test -> return false
+    }
+    val tmp0_other_with_cast: Test = other as Test
+    when {
+      EQEQ(arg0 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "Test(" + "x=" + <this>.#x + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.fir.kt.txt b/compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.fir.kt.txt
new file mode 100644
index 00000000000..9e57b45e94a
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/inlineClassSyntheticMethods.fir.kt.txt
@@ -0,0 +1,60 @@
+class C<T : Any?> {
+  constructor(t: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val c: C<TT>
+    field = c
+    get
+
+  fun foo(): Int {
+    return <this>.<get-c>().hashCode()
+  }
+
+  override 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 = <this>.#c, arg1 = tmp0_other_with_cast.#c).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#c.hashCode()
+  }
+
+  override fun toString(): String {
+    return "IC(" + "c=" + <this>.#c + ")"
+  }
+
+}
+
+fun box(): String {
+  val ic: IC<Int> = IC<Int>(c = C<Int>(t = 42))
+  when {
+    EQEQ(arg0 = ic.foo(), arg1 = 42).not() -> return "FAIL"
+  }
+  return "OK"
+}
diff --git a/compiler/testData/ir/irText/classes/innerClass.fir.kt.txt b/compiler/testData/ir/irText/classes/innerClass.fir.kt.txt
new file mode 100644
index 00000000000..70489fb8082
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/innerClass.fir.kt.txt
@@ -0,0 +1,26 @@
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  open inner class TestInnerClass {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+  inner class DerivedInnerClass : TestInnerClass {
+    constructor() /* primary */ {
+      <this>.super/*TestInnerClass*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/innerClassWithDelegatingConstructor.fir.kt.txt b/compiler/testData/ir/irText/classes/innerClassWithDelegatingConstructor.fir.kt.txt
new file mode 100644
index 00000000000..67d9bb6242f
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/innerClassWithDelegatingConstructor.fir.kt.txt
@@ -0,0 +1,25 @@
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  inner class Inner {
+    constructor(x: Int) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val x: Int
+      field = x
+      get
+
+    constructor() {
+      <this>.this/*Inner*/(x = 0)
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/kt31649.fir.kt.txt b/compiler/testData/ir/irText/classes/kt31649.fir.kt.txt
new file mode 100644
index 00000000000..0947f7f3e7e
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/kt31649.fir.kt.txt
@@ -0,0 +1,80 @@
+data class TestData {
+  constructor(nn: Nothing?) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val nn: Nothing?
+    field = nn
+    get
+
+  fun component1(): Nothing? {
+    return <this>.#nn
+  }
+
+  fun copy(nn: Nothing? = <this>.#nn): TestData {
+    return TestData(nn = nn)
+  }
+
+  override 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 = <this>.#nn, arg1 = tmp0_other_with_cast.#nn).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#nn, arg1 = null) -> 0
+      else -> <this>.#nn.hashCode()
+    }
+  }
+
+  override fun toString(): String {
+    return "TestData(" + "nn=" + <this>.#nn + ")"
+  }
+
+}
+
+inline class TestInline {
+  constructor(nn: Nothing?) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val nn: Nothing?
+    field = nn
+    get
+
+  override fun equals(other: Any?): Boolean {
+    when {
+      other !is TestInline -> return false
+    }
+    val tmp0_other_with_cast: TestInline = other as TestInline
+    when {
+      EQEQ(arg0 = <this>.#nn, arg1 = tmp0_other_with_cast.#nn).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#nn, arg1 = null) -> 0
+      else -> <this>.#nn.hashCode()
+    }
+  }
+
+  override fun toString(): String {
+    return "TestInline(" + "nn=" + <this>.#nn + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/kt43217.fir.kt.txt b/compiler/testData/ir/irText/classes/kt43217.fir.kt.txt
new file mode 100644
index 00000000000..bd07aa4c60f
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/kt43217.fir.kt.txt
@@ -0,0 +1,40 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  private val b: <no name provided>
+    field = { // BLOCK
+      local class <no name provided> : DoubleExpression {
+        private constructor() /* primary */ {
+          super/*DoubleExpression*/()
+          /* <init>() */
+
+        }
+
+        override operator fun get(): Double {
+          return 0.0D
+        }
+
+      }
+
+      <no name provided>()
+    }
+    private get
+
+}
+
+class C : DoubleExpression {
+  constructor() /* primary */ {
+    super/*DoubleExpression*/()
+    /* <init>() */
+
+  }
+
+  override operator fun get(): Double {
+    return 0.0D
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt
new file mode 100644
index 00000000000..726406607bb
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/lambdaInDataClassDefaultParameter.fir.kt.txt
@@ -0,0 +1,99 @@
+data class A {
+  constructor(runA: @ExtensionFunctionType @ExtensionFunctionType Function2<A, String, Unit> = local fun A.<anonymous>(it: String) {
+    return Unit
+  }
+) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val runA: @ExtensionFunctionType @ExtensionFunctionType Function2<A, String, Unit>
+    field = runA
+    get
+
+  fun component1(): @ExtensionFunctionType @ExtensionFunctionType Function2<A, String, Unit> {
+    return <this>.#runA
+  }
+
+  fun copy(runA: @ExtensionFunctionType @ExtensionFunctionType Function2<A, String, Unit> = <this>.#runA): A {
+    return A(runA = runA)
+  }
+
+  override 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 = <this>.#runA, arg1 = tmp0_other_with_cast.#runA).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#runA.hashCode()
+  }
+
+  override fun toString(): String {
+    return "A(" + "runA=" + <this>.#runA + ")"
+  }
+
+}
+
+data class B {
+  constructor(x: Any = { // BLOCK
+    local class <no name provided> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+    }
+
+    <no name provided>()
+  }) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Any
+    field = x
+    get
+
+  fun component1(): Any {
+    return <this>.#x
+  }
+
+  fun copy(x: Any = <this>.#x): B {
+    return B(x = x)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "B(" + "x=" + <this>.#x + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/objectLiteralExpressions.fir.kt.txt b/compiler/testData/ir/irText/classes/objectLiteralExpressions.fir.kt.txt
new file mode 100644
index 00000000000..b9886d37fce
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/objectLiteralExpressions.fir.kt.txt
@@ -0,0 +1,94 @@
+interface IFoo {
+  abstract fun foo()
+
+}
+
+val test1: <no name provided>
+  field = { // BLOCK
+    local class <no name provided> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+    }
+
+    <no name provided>()
+  }
+  get
+
+val test2: IFoo
+  field = { // BLOCK
+    local class <no name provided> : IFoo {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      override fun foo() {
+        println(message = "foo")
+      }
+
+    }
+
+    <no name provided>()
+  }
+  get
+
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  abstract inner class Inner : IFoo {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+  fun test3(): Inner {
+    return { // BLOCK
+      local class <no name provided> : Inner {
+        private constructor() /* primary */ {
+          <this>.super/*Inner*/()
+          /* <init>() */
+
+        }
+
+        override fun foo() {
+          println(message = "foo")
+        }
+
+      }
+
+      <no name provided>()
+    }
+  }
+
+}
+
+fun Outer.test4(): Inner {
+  return { // BLOCK
+    local class <no name provided> : Inner {
+      private constructor() /* primary */ {
+        <this>.super/*Inner*/()
+        /* <init>() */
+
+      }
+
+      override fun foo() {
+        println(message = "foo")
+      }
+
+    }
+
+    <no name provided>()
+  }
+}
diff --git a/compiler/testData/ir/irText/classes/objectWithInitializers.fir.kt.txt b/compiler/testData/ir/irText/classes/objectWithInitializers.fir.kt.txt
new file mode 100644
index 00000000000..2ea6b369681
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/objectWithInitializers.fir.kt.txt
@@ -0,0 +1,28 @@
+abstract class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object Test : Base {
+  private constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = 1
+    get
+
+  val y: Int
+    get
+
+  init {
+    <this>.#y = <this>.<get-x>()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/primaryConstructorWithSuperConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/classes/primaryConstructorWithSuperConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..ad72db20377
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/primaryConstructorWithSuperConstructorCall.fir.kt.txt
@@ -0,0 +1,47 @@
+open class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class TestImplicitPrimaryConstructor : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+}
+
+class TestExplicitPrimaryConstructor : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+}
+
+class TestWithDelegatingConstructor : Base {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  constructor(x: Int) {
+    this/*TestWithDelegatingConstructor*/(x = x, y = 0)
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/qualifiedSuperCalls.fir.kt.txt b/compiler/testData/ir/irText/classes/qualifiedSuperCalls.fir.kt.txt
new file mode 100644
index 00000000000..b6675975ff3
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/qualifiedSuperCalls.fir.kt.txt
@@ -0,0 +1,40 @@
+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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override fun foo() {
+    super.foo()
+    super.foo()
+  }
+
+  override val bar: Int
+    override get(): Int {
+      return super.<get-bar>().plus(other = super.<get-bar>())
+    }
+
+}
diff --git a/compiler/testData/ir/irText/classes/sealedClasses.fir.kt.txt b/compiler/testData/ir/irText/classes/sealedClasses.fir.kt.txt
new file mode 100644
index 00000000000..2c148f51ccb
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/sealedClasses.fir.kt.txt
@@ -0,0 +1,47 @@
+sealed class Expr {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  class Const : Expr {
+    constructor(number: Double) /* primary */ {
+      super/*Expr*/()
+      /* <init>() */
+
+    }
+
+    val number: Double
+      field = number
+      get
+
+  }
+
+  class Sum : Expr {
+    constructor(e1: Expr, e2: Expr) /* primary */ {
+      super/*Expr*/()
+      /* <init>() */
+
+    }
+
+    val e1: Expr
+      field = e1
+      get
+
+    val e2: Expr
+      field = e2
+      get
+
+  }
+
+  object NotANumber : Expr {
+    private constructor() /* primary */ {
+      super/*Expr*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/secondaryConstructorWithInitializersFromClassBody.fir.kt.txt b/compiler/testData/ir/irText/classes/secondaryConstructorWithInitializersFromClassBody.fir.kt.txt
new file mode 100644
index 00000000000..997168e114f
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/secondaryConstructorWithInitializersFromClassBody.fir.kt.txt
@@ -0,0 +1,47 @@
+open class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class TestProperty : Base {
+  val x: Int
+    field = 0
+    get
+
+  constructor() {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+}
+
+class TestInitBlock : Base {
+  val x: Int
+    get
+
+  init {
+    <this>.#x = 0
+  }
+
+  constructor() {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  constructor(z: Any) {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  constructor(y: Int) {
+    this/*TestInitBlock*/()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/classes/superCalls.fir.kt.txt b/compiler/testData/ir/irText/classes/superCalls.fir.kt.txt
new file mode 100644
index 00000000000..abea417af69
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/superCalls.fir.kt.txt
@@ -0,0 +1,37 @@
+open class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  open fun foo() {
+  }
+
+  open val bar: String
+    field = ""
+    open get
+
+  override fun hashCode(): Int {
+    return super.hashCode()
+  }
+
+}
+
+class Derived : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  override fun foo() {
+    super.foo()
+  }
+
+  override val bar: String
+    override get(): String {
+      return super.<get-bar>()
+    }
+
+}
diff --git a/compiler/testData/ir/irText/classes/superCallsComposed.fir.kt.txt b/compiler/testData/ir/irText/classes/superCallsComposed.fir.kt.txt
new file mode 100644
index 00000000000..6eb02e0dfe5
--- /dev/null
+++ b/compiler/testData/ir/irText/classes/superCallsComposed.fir.kt.txt
@@ -0,0 +1,40 @@
+open class Base {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  override fun foo() {
+    super.foo()
+  }
+
+  override val bar: String
+    override get(): String {
+      return super.<get-bar>()
+    }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/annotationsInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/annotationsInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..ac5cb764f23
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/annotationsInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,28 @@
+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(a = A1(x = 42))
+@AA(xs = [A1(x = 1), A1(x = 2)])
+fun test() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/annotationsOnDelegatedMembers.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/annotationsOnDelegatedMembers.fir.kt.txt
new file mode 100644
index 00000000000..5d627c4940a
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/annotationsOnDelegatedMembers.fir.kt.txt
@@ -0,0 +1,50 @@
+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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = d
+  }
+
+  override fun testFun() {
+    <this>.#<$$delegate_0>.testFun()
+  }
+
+  override fun String.testExtFun() {
+    (<this>.#<$$delegate_0>, <this>).testExtFun()
+  }
+
+  override val testVal: String
+    override get(): String {
+      return <this>.#<$$delegate_0>.<get-testVal>()
+    }
+
+  override val String.testExtVal: String
+    override get(): String {
+      return (<this>.#<$$delegate_0>, <this>).<get-testExtVal>()
+    }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/annotationsWithDefaultParameterValues.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/annotationsWithDefaultParameterValues.fir.kt.txt
new file mode 100644
index 00000000000..3e2c5ad151c
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/annotationsWithDefaultParameterValues.fir.kt.txt
@@ -0,0 +1,31 @@
+annotation class A : Annotation {
+  constructor(x: String = "", y: Int = 42) /* primary */
+  val x: String
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+}
+
+@A(x = "abc", y = 123)
+fun test1() {
+}
+
+@A(x = "def")
+fun test2() {
+}
+
+@A(x = "ghi")
+fun test3() {
+}
+
+@A(, y = 456)
+fun test4() {
+}
+
+@A
+fun test5() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/annotationsWithVarargParameters.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/annotationsWithVarargParameters.fir.kt.txt
new file mode 100644
index 00000000000..0d5ed9fb16e
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/annotationsWithVarargParameters.fir.kt.txt
@@ -0,0 +1,19 @@
+annotation class A : Annotation {
+  constructor(vararg xs: String) /* primary */
+  val xs: Array<out String>
+    field = xs
+    get
+
+}
+
+@A(xs = ["abc", "def"])
+fun test1() {
+}
+
+@A(xs = ["abc"])
+fun test2() {
+}
+
+@A(xs = [])
+fun test3() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/arrayInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/arrayInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..d03a05dbf1f
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/arrayInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,25 @@
+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(x = [1, 2, 3])
+@TestAnnWithStringArray(x = ["a", "b", "c"])
+fun test1() {
+}
+
+@TestAnnWithIntArray(x = [4, 5, 6])
+@TestAnnWithStringArray(x = ["d", "e", "f"])
+fun test2() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/classLiteralInAnnotation.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/classLiteralInAnnotation.fir.kt.txt
new file mode 100644
index 00000000000..5244da04b7a
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/classLiteralInAnnotation.fir.kt.txt
@@ -0,0 +1,20 @@
+annotation class A : Annotation {
+  constructor(klass: KClass<*>) /* primary */
+  val klass: KClass<*>
+    field = klass
+    get
+
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+@A(klass = C::class)
+fun test1() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..4bdfa727a8f
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.fir.kt.txt
@@ -0,0 +1,71 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+@TestAnn(x = "class")
+class TestClass {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+@TestAnn(x = "interface")
+interface TestInterface {
+
+}
+
+@TestAnn(x = "object")
+object TestObject {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Host {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  @TestAnn(x = "companion")
+  companion object TestCompanion {
+    private constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
+
+@TestAnn(x = "enum")
+enum class TestEnum : Enum<TestEnum> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestEnum>()
+    /* <init>() */
+
+  }
+
+  fun values(): Array<TestEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+@TestAnn(x = "annotation")
+annotation class TestAnnotation : Annotation {
+  constructor() /* primary */
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/constExpressionsInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/constExpressionsInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..d1e9b133d95
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/constExpressionsInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,19 @@
+const val ONE: Int
+  field = 1
+  get
+
+annotation class A : Annotation {
+  constructor(x: Int) /* primary */
+  val x: Int
+    field = x
+    get
+
+}
+
+@A(x = 1)
+fun test1() {
+}
+
+@A(x = 2)
+fun test2() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/constructorsWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/constructorsWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..d73410ec5ad
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/constructorsWithAnnotations.fir.kt.txt
@@ -0,0 +1,22 @@
+annotation class TestAnn : Annotation {
+  constructor(x: Int) /* primary */
+  val x: Int
+    field = x
+    get
+
+}
+
+class TestClass {
+  @TestAnn(x = 1)
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  @TestAnn(x = 2)
+  constructor(x: Int) {
+    this/*TestClass*/()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/delegateFieldWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/delegateFieldWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..50f94ade6b1
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/delegateFieldWithAnnotations.fir.kt.txt
@@ -0,0 +1,13 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */
+
+}
+
+val test1: Int /* by */
+  field = lazy<Int>(initializer = local fun <anonymous>(): Int {
+    return 42
+  }
+)
+  get(): Int {
+    return #test1$delegate.getValue<Int>(thisRef = null, property = ::test1)
+  }
diff --git a/compiler/testData/ir/irText/declarations/annotations/delegatedPropertyAccessorsWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/delegatedPropertyAccessorsWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..88ae26ae9aa
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/delegatedPropertyAccessorsWithAnnotations.fir.kt.txt
@@ -0,0 +1,47 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+class Cell {
+  constructor(value: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 = Cell(value = 1)
+  @A(x = "test1.get")
+  get(): Int {
+    return #test1$delegate.getValue(thisRef = null, kProp = ::test1)
+  }
+
+var test2: Int /* by */
+  field = Cell(value = 2)
+  @A(x = "test2.get")
+  get(): Int {
+    return #test2$delegate.getValue(thisRef = null, kProp = ::test2)
+  }
+  @A(x = "test2.set")
+  set(@A(x = "test2.set.param") <set-?>: Int) {
+    #test2$delegate.setValue(thisRef = null, kProp = ::test2, newValue = <set-?>)
+  }
diff --git a/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..cc33301670a
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.fir.kt.txt
@@ -0,0 +1,39 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+open enum class TestEnum : Enum<TestEnum> {
+  private constructor() /* primary */ {
+    super/*Enum*/<TestEnum>()
+    /* <init>() */
+
+  }
+
+  @TestAnn(x = "ENTRY1")
+  ENTRY1 = TestEnum()
+
+  @TestAnn(x = "ENTRY2")
+  ENTRY2 = ENTRY2()
+  @TestAnn(x = "ENTRY2")
+  private enum entry class ENTRY2 : TestEnum {
+    private constructor() /* primary */ {
+      super/*TestEnum*/()
+      /* <init>() */
+
+    }
+
+    val x: Int
+      field = 42
+      get
+
+  }
+
+  fun values(): Array<TestEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): TestEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..8b8fb80eb7d
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,32 @@
+enum class En : Enum<En> {
+  private constructor() /* primary */ {
+    super/*Enum*/<En>()
+    /* <init>() */
+
+  }
+
+  A = En()
+
+  B = En()
+
+  C = En()
+
+  D = En()
+
+  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(x = En.A)
+fun test1() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/fieldsWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/fieldsWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..65cf9cc5679
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/fieldsWithAnnotations.fir.kt.txt
@@ -0,0 +1,16 @@
+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
diff --git a/compiler/testData/ir/irText/declarations/annotations/fileAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/fileAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..2c6453f4a48
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/fileAnnotations.fir.kt.txt
@@ -0,0 +1,11 @@
+@file:A(x = "File annotation")
+package test
+
+@Target(allowedTargets = [AnnotationTarget.FILE])
+annotation class A : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/functionsWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/functionsWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..fb9f4d773c6
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/functionsWithAnnotations.fir.kt.txt
@@ -0,0 +1,11 @@
+annotation class TestAnn : Annotation {
+  constructor(x: Int) /* primary */
+  val x: Int
+    field = x
+    get
+
+}
+
+@TestAnn(x = 42)
+fun testSimpleFunction() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/inheritingDeprecation.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/inheritingDeprecation.fir.kt.txt
new file mode 100644
index 00000000000..f2c20e552fc
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/inheritingDeprecation.fir.kt.txt
@@ -0,0 +1,64 @@
+interface IFoo {
+  @Deprecated(message = "")
+  val prop: String
+    get(): String {
+      return ""
+    }
+
+  @Deprecated(message = "")
+  val String.extProp: String
+    get(): String {
+      return ""
+    }
+
+}
+
+class Delegated : IFoo {
+  constructor(foo: IFoo) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = foo
+  }
+
+  override val prop: String
+    override get(): String {
+      return <this>.#<$$delegate_0>.<get-prop>()
+    }
+
+  override val String.extProp: String
+    override get(): String {
+      return (<this>.#<$$delegate_0>, <this>).<get-extProp>()
+    }
+
+  local /*final field*/ val <$$delegate_0>: IFoo
+
+}
+
+class DefaultImpl : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class ExplicitOverride : IFoo {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override val prop: String
+    override get(): String {
+      return ""
+    }
+
+  override val String.extProp: String
+    override get(): String {
+      return ""
+    }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/localDelegatedPropertiesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/localDelegatedPropertiesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..996e6c558a6
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/localDelegatedPropertiesWithAnnotations.fir.kt.txt
@@ -0,0 +1,19 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+fun foo(m: Map<String, Int>) {
+  val test: Int
+    val test$delegate: Lazy<Int> = lazy<Int>(initializer = local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    local get(): Int {
+      return test$delegate.getValue<Int>(thisRef = null, property = ::test)
+    }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/multipleAnnotationsInSquareBrackets.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/multipleAnnotationsInSquareBrackets.fir.kt.txt
new file mode 100644
index 00000000000..583d890bf3e
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/multipleAnnotationsInSquareBrackets.fir.kt.txt
@@ -0,0 +1,20 @@
+annotation class A1 : Annotation {
+  constructor() /* primary */
+
+}
+
+annotation class A2 : Annotation {
+  constructor() /* primary */
+
+}
+
+annotation class A3 : Annotation {
+  constructor() /* primary */
+
+}
+
+@A1
+@A2
+@A3
+fun test() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/primaryConstructorParameterWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/primaryConstructorParameterWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..d5cc5c32c3a
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/primaryConstructorParameterWithAnnotations.fir.kt.txt
@@ -0,0 +1,17 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */
+
+}
+
+class Test {
+  constructor(@Ann x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/propertiesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/propertiesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..3006aada3f3
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/propertiesWithAnnotations.fir.kt.txt
@@ -0,0 +1,12 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+@TestAnn(x = "testVal.property")
+val testVal: String
+  field = ""
+  get
diff --git a/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsFromClassHeaderWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsFromClassHeaderWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..3340c0f3884
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsFromClassHeaderWithAnnotations.fir.kt.txt
@@ -0,0 +1,28 @@
+annotation class A : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+class C {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    @A(x = "C.x.get")
+    get
+
+  var y: Int
+    field = y
+    @A(x = "C.y.get")
+    get
+    @A(x = "C.y.set")
+    set
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..441a53b5564
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/propertyAccessorsWithAnnotations.fir.kt.txt
@@ -0,0 +1,34 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+val test1: String
+  @TestAnn(x = "test1.get")
+  get(): String {
+    return ""
+  }
+
+var test2: String
+  @TestAnn(x = "test2.get")
+  get(): String {
+    return ""
+  }
+  @TestAnn(x = "test2.set")
+  set(value: String) {
+  }
+
+val test3: String
+  field = ""
+  @TestAnn(x = "test3.get")
+  get
+
+var test4: String
+  field = ""
+  @TestAnn(x = "test4.get")
+  get
+  @TestAnn(x = "test4.set")
+  set
diff --git a/compiler/testData/ir/irText/declarations/annotations/propertySetterParameterWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/propertySetterParameterWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..e64e83fcde1
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/propertySetterParameterWithAnnotations.fir.kt.txt
@@ -0,0 +1,23 @@
+annotation class AnnParam : Annotation {
+  constructor() /* primary */
+
+}
+
+var p: Int
+  field = 0
+  get
+  set
+
+class C {
+  constructor(p: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var p: Int
+    field = p
+    get
+    set
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/receiverParameterWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/receiverParameterWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..a3fb025d70e
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/receiverParameterWithAnnotations.fir.kt.txt
@@ -0,0 +1,31 @@
+annotation class Ann : Annotation {
+  constructor() /* primary */
+
+}
+
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun @Ann String.f(): String {
+    return ""
+  }
+
+  val @Ann String?.p: String
+    get(): String {
+      return ""
+    }
+
+}
+
+fun @Ann String?.topLevelF(): String {
+  return ""
+}
+
+val @Ann String.topLevelP: String
+  get(): String {
+    return ""
+  }
diff --git a/compiler/testData/ir/irText/declarations/annotations/spreadOperatorInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/spreadOperatorInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..72a0ed3bd66
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/spreadOperatorInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,11 @@
+annotation class A : Annotation {
+  constructor(vararg xs: String) /* primary */
+  val xs: Array<out String>
+    field = xs
+    get
+
+}
+
+@A(xs = ["a", "b"])
+fun test() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..fca88dbbc9c
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.fir.kt.txt
@@ -0,0 +1,10 @@
+@TestAnn(x = "TestTypeAlias")
+typealias TestTypeAlias = String
+@Target(allowedTargets = [AnnotationTarget.TYPEALIAS])
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..a7f3c43c166
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/typeParametersWithAnnotations.fir.kt.txt
@@ -0,0 +1,8 @@
+@Target(allowedTargets = [AnnotationTarget.TYPE_PARAMETER])
+annotation class Anno : Annotation {
+  constructor() /* primary */
+
+}
+
+fun <T : Any?> foo() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/valueParametersWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/valueParametersWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..15710f9363f
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/valueParametersWithAnnotations.fir.kt.txt
@@ -0,0 +1,23 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+fun testFun(@TestAnn(x = "testFun.x") x: Int) {
+}
+
+class TestClassConstructor1 {
+  constructor(@TestAnn(x = "TestClassConstructor1.x") x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val xx: Int
+    field = x
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/varargsInAnnotationArguments.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/varargsInAnnotationArguments.fir.kt.txt
new file mode 100644
index 00000000000..42a3957deb9
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/varargsInAnnotationArguments.fir.kt.txt
@@ -0,0 +1,35 @@
+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(xs = [1, 2, 3])
+@A2(xs = ["a", "b", "c"])
+@AA(xs = [A1(xs = [4]), A1(xs = [5]), A1(xs = [6])])
+fun test1() {
+}
+
+@A1(xs = [])
+@A2(xs = [])
+@AA(xs = [])
+fun test2() {
+}
diff --git a/compiler/testData/ir/irText/declarations/annotations/variablesWithAnnotations.fir.kt.txt b/compiler/testData/ir/irText/declarations/annotations/variablesWithAnnotations.fir.kt.txt
new file mode 100644
index 00000000000..a9c7989fc4d
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/annotations/variablesWithAnnotations.fir.kt.txt
@@ -0,0 +1,12 @@
+annotation class TestAnn : Annotation {
+  constructor(x: String) /* primary */
+  val x: String
+    field = x
+    get
+
+}
+
+fun foo() {
+  val testVal: String = "testVal"
+  var testVar: String = "testVar"
+}
diff --git a/compiler/testData/ir/irText/declarations/catchParameterInTopLevelProperty.fir.kt.txt b/compiler/testData/ir/irText/declarations/catchParameterInTopLevelProperty.fir.kt.txt
new file mode 100644
index 00000000000..1be53a5cc95
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/catchParameterInTopLevelProperty.fir.kt.txt
@@ -0,0 +1,7 @@
+val test: Unit
+  field = try { // BLOCK
+  }
+  catch (e: Throwable){ // BLOCK
+  }
+
+  get
diff --git a/compiler/testData/ir/irText/declarations/classLevelProperties.fir.kt.txt b/compiler/testData/ir/irText/declarations/classLevelProperties.fir.kt.txt
new file mode 100644
index 00000000000..acb53720654
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/classLevelProperties.fir.kt.txt
@@ -0,0 +1,56 @@
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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) {
+      <this>.#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 <this>.#test7$delegate.getValue<Int>(thisRef = <this>, property = C::test7)
+    }
+
+  var test8: Int? /* by */
+    field = hashMapOf<String, Int>()
+    get(): Int? {
+      return <this>.#test8$delegate.getValue<Int?, Int?>(thisRef = <this>, property = C::test8)
+    }
+    set(<set-?>: Int?) {
+      <this>.#test8$delegate.setValue<Int?>(thisRef = <this>, property = C::test8, value = <set-?>)
+    }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/delegatedProperties.fir.kt.txt b/compiler/testData/ir/irText/declarations/delegatedProperties.fir.kt.txt
new file mode 100644
index 00000000000..67b7211da25
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/delegatedProperties.fir.kt.txt
@@ -0,0 +1,48 @@
+val test1: Int /* by */
+  field = lazy<Int>(initializer = local fun <anonymous>(): Int {
+    return 42
+  }
+)
+  get(): Int {
+    return #test1$delegate.getValue<Int>(thisRef = null, property = ::test1)
+  }
+
+class C {
+  constructor(map: MutableMap<String, Any>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 <this>.#test2$delegate.getValue<Int>(thisRef = <this>, property = C::test2)
+    }
+
+  var test3: Any /* by */
+    field = <this>.<get-map>()
+    get(): Any {
+      return <this>.#test3$delegate.getValue<Any, Any>(thisRef = <this>, property = C::test3)
+    }
+    set(<set-?>: Any) {
+      <this>.#test3$delegate.setValue<Any>(thisRef = <this>, property = C::test3, value = <set-?>)
+    }
+
+}
+
+var test4: Any? /* by */
+  field = hashMapOf<String, Any>()
+  get(): Any? {
+    return #test4$delegate.getValue<Any?, Any?>(thisRef = null, property = ::test4)
+  }
+  set(<set-?>: Any?) {
+    #test4$delegate.setValue<Any?>(thisRef = null, property = ::test4, value = <set-?>)
+  }
diff --git a/compiler/testData/ir/irText/declarations/fakeOverrides.fir.kt.txt b/compiler/testData/ir/irText/declarations/fakeOverrides.fir.kt.txt
new file mode 100644
index 00000000000..35a49aaa6e7
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/fakeOverrides.fir.kt.txt
@@ -0,0 +1,35 @@
+interface IFooStr {
+  abstract fun foo(x: String)
+
+}
+
+interface IBar {
+  abstract val bar: Int
+    abstract get
+
+}
+
+abstract class CFoo<T : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun foo(x: T) {
+  }
+
+}
+
+class Test1 : CFoo<String>, IFooStr, IBar {
+  constructor() /* primary */ {
+    super/*CFoo*/<String>()
+    /* <init>() */
+
+  }
+
+  override val bar: Int
+    field = 42
+    override get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/genericDelegatedProperty.fir.kt.txt b/compiler/testData/ir/irText/declarations/genericDelegatedProperty.fir.kt.txt
new file mode 100644
index 00000000000..23037eff964
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/genericDelegatedProperty.fir.kt.txt
@@ -0,0 +1,33 @@
+class C<T : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object Delegate {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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/*</* null */>()*/)
+  }
+  set(<set-?>: Int) {
+    #genericDelegatedProperty$delegate.setValue(thisRef = <this>, kProp = ::genericDelegatedProperty/*</* null */>()*/, newValue = <set-?>)
+  }
diff --git a/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.kt.txt b/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.kt.txt
new file mode 100644
index 00000000000..b2da2bf4441
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/inlineCollectionOfInlineClass.fir.kt.txt
@@ -0,0 +1,108 @@
+inline class IT {
+  constructor(x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  override fun equals(other: Any?): Boolean {
+    when {
+      other !is IT -> return false
+    }
+    val tmp0_other_with_cast: IT = other as IT
+    when {
+      EQEQ(arg0 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#x.hashCode()
+  }
+
+  override fun toString(): String {
+    return "IT(" + "x=" + <this>.#x + ")"
+  }
+
+}
+
+inline class InlineMutableSet : MutableSet<IT> {
+  constructor(ms: MutableSet<IT>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  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 equals(other: Any?): Boolean {
+    when {
+      other !is InlineMutableSet -> return false
+    }
+    val tmp0_other_with_cast: InlineMutableSet = other as InlineMutableSet
+    when {
+      EQEQ(arg0 = <this>.#ms, arg1 = tmp0_other_with_cast.#ms).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#ms.hashCode()
+  }
+
+  override fun toString(): String {
+    return "InlineMutableSet(" + "ms=" + <this>.#ms + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/kt29833.fir.kt.txt b/compiler/testData/ir/irText/declarations/kt29833.fir.kt.txt
new file mode 100644
index 00000000000..793d73e0144
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/kt29833.fir.kt.txt
@@ -0,0 +1,18 @@
+package interop
+
+object Definitions {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  const val KT_CONSTANT: String?
+    field = "constant"
+    get
+
+  val ktValue: String?
+    field = #CONSTANT
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/kt35550.fir.kt.txt b/compiler/testData/ir/irText/declarations/kt35550.fir.kt.txt
new file mode 100644
index 00000000000..7ed89add857
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/kt35550.fir.kt.txt
@@ -0,0 +1,24 @@
+interface I {
+  val <T : Any?> T.id: T
+    get(): T {
+      return <this>
+    }
+
+}
+
+class A : I {
+  constructor(i: I) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = i
+  }
+
+  override val <T : Any?> T.id: T
+    override get(): T {
+      return (<this>.#<$$delegate_0>, <this>).<get-id></* null */>()
+    }
+
+  local /*final field*/ val <$$delegate_0>: I
+
+}
diff --git a/compiler/testData/ir/irText/declarations/localClassWithOverrides.fir.kt.txt b/compiler/testData/ir/irText/declarations/localClassWithOverrides.fir.kt.txt
new file mode 100644
index 00000000000..c346b56d7d4
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/localClassWithOverrides.fir.kt.txt
@@ -0,0 +1,40 @@
+fun outer() {
+  local abstract class ALocal {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    abstract fun afun()
+    abstract val aval: Int
+      abstract get
+
+    abstract var avar: Int
+      abstract get
+      abstract set
+
+  }
+
+  local class Local : ALocal {
+    constructor() /* primary */ {
+      super/*ALocal*/()
+      /* <init>() */
+
+    }
+
+    override fun afun() {
+    }
+
+    override val aval: Int
+      field = 1
+      override get
+
+    override var avar: Int
+      field = 2
+      override get
+      override set
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/localDelegatedProperties.fir.kt.txt b/compiler/testData/ir/irText/declarations/localDelegatedProperties.fir.kt.txt
new file mode 100644
index 00000000000..bb38bedafe8
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/localDelegatedProperties.fir.kt.txt
@@ -0,0 +1,29 @@
+fun test1() {
+  val x: Int
+    val x$delegate: Lazy<Int> = lazy<Int>(initializer = local fun <anonymous>(): Int {
+      return 42
+    }
+)
+    local get(): Int {
+      return x$delegate.getValue<Int>(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 x$delegate.getValue<Int?, Int?>(thisRef = null, property = ::x)
+    }
+    local set(<set-?>: Int?) {
+      x$delegate.setValue<Int?>(thisRef = null, property = ::x, value = <set-?>)
+    }
+
+  <set-x>(<set-?> = 0)
+  val <unary>: Int = <get-x>() /*as Int */
+  <set-x>(<set-?> = <unary>.inc())
+  <unary> /*~> Unit */
+  <set-x>(<set-?> = <get-x>() /*as Int */.plus(other = 1))
+}
diff --git a/compiler/testData/ir/irText/declarations/localVarInDoWhile.fir.kt.txt b/compiler/testData/ir/irText/declarations/localVarInDoWhile.fir.kt.txt
new file mode 100644
index 00000000000..dec2c330262
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/localVarInDoWhile.fir.kt.txt
@@ -0,0 +1,5 @@
+fun foo() {
+  do// COMPOSITE {
+  val x: Int = 42
+  // }  while (EQEQ(arg0 = x, arg1 = 42).not())
+}
diff --git a/compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.fir.kt.txt b/compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.fir.kt.txt
new file mode 100644
index 00000000000..c377c786972
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/multiplatform/expectClassInherited.fir.kt.txt
@@ -0,0 +1,38 @@
+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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  abstract fun foo()
+
+}
+
+open class B : A {
+  constructor(i: Int) /* primary */ {
+    super/*A*/()
+    /* <init>() */
+
+  }
+
+  override fun foo() {
+  }
+
+  open fun bar(s: String) {
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.fir.kt.txt b/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.fir.kt.txt
new file mode 100644
index 00000000000..28d099e85bd
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.fir.kt.txt
@@ -0,0 +1,29 @@
+expect enum class MyEnum : Enum<MyEnum> {
+  private expect constructor() /* primary */
+  FOO = MyEnum()
+
+  BAR = MyEnum()
+
+  expect fun values(): Array<MyEnum>
+  expect fun valueOf(value: String): MyEnum
+
+}
+
+enum class MyEnum : Enum<MyEnum> {
+  private constructor() /* primary */ {
+    super/*Enum*/<MyEnum>()
+    /* <init>() */
+
+  }
+
+  FOO = MyEnum()
+
+  BAR = MyEnum()
+
+  BAZ = MyEnum()
+
+  fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): MyEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/declarations/multiplatform/expectedSealedClass.fir.kt.txt b/compiler/testData/ir/irText/declarations/multiplatform/expectedSealedClass.fir.kt.txt
new file mode 100644
index 00000000000..c409b307440
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/multiplatform/expectedSealedClass.fir.kt.txt
@@ -0,0 +1,27 @@
+expect sealed class Ops {
+  private expect constructor() /* primary */
+
+}
+
+expect class Add : Ops {
+  expect constructor() /* primary */
+
+}
+
+sealed class Ops {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Add : Ops {
+  constructor() /* primary */ {
+    super/*Ops*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/packageLevelProperties.fir.kt.txt b/compiler/testData/ir/irText/declarations/packageLevelProperties.fir.kt.txt
new file mode 100644
index 00000000000..da79cbe2ac8
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/packageLevelProperties.fir.kt.txt
@@ -0,0 +1,47 @@
+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 #test7$delegate.getValue<Int>(thisRef = null, property = ::test7)
+  }
+
+var test8: Int? /* by */
+  field = hashMapOf<String, Int>()
+  get(): Int? {
+    return #test8$delegate.getValue<Int?, Int?>(thisRef = null, property = ::test8)
+  }
+  set(<set-?>: Int?) {
+    #test8$delegate.setValue<Int?>(thisRef = null, property = ::test8, value = <set-?>)
+  }
diff --git a/compiler/testData/ir/irText/declarations/parameters/constructor.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/constructor.fir.kt.txt
new file mode 100644
index 00000000000..31503aa07fc
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/constructor.fir.kt.txt
@@ -0,0 +1,80 @@
+class Test1<T1 : Any?, T2 : Any?> {
+  constructor(x: T1, y: T2) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T1
+    field = x
+    get
+
+  val y: T2
+    field = y
+    get
+
+}
+
+class Test2 {
+  constructor(x: Int, y: String) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val y: String
+    field = y
+    get
+
+  inner class TestInner<Z : Any?> {
+    constructor(z: Z) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val z: Z
+      field = z
+      get
+
+    constructor(z: Z, i: Int) {
+      <this>.this/*TestInner*/<Z>(z = z)
+    }
+
+  }
+
+}
+
+class Test3 {
+  constructor(x: Int, y: String = "") /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+}
+
+class Test4<T : Any?> {
+  constructor(x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  constructor(x: Int, y: Int = 42) {
+    this/*Test4*/<T>(x = x.plus(other = y))
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/parameters/dataClassMembers.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/dataClassMembers.fir.kt.txt
new file mode 100644
index 00000000000..c60bd70017d
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/dataClassMembers.fir.kt.txt
@@ -0,0 +1,58 @@
+data class Test<T : Any?> {
+  constructor(x: T, y: String = "") /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  val y: String
+    field = y
+    get
+
+  fun component1(): T {
+    return <this>.#x
+  }
+
+  fun component2(): String {
+    return <this>.#y
+  }
+
+  fun copy(x: T = <this>.#x, y: String = <this>.#y): Test<T> {
+    return Test<Any>(x = x, y = y)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#y, arg1 = tmp0_other_with_cast.#y).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = when {
+      EQEQ(arg0 = <this>.#x, arg1 = null) -> 0
+      else -> <this>.#x.hashCode()
+    }
+    result = result.times(other = 31).plus(other = <this>.#y.hashCode())
+    return result
+  }
+
+  override fun toString(): String {
+    return "Test(" + "x=" + <this>.#x + ", " + "y=" + <this>.#y + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.fir.kt.txt
new file mode 100644
index 00000000000..f8509a6c22c
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.fir.kt.txt
@@ -0,0 +1,33 @@
+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 */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = impl
+  }
+
+  override fun foo(x: Int) {
+    <this>.#<$$delegate_0>.foo(x = x)
+  }
+
+  override fun <X : Any?> qux(t: TT, x: X) {
+    <this>.#<$$delegate_0>.qux</* null */>(t = t, x = x)
+  }
+
+  override val bar: Int
+    override get(): Int {
+      return <this>.#<$$delegate_0>.<get-bar>()
+    }
+
+  local /*final field*/ val <$$delegate_0>: IBase<TT>
+
+}
diff --git a/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt
new file mode 100644
index 00000000000..e097d10a472
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/lambdas.fir.kt.txt
@@ -0,0 +1,26 @@
+val test1: Function1<String, String>
+  field = local fun <anonymous>(it: String): String {
+    return it
+  }
+
+  get
+
+val test2: @ExtensionFunctionType @ExtensionFunctionType Function2<Any, Any, Any>
+  field = local fun Any.<anonymous>(it: Any): Int {
+    return it.hashCode()
+  }
+
+  get
+
+val test3: Function2<Int, Int, Unit>
+  field = local fun <anonymous>(i: Int, j: Int) {
+    return Unit
+  }
+
+  get
+
+val test4: Function2<Int, Int, Unit>
+  field = local fun <no name provided>(i: Int, j: Int) {
+  }
+
+  get
diff --git a/compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.fir.kt.txt
new file mode 100644
index 00000000000..7fb49758dad
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/typeParameterBeforeBound.fir.kt.txt
@@ -0,0 +1,17 @@
+class Test1<T : U, U : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun <T : U, U : Any?> test2() {
+}
+
+var <T : U, U : Any?> Test1<T, U>.test3: Unit
+  get() {
+  }
+  set(value: Unit) {
+  }
diff --git a/compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.fir.kt.txt
new file mode 100644
index 00000000000..b070d0dcb67
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/typeParameterBoundedBySubclass.fir.kt.txt
@@ -0,0 +1,38 @@
+abstract class Base1<T : Derived1> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Derived1 : Base1<Derived1> {
+  constructor() /* primary */ {
+    super/*Base1*/<Derived1>()
+    /* <init>() */
+
+  }
+
+}
+
+abstract class Base2 {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun <T : Derived2> foo(x: T) {
+  }
+
+}
+
+class Derived2 : Base2 {
+  constructor() /* primary */ {
+    super/*Base2*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/declarations/parameters/useNextParamInLambda.fir.kt.txt b/compiler/testData/ir/irText/declarations/parameters/useNextParamInLambda.fir.kt.txt
new file mode 100644
index 00000000000..ff26f4f0234
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/parameters/useNextParamInLambda.fir.kt.txt
@@ -0,0 +1,25 @@
+fun f(f1: Function0<String> = local fun <anonymous>(): ErrorType /* ERROR */ {
+  return error("") /* ERROR CALL */
+}
+, f2: Function0<String> = local fun <anonymous>(): String {
+  return "FAIL"
+}
+): String {
+  return f1.invoke()
+}
+
+fun box(): String {
+  var result: String = "fail"
+  try f()
+  catch (e: Exception){ // BLOCK
+    result = "OK"
+  }
+ /*~> Unit */
+  return f(, f2 = local fun <anonymous>(): String {
+    return "O"
+  }
+).plus(other = f(f1 = local fun <anonymous>(): String {
+    return "K"
+  }
+))
+}
diff --git a/compiler/testData/ir/irText/declarations/provideDelegate/memberExtension.fir.kt.txt b/compiler/testData/ir/irText/declarations/provideDelegate/memberExtension.fir.kt.txt
new file mode 100644
index 00000000000..175e23fdae8
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/provideDelegate/memberExtension.fir.kt.txt
@@ -0,0 +1,39 @@
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  class StringDelegate {
+    constructor(s: String) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val s: String
+      field = s
+      get
+
+    operator fun getValue(receiver: String, p: Any): String {
+      return receiver.plus(other = <this>.<get-s>())
+    }
+
+  }
+
+  operator fun String.provideDelegate(host: Any?, p: Any): StringDelegate {
+    return StringDelegate(s = <this>)
+  }
+
+  val String.plusK: String /* by */
+    field = (<this>, "K").provideDelegate(host = <this>, p = Host::plusK)
+    get(): String {
+      return <this>.#plusK$delegate.getValue(receiver = <this>, p = Host::plusK)
+    }
+
+  val ok: String
+    field = (<this>, "O").<get-plusK>()
+    get
+
+}
diff --git a/compiler/testData/ir/irText/declarations/typeAlias.fir.kt.txt b/compiler/testData/ir/irText/declarations/typeAlias.fir.kt.txt
new file mode 100644
index 00000000000..f10bbf8eb16
--- /dev/null
+++ b/compiler/testData/ir/irText/declarations/typeAlias.fir.kt.txt
@@ -0,0 +1,14 @@
+typealias Test1 = String
+fun foo() {
+  { // BLOCK
+  }
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/errors/unresolvedReference.fir.kt.txt b/compiler/testData/ir/irText/errors/unresolvedReference.fir.kt.txt
new file mode 100644
index 00000000000..6194e780b11
--- /dev/null
+++ b/compiler/testData/ir/irText/errors/unresolvedReference.fir.kt.txt
@@ -0,0 +1,15 @@
+val test1: ErrorType /* ERROR */
+  field = error("") /* ERROR CALL */
+  get
+
+val test2: ErrorType /* ERROR */
+  field = error("") /* ERROR CALL */
+  get
+
+val test3: ErrorType /* ERROR */
+  field = error("") /* ERROR CALL */56;
+  get
+
+val test4: ErrorType /* ERROR */
+  field = error("") /* ERROR CALL */error("") /* ERROR EXPRESSION */;
+  get
diff --git a/compiler/testData/ir/irText/expressions/argumentMappedWithError.fir.kt.txt b/compiler/testData/ir/irText/expressions/argumentMappedWithError.fir.kt.txt
new file mode 100644
index 00000000000..f74e529006e
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/argumentMappedWithError.fir.kt.txt
@@ -0,0 +1,11 @@
+fun <R : Number> Number.convert(): R {
+  return TODO()
+}
+
+fun foo(arg: Number) {
+}
+
+fun main(args: Array<String>) {
+  val x: Int = 0
+  foo(arg = x.convert<Number>())
+}
diff --git a/compiler/testData/ir/irText/expressions/arrayAccess.fir.kt.txt b/compiler/testData/ir/irText/expressions/arrayAccess.fir.kt.txt
new file mode 100644
index 00000000000..e33ba09ae54
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/arrayAccess.fir.kt.txt
@@ -0,0 +1,11 @@
+val p: Int
+  field = 0
+  get
+
+fun foo(): Int {
+  return 1
+}
+
+fun test(a: IntArray): Int {
+  return a.get(index = 0).plus(other = a.get(index = <get-p>())).plus(other = a.get(index = foo()))
+}
diff --git a/compiler/testData/ir/irText/expressions/arrayAssignment.fir.kt.txt b/compiler/testData/ir/irText/expressions/arrayAssignment.fir.kt.txt
new file mode 100644
index 00000000000..b3e3170c83c
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/arrayAssignment.fir.kt.txt
@@ -0,0 +1,12 @@
+fun test() {
+  val x: IntArray = intArrayOf(elements = [1, 2, 3])
+  x.set(index = 1, value = 0)
+}
+
+fun foo(): Int {
+  return 1
+}
+
+fun test2() {
+  intArrayOf(elements = [1, 2, 3]).set(index = foo(), value = 1)
+}
diff --git a/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.fir.kt.txt b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.fir.kt.txt
new file mode 100644
index 00000000000..7b081b2502e
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.fir.kt.txt
@@ -0,0 +1,45 @@
+fun foo(): IntArray {
+  return intArrayOf(elements = [1, 2, 3])
+}
+
+fun bar(): Int {
+  return 42
+}
+
+class C {
+  constructor(x: IntArray) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: IntArray
+    field = x
+    get
+
+}
+
+fun testVariable() {
+  var x: IntArray = foo()
+  { // BLOCK
+    val <<array>>: IntArray = x
+    val <<index_0>>: Int = 0
+    <<array>>.set(index = <<index_0>>, value = <<array>>.get(index = <<index_0>>).plus(other = 1))
+  }
+}
+
+fun testCall() {
+  { // BLOCK
+    val <<array>>: IntArray = foo()
+    val <<index_0>>: Int = bar()
+    <<array>>.set(index = <<index_0>>, value = <<array>>.get(index = <<index_0>>).times(other = 2))
+  }
+}
+
+fun testMember(c: C) {
+  val <array>: IntArray = c.<get-x>()
+  val <index0>: Int = 0
+  val <unary>: Int = <array>.get(index = <index0>)
+  <array>.set(index = <index0>, value = <unary>.inc())
+  <unary> /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment2.fir.kt.txt b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment2.fir.kt.txt
new file mode 100644
index 00000000000..4c7242bb03b
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment2.fir.kt.txt
@@ -0,0 +1,17 @@
+interface IA {
+  abstract operator fun get(index: String): Int
+
+}
+
+interface IB {
+  abstract operator fun IA.set(index: String, value: Int)
+
+}
+
+fun IB.test(a: IA) {
+  { // BLOCK
+    val <<array>>: IA = a
+    val <<index_0>>: String = ""
+    (<this>, <<array>>).set(index = <<index_0>>, value = <<array>>.get(index = <<index_0>>).plus(other = 42))
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/augmentedAssignment1.fir.kt.txt b/compiler/testData/ir/irText/expressions/augmentedAssignment1.fir.kt.txt
new file mode 100644
index 00000000000..245950f4c16
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/augmentedAssignment1.fir.kt.txt
@@ -0,0 +1,21 @@
+var p: Int
+  field = 0
+  get
+  set
+
+fun testVariable() {
+  var x: Int = 0
+  x = x.plus(other = 1)
+  x = x.minus(other = 2)
+  x = x.times(other = 3)
+  x = x.div(other = 4)
+  x = x.rem(other = 5)
+}
+
+fun testProperty() {
+  <set-p>(<set-?> = <get-p>().plus(other = 1))
+  <set-p>(<set-?> = <get-p>().minus(other = 2))
+  <set-p>(<set-?> = <get-p>().times(other = 3))
+  <set-p>(<set-?> = <get-p>().div(other = 4))
+  <set-p>(<set-?> = <get-p>().rem(other = 5))
+}
diff --git a/compiler/testData/ir/irText/expressions/augmentedAssignment2.fir.kt.txt b/compiler/testData/ir/irText/expressions/augmentedAssignment2.fir.kt.txt
new file mode 100644
index 00000000000..553f4cec3e5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/augmentedAssignment2.fir.kt.txt
@@ -0,0 +1,44 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+operator fun A.plusAssign(s: String) {
+}
+
+operator fun A.minusAssign(s: String) {
+}
+
+operator fun A.timesAssign(s: String) {
+}
+
+operator fun A.divAssign(s: String) {
+}
+
+operator fun A.remAssign(s: String) {
+}
+
+val p: A
+  field = A()
+  get
+
+fun testVariable() {
+  val a: A = A()
+  a.plusAssign(s = "+=")
+  a.minusAssign(s = "-=")
+  a.timesAssign(s = "*=")
+  a.divAssign(s = "/=")
+  a.remAssign(s = "*=")
+}
+
+fun testProperty() {
+  <get-p>().plusAssign(s = "+=")
+  <get-p>().minusAssign(s = "-=")
+  <get-p>().timesAssign(s = "*=")
+  <get-p>().divAssign(s = "/=")
+  <get-p>().remAssign(s = "%=")
+}
diff --git a/compiler/testData/ir/irText/expressions/augmentedAssignmentWithExpression.fir.kt.txt b/compiler/testData/ir/irText/expressions/augmentedAssignmentWithExpression.fir.kt.txt
new file mode 100644
index 00000000000..c4ee2156298
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/augmentedAssignmentWithExpression.fir.kt.txt
@@ -0,0 +1,31 @@
+class Host {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun plusAssign(x: Int) {
+  }
+
+  fun test1() {
+    <this>.plusAssign(x = 1)
+  }
+
+}
+
+fun foo(): Host {
+  return Host()
+}
+
+fun Host.test2() {
+  <this>.plusAssign(x = 1)
+}
+
+fun test3() {
+  foo().plusAssign(x = 1)
+}
+
+fun test4(a: Function0<Host>) {
+  a.invoke().plusAssign(x = 1)
+}
diff --git a/compiler/testData/ir/irText/expressions/badBreakContinue.fir.kt.txt b/compiler/testData/ir/irText/expressions/badBreakContinue.fir.kt.txt
new file mode 100644
index 00000000000..64d184dc86f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/badBreakContinue.fir.kt.txt
@@ -0,0 +1,28 @@
+fun test1() {
+  error("") /* ERROR EXPRESSION */
+  error("") /* ERROR EXPRESSION */
+}
+
+fun test2() {
+  L1@ while (true) { // BLOCK
+    error("") /* ERROR EXPRESSION */
+    error("") /* ERROR EXPRESSION */
+  }
+}
+
+fun test3() {
+  L1@ while (true) { // BLOCK
+    val lambda: Function0<Nothing> = local fun <anonymous>(): Nothing {
+      break@L1
+      continue@L1
+    }
+
+  }
+}
+
+fun test4() {
+  while (error("") /* ERROR EXPRESSION */) { // BLOCK
+  }
+  while (error("") /* ERROR EXPRESSION */) { // BLOCK
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/bangbang.fir.kt.txt b/compiler/testData/ir/irText/expressions/bangbang.fir.kt.txt
new file mode 100644
index 00000000000..dd8140cc05f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/bangbang.fir.kt.txt
@@ -0,0 +1,29 @@
+fun test1(a: Any?): Any {
+  return CHECK_NOT_NULL<Any>(arg0 = a)
+}
+
+fun test2(a: Any?): Int {
+  return CHECK_NOT_NULL<Int>(arg0 = { // BLOCK
+    val tmp0_safe_receiver: Any? = a
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.hashCode()
+    }
+  })
+}
+
+fun <X : Any?> test3(a: X): X {
+  return CHECK_NOT_NULL<X>(arg0 = a)
+}
+
+fun useString(s: String) {
+}
+
+fun <X : Any?> test4(a: X) {
+  when {
+    a is String? -> CHECK_NOT_NULL<String>(arg0 = a /*as String? */) /*~> Unit */
+  }
+  when {
+    a is String? -> useString(s = CHECK_NOT_NULL<String>(arg0 = a /*as String? */))
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/breakContinue.fir.kt.txt b/compiler/testData/ir/irText/expressions/breakContinue.fir.kt.txt
new file mode 100644
index 00000000000..df1be4e5fc9
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/breakContinue.fir.kt.txt
@@ -0,0 +1,34 @@
+fun test1() {
+  while (true) break
+  dobreak  while (true)
+  while (true) continue
+  docontinue  while (true)
+}
+
+fun test2() {
+  OUTER@ while (true) { // BLOCK
+    INNER@ while (true) { // BLOCK
+      break@INNER
+      break@OUTER
+    }
+    break@OUTER
+  }
+  OUTER@ while (true) { // BLOCK
+    INNER@ while (true) { // BLOCK
+      continue@INNER
+      continue@OUTER
+    }
+    continue@OUTER
+  }
+}
+
+fun test3() {
+  L@ while (true) { // BLOCK
+    L@ while (true) break@L
+    break@L
+  }
+  L@ while (true) { // BLOCK
+    L@ while (true) continue@L
+    continue@L
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/breakContinueInLoopHeader.fir.kt.txt b/compiler/testData/ir/irText/expressions/breakContinueInLoopHeader.fir.kt.txt
new file mode 100644
index 00000000000..88576c0eed8
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/breakContinueInLoopHeader.fir.kt.txt
@@ -0,0 +1,78 @@
+fun test1(c: Boolean?) {
+  L@ while (true) { // BLOCK
+    L2@ while ({ // BLOCK
+      val <elvis>: Boolean? = c
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> break@L
+        else -> <elvis> /*as Boolean */
+      }
+    }) { // BLOCK
+    }
+  }
+}
+
+fun test2(c: Boolean?) {
+  L@ while (true) { // BLOCK
+    L2@ while ({ // BLOCK
+      val <elvis>: Boolean? = c
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> continue@L
+        else -> <elvis> /*as Boolean */
+      }
+    }) { // BLOCK
+    }
+  }
+}
+
+fun test3(ss: List<String>?) {
+  L@ while (true) { // BLOCK
+    { // BLOCK
+      val <iterator>: Iterator<String> = { // BLOCK
+        val <elvis>: List<String>? = ss
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> continue@L
+          else -> <elvis> /*as List<String> */
+        }
+      }.iterator()
+      L2@ while (<iterator>.hasNext()) { // BLOCK
+        val s: String = <iterator>.next()
+      }
+    }
+  }
+}
+
+fun test4(ss: List<String>?) {
+  L@ while (true) { // BLOCK
+    { // BLOCK
+      val <iterator>: Iterator<String> = { // BLOCK
+        val <elvis>: List<String>? = ss
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> break@L
+          else -> <elvis> /*as List<String> */
+        }
+      }.iterator()
+      L2@ while (<iterator>.hasNext()) { // BLOCK
+        val s: String = <iterator>.next()
+      }
+    }
+  }
+}
+
+fun test5() {
+  var i: Int = 0
+  Outer@ while (true) { // BLOCK
+    i = i.inc()
+    i /*~> Unit */
+    var j: Int = 0
+    Inner@ do// COMPOSITE {
+    j = j.inc()
+    j
+    // }    while (when {
+      greaterOrEqual(arg0 = j, arg1 = 3) -> false
+      else -> break@Outer
+    })
+    when {
+      EQEQ(arg0 = i, arg1 = 3) -> break@Outer
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/breakContinueInWhen.fir.kt.txt b/compiler/testData/ir/irText/expressions/breakContinueInWhen.fir.kt.txt
new file mode 100644
index 00000000000..9e334cc43e2
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/breakContinueInWhen.fir.kt.txt
@@ -0,0 +1,70 @@
+fun testBreakFor() {
+  val xs: IntArray = IntArray(size = 10, init = local fun <anonymous>(i: Int): Int {
+    return i
+  }
+)
+  var k: Int = 0
+  { // BLOCK
+    val <iterator>: IntIterator = xs.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: Int = <iterator>.next()
+      when {
+        greater(arg0 = k, arg1 = 2) -> break
+      }
+    }
+  }
+}
+
+fun testBreakWhile() {
+  var k: Int = 0
+  while (less(arg0 = k, arg1 = 10)) when {
+    greater(arg0 = k, arg1 = 2) -> break
+  }
+}
+
+fun testBreakDoWhile() {
+  var k: Int = 0
+  dowhen {
+    greater(arg0 = k, arg1 = 2) -> break
+  }  while (less(arg0 = k, arg1 = 10))
+}
+
+fun testContinueFor() {
+  val xs: IntArray = IntArray(size = 10, init = local fun <anonymous>(i: Int): Int {
+    return i
+  }
+)
+  var k: Int = 0
+  { // BLOCK
+    val <iterator>: IntIterator = xs.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: Int = <iterator>.next()
+      when {
+        greater(arg0 = k, arg1 = 2) -> continue
+      }
+    }
+  }
+}
+
+fun testContinueWhile() {
+  var k: Int = 0
+  while (less(arg0 = k, arg1 = 10)) when {
+    greater(arg0 = k, arg1 = 2) -> continue
+  }
+}
+
+fun testContinueDoWhile() {
+  var k: Int = 0
+  var s: String = ""
+  do// COMPOSITE {
+  k = k.inc()
+  k /*~> Unit */
+  when {
+    greater(arg0 = k, arg1 = 2) -> continue
+  }
+  s = s.plus(other = k.toString() + ";")
+  // }  while (less(arg0 = k, arg1 = 10))
+  when {
+    EQEQ(arg0 = s, arg1 = "1;2;").not() -> throw AssertionError(p0 = s)
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt
new file mode 100644
index 00000000000..801dd51fa50
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/adaptedExtensionFunctions.fir.kt.txt
@@ -0,0 +1,32 @@
+fun use(f: @ExtensionFunctionType @ExtensionFunctionType Function2<C, Int, Unit>) {
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun C.extensionVararg(i: Int, vararg s: String) {
+}
+
+fun C.extensionDefault(i: Int, s: String = "") {
+}
+
+fun C.extensionBoth(i: Int, s: String = "", vararg t: String) {
+}
+
+fun testExtensionVararg() {
+  use(f = ::extensionVararg)
+}
+
+fun testExtensionDefault() {
+  use(f = ::extensionDefault)
+}
+
+fun testExtensionBoth() {
+  use(f = ::extensionBoth)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/adaptedWithCoercionToUnit.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/adaptedWithCoercionToUnit.fir.kt.txt
new file mode 100644
index 00000000000..5786451f5dd
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/adaptedWithCoercionToUnit.fir.kt.txt
@@ -0,0 +1,45 @@
+fun useUnit0(fn: Function0<Unit>) {
+}
+
+fun useUnit1(fn: Function1<Int, Unit>) {
+}
+
+fun fn0(): Int {
+  return 1
+}
+
+fun fn1(x: Int): Int {
+  return 1
+}
+
+fun fnv(vararg xs: Int): Int {
+  return 1
+}
+
+fun test0() {
+  return useUnit0(fn = local fun fn0() {
+    fn0()
+  }
+)
+}
+
+fun test1() {
+  return useUnit1(fn = local fun fn1(p0: Int) {
+    fn1(x = p0)
+  }
+)
+}
+
+fun testV0() {
+  return useUnit0(fn = local fun fnv() {
+    fnv()
+  }
+)
+}
+
+fun testV1() {
+  return useUnit1(fn = local fun fnv(p0: Int) {
+    fnv(xs = [p0])
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/boundInlineAdaptedReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/boundInlineAdaptedReference.fir.kt.txt
new file mode 100644
index 00000000000..78394c432fc
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/boundInlineAdaptedReference.fir.kt.txt
@@ -0,0 +1,18 @@
+package test
+
+inline fun foo(x: Function0<Unit>) {
+}
+
+fun String.id(s: String = <this>, vararg xs: Int): String {
+  return s
+}
+
+fun test() {
+  foo(x = { // BLOCK
+    local fun String.id() {
+      receiver.id()
+    }
+
+    "Fail"::id
+  })
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt
new file mode 100644
index 00000000000..21a1418b094
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/caoWithAdaptationForSam.fir.kt.txt
@@ -0,0 +1,97 @@
+fun interface IFoo {
+  abstract fun foo(i: Int)
+
+}
+
+fun interface IFoo2 : IFoo {
+
+}
+
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object B {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+operator fun A.get(i: IFoo): Int {
+  return 1
+}
+
+operator fun A.set(i: IFoo, newValue: Int) {
+}
+
+operator fun B.get(i: IFoo): Int {
+  return 1
+}
+
+operator fun B.set(i: IFoo2, newValue: Int) {
+}
+
+fun withVararg(vararg xs: Int): Int {
+  return 42
+}
+
+fun test1() {
+  { // BLOCK
+    val <<array>>: A = A
+    val <<index_0>>: KFunction1<IntArray, Int> = ::withVararg
+    error("") /* ERROR CALL */<<index_0>>; error("") /* ERROR CALL */<<index_0>>; .plus(other = 1);
+  }
+}
+
+fun test2() {
+  { // BLOCK
+    val <<array>>: B = B
+    val <<index_0>>: KFunction1<IntArray, Int> = ::withVararg
+    error("") /* ERROR CALL */<<index_0>>; error("") /* ERROR CALL */<<index_0>>; .plus(other = 1);
+  }
+}
+
+fun test3(fn: Function1<Int, Unit>) {
+  { // BLOCK
+    val <<array>>: A = A
+    val <<index_0>>: Function1<Int, Unit> = fn
+    <<array>>.set(i = <<index_0>> /*-> IFoo */, newValue = <<array>>.get(i = <<index_0>> /*-> IFoo */).plus(other = 1))
+  }
+}
+
+fun test4(fn: Function1<Int, Unit>) {
+  when {
+    fn is IFoo -> { // BLOCK
+      val <<array>>: A = A
+      val <<index_0>>: IFoo = fn /*as IFoo */
+      <<array>>.set(i = <<index_0>>, newValue = <<array>>.get(i = <<index_0>>).plus(other = 1))
+    }
+  }
+}
+
+fun test5(a: Any) {
+  a as Function1<Int, Unit> /*~> Unit */
+  { // BLOCK
+    val <<array>>: A = A
+    val <<index_0>>: Function1<Int, Unit> = a /*as Function1<Int, Unit> */
+    <<array>>.set(i = <<index_0>> /*-> IFoo */, newValue = <<array>>.get(i = <<index_0>> /*-> IFoo */).plus(other = 1))
+  }
+}
+
+fun test6(a: Any) {
+  a as Function1<Int, Unit> /*~> Unit */
+  a /*as Function1<Int, Unit> */ as IFoo /*~> Unit */
+  { // BLOCK
+    val <<array>>: A = A
+    val <<index_0>>: Function1<Int, Unit> = a /*as Function1<Int, Unit> */
+    <<array>>.set(i = <<index_0>>, newValue = <<array>>.get(i = <<index_0>>).plus(other = 1))
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/constructorWithAdaptedArguments.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/constructorWithAdaptedArguments.fir.kt.txt
new file mode 100644
index 00000000000..d4ac82252f5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/constructorWithAdaptedArguments.fir.kt.txt
@@ -0,0 +1,42 @@
+fun use(fn: Function1<Int, Any>): Any {
+  return fn.invoke(p1 = 42)
+}
+
+class C {
+  constructor(vararg xs: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  inner class Inner {
+    constructor(vararg xs: Int) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
+
+fun testConstructor(): Any {
+  return use(fn = C::<init>)
+}
+
+fun testInnerClassConstructor(outer: Outer): Any {
+  return use(fn = outer::<init>)
+}
+
+fun testInnerClassConstructorCapturingOuter(): Any {
+  return use(fn = Outer()::<init>)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/kt37131.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/kt37131.fir.kt.txt
new file mode 100644
index 00000000000..f4cd26c31b7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/kt37131.fir.kt.txt
@@ -0,0 +1,28 @@
+fun foo(x: String = ""): String {
+  return x
+}
+
+class C {
+  constructor(x: String = "") /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: String
+    field = x
+    get
+
+}
+
+fun use(fn: Function0<Any>): Any {
+  return fn.invoke()
+}
+
+fun testFn(): Any {
+  return use(fn = ::foo)
+}
+
+fun testCtor(): Any {
+  return use(fn = C::<init>)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/suspendConversion.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/suspendConversion.fir.kt.txt
new file mode 100644
index 00000000000..43399532177
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/suspendConversion.fir.kt.txt
@@ -0,0 +1,99 @@
+fun useSuspend(fn: SuspendFunction0<Unit>) {
+}
+
+fun useSuspendInt(fn: SuspendFunction1<Int, Unit>) {
+}
+
+suspend fun foo0() {
+}
+
+fun foo1() {
+}
+
+fun fooInt(x: Int) {
+}
+
+fun foo2(vararg xs: Int) {
+}
+
+fun foo3(): Int {
+  return 42
+}
+
+fun foo4(i: Int = 42) {
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun bar() {
+  }
+
+}
+
+fun testLambda() {
+  useSuspend(fn = local suspend fun <anonymous>() {
+    foo1()
+  }
+)
+}
+
+fun testNoCoversion() {
+  useSuspend(fn = ::foo0)
+}
+
+fun testSuspendPlain() {
+  useSuspend(fn = local suspend fun foo1() {
+    foo1()
+  }
+)
+}
+
+fun testSuspendWithArgs() {
+  useSuspendInt(fn = local suspend fun fooInt(p0: Int) {
+    fooInt(x = p0)
+  }
+)
+}
+
+fun testWithVararg() {
+  useSuspend(fn = local suspend fun foo2() {
+    foo2()
+  }
+)
+}
+
+fun testWithVarargMapped() {
+  useSuspendInt(fn = local suspend fun foo2(p0: Int) {
+    foo2(xs = [p0])
+  }
+)
+}
+
+fun testWithCoercionToUnit() {
+  useSuspend(fn = local suspend fun foo3() {
+    foo3()
+  }
+)
+}
+
+fun testWithDefaults() {
+  useSuspend(fn = local suspend fun foo4() {
+    foo4()
+  }
+)
+}
+
+fun testWithBoundReceiver() {
+  useSuspend(fn = { // BLOCK
+    local suspend fun C.bar() {
+      receiver.bar()
+    }
+
+    C()::bar
+  })
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/typeArguments.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/typeArguments.fir.kt.txt
new file mode 100644
index 00000000000..b77a45000ec
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/typeArguments.fir.kt.txt
@@ -0,0 +1,29 @@
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  inline fun <reified T : Any?> objectMember(x: T) {
+  }
+
+}
+
+inline fun <reified T : Any?> topLevel1(x: T) {
+}
+
+inline fun <reified T : Any?> topLevel2(x: List<T>) {
+}
+
+val test1: Function1<Int, Unit>
+  field = ::topLevel1/*<Int>()*/
+  get
+
+val test2: Function1<List<String>, Unit>
+  field = ::topLevel2/*<String>()*/
+  get
+
+val test3: Function1<Int, Unit>
+  field = Host::objectMember/*<Int>()*/
+  get
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/unboundMemberReferenceWithAdaptedArguments.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/unboundMemberReferenceWithAdaptedArguments.fir.kt.txt
new file mode 100644
index 00000000000..3f60c4c9a20
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/unboundMemberReferenceWithAdaptedArguments.fir.kt.txt
@@ -0,0 +1,58 @@
+fun use1(fn: Function2<A, Int, Unit>) {
+}
+
+fun use2(fn: Function1<Int, Unit>) {
+}
+
+open class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  open fun foo(vararg xs: Int): Int {
+    return 1
+  }
+
+}
+
+object Obj : A {
+  private constructor() /* primary */ {
+    super/*A*/()
+    /* <init>() */
+
+  }
+
+  override fun foo(vararg xs: Int): Int {
+    return 1
+  }
+
+}
+
+fun testUnbound() {
+  use1(fn = local fun foo(p0: A, p1: Int) {
+    p0.foo()
+  }
+)
+}
+
+fun testBound(a: A) {
+  use2(fn = { // BLOCK
+    local fun A.foo(p0: Int) {
+      receiver.foo(xs = [p0])
+    }
+
+    a::foo
+  })
+}
+
+fun testObject() {
+  use2(fn = { // BLOCK
+    local fun Obj.foo(p0: Int) {
+      receiver.foo(xs = [p0])
+    }
+
+    Obj::foo
+  })
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/withAdaptationForSam.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/withAdaptationForSam.fir.kt.txt
new file mode 100644
index 00000000000..66a0dce09b3
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/withAdaptationForSam.fir.kt.txt
@@ -0,0 +1,18 @@
+fun interface IFoo {
+  abstract fun foo(i: Int)
+
+}
+
+fun useFoo(foo: IFoo) {
+}
+
+fun withVararg(vararg xs: Int): Int {
+  return 42
+}
+
+fun test() {
+  useFoo(foo = local fun withVararg(p0: Int) {
+    withVararg(xs = [p0])
+  }
+ /*-> IFoo */)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/withAdaptedArguments.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/withAdaptedArguments.fir.kt.txt
new file mode 100644
index 00000000000..8063416bc28
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/withAdaptedArguments.fir.kt.txt
@@ -0,0 +1,71 @@
+fun use(fn: Function1<Int, String>): String {
+  return fn.invoke(p1 = 1)
+}
+
+fun use0(fn: Function0<String>): String {
+  return fn.invoke()
+}
+
+fun coerceToUnit(fn: Function1<Int, Unit>) {
+}
+
+fun fnWithDefault(a: Int, b: Int = 42): String {
+  return "abc"
+}
+
+fun fnWithDefaults(a: Int = 1, b: Int = 2): String {
+  return ""
+}
+
+fun fnWithVarargs(vararg xs: Int): String {
+  return "abc"
+}
+
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun importedObjectMemberWithVarargs(vararg xs: Int): String {
+    return "abc"
+  }
+
+}
+
+fun testDefault(): String {
+  return use(fn = ::fnWithDefault)
+}
+
+fun testVararg(): String {
+  return use(fn = local fun fnWithVarargs(p0: Int): String {
+    return fnWithVarargs(xs = [p0])
+  }
+)
+}
+
+fun testCoercionToUnit() {
+  return coerceToUnit(fn = local fun fnWithDefault(p0: Int) {
+    fnWithDefault(a = p0)
+  }
+)
+}
+
+fun testImportedObjectMember(): String {
+  return use(fn = { // BLOCK
+    local fun Host.importedObjectMemberWithVarargs(p0: Int): String {
+      return receiver.importedObjectMemberWithVarargs(xs = [p0])
+    }
+
+    ::importedObjectMemberWithVarargs
+  })
+}
+
+fun testDefault0(): String {
+  return use0(fn = ::fnWithDefaults)
+}
+
+fun testVararg0(): String {
+  return use0(fn = ::fnWithVarargs)
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/withArgumentAdaptationAndReceiver.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/withArgumentAdaptationAndReceiver.fir.kt.txt
new file mode 100644
index 00000000000..706b2504009
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/withArgumentAdaptationAndReceiver.fir.kt.txt
@@ -0,0 +1,68 @@
+fun use(fn: Function1<Int, Unit>) {
+  fn.invoke(p1 = 1)
+}
+
+class Host {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun withVararg(vararg xs: Int): String {
+    return ""
+  }
+
+  fun testImplicitThis() {
+    use(fn = { // BLOCK
+      local fun Host.withVararg(p0: Int) {
+        receiver.withVararg(xs = [p0])
+      }
+
+      Host::withVararg
+    })
+  }
+
+  fun testBoundReceiverLocalVal() {
+    val h: Host = Host()
+    use(fn = { // BLOCK
+      local fun Host.withVararg(p0: Int) {
+        receiver.withVararg(xs = [p0])
+      }
+
+      h::withVararg
+    })
+  }
+
+  fun testBoundReceiverLocalVar() {
+    var h: Host = Host()
+    use(fn = { // BLOCK
+      local fun Host.withVararg(p0: Int) {
+        receiver.withVararg(xs = [p0])
+      }
+
+      h::withVararg
+    })
+  }
+
+  fun testBoundReceiverParameter(h: Host) {
+    use(fn = { // BLOCK
+      local fun Host.withVararg(p0: Int) {
+        receiver.withVararg(xs = [p0])
+      }
+
+      h::withVararg
+    })
+  }
+
+  fun testBoundReceiverExpression() {
+    use(fn = { // BLOCK
+      local fun Host.withVararg(p0: Int) {
+        receiver.withVararg(xs = [p0])
+      }
+
+      Host()::withVararg
+    })
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/callableReferences/withVarargViewedAsArray.fir.kt.txt b/compiler/testData/ir/irText/expressions/callableReferences/withVarargViewedAsArray.fir.kt.txt
new file mode 100644
index 00000000000..b124b6438db
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/callableReferences/withVarargViewedAsArray.fir.kt.txt
@@ -0,0 +1,52 @@
+fun sum(vararg args: Int): Int {
+  var result: Int = 0
+  { // BLOCK
+    val <iterator>: IntIterator = args.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val arg: Int = <iterator>.next()
+      result = result.plus(other = arg)
+    }
+  }
+  return result
+}
+
+fun nsum(vararg args: Number): Int {
+  return sum(args = [*IntArray(size = args.<get-size>(), init = local fun <anonymous>(it: Int): Int {
+    return args.get(index = it).toInt()
+  }
+)])
+}
+
+fun zap(vararg b: String, k: Int = 42) {
+}
+
+fun usePlainArgs(fn: Function2<Int, Int, Int>) {
+}
+
+fun usePrimitiveArray(fn: Function1<IntArray, Int>) {
+}
+
+fun useArray(fn: Function1<Array<Int>, Int>) {
+}
+
+fun useStringArray(fn: Function1<Array<String>, Unit>) {
+}
+
+fun testPlainArgs() {
+  usePlainArgs(fn = local fun sum(p0: Int, p1: Int): Int {
+    return sum(args = [p0, p1])
+  }
+)
+}
+
+fun testPrimitiveArrayAsVararg() {
+  usePrimitiveArray(fn = ::sum)
+}
+
+fun testArrayAsVararg() {
+  useArray(fn = ::nsum)
+}
+
+fun testArrayAndDefaults() {
+  useStringArray(fn = ::zap)
+}
diff --git a/compiler/testData/ir/irText/expressions/catchParameterAccess.fir.kt.txt b/compiler/testData/ir/irText/expressions/catchParameterAccess.fir.kt.txt
new file mode 100644
index 00000000000..ccb59492ec7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/catchParameterAccess.fir.kt.txt
@@ -0,0 +1,5 @@
+fun test(f: Function0<Unit>) {
+  return try f.invoke()
+  catch (e: Exception)throw e
+
+}
diff --git a/compiler/testData/ir/irText/expressions/classReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/classReference.fir.kt.txt
new file mode 100644
index 00000000000..e03a82adcb7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/classReference.fir.kt.txt
@@ -0,0 +1,15 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun test() {
+  A::class /*~> Unit */
+  A()::class /*~> Unit */
+  A::class.<get-java><A>() /*~> Unit */
+  A()::class.<get-java><A>() /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt
new file mode 100644
index 00000000000..ab06fa52ba3
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/coercionToUnit.fir.kt.txt
@@ -0,0 +1,27 @@
+val test1: Function0<Unit>
+  field = local fun <anonymous>(): Int {
+    return 42
+  }
+
+  get
+
+fun test2(mc: MutableCollection<String>) {
+  mc.add(element = "") /*~> Unit */
+}
+
+fun test3() {
+  { // BLOCK
+    val tmp0_safe_receiver: PrintStream? = #out
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.println(p0 = "Hello,")
+    }
+  } /*~> Unit */
+  { // BLOCK
+    val tmp1_safe_receiver: PrintStream? = #out
+    when {
+      EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+      else -> tmp1_safe_receiver.println(p0 = "world!")
+    }
+  } /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/complexAugmentedAssignment.fir.kt.txt b/compiler/testData/ir/irText/expressions/complexAugmentedAssignment.fir.kt.txt
new file mode 100644
index 00000000000..e0c7037a1d5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/complexAugmentedAssignment.fir.kt.txt
@@ -0,0 +1,100 @@
+object X1 {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var x1: Int
+    field = 0
+    get
+    set
+
+  object X2 {
+    private constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    var x2: Int
+      field = 0
+      get
+      set
+
+    object X3 {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      var x3: Int
+        field = 0
+        get
+        set
+
+    }
+
+  }
+
+}
+
+fun test1(a: IntArray) {
+  var i: Int = 0
+  val <array>: IntArray = a
+  val <index0>: Int = { // BLOCK
+    val <unary>: Int = i
+    i = <unary>.inc()
+    <unary>
+  }
+  val <unary>: Int = <array>.get(index = <index0>)
+  <array>.set(index = <index0>, value = <unary>.inc())
+  <unary> /*~> Unit */
+}
+
+fun test2() {
+  val <receiver>: X1 = X1
+  val <unary>: Int = <receiver>.<get-x1>()
+  <receiver>.<set-x1>(<set-?> = <unary>.inc())
+  <unary> /*~> Unit */
+  val <receiver>: X2 = X2
+  val <unary>: Int = <receiver>.<get-x2>()
+  <receiver>.<set-x2>(<set-?> = <unary>.inc())
+  <unary> /*~> Unit */
+  val <receiver>: X3 = X3
+  val <unary>: Int = <receiver>.<get-x3>()
+  <receiver>.<set-x3>(<set-?> = <unary>.inc())
+  <unary> /*~> Unit */
+}
+
+class B {
+  constructor(s: Int = 0) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var s: Int
+    field = s
+    get
+    set
+
+}
+
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun B.plusAssign(b: B) {
+    <this>.<set-s>(<set-?> = <this>.<get-s>().plus(other = b.<get-s>()))
+  }
+
+}
+
+fun Host.test3(v: B) {
+  (<this>, v).plusAssign(b = B(s = 1000))
+}
diff --git a/compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.fir.kt.txt
new file mode 100644
index 00000000000..9ab58236aa5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/constructorWithOwnTypeParametersCall.fir.kt.txt
@@ -0,0 +1,25 @@
+fun testKotlin(): K2<String, Int> {
+  return K1<Int>().K2<String>()
+}
+
+fun testJava(): J2<Double?, Int?> {
+  return J1<Int?, String?>().J2<Double?, CharSequence?>()
+}
+
+class K1<T1 : Number> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  inner class K2<T2 : CharSequence> {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/conventionComparisons.fir.kt.txt b/compiler/testData/ir/irText/expressions/conventionComparisons.fir.kt.txt
new file mode 100644
index 00000000000..8759cf24cc9
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/conventionComparisons.fir.kt.txt
@@ -0,0 +1,24 @@
+interface IA {
+
+}
+
+interface IB {
+  abstract operator fun IA.compareTo(other: IA): Int
+
+}
+
+fun IB.test1(a1: IA, a2: IA): Boolean {
+  return greater(arg0 = (<this>, a1).compareTo(other = a2), arg1 = 0)
+}
+
+fun IB.test2(a1: IA, a2: IA): Boolean {
+  return greaterOrEqual(arg0 = (<this>, a1).compareTo(other = a2), arg1 = 0)
+}
+
+fun IB.test3(a1: IA, a2: IA): Boolean {
+  return less(arg0 = (<this>, a1).compareTo(other = a2), arg1 = 0)
+}
+
+fun IB.test4(a1: IA, a2: IA): Boolean {
+  return lessOrEqual(arg0 = (<this>, a1).compareTo(other = a2), arg1 = 0)
+}
diff --git a/compiler/testData/ir/irText/expressions/destructuring1.fir.kt.txt b/compiler/testData/ir/irText/expressions/destructuring1.fir.kt.txt
new file mode 100644
index 00000000000..a5f746ddfba
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/destructuring1.fir.kt.txt
@@ -0,0 +1,31 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object B {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun A.component1(): Int {
+    return 1
+  }
+
+  operator fun A.component2(): Int {
+    return 2
+  }
+
+}
+
+fun B.test() {
+  val <destruct>: A = A
+  val x: Int = (<this>, <destruct>).component1()
+  val y: Int = (<this>, <destruct>).component2()
+}
diff --git a/compiler/testData/ir/irText/expressions/destructuringWithUnderscore.fir.kt.txt b/compiler/testData/ir/irText/expressions/destructuringWithUnderscore.fir.kt.txt
new file mode 100644
index 00000000000..dff11a75023
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/destructuringWithUnderscore.fir.kt.txt
@@ -0,0 +1,36 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object B {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun A.component1(): Int {
+    return 1
+  }
+
+  operator fun A.component2(): Int {
+    return 2
+  }
+
+  operator fun A.component3(): Int {
+    return 3
+  }
+
+}
+
+fun B.test() {
+  val <destruct>: A = A
+  val x: Int = (<this>, <destruct>).component1()
+  val _: Int = (<this>, <destruct>).component2()
+  val z: Int = (<this>, <destruct>).component3()
+}
diff --git a/compiler/testData/ir/irText/expressions/elvis.fir.kt.txt b/compiler/testData/ir/irText/expressions/elvis.fir.kt.txt
new file mode 100644
index 00000000000..0ec550b8a10
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/elvis.fir.kt.txt
@@ -0,0 +1,63 @@
+val p: Any?
+  field = null
+  get
+
+fun foo(): Any? {
+  return null
+}
+
+fun test1(a: Any?, b: Any): Any {
+  return { // BLOCK
+    val <elvis>: Any? = a
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> b
+      else -> <elvis> /*as Any */
+    }
+  }
+}
+
+fun test2(a: String?, b: Any): Any {
+  return { // BLOCK
+    val <elvis>: String? = a
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> b
+      else -> <elvis> /*as String */
+    }
+  }
+}
+
+fun test3(a: Any?, b: Any?): String {
+  when {
+    b !is String -> return ""
+  }
+  when {
+    a !is String? -> return ""
+  }
+  return { // BLOCK
+    val <elvis>: String? = a /*as String? */
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> b /*as String */
+      else -> <elvis> /*as String */
+    }
+  }
+}
+
+fun test4(x: Any): Any {
+  return { // BLOCK
+    val <elvis>: Any? = <get-p>()
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> x
+      else -> <elvis> /*as Any */
+    }
+  }
+}
+
+fun test5(x: Any): Any {
+  return { // BLOCK
+    val <elvis>: Any? = foo()
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> x
+      else -> <elvis> /*as Any */
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.fir.kt.txt b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.fir.kt.txt
new file mode 100644
index 00000000000..898af00a36b
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.fir.kt.txt
@@ -0,0 +1,40 @@
+abstract enum class X : Enum<X> {
+  private constructor() /* primary */ {
+    super/*Enum*/<X>()
+    /* <init>() */
+
+  }
+
+  B = B()
+  private enum entry class B : X {
+    private constructor() /* primary */ {
+      super/*X*/()
+      /* <init>() */
+
+    }
+
+    val value2: String
+      field = "OK"
+      get
+
+    override val value: Function0<String>
+      field = local fun <anonymous>(): String {
+        return <this>.<get-value2>()
+      }
+
+      override get
+
+  }
+
+  abstract val value: Function0<String>
+    abstract get
+
+  fun values(): Array<X> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): X /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+fun box(): String {
+  return X.B.<get-value>().invoke()
+}
diff --git a/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.fir.kt.txt b/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.fir.kt.txt
new file mode 100644
index 00000000000..48ca5fef585
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.fir.kt.txt
@@ -0,0 +1,68 @@
+open enum class MyEnum : Enum<MyEnum> {
+  private constructor() /* primary */ {
+    super/*Enum*/<MyEnum>()
+    /* <init>() */
+
+  }
+
+  Z = Z()
+  private enum entry class Z : MyEnum {
+    private constructor() /* primary */ {
+      super/*MyEnum*/()
+      /* <init>() */
+
+    }
+
+    var counter: Int
+      field = 0
+      get
+      set
+
+    fun foo() {
+    }
+
+    fun bar() {
+      <this>.<set-counter>(<set-?> = 1)
+      <this>.foo()
+    }
+
+    val aLambda: Function0<Unit>
+      field = local fun <anonymous>() {
+        <this>.<set-counter>(<set-?> = 1)
+        <this>.foo()
+      }
+
+      get
+
+    val anObject: <no name provided>
+      field = { // BLOCK
+        local class <no name provided> {
+          private constructor() /* primary */ {
+            super/*Any*/()
+            /* <init>() */
+
+          }
+
+          init {
+            <this>.<set-counter>(<set-?> = 1)
+            <this>.foo()
+          }
+
+          fun test() {
+            <this>.<set-counter>(<set-?> = 1)
+            <this>.foo()
+          }
+
+        }
+
+        <no name provided>()
+      }
+      get
+
+  }
+
+  fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): MyEnum /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/expressions/equals.fir.kt.txt b/compiler/testData/ir/irText/expressions/equals.fir.kt.txt
new file mode 100644
index 00000000000..bfc8d01fbe4
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/equals.fir.kt.txt
@@ -0,0 +1,15 @@
+fun testEqeq(a: Int, b: Int): Boolean {
+  return EQEQ(arg0 = a, arg1 = b)
+}
+
+fun testEquals(a: Int, b: Int): Boolean {
+  return a.equals(other = b)
+}
+
+fun testJEqeqNull(): Boolean {
+  return EQEQ(arg0 = #INT_NULL, arg1 = null)
+}
+
+fun testJEqualsNull(): Boolean {
+  return #INT_NULL.equals(other = null)
+}
diff --git a/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.fir.kt.txt b/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.fir.kt.txt
new file mode 100644
index 00000000000..057c233f5a0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.fir.kt.txt
@@ -0,0 +1,119 @@
+enum class A : Enum<A> {
+  private constructor() /* primary */ {
+    super/*Enum*/<A>()
+    /* <init>() */
+
+  }
+
+  V1 = A()
+
+  fun values(): Array<A> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): A /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+fun testVariableAssignment_throws(a: A) {
+  val x: Int
+  { // BLOCK
+    val tmp0_subject: A = a
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = A.V1) -> { // BLOCK
+        x = 11
+      }
+      else -> noWhenBranchMatchedException()
+    }
+  }
+}
+
+fun testStatement_empty(a: A) {
+  { // BLOCK
+    val tmp1_subject: A = a
+    when {
+      EQEQ(arg0 = tmp1_subject, arg1 = A.V1) -> 1
+      else -> noWhenBranchMatchedException()
+    }
+  } /*~> Unit */
+}
+
+fun testParenthesized_throwsJvm(a: A) {
+  { // BLOCK
+    val tmp2_subject: A = a
+    when {
+      EQEQ(arg0 = tmp2_subject, arg1 = A.V1) -> 1
+      else -> noWhenBranchMatchedException()
+    }
+  } /*~> Unit */
+}
+
+fun testAnnotated_throwsJvm(a: A) {
+  { // BLOCK
+    val tmp3_subject: A = a
+    when {
+      EQEQ(arg0 = tmp3_subject, arg1 = A.V1) -> 1
+      else -> noWhenBranchMatchedException()
+    }
+  } /*~> Unit */
+}
+
+fun testExpression_throws(a: A): Int {
+  return { // BLOCK
+    val tmp4_subject: A = a
+    when {
+      EQEQ(arg0 = tmp4_subject, arg1 = A.V1) -> 1
+      else -> noWhenBranchMatchedException()
+    }
+  }
+}
+
+fun testIfTheElseStatement_empty(a: A, flag: Boolean) {
+  when {
+    flag -> 0
+    else -> { // BLOCK
+      val tmp5_subject: A = a
+      when {
+        EQEQ(arg0 = tmp5_subject, arg1 = A.V1) -> 1
+        else -> noWhenBranchMatchedException()
+      }
+    }
+  } /*~> Unit */
+}
+
+fun testIfTheElseParenthesized_throwsJvm(a: A, flag: Boolean) {
+  when {
+    flag -> 0
+    else -> { // BLOCK
+      val tmp6_subject: A = a
+      when {
+        EQEQ(arg0 = tmp6_subject, arg1 = A.V1) -> 1
+        else -> noWhenBranchMatchedException()
+      }
+    }
+  } /*~> Unit */
+}
+
+fun testIfTheElseAnnotated_throwsJvm(a: A, flag: Boolean) {
+  when {
+    flag -> 0
+    else -> { // BLOCK
+      val tmp7_subject: A = a
+      when {
+        EQEQ(arg0 = tmp7_subject, arg1 = A.V1) -> 1
+        else -> noWhenBranchMatchedException()
+      }
+    }
+  } /*~> Unit */
+}
+
+fun testLambdaResultExpression_throws(a: A) {
+  local fun <anonymous>(): Int {
+    return { // BLOCK
+      val tmp8_subject: A = a
+      when {
+        EQEQ(arg0 = tmp8_subject, arg1 = A.V1) -> 1
+        else -> noWhenBranchMatchedException()
+      }
+    }
+  }
+.invoke() /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt
new file mode 100644
index 00000000000..de1341623b5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/extFunInvokeAsFun.fir.kt.txt
@@ -0,0 +1,7 @@
+fun with1(receiver: Any?, block: @ExtensionFunctionType @ExtensionFunctionType Function1<Any?, Unit>) {
+  return block.invoke(p1 = receiver)
+}
+
+fun with2(receiver: Any?, block: @ExtensionFunctionType @ExtensionFunctionType Function1<Any?, Unit>) {
+  return block.invoke(p1 = receiver)
+}
diff --git a/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt
new file mode 100644
index 00000000000..dff7557aa76
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/extFunSafeInvoke.fir.kt.txt
@@ -0,0 +1,9 @@
+fun test(receiver: Any?, fn: @ExtensionFunctionType @ExtensionFunctionType Function3<Any, Int, String, Unit>): Unit? {
+  return { // BLOCK
+    val tmp0_safe_receiver: Any? = receiver
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> fn.invoke(p1 = tmp0_safe_receiver, p2 = 42, p3 = "Hello")
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/field.fir.kt.txt b/compiler/testData/ir/irText/expressions/field.fir.kt.txt
new file mode 100644
index 00000000000..810d860b9b1
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/field.fir.kt.txt
@@ -0,0 +1,13 @@
+var testSimple: Int
+  field = 0
+  get
+  set(value: Int) {
+    #testSimple = value
+  }
+
+var testAugmented: Int
+  field = 0
+  get
+  set(value: Int) {
+    #testAugmented = #testAugmented.plus(other = value)
+  }
diff --git a/compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEquals.fir.kt.txt b/compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEquals.fir.kt.txt
new file mode 100644
index 00000000000..a1ed83271ac
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/floatingPointComparisons/floatingPointEquals.fir.kt.txt
@@ -0,0 +1,115 @@
+fun test1d(x: Double, y: Double): Boolean {
+  return x.equals(other = y)
+}
+
+fun test2d(x: Double, y: Double?): Boolean {
+  return x.equals(other = y)
+}
+
+fun test3d(x: Double, y: Any): Boolean {
+  return x.equals(other = y)
+}
+
+fun test4d(x: Double, y: Number): Boolean {
+  return x.equals(other = y)
+}
+
+fun test5d(x: Double, y: Any): Boolean {
+  return when {
+    y is Double -> x.equals(other = y /*as Double */)
+    else -> false
+  }
+}
+
+fun test6d(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Double
+      else -> false
+    } -> x /*as Double */.equals(other = y /*as Double */)
+    else -> false
+  }
+}
+
+fun test1f(x: Float, y: Float): Boolean {
+  return x.equals(other = y)
+}
+
+fun test2f(x: Float, y: Float?): Boolean {
+  return x.equals(other = y)
+}
+
+fun test3f(x: Float, y: Any): Boolean {
+  return x.equals(other = y)
+}
+
+fun test4f(x: Float, y: Number): Boolean {
+  return x.equals(other = y)
+}
+
+fun test5f(x: Float, y: Any): Boolean {
+  return when {
+    y is Float -> x.equals(other = y /*as Float */)
+    else -> false
+  }
+}
+
+fun test6f(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Float
+      else -> false
+    } -> x /*as Float */.equals(other = y /*as Float */)
+    else -> false
+  }
+}
+
+fun testFD(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Float -> y is Double
+      else -> false
+    } -> x /*as Float */.equals(other = y /*as Double */)
+    else -> false
+  }
+}
+
+fun testDF(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Double -> y is Float
+      else -> false
+    } -> x /*as Double */.equals(other = y /*as Float */)
+    else -> false
+  }
+}
+
+fun Float.test1fr(x: Float): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test2fr(x: Float?): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test3fr(x: Any): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test4fr(x: Number): Boolean {
+  return <this>.equals(other = x)
+}
+
+fun Float.test5fr(x: Any): Boolean {
+  return when {
+    x is Float -> <this>.equals(other = x /*as Float */)
+    else -> false
+  }
+}
+
+fun Float.test6fr(x: Any): Boolean {
+  return when {
+    x is Double -> <this>.equals(other = x /*as Double */)
+    else -> false
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableAnyAsIntToDouble.fir.kt.txt b/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableAnyAsIntToDouble.fir.kt.txt
new file mode 100644
index 00000000000..88e971888fe
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableAnyAsIntToDouble.fir.kt.txt
@@ -0,0 +1,6 @@
+fun test(x: Any?, y: Double): Boolean {
+  return when {
+    x is Int -> less(arg0 = x /*as Int */.toDouble(), arg1 = y)
+    else -> false
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableFloatingPointEqeq.fir.kt.txt b/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableFloatingPointEqeq.fir.kt.txt
new file mode 100644
index 00000000000..e9599a84b7d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/floatingPointComparisons/nullableFloatingPointEqeq.fir.kt.txt
@@ -0,0 +1,45 @@
+fun testDD(x: Double?, y: Double?): Boolean {
+  return ieee754equals(arg0 = x, arg1 = y)
+}
+
+fun testDF(x: Double?, y: Any?): Boolean {
+  return when {
+    y is Float? -> ieee754equals(arg0 = x, arg1 = { // BLOCK
+      val tmp0_safe_receiver: Float? = y /*as Float? */
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        else -> tmp0_safe_receiver.toDouble()
+      }
+    })
+    else -> false
+  }
+}
+
+fun testDI(x: Double?, y: Any?): Boolean {
+  return when {
+    y is Int? -> ieee754equals(arg0 = x, arg1 = { // BLOCK
+      val tmp1_safe_receiver: Int? = y /*as Int? */
+      when {
+        EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+        else -> tmp1_safe_receiver.toDouble()
+      }
+    })
+    else -> false
+  }
+}
+
+fun testDI2(x: Any?, y: Any?): Boolean {
+  return when {
+    when {
+      x is Int? -> y is Double
+      else -> false
+    } -> ieee754equals(arg0 = { // BLOCK
+      val tmp2_safe_receiver: Int? = x /*as Int? */
+      when {
+        EQEQ(arg0 = tmp2_safe_receiver, arg1 = null) -> null
+        else -> tmp2_safe_receiver.toDouble()
+      }
+    }, arg1 = y /*as Double */)
+    else -> false
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.fir.kt.txt b/compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.fir.kt.txt
new file mode 100644
index 00000000000..879bb4ba492
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/floatingPointComparisons/typeParameterWithPrimitiveNumericSupertype.fir.kt.txt
@@ -0,0 +1,64 @@
+fun <T : Any?> test0(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> EQEQ(arg0 = x /*as Int */, arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Float> test1(x: Any, y: T): Boolean {
+  return when {
+    x is Float -> ieee754equals(arg0 = x /*as Float */, arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Double> test2(x: Any, y: T): Boolean {
+  return when {
+    x is Float -> ieee754equals(arg0 = x /*as Float */.toDouble(), arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Float> test3(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Float?> test4(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Float?, R : T> test5(x: Any, y: R): Boolean {
+  return when {
+    x is Int -> ieee754equals(arg0 = x /*as Int */.toFloat(), arg1 = y)
+    else -> false
+  }
+}
+
+fun <T : Number> test6(x: Any, y: T): Boolean {
+  return when {
+    x is Int -> EQEQ(arg0 = x /*as Int */, arg1 = y)
+    else -> false
+  }
+}
+
+class F<T : Float> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun testCapturedType(x: T, y: Any): Boolean {
+    return when {
+      y is Double -> ieee754equals(arg0 = x.toDouble(), arg1 = y /*as Double */)
+      else -> false
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/floatingPointComparisons/whenByFloatingPoint.fir.kt.txt b/compiler/testData/ir/irText/expressions/floatingPointComparisons/whenByFloatingPoint.fir.kt.txt
new file mode 100644
index 00000000000..da3ff7b2233
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/floatingPointComparisons/whenByFloatingPoint.fir.kt.txt
@@ -0,0 +1,79 @@
+fun testSimple(x: Double): Int {
+  return { // BLOCK
+    val tmp0_subject: Double = x
+    when {
+      ieee754equals(arg0 = tmp0_subject, arg1 = 0.0D) -> 0
+      else -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenSubject(x: Any): Int {
+  when {
+    x !is Double -> return -1
+  }
+  return { // BLOCK
+    val tmp1_subject: Double = x /*as Double */
+    when {
+      ieee754equals(arg0 = tmp1_subject, arg1 = 0.0D) -> 0
+      else -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenCondition(x: Double, y: Any): Int {
+  when {
+    y !is Double -> return -1
+  }
+  return { // BLOCK
+    val tmp2_subject: Double = x
+    when {
+      ieee754equals(arg0 = tmp2_subject, arg1 = y /*as Double */) -> 0
+      else -> 1
+    }
+  }
+}
+
+fun testSmartCastInWhenConditionInBranch(x: Any): Int {
+  return { // BLOCK
+    val tmp3_subject: Any = x
+    when {
+      tmp3_subject !is Double -> -1
+      EQEQ(arg0 = tmp3_subject, arg1 = 0.0D) -> 0
+      else -> 1
+    }
+  }
+}
+
+fun testSmartCastToDifferentTypes(x: Any, y: Any): Int {
+  when {
+    x !is Double -> return -1
+  }
+  when {
+    y !is Float -> return -1
+  }
+  return { // BLOCK
+    val tmp4_subject: Double = x /*as Double */
+    when {
+      ieee754equals(arg0 = tmp4_subject, arg1 = y /*as Float */.toDouble()) -> 0
+      else -> 1
+    }
+  }
+}
+
+fun foo(x: Double): Double {
+  return x
+}
+
+fun testWithPrematureExitInConditionSubexpression(x: Any): Int {
+  return { // BLOCK
+    val tmp5_subject: Any = x
+    when {
+      EQEQ(arg0 = tmp5_subject, arg1 = foo(x = when {
+        x !is Double -> return 42
+        else -> x /*as Double */
+      })) -> 0
+      else -> 1
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/for.fir.kt.txt b/compiler/testData/ir/irText/expressions/for.fir.kt.txt
new file mode 100644
index 00000000000..d24d3e0c666
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/for.fir.kt.txt
@@ -0,0 +1,40 @@
+fun testEmpty(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val s: String = <iterator>.next()
+    }
+  }
+}
+
+fun testIterable(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val s: String = <iterator>.next()
+      println(message = s)
+    }
+  }
+}
+
+fun testDestructuring(pp: List<Pair<Int, String>>) {
+  { // BLOCK
+    val <iterator>: Iterator<Pair<Int, String>> = pp.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val <destruct>: Pair<Int, String> = <iterator>.next()
+      val i: Int = <destruct>.component1()
+      val s: String = <destruct>.component2()
+      println(message = i)
+      println(message = s)
+    }
+  }
+}
+
+fun testRange() {
+  { // BLOCK
+    val <iterator>: IntIterator = 1.rangeTo(other = 10).iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val i: Int = <iterator>.next()
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/forWithBreakContinue.fir.kt.txt b/compiler/testData/ir/irText/expressions/forWithBreakContinue.fir.kt.txt
new file mode 100644
index 00000000000..2a96bfab610
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/forWithBreakContinue.fir.kt.txt
@@ -0,0 +1,57 @@
+fun testForBreak1(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val s: String = <iterator>.next()
+      break
+    }
+  }
+}
+
+fun testForBreak2(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    OUTER@ while (<iterator>.hasNext()) { // BLOCK
+      val s1: String = <iterator>.next()
+      { // BLOCK
+        val <iterator>: Iterator<String> = ss.iterator()
+        INNER@ while (<iterator>.hasNext()) { // BLOCK
+          val s2: String = <iterator>.next()
+          break@OUTER
+          break@INNER
+          break@INNER
+        }
+      }
+      break@OUTER
+    }
+  }
+}
+
+fun testForContinue1(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val s: String = <iterator>.next()
+      continue
+    }
+  }
+}
+
+fun testForContinue2(ss: List<String>) {
+  { // BLOCK
+    val <iterator>: Iterator<String> = ss.iterator()
+    OUTER@ while (<iterator>.hasNext()) { // BLOCK
+      val s1: String = <iterator>.next()
+      { // BLOCK
+        val <iterator>: Iterator<String> = ss.iterator()
+        INNER@ while (<iterator>.hasNext()) { // BLOCK
+          val s2: String = <iterator>.next()
+          continue@OUTER
+          continue@INNER
+          continue@INNER
+        }
+      }
+      continue@OUTER
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.fir.kt.txt b/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.fir.kt.txt
new file mode 100644
index 00000000000..713711ed6f5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.fir.kt.txt
@@ -0,0 +1,51 @@
+object FiveTimes {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class IntCell {
+  constructor(value: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var value: Int
+    field = value
+    get
+    set
+
+}
+
+interface IReceiver {
+  operator fun FiveTimes.iterator(): IntCell {
+    return IntCell(value = 5)
+  }
+
+  operator fun IntCell.hasNext(): Boolean {
+    return greater(arg0 = <this>.<get-value>(), arg1 = 0)
+  }
+
+  operator fun IntCell.next(): Int {
+    return { // BLOCK
+      val <unary>: Int = <this>.<get-value>()
+      <this>.<set-value>(<set-?> = <unary>.dec())
+      <unary>
+    }
+  }
+
+}
+
+fun IReceiver.test() {
+  { // BLOCK
+    val <iterator>: IntCell = (<this>, FiveTimes).iterator()
+    while ((<this>, <iterator>).hasNext()) { // BLOCK
+      val i: Int = (<this>, <iterator>).next()
+      println(message = i)
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.kt.txt b/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.kt.txt
new file mode 100644
index 00000000000..cd1a19710b7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.kt.txt
@@ -0,0 +1,66 @@
+fun interface Fn<T : Any?, R : Any?> {
+  abstract fun run(s: String, i: Int, t: T): R
+
+}
+
+class J {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun runConversion(f1: Fn<String, Int>, f2: Fn<Int, String>): Int {
+    return f1.run(s = "Bar", i = 1, t = f2.run(s = "Foo", i = 42, t = 239))
+  }
+
+}
+
+val fsi: Fn<String, Int>
+  field = { // BLOCK
+    local class <no name provided> : Fn<String, Int> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      override fun run(s: String, i: Int, t: String): Int {
+        return 1
+      }
+
+    }
+
+    <no name provided>()
+  }
+  get
+
+val fis: Fn<Int, String>
+  field = { // BLOCK
+    local class <no name provided> : Fn<Int, String> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      override fun run(s: String, i: Int, t: Int): String {
+        return ""
+      }
+
+    }
+
+    <no name provided>()
+  }
+  get
+
+fun test(j: J) {
+  j.runConversion(f1 = <get-fsi>(), f2 = local fun <anonymous>(s: String, i: Int, ti: Int): String {
+    return ""
+  }
+ /*-> Fn<Int, String> */) /*~> Unit */
+  j.runConversion(f1 = local fun <anonymous>(s: String, i: Int, ts: String): Int {
+    return 1
+  }
+ /*-> Fn<String, Int> */, f2 = <get-fis>()) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargs.fir.kt.txt b/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargs.fir.kt.txt
new file mode 100644
index 00000000000..d37014897d3
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargs.fir.kt.txt
@@ -0,0 +1,38 @@
+fun interface IFoo {
+  abstract fun foo(i: Int)
+
+}
+
+fun useVararg(vararg foos: IFoo) {
+}
+
+fun testLambda() {
+  useVararg(foos = [local fun <anonymous>(it: Int) {
+    return Unit
+  }
+ /*-> IFoo */])
+}
+
+fun testSeveralLambdas() {
+  useVararg(foos = [local fun <anonymous>(it: Int) {
+    return Unit
+  }
+ /*-> IFoo */, local fun <anonymous>(it: Int) {
+    return Unit
+  }
+ /*-> IFoo */, local fun <anonymous>(it: Int) {
+    return Unit
+  }
+ /*-> IFoo */])
+}
+
+fun withVarargOfInt(vararg xs: Int): String {
+  return ""
+}
+
+fun testAdaptedCR() {
+  useVararg(foos = [local fun withVarargOfInt(p0: Int) {
+    withVarargOfInt(xs = [p0])
+  }
+ /*-> IFoo */])
+}
diff --git a/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargsMixed.fir.kt.txt b/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargsMixed.fir.kt.txt
new file mode 100644
index 00000000000..4e96e4a9a78
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/funInterface/samConversionInVarargsMixed.fir.kt.txt
@@ -0,0 +1,16 @@
+fun interface MyRunnable {
+  abstract fun run()
+
+}
+
+fun test(a: Any, r: MyRunnable) {
+  when {
+    a is MyRunnable -> foo(rs = [local fun <anonymous>() {
+      return Unit
+    }
+ /*-> MyRunnable */, r, a /*as MyRunnable */])
+  }
+}
+
+fun foo(vararg rs: MyRunnable) {
+}
diff --git a/compiler/testData/ir/irText/expressions/funInterface/samConversionOnCallableReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/funInterface/samConversionOnCallableReference.fir.kt.txt
new file mode 100644
index 00000000000..38484efcba1
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/funInterface/samConversionOnCallableReference.fir.kt.txt
@@ -0,0 +1,36 @@
+fun interface KRunnable {
+  abstract fun run()
+
+}
+
+fun foo0() {
+}
+
+fun foo1(vararg xs: Int): Int {
+  return 1
+}
+
+fun use(r: KRunnable) {
+}
+
+fun testSamConstructor(): KRunnable {
+  return ::foo0 /*-> KRunnable */
+}
+
+fun testSamCosntructorOnAdapted(): KRunnable {
+  return local fun foo1() {
+    foo1()
+  }
+ /*-> KRunnable */
+}
+
+fun testSamConversion() {
+  use(r = ::foo0 /*-> KRunnable */)
+}
+
+fun testSamConversionOnAdapted() {
+  use(r = local fun foo1() {
+    foo1()
+  }
+ /*-> KRunnable */)
+}
diff --git a/compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.fir.kt.txt b/compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.fir.kt.txt
new file mode 100644
index 00000000000..b769f5e4a61
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/funInterface/samConversionsWithSmartCasts.fir.kt.txt
@@ -0,0 +1,69 @@
+fun interface KRunnable {
+  abstract fun run()
+
+}
+
+fun <T : Any?> id(x: T): T {
+  return x
+}
+
+fun run1(r: KRunnable) {
+}
+
+fun run2(r1: KRunnable, r2: KRunnable) {
+}
+
+fun <T> test0(a: T) where T : KRunnable, T : Function0<Unit> {
+  run1(r = a)
+}
+
+fun test1(a: Function0<Unit>) {
+  when {
+    a is KRunnable -> run1(r = a /*as KRunnable */)
+  }
+}
+
+fun test2(a: KRunnable) {
+  a as Function0<Unit> /*~> Unit */
+  run1(r = a /*as Function0<Unit> */)
+}
+
+fun test3(a: Function0<Unit>) {
+  when {
+    a is KRunnable -> run2(r1 = a /*as KRunnable */, r2 = a /*as KRunnable */)
+  }
+}
+
+fun test4(a: Function0<Unit>, b: Function0<Unit>) {
+  when {
+    a is KRunnable -> run2(r1 = a /*as KRunnable */, r2 = b /*-> KRunnable */)
+  }
+}
+
+fun test5(a: Any) {
+  when {
+    a is KRunnable -> run1(r = a /*as KRunnable */)
+  }
+}
+
+fun test5x(a: Any) {
+  when {
+    a is KRunnable -> { // BLOCK
+      a /*as KRunnable */ as Function0<Unit> /*~> Unit */
+      run1(r = a /*as KRunnable */)
+    }
+  }
+}
+
+fun test6(a: Any) {
+  a as Function0<Unit> /*~> Unit */
+  run1(r = a /*as Function0<Unit> */ /*-> KRunnable */)
+}
+
+fun test8(a: Function0<Unit>) {
+  run1(r = id<Function0<Unit>>(x = a) /*-> KRunnable */)
+}
+
+fun test9() {
+  run1(r = ::test9 /*-> KRunnable */)
+}
diff --git a/compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.fir.kt.txt b/compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.fir.kt.txt
new file mode 100644
index 00000000000..a313764ee48
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/genericConstructorCallWithTypeArguments.fir.kt.txt
@@ -0,0 +1,23 @@
+fun testSimple(): Box<Long> {
+  return Box<Long>(value = 6L)
+}
+
+inline fun <reified T : Any?> testArray(n: Int, crossinline block: Function0<T>): Array<T> {
+  return Array<T>(size = n, init = local fun <anonymous>(it: Int): T {
+    return block.invoke()
+  }
+)
+}
+
+class Box<T : Any?> {
+  constructor(value: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+}
diff --git a/compiler/testData/ir/irText/expressions/genericPropertyRef.fir.kt.txt b/compiler/testData/ir/irText/expressions/genericPropertyRef.fir.kt.txt
new file mode 100644
index 00000000000..92837ccb850
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/genericPropertyRef.fir.kt.txt
@@ -0,0 +1,70 @@
+class Value<T : Any?> {
+  constructor(value: T = null as T, text: String? = null) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var value: T
+    field = value
+    get
+    set
+
+  var text: String?
+    field = text
+    get
+    set
+
+}
+
+val <T : Any?> Value<T>.additionalText: Int /* by */
+  field = DVal(kmember = Value::text)
+  get(): Int {
+    return #additionalText$delegate.getValue(t = <this>, p = ::additionalText/*</* null */>()*/)
+  }
+
+val <T : Any?> Value<T>.additionalValue: Int /* by */
+  field = DVal(kmember = Value::value)
+  get(): Int {
+    return #additionalValue$delegate.getValue(t = <this>, p = ::additionalValue/*</* null */>()*/)
+  }
+
+class DVal {
+  constructor(kmember: Any) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val kmember: Any
+    field = kmember
+    get
+
+  operator fun getValue(t: Any?, p: Any): Int {
+    return 42
+  }
+
+}
+
+var recivier: Any?
+  field = "fail"
+  get
+  set
+
+var value2: Any?
+  field = "fail2"
+  get
+  set
+
+var <T : Any?> T.bar: T
+  get(): T {
+    return <this>
+  }
+  set(value: T) {
+    <set-recivier>(<set-?> = <this>)
+    <set-value2>(<set-?> = value)
+  }
+
+val barRef: KMutableProperty1<String?, String?>
+  field = ::bar/*<String?>()*/
+  get
diff --git a/compiler/testData/ir/irText/expressions/ifElseIf.fir.kt.txt b/compiler/testData/ir/irText/expressions/ifElseIf.fir.kt.txt
new file mode 100644
index 00000000000..dc7d00ebb86
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/ifElseIf.fir.kt.txt
@@ -0,0 +1,39 @@
+fun test(i: Int): Int {
+  return when {
+    greater(arg0 = i, arg1 = 0) -> 1
+    else -> when {
+      less(arg0 = i, arg1 = 0) -> -1
+      else -> 0
+    }
+  }
+}
+
+fun testEmptyBranches1(flag: Boolean) {
+  when {
+    flag -> { // BLOCK
+    }
+    else -> true
+  } /*~> Unit */
+  when {
+    flag -> true
+  }
+}
+
+fun testEmptyBranches2(flag: Boolean) {
+  when {
+    flag -> { // BLOCK
+    }
+    else -> true
+  } /*~> Unit */
+  when {
+    flag -> true
+  }
+}
+
+fun testEmptyBranches3(flag: Boolean) {
+  when {
+    flag -> { // BLOCK
+    }
+    else -> true
+  } /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/implicitCastInReturnFromConstructor.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitCastInReturnFromConstructor.fir.kt.txt
new file mode 100644
index 00000000000..23546a6f1f1
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/implicitCastInReturnFromConstructor.fir.kt.txt
@@ -0,0 +1,15 @@
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  constructor(x: Any?) {
+    this/*C*/()
+    when {
+      x is Unit -> return x /*as Unit */
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/implicitCastOnPlatformType.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitCastOnPlatformType.fir.kt.txt
new file mode 100644
index 00000000000..174fb1c518b
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/implicitCastOnPlatformType.fir.kt.txt
@@ -0,0 +1,3 @@
+fun test(): String {
+  return getProperty(p0 = "test") /*!! String */
+}
diff --git a/compiler/testData/ir/irText/expressions/implicitCastToNonNull.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitCastToNonNull.fir.kt.txt
new file mode 100644
index 00000000000..f1ea7098be2
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/implicitCastToNonNull.fir.kt.txt
@@ -0,0 +1,33 @@
+fun test1(x: String?): Int {
+  return when {
+    EQEQ(arg0 = x, arg1 = null) -> 0
+    else -> x /*as String */.<get-length>()
+  }
+}
+
+fun <T : CharSequence?> test2(x: T): Int {
+  return when {
+    EQEQ(arg0 = x, arg1 = null) -> 0
+    else -> x.<get-length>()
+  }
+}
+
+inline fun <reified T : CharSequence?> test3(x: Any): Int {
+  return when {
+    x !is T -> 0
+    else -> x /*as T */.<get-length>()
+  }
+}
+
+inline fun <reified T : CharSequence> test4(x: Any?): Int {
+  return when {
+    x !is T -> 0
+    else -> x /*as T */.<get-length>()
+  }
+}
+
+fun <T : S?, S : Any?> test5(x: T, fn: Function1<S, Unit>) {
+  when {
+    EQEQ(arg0 = x, arg1 = null).not() -> fn.invoke(p1 = x)
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.fir.kt.txt
new file mode 100644
index 00000000000..8afcaf303af
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/implicitCastToTypeParameter.fir.kt.txt
@@ -0,0 +1,35 @@
+inline fun <reified T : Any> Any.test1(): T? {
+  return when {
+    <this> is T -> <this>
+    else -> null
+  }
+}
+
+interface Foo<T : Any?> {
+
+}
+
+val <reified T : Any> Foo<T>.asT: T?
+  inline get(): T? {
+    return when {
+      <this> is T -> <this> /*as T */
+      else -> null
+    }
+  }
+
+class Bar<T : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun test(arg: Any) {
+    arg as T /*~> Unit */
+    <this>.useT(t = arg /*as T */)
+  }
+
+  fun useT(t: T) {
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt
new file mode 100644
index 00000000000..e4947d8c8b7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/implicitNotNullInDestructuringAssignment.fir.kt.txt
@@ -0,0 +1,13 @@
+operator fun J?.component1(): Int {
+  return 1
+}
+
+private operator fun J.component2(): Int {
+  return 2
+}
+
+fun test() {
+  val <destruct>: J? = j()
+  val a: Int = <destruct>.component1()
+  val b: Int = <destruct>.component2()
+}
diff --git a/compiler/testData/ir/irText/expressions/in.fir.kt.txt b/compiler/testData/ir/irText/expressions/in.fir.kt.txt
new file mode 100644
index 00000000000..e582eb28918
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/in.fir.kt.txt
@@ -0,0 +1,15 @@
+fun test1(a: Any, x: Collection<Any>): Boolean {
+  return x.contains(element = a)
+}
+
+fun test2(a: Any, x: Collection<Any>): Boolean {
+  return x.contains(element = a).not()
+}
+
+fun <T : Any?> test3(a: T, x: Collection<T>): Boolean {
+  return x.contains(element = a)
+}
+
+fun <T : Any?> test4(a: T, x: Collection<T>): Boolean {
+  return x.contains(element = a).not()
+}
diff --git a/compiler/testData/ir/irText/expressions/incrementDecrement.fir.kt.txt b/compiler/testData/ir/irText/expressions/incrementDecrement.fir.kt.txt
new file mode 100644
index 00000000000..ae5e74d0547
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/incrementDecrement.fir.kt.txt
@@ -0,0 +1,91 @@
+var p: Int
+  field = 0
+  get
+  set
+
+val arr: IntArray
+  field = intArrayOf(elements = [1, 2, 3])
+  get
+
+fun testVarPrefix() {
+  var x: Int = 0
+  val x1: Int = { // BLOCK
+    x = x.inc()
+    x
+  }
+  val x2: Int = { // BLOCK
+    x = x.dec()
+    x
+  }
+}
+
+fun testVarPostfix() {
+  var x: Int = 0
+  val x1: Int = { // BLOCK
+    val <unary>: Int = x
+    x = <unary>.inc()
+    <unary>
+  }
+  val x2: Int = { // BLOCK
+    val <unary>: Int = x
+    x = <unary>.dec()
+    <unary>
+  }
+}
+
+fun testPropPrefix() {
+  val p1: Int = { // BLOCK
+    <set-p>(<set-?> = <get-p>().inc())
+    <get-p>()
+  }
+  val p2: Int = { // BLOCK
+    <set-p>(<set-?> = <get-p>().dec())
+    <get-p>()
+  }
+}
+
+fun testPropPostfix() {
+  val p1: Int = { // BLOCK
+    val <unary>: Int = <get-p>()
+    <set-p>(<set-?> = <unary>.inc())
+    <unary>
+  }
+  val p2: Int = { // BLOCK
+    <set-p>(<set-?> = <get-p>().dec())
+    <get-p>()
+  }
+}
+
+fun testArrayPrefix() {
+  val a1: Int = { // BLOCK
+    val <array>: IntArray = <get-arr>()
+    val <index0>: Int = 0
+    val <unary-result>: Int = <array>.get(index = <index0>).inc()
+    <array>.set(index = <index0>, value = <unary-result>)
+    <unary-result>
+  }
+  val a2: Int = { // BLOCK
+    val <array>: IntArray = <get-arr>()
+    val <index0>: Int = 0
+    val <unary-result>: Int = <array>.get(index = <index0>).dec()
+    <array>.set(index = <index0>, value = <unary-result>)
+    <unary-result>
+  }
+}
+
+fun testArrayPostfix() {
+  val a1: Int = { // BLOCK
+    val <array>: IntArray = <get-arr>()
+    val <index0>: Int = 0
+    val <unary>: Int = <array>.get(index = <index0>)
+    <array>.set(index = <index0>, value = <unary>.inc())
+    <unary>
+  }
+  val a2: Int = { // BLOCK
+    val <array>: IntArray = <get-arr>()
+    val <index0>: Int = 0
+    val <unary>: Int = <array>.get(index = <index0>)
+    <array>.set(index = <index0>, value = <unary>.dec())
+    <unary>
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/javaSyntheticGenericPropertyAccess.fir.kt.txt b/compiler/testData/ir/irText/expressions/javaSyntheticGenericPropertyAccess.fir.kt.txt
new file mode 100644
index 00000000000..bc01ad1333c
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/javaSyntheticGenericPropertyAccess.fir.kt.txt
@@ -0,0 +1,9 @@
+fun <F : Any?> test(j: J<F>) {
+  j.getFoo() /*~> Unit */
+  j.setFoo(x = 1)
+  val <receiver>: J<F> = j
+  val <unary>: Int = <receiver>.getFoo()
+  <receiver>.setFoo(x = <unary>.inc())
+  <unary> /*~> Unit */
+  j.setFoo(x = j.getFoo().plus(other = 1))
+}
diff --git a/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.kt.txt b/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.kt.txt
new file mode 100644
index 00000000000..fce2040c4c7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/javaSyntheticPropertyAccess.fir.kt.txt
@@ -0,0 +1,9 @@
+fun test(j: J) {
+  j.getFoo() /*~> Unit */
+  j.setFoo(x = 1)
+  val <receiver>: J = j
+  val <unary>: Int = <receiver>.getFoo()
+  <receiver>.setFoo(x = <unary>.inc())
+  <unary> /*~> Unit */
+  j.setFoo(x = j.getFoo().plus(other = 1))
+}
diff --git a/compiler/testData/ir/irText/expressions/jvmFieldWithIntersectionTypes.fir.kt.txt b/compiler/testData/ir/irText/expressions/jvmFieldWithIntersectionTypes.fir.kt.txt
new file mode 100644
index 00000000000..19a6f58cbab
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/jvmFieldWithIntersectionTypes.fir.kt.txt
@@ -0,0 +1,67 @@
+interface IFoo {
+
+}
+
+class Derived1 : JFieldOwner, IFoo {
+  constructor() /* primary */ {
+    super/*JFieldOwner*/()
+    /* <init>() */
+
+  }
+
+}
+
+class Derived2 : JFieldOwner, IFoo {
+  constructor() /* primary */ {
+    super/*JFieldOwner*/()
+    /* <init>() */
+
+  }
+
+}
+
+open class Mid : JFieldOwner {
+  constructor() /* primary */ {
+    super/*JFieldOwner*/()
+    /* <init>() */
+
+  }
+
+}
+
+class DerivedThroughMid1 : Mid, IFoo {
+  constructor() /* primary */ {
+    super/*Mid*/()
+    /* <init>() */
+
+  }
+
+}
+
+class DerivedThroughMid2 : Mid, IFoo {
+  constructor() /* primary */ {
+    super/*Mid*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun test(b: Boolean) {
+  val d1: Derived1 = Derived1()
+  val d2: Derived2 = Derived2()
+  val k: JFieldOwner = when {
+    b -> d1
+    else -> d2
+  }
+  k.#f = 42
+  k.#f /*~> Unit */
+  val md1: DerivedThroughMid1 = DerivedThroughMid1()
+  val md2: DerivedThroughMid2 = DerivedThroughMid2()
+  val mk: Mid = when {
+    b -> md1
+    else -> md2
+  }
+  mk.#f = 44
+  mk.#f /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.fir.kt.txt
new file mode 100644
index 00000000000..242c7bc48aa
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.fir.kt.txt
@@ -0,0 +1,20 @@
+class Derived : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  init {
+    <this>.#value = 0
+  }
+
+  fun getValue(): Int {
+    return <this>.#value
+  }
+
+  fun setValue(value: Int) {
+    <this>.#value = value
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/jvmStaticFieldReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/jvmStaticFieldReference.fir.kt.txt
new file mode 100644
index 00000000000..30bafebac69
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/jvmStaticFieldReference.fir.kt.txt
@@ -0,0 +1,34 @@
+fun testFun() {
+  #out.println(p0 = "testFun")
+}
+
+var testProp: Any
+  get(): Any {
+    #out.println(p0 = "testProp/get")
+    return 42
+  }
+  set(value: Any) {
+    #out.println(p0 = "testProp/set")
+  }
+
+class TestClass {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val test: Int
+    field = when {
+      else -> { // BLOCK
+        #out.println(p0 = "TestClass/test")
+        42
+      }
+    }
+    get
+
+  init {
+    #out.println(p0 = "TestClass/init")
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/kt16904.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt16904.fir.kt.txt
new file mode 100644
index 00000000000..8505dcfe34f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt16904.fir.kt.txt
@@ -0,0 +1,53 @@
+abstract class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: B
+    field = B()
+    get
+
+  var y: Int
+    field = 0
+    get
+    set
+
+}
+
+class B {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun plusAssign(x: Int) {
+  }
+
+}
+
+class Test1 : A {
+  constructor() {
+    super/*A*/()
+    /* <init>() */
+
+    <this>.<get-x>().plusAssign(x = 42)
+    <this>.<set-y>(<set-?> = <this>.<get-y>().plus(other = 42))
+  }
+
+}
+
+class Test2 : J {
+  constructor() /* primary */ {
+    super/*J*/()
+    /* <init>() */
+
+  }
+
+  init {
+    <this>.#field = 42
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/kt16905.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt16905.fir.kt.txt
new file mode 100644
index 00000000000..a183fef06e5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt16905.fir.kt.txt
@@ -0,0 +1,40 @@
+typealias OI = Inner
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  open inner class Inner {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+  inner class InnerDerived0 : Inner {
+    constructor() /* primary */ {
+      <this>.super/*Inner*/()
+      /* <init>() */
+
+    }
+
+  }
+
+  inner class InnerDerived1 : Inner {
+    constructor() /* primary */ {
+      <this>.super/*Inner*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
+
+fun test(): Inner {
+  return Outer().Inner()
+}
diff --git a/compiler/testData/ir/irText/expressions/kt23030.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt23030.fir.kt.txt
new file mode 100644
index 00000000000..72c686100ce
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt23030.fir.kt.txt
@@ -0,0 +1,54 @@
+operator fun Int.compareTo(c: Char): Int {
+  return 0
+}
+
+fun testOverloadedCompareToCall(x: Int, y: Char): Boolean {
+  return less(arg0 = x.compareTo(c = y), arg1 = 0)
+}
+
+fun testOverloadedCompareToCallWithSmartCast(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Int -> y is Char
+      else -> false
+    } -> less(arg0 = x /*as Int */.compareTo(c = y /*as Char */), arg1 = 0)
+    else -> false
+  }
+}
+
+fun testEqualsWithSmartCast(x: Any, y: Any): Boolean {
+  return when {
+    when {
+      x is Int -> y is Char
+      else -> false
+    } -> EQEQ(arg0 = x /*as Int */, arg1 = y /*as Char */)
+    else -> false
+  }
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun Int.compareTo(c: Char): Int {
+    return 0
+  }
+
+  fun testMemberExtensionCompareToCall(x: Int, y: Char): Boolean {
+    return less(arg0 = (<this>, x).compareTo(c = y), arg1 = 0)
+  }
+
+  fun testMemberExtensionCompareToCallWithSmartCast(x: Any, y: Any): Boolean {
+    return when {
+      when {
+        x is Int -> y is Char
+        else -> false
+      } -> less(arg0 = (<this>, x /*as Int */).compareTo(c = y /*as Char */), arg1 = 0)
+      else -> false
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/kt24804.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt24804.fir.kt.txt
new file mode 100644
index 00000000000..509317c8937
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt24804.fir.kt.txt
@@ -0,0 +1,24 @@
+inline fun foo(): Boolean {
+  return false
+}
+
+fun run(x: Boolean, y: Boolean): String {
+  var z: Int = 10
+  l2@ do// COMPOSITE {
+  z = z.plus(other = 1)
+  when {
+    greater(arg0 = z, arg1 = 100) -> return "NOT_OK"
+  }
+  when {
+    x -> error("") /* ERROR EXPRESSION */
+  }
+  when {
+    y -> continue@l2
+  }
+  // }  while (foo())
+  return "OK"
+}
+
+fun box(): String {
+  return run(x = true, y = true)
+}
diff --git a/compiler/testData/ir/irText/expressions/kt27933.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt27933.fir.kt.txt
new file mode 100644
index 00000000000..d1e3e1b00d5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt27933.fir.kt.txt
@@ -0,0 +1,16 @@
+fun box(): String {
+  var r: String = ""
+  when {
+    EQEQ(arg0 = r, arg1 = "").not() -> { // BLOCK
+    }
+    else -> { // BLOCK
+      r = r.plus(other = "O")
+    }
+  }
+  when {
+    EQEQ(arg0 = r, arg1 = "O") -> { // BLOCK
+      r = r.plus(other = "K")
+    }
+  }
+  return r
+}
diff --git a/compiler/testData/ir/irText/expressions/kt28006.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt28006.fir.kt.txt
new file mode 100644
index 00000000000..930972b7920
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt28006.fir.kt.txt
@@ -0,0 +1,36 @@
+val test1: String
+  field = "\uD83E\uDD17"
+  get
+
+val test2: String
+  field = "\uD83E\uDD17\uD83E\uDD17"
+  get
+
+const val testConst1: String
+  field = "\uD83E\uDD17"
+  get
+
+const val testConst2: String
+  field = "\uD83E\uDD17\uD83E\uDD17"
+  get
+
+const val testConst3: String
+  field = "\uD83E\uDD17\uD83E\uDD17\uD83E\uDD17"
+  get
+
+const val testConst4: String
+  field = "\uD83E\uDD17\uD83E\uDD17\uD83E\uDD17\uD83E\uDD17"
+  get
+
+fun test1(x: Int): String {
+  return "\uD83E" + "\uDD17" + x.toString()
+}
+
+fun test2(x: Int): String {
+  return x.toString() + "\uD83E" + "\uDD17"
+}
+
+fun test3(x: Int): String {
+  return x.toString() + "\uD83E" + "\uDD17" + x.toString()
+}
+
diff --git a/compiler/testData/ir/irText/expressions/kt28456.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt28456.fir.kt.txt
new file mode 100644
index 00000000000..bea687736e0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt28456.fir.kt.txt
@@ -0,0 +1,39 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+operator fun A.get(vararg xs: Int): Int {
+  return 0
+}
+
+operator fun A.set(i: Int, j: Int, v: Int) {
+}
+
+fun testSimpleAssignment(a: A) {
+  a.set(i = 1, j = 2, v = 0)
+}
+
+fun testPostfixIncrement(a: A): Int {
+  return { // BLOCK
+    val <array>: A = a
+    val <index0>: Int = 1
+    val <index1>: Int = 2
+    val <unary>: Int = <array>.get(xs = [<index0>, <index1>])
+    <array>.set(i = <index0>, j = <index1>, v = <unary>.inc())
+    <unary>
+  }
+}
+
+fun testCompoundAssignment(a: A) {
+  { // BLOCK
+    val <<array>>: A = a
+    val <<index_0>>: Int = 1
+    val <<index_1>>: Int = 2
+    <<array>>.set(i = <<index_0>>, j = <<index_1>>, v = <<array>>.get(xs = [<<index_0>>, <<index_1>>]).plus(other = 10))
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/kt28456a.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt28456a.fir.kt.txt
new file mode 100644
index 00000000000..e336daf21c7
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt28456a.fir.kt.txt
@@ -0,0 +1,15 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+operator fun A.set(vararg i: Int, v: Int) {
+}
+
+fun testSimpleAssignment(a: A) {
+  a.set(i = [1, 2, 3], v = 0)
+}
diff --git a/compiler/testData/ir/irText/expressions/kt28456b.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt28456b.fir.kt.txt
new file mode 100644
index 00000000000..4261eb2d798
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt28456b.fir.kt.txt
@@ -0,0 +1,37 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+operator fun A.get(i: Int, a: Int = 1, b: Int = 2, c: Int = 3, d: Int = 4): Int {
+  return 0
+}
+
+operator fun A.set(i: Int, j: Int = 42, v: Int) {
+}
+
+fun testSimpleAssignment(a: A) {
+  a.set(i = 1, v = 0)
+}
+
+fun testPostfixIncrement(a: A): Int {
+  return { // BLOCK
+    val <array>: A = a
+    val <index0>: Int = 1
+    val <unary>: Int = <array>.get(i = <index0>)
+    <array>.set(i = <index0>, v = <unary>.inc())
+    <unary>
+  }
+}
+
+fun testCompoundAssignment(a: A) {
+  { // BLOCK
+    val <<array>>: A = a
+    val <<index_0>>: Int = 1
+    <<array>>.set(i = <<index_0>>, v = <<array>>.get(i = <<index_0>>).plus(other = 10))
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/kt30020.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt30020.fir.kt.txt
new file mode 100644
index 00000000000..fd3b77edb9d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt30020.fir.kt.txt
@@ -0,0 +1,58 @@
+interface X {
+  abstract val xs: MutableList<Any>
+    abstract get
+
+  abstract fun f(): MutableList<Any>
+
+}
+
+fun test(x: X, nx: X?) {
+  x.<get-xs>().plusAssign<Int>(element = 1)
+  x.f().plusAssign<Int>(element = 2)
+  x.<get-xs>() as MutableList<Int>.plusAssign<Int>(element = 3)
+  x.f() as MutableList<Int>.plusAssign<Int>(element = 4)
+  CHECK_NOT_NULL<MutableList<Any>>(arg0 = { // BLOCK
+    val tmp0_safe_receiver: X? = nx
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.<get-xs>()
+    }
+  }).plusAssign<Int>(element = 5)
+  CHECK_NOT_NULL<MutableList<Any>>(arg0 = { // BLOCK
+    val tmp1_safe_receiver: X? = nx
+    when {
+      EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+      else -> tmp1_safe_receiver.f()
+    }
+  }).plusAssign<Int>(element = 6)
+}
+
+fun MutableList<Any>.testExtensionReceiver() {
+  <this>.plusAssign<Int>(element = 100)
+}
+
+abstract class AML : MutableList<Int> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun testExplicitThis() {
+    <this>.plusAssign<Int>(element = 200)
+  }
+
+  inner class Inner {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    fun testOuterThis() {
+      <this>.plusAssign<Int>(element = 300)
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/kt30796.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt30796.fir.kt.txt
new file mode 100644
index 00000000000..f45cf10a60b
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt30796.fir.kt.txt
@@ -0,0 +1,85 @@
+fun <T : Any?> magic(): T {
+  return throw Exception()
+}
+
+fun <T : Any?> test(value: T, value2: T) {
+  val x1: Any = { // BLOCK
+    val <elvis>: T = value
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis>
+    }
+  }
+  val x2: Any = { // BLOCK
+    val <elvis>: T = value
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> { // BLOCK
+        val <elvis>: T = value2
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+          else -> <elvis>
+        }
+      }
+      else -> <elvis>
+    }
+  }
+  val x3: Any = { // BLOCK
+    val <elvis>: T = { // BLOCK
+      val <elvis>: T = value
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> value2
+        else -> <elvis>
+      }
+    }
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis>
+    }
+  }
+  val x4: Any = { // BLOCK
+    val <elvis>: T = { // BLOCK
+      val <elvis>: T = value
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> value2
+        else -> <elvis>
+      }
+    }
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis>
+    }
+  }
+  val x5: Any = { // BLOCK
+    val <elvis>: Int? = magic<Int?>()
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis> /*as Int */
+    }
+  }
+  val x6: Any = { // BLOCK
+    val <elvis>: T = { // BLOCK
+      val <elvis>: T = value
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> magic<T>()
+        else -> <elvis>
+      }
+    }
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis>
+    }
+  }
+  val x7: Any = { // BLOCK
+    val <elvis>: T? = { // BLOCK
+      val <elvis>: T? = magic<T?>()
+      when {
+        EQEQ(arg0 = <elvis>, arg1 = null) -> value
+        else -> <elvis> /*as T */
+      }
+    }
+    when {
+      EQEQ(arg0 = <elvis>, arg1 = null) -> 42
+      else -> <elvis> /*as T */
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/kt35730.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt35730.fir.kt.txt
new file mode 100644
index 00000000000..44446d56be0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt35730.fir.kt.txt
@@ -0,0 +1,19 @@
+interface Base {
+  fun foo() {
+  }
+
+}
+
+object Derived : Base {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun test() {
+  Derived.foo()
+  Derived.foo()
+}
diff --git a/compiler/testData/ir/irText/expressions/kt36956.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt36956.fir.kt.txt
new file mode 100644
index 00000000000..d5b48c07d6c
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt36956.fir.kt.txt
@@ -0,0 +1,33 @@
+class A<T : Any?> {
+  constructor(value: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  private val value: T
+    field = value
+    private get
+
+  operator fun get(i: Int): T {
+    return <this>.<get-value>()
+  }
+
+  operator fun set(i: Int, v: T) {
+  }
+
+}
+
+val aFloat: A<Float>
+  field = A<Float>(value = 0.0F)
+  get
+
+val aInt: Float
+  field = { // BLOCK
+    val <array>: A<Float> = <get-aFloat>()
+    val <index0>: Int = 1
+    val <unary>: Float = <array>.get(i = <index0>)
+    <array>.set(i = <index0>, v = <unary>.dec())
+    <unary>
+  }
+  get
diff --git a/compiler/testData/ir/irText/expressions/kt36963.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt36963.fir.kt.txt
new file mode 100644
index 00000000000..1121fbdab3a
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt36963.fir.kt.txt
@@ -0,0 +1,6 @@
+fun foo() {
+}
+
+fun test(): KFunction0<Unit> {
+  return CHECK_NOT_NULL<KFunction0<Unit>>(arg0 = ::foo)
+}
diff --git a/compiler/testData/ir/irText/expressions/kt37570.fir.kt.txt b/compiler/testData/ir/irText/expressions/kt37570.fir.kt.txt
new file mode 100644
index 00000000000..76ba6c9c5c6
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/kt37570.fir.kt.txt
@@ -0,0 +1,22 @@
+fun a(): String {
+  return "string"
+}
+
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val b: String
+    get
+
+  init {
+    a().apply<String>(block = local fun String.<anonymous>() {
+      <this>.#b = <this>
+    }
+) /*~> Unit */
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt
new file mode 100644
index 00000000000..f6c877506fb
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/lambdaInCAO.fir.kt.txt
@@ -0,0 +1,31 @@
+operator fun Any.plusAssign(lambda: Function0<Unit>) {
+}
+
+operator fun Any.get(index: Function0<Unit>): Int {
+  return 42
+}
+
+operator fun Any.set(index: Function0<Unit>, value: Int) {
+}
+
+fun test1(a: Any) {
+  a.plusAssign(lambda = local fun <anonymous>() {
+    return Unit
+  }
+)
+}
+
+fun test2(a: Any) {
+  error("") /* ERROR CALL */
+}
+
+fun test3(a: Any) {
+  val <array>: Any = a
+  val <index0>: Function0<Unit> = local fun <anonymous>() {
+    return Unit
+  }
+
+  val <unary>: Int = <array>.get(index = <index0>)
+  <array>.set(index = <index0>, value = <unary>.inc())
+  <unary> /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/literals.fir.kt.txt b/compiler/testData/ir/irText/expressions/literals.fir.kt.txt
new file mode 100644
index 00000000000..253306edf33
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/literals.fir.kt.txt
@@ -0,0 +1,67 @@
+val test1: Int
+  field = 1
+  get
+
+val test2: Int
+  field = -1
+  get
+
+val test3: Boolean
+  field = true
+  get
+
+val test4: Boolean
+  field = false
+  get
+
+val test5: String
+  field = "abc"
+  get
+
+val test6: Nothing?
+  field = null
+  get
+
+val test7: Long
+  field = 1L
+  get
+
+val test8: Long
+  field = 1L.unaryMinus()
+  get
+
+val test9: Double
+  field = 1.0D
+  get
+
+val test10: Double
+  field = 1.0D.unaryMinus()
+  get
+
+val test11: Float
+  field = 1.0F
+  get
+
+val test12: Float
+  field = 1.0F.unaryMinus()
+  get
+
+val test13: Char
+  field = 'a'
+  get
+
+val testB: Byte
+  field = 1B
+  get
+
+val testS: Short
+  field = 1S
+  get
+
+val testI: Int
+  field = 1
+  get
+
+val testL: Long
+  field = 1L
+  get
diff --git a/compiler/testData/ir/irText/expressions/multipleThisReferences.fir.kt.txt b/compiler/testData/ir/irText/expressions/multipleThisReferences.fir.kt.txt
new file mode 100644
index 00000000000..64218022524
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/multipleThisReferences.fir.kt.txt
@@ -0,0 +1,53 @@
+class Outer {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  open inner class Inner {
+    constructor(x: Int) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val x: Int
+      field = x
+      get
+
+  }
+
+}
+
+class Host {
+  constructor(y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val y: Int
+    field = y
+    get
+
+  fun Outer.test(): Inner {
+    return { // BLOCK
+      local class <no name provided> : Inner {
+        private constructor() /* primary */ {
+          <this>.super/*Inner*/(x = 42)
+          /* <init>() */
+
+        }
+
+        val xx: Int
+          field = <this>.<get-x>().plus(other = <this>.<get-y>())
+          get
+
+      }
+
+      <no name provided>()
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/nullCheckOnGenericLambdaReturn.fir.kt.txt b/compiler/testData/ir/irText/expressions/nullCheckOnGenericLambdaReturn.fir.kt.txt
new file mode 100644
index 00000000000..2aeea6b4888
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/nullCheckOnGenericLambdaReturn.fir.kt.txt
@@ -0,0 +1,47 @@
+fun checkAny(fn: Function0<Any>): Any {
+  return fn.invoke()
+}
+
+fun checkAnyN(fn: Function0<Any?>): Any? {
+  return fn.invoke()
+}
+
+fun <T : Any?> checkT(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun <T : Any> checkTAny(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun <T : Any?> id(x: T): T {
+  return x
+}
+
+fun test1(): String? {
+  return checkT<String?>(fn = local fun <anonymous>(): String? {
+    return foo()
+  }
+)
+}
+
+fun test2(): String {
+  return checkT<@EnhancedNullability String>(fn = local fun <anonymous>(): @EnhancedNullability String {
+    return nnFoo()
+  }
+) /*!! String */
+}
+
+fun test3(): String? {
+  return checkTAny<String?>(fn = local fun <anonymous>(): String? {
+    return foo()
+  }
+)
+}
+
+fun test4(): String {
+  return checkTAny<@EnhancedNullability String>(fn = local fun <anonymous>(): @EnhancedNullability String {
+    return nnFoo()
+  }
+) /*!! String */
+}
diff --git a/compiler/testData/ir/irText/expressions/nullCheckOnLambdaReturn.fir.kt.txt b/compiler/testData/ir/irText/expressions/nullCheckOnLambdaReturn.fir.kt.txt
new file mode 100644
index 00000000000..a4286acb737
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/nullCheckOnLambdaReturn.fir.kt.txt
@@ -0,0 +1,53 @@
+fun checkAny(fn: Function0<Any>): Any {
+  return fn.invoke()
+}
+
+fun checkAnyN(fn: Function0<Any?>): Any? {
+  return fn.invoke()
+}
+
+fun <T : Any?> id(x: T): T {
+  return x
+}
+
+fun test1(): Any {
+  return checkAny(fn = local fun <anonymous>(): Any {
+    return foo() /*!! String */
+  }
+)
+}
+
+val test2: Function0<Any>
+  field = local fun <anonymous>(): String? {
+    return foo()
+  }
+
+  get
+
+val test3: Function0<Any>
+  field = local fun <anonymous>(): String? {
+    return foo()
+  }
+ as Function0<Any>
+  get
+
+val test4: Function0<Any>
+  field = id<Function0<String?>>(x = local fun <anonymous>(): String? {
+    return foo()
+  }
+)
+  get
+
+fun test5(): Any? {
+  return checkAnyN(fn = local fun <anonymous>(): Any? {
+    return foo()
+  }
+)
+}
+
+fun test6(): Any? {
+  return checkAnyN(fn = local fun <anonymous>(): Any? {
+    return nnFoo()
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/expressions/objectAsCallable.fir.kt.txt b/compiler/testData/ir/irText/expressions/objectAsCallable.fir.kt.txt
new file mode 100644
index 00000000000..11639efa551
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/objectAsCallable.fir.kt.txt
@@ -0,0 +1,39 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+enum class En : Enum<En> {
+  private constructor() /* primary */ {
+    super/*Enum*/<En>()
+    /* <init>() */
+
+  }
+
+  X = En()
+
+  fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): En /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+operator fun A.invoke(i: Int): Int {
+  return i
+}
+
+operator fun En.invoke(i: Int): Int {
+  return i
+}
+
+val test1: Int
+  field = A.invoke(i = 42)
+  get
+
+val test2: Int
+  field = En.X.invoke(i = 42)
+  get
diff --git a/compiler/testData/ir/irText/expressions/objectByNameInsideObject.fir.kt.txt b/compiler/testData/ir/irText/expressions/objectByNameInsideObject.fir.kt.txt
new file mode 100644
index 00000000000..48a45ae537a
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/objectByNameInsideObject.fir.kt.txt
@@ -0,0 +1,32 @@
+open class Base {
+  constructor(f1: Function0<Any>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val f1: Function0<Any>
+    field = f1
+    get
+
+}
+
+object Thing : Base {
+  private constructor() /* primary */ {
+    super/*Base*/(f1 = local fun <anonymous>(): Any {
+      return Thing
+    }
+)
+    /* <init>() */
+
+  }
+
+  fun test1(): Thing {
+    return Thing
+  }
+
+  fun test2(): Thing {
+    return <this>
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/objectReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/objectReference.fir.kt.txt
new file mode 100644
index 00000000000..a079149616d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/objectReference.fir.kt.txt
@@ -0,0 +1,92 @@
+object Z {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var counter: Int
+    field = 0
+    get
+    set
+
+  fun foo() {
+  }
+
+  fun bar() {
+    <this>.<set-counter>(<set-?> = 1)
+    <this>.foo()
+    Z.<set-counter>(<set-?> = 1)
+    Z.foo()
+  }
+
+  class Nested {
+    constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    init {
+      Z.<set-counter>(<set-?> = 1)
+      Z.foo()
+      Z.<set-counter>(<set-?> = 1)
+      Z.foo()
+    }
+
+    fun test() {
+      Z.<set-counter>(<set-?> = 1)
+      Z.foo()
+      Z.<set-counter>(<set-?> = 1)
+      Z.foo()
+    }
+
+  }
+
+  val aLambda: Function0<Unit>
+    field = local fun <anonymous>() {
+      <this>.<set-counter>(<set-?> = 1)
+      <this>.foo()
+      Z.<set-counter>(<set-?> = 1)
+      Z.foo()
+    }
+
+    get
+
+  val anObject: <no name provided>
+    field = { // BLOCK
+      local class <no name provided> {
+        private constructor() /* primary */ {
+          super/*Any*/()
+          /* <init>() */
+
+        }
+
+        init {
+          Z.<set-counter>(<set-?> = 1)
+          Z.foo()
+          Z.<set-counter>(<set-?> = 1)
+          Z.foo()
+        }
+
+        fun test() {
+          Z.<set-counter>(<set-?> = 1)
+          Z.foo()
+          Z.<set-counter>(<set-?> = 1)
+          Z.foo()
+        }
+
+      }
+
+      <no name provided>()
+    }
+    get
+
+}
+
+fun Z.test() {
+  <this>.<set-counter>(<set-?> = 1)
+  <this>.foo()
+  Z.<set-counter>(<set-?> = 1)
+  Z.foo()
+}
diff --git a/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..b2e99c61e65
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/objectReferenceInClosureInSuperConstructorCall.fir.kt.txt
@@ -0,0 +1,24 @@
+abstract class Base {
+  constructor(lambda: Function0<Any>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val lambda: Function0<Any>
+    field = lambda
+    get
+
+}
+
+object Test : Base {
+  private constructor() /* primary */ {
+    super/*Base*/(lambda = local fun <anonymous>(): Any {
+      return Test
+    }
+)
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/objectReferenceInFieldInitializer.fir.kt.txt b/compiler/testData/ir/irText/expressions/objectReferenceInFieldInitializer.fir.kt.txt
new file mode 100644
index 00000000000..c6c1947e457
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/objectReferenceInFieldInitializer.fir.kt.txt
@@ -0,0 +1,20 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  private val a: String
+    field = "$"
+    private get
+
+  private val b: String
+    field = "1234" + <this>.<get-a>().toString()
+    private get
+
+  private val c: Int
+    field = 10000
+    private get
+
+}
diff --git a/compiler/testData/ir/irText/expressions/primitivesImplicitConversions.fir.kt.txt b/compiler/testData/ir/irText/expressions/primitivesImplicitConversions.fir.kt.txt
new file mode 100644
index 00000000000..0462a5c1fc5
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/primitivesImplicitConversions.fir.kt.txt
@@ -0,0 +1,49 @@
+val test1: Long
+  field = 42L
+  get
+
+val test2: Short
+  field = 42S
+  get
+
+val test3: Byte
+  field = 42B
+  get
+
+val test4: Long
+  field = 42.unaryMinus()
+  get
+
+val test5: Short
+  field = 42.unaryMinus()
+  get
+
+val test6: Byte
+  field = 42.unaryMinus()
+  get
+
+fun test() {
+  val test1: Int? = 42
+  val test2: Long = 42L
+  val test3: Long? = 42L
+  val test4: Long? = -1L
+  val test5: Long? = -1
+  val test6: Short? = -1
+  val test7: Byte? = -1
+}
+
+fun testImplicitArguments(x: Long = -1) {
+}
+
+class TestImplicitArguments {
+  constructor(x: Long = -1) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Long
+    field = x
+    get
+
+}
diff --git a/compiler/testData/ir/irText/expressions/propertyReferences.fir.kt.txt b/compiler/testData/ir/irText/expressions/propertyReferences.fir.kt.txt
new file mode 100644
index 00000000000..7e089c78274
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/propertyReferences.fir.kt.txt
@@ -0,0 +1,131 @@
+object Delegate {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  operator fun getValue(thisRef: Any?, kProp: Any): Int {
+    return 1
+  }
+
+  operator fun setValue(thisRef: Any?, kProp: Any, value: Int) {
+  }
+
+}
+
+open class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var varWithPrivateSet: Int
+    field = 1
+    get
+    private set
+
+  var varWithProtectedSet: Int
+    field = 1
+    get
+    protected set
+
+}
+
+val valWithBackingField: Int
+  field = 1
+  get
+
+val test_valWithBackingField: KProperty0<Int>
+  field = ::valWithBackingField
+  get
+
+var varWithBackingField: Int
+  field = 1
+  get
+  set
+
+val test_varWithBackingField: KMutableProperty0<Int>
+  field = ::varWithBackingField
+  get
+
+var varWithBackingFieldAndAccessors: Int
+  field = 1
+  get(): Int {
+    return #varWithBackingFieldAndAccessors
+  }
+  set(value: Int) {
+    #varWithBackingFieldAndAccessors = value
+  }
+
+val test_varWithBackingFieldAndAccessors: KMutableProperty0<Int>
+  field = ::varWithBackingFieldAndAccessors
+  get
+
+val valWithAccessors: Int
+  get(): Int {
+    return 1
+  }
+
+val test_valWithAccessors: KProperty0<Int>
+  field = ::valWithAccessors
+  get
+
+var varWithAccessors: Int
+  get(): Int {
+    return 1
+  }
+  set(value: Int) {
+  }
+
+val test_varWithAccessors: KMutableProperty0<Int>
+  field = ::varWithAccessors
+  get
+
+val delegatedVal: Int /* by */
+  field = Delegate
+  get(): Int {
+    return #delegatedVal$delegate.getValue(thisRef = null, kProp = ::delegatedVal)
+  }
+
+val test_delegatedVal: KProperty0<Int>
+  field = ::delegatedVal
+  get
+
+var delegatedVar: Int /* by */
+  field = Delegate
+  get(): Int {
+    return #delegatedVar$delegate.getValue(thisRef = null, kProp = ::delegatedVar)
+  }
+  set(<set-?>: Int) {
+    #delegatedVar$delegate.setValue(thisRef = null, kProp = ::delegatedVar, value = <set-?>)
+  }
+
+val test_delegatedVar: KMutableProperty0<Int>
+  field = ::delegatedVar
+  get
+
+val constVal: Int
+  field = 1
+  get
+
+val test_constVal: KProperty0<Int>
+  field = ::constVal
+  get
+
+val test_J_CONST: KProperty0<Int>
+  field = J::CONST/*</* null */>()*/
+  get
+
+val test_J_nonConst: KMutableProperty0<Int>
+  field = J::nonConst/*</* null */>()*/
+  get
+
+val test_varWithPrivateSet: KProperty1<C, Int>
+  field = C::varWithPrivateSet
+  get
+
+val test_varWithProtectedSet: KProperty1<C, Int>
+  field = C::varWithProtectedSet
+  get
diff --git a/compiler/testData/ir/irText/expressions/reflectionLiterals.fir.kt.txt b/compiler/testData/ir/irText/expressions/reflectionLiterals.fir.kt.txt
new file mode 100644
index 00000000000..13152677fbc
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/reflectionLiterals.fir.kt.txt
@@ -0,0 +1,42 @@
+class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun foo() {
+  }
+
+}
+
+fun bar() {
+}
+
+val qux: Int
+  field = 1
+  get
+
+val test1: KClass<A>
+  field = A::class
+  get
+
+val test2: KClass<Int>
+  field = <get-qux>()::class
+  get
+
+val test3: KFunction1<A, Unit>
+  field = A::foo
+  get
+
+val test4: KFunction0<A>
+  field = A::<init>
+  get
+
+val test5: KFunction0<Unit>
+  field = A()::foo
+  get
+
+val test6: KFunction0<Unit>
+  field = ::bar
+  get
diff --git a/compiler/testData/ir/irText/expressions/safeAssignment.fir.kt.txt b/compiler/testData/ir/irText/expressions/safeAssignment.fir.kt.txt
new file mode 100644
index 00000000000..a44b20dfee8
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/safeAssignment.fir.kt.txt
@@ -0,0 +1,23 @@
+class C {
+  constructor(x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var x: Int
+    field = x
+    get
+    set
+
+}
+
+fun test(nc: C?) {
+  { // BLOCK
+    val tmp0_safe_receiver: C? = nc
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.<set-x>(<set-?> = 42)
+    }
+  } /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/safeCallWithIncrementDecrement.fir.kt.txt b/compiler/testData/ir/irText/expressions/safeCallWithIncrementDecrement.fir.kt.txt
new file mode 100644
index 00000000000..ea0d8518045
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/safeCallWithIncrementDecrement.fir.kt.txt
@@ -0,0 +1,66 @@
+package test
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+var C?.p: Int
+  get(): Int {
+    return 42
+  }
+  set(value: Int) {
+  }
+
+operator fun Int?.inc(): Int? {
+  return { // BLOCK
+    val tmp0_safe_receiver: Int? = <this>
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.inc()
+    }
+  }
+}
+
+operator fun Int?.get(index: Int): Int {
+  return 42
+}
+
+operator fun Int?.set(index: Int, value: Int) {
+}
+
+fun testProperty(nc: C?) {
+  val <unary>: Int? = { // BLOCK
+    val tmp1_safe_receiver: C? = nc
+    when {
+      EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+      else -> tmp1_safe_receiver.<get-p>()
+    }
+  }
+  { // BLOCK
+    val tmp2_safe_receiver: C? = nc
+    when {
+      EQEQ(arg0 = tmp2_safe_receiver, arg1 = null) -> null
+      else -> tmp2_safe_receiver.<set-p>(value = <unary>.inc())
+    }
+  } /*~> Unit */
+  <unary> /*~> Unit */
+}
+
+fun testArrayAccess(nc: C?) {
+  val <array>: Int? = { // BLOCK
+    val tmp3_safe_receiver: C? = nc
+    when {
+      EQEQ(arg0 = tmp3_safe_receiver, arg1 = null) -> null
+      else -> tmp3_safe_receiver.<get-p>()
+    }
+  }
+  val <index0>: Int = 0
+  val <unary>: Int = <array>.get(index = <index0>)
+  <array>.set(index = <index0>, value = <unary>.inc())
+  <unary> /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/safeCalls.fir.kt.txt b/compiler/testData/ir/irText/expressions/safeCalls.fir.kt.txt
new file mode 100644
index 00000000000..9805859fa15
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/safeCalls.fir.kt.txt
@@ -0,0 +1,84 @@
+class Ref {
+  constructor(value: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var value: Int
+    field = value
+    get
+    set
+
+}
+
+interface IHost {
+  fun String.extLength(): Int {
+    return <this>.<get-length>()
+  }
+
+}
+
+fun test1(x: String?): Int? {
+  return { // BLOCK
+    val tmp0_safe_receiver: String? = x
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.<get-length>()
+    }
+  }
+}
+
+fun test2(x: String?): Int? {
+  return { // BLOCK
+    val tmp1_safe_receiver: String? = x
+    when {
+      EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+      else -> tmp1_safe_receiver.hashCode()
+    }
+  }
+}
+
+fun test3(x: String?, y: Any?): Boolean? {
+  return { // BLOCK
+    val tmp2_safe_receiver: String? = x
+    when {
+      EQEQ(arg0 = tmp2_safe_receiver, arg1 = null) -> null
+      else -> tmp2_safe_receiver.equals(other = y)
+    }
+  }
+}
+
+fun test4(x: Ref?) {
+  { // BLOCK
+    val tmp3_safe_receiver: Ref? = x
+    when {
+      EQEQ(arg0 = tmp3_safe_receiver, arg1 = null) -> null
+      else -> tmp3_safe_receiver.<set-value>(<set-?> = 0)
+    }
+  } /*~> Unit */
+}
+
+fun IHost.test5(s: String?): Int? {
+  return { // BLOCK
+    val tmp4_safe_receiver: String? = s
+    when {
+      EQEQ(arg0 = tmp4_safe_receiver, arg1 = null) -> null
+      else -> (<this>, tmp4_safe_receiver).extLength()
+    }
+  }
+}
+
+fun Int.foo(): Int {
+  return 239
+}
+
+fun box() {
+  { // BLOCK
+    val tmp5_safe_receiver: Int = 42
+    when {
+      EQEQ(arg0 = tmp5_safe_receiver, arg1 = null) -> null
+      else -> tmp5_safe_receiver.foo()
+    }
+  } /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/arrayAsVarargAfterSamArgument.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/arrayAsVarargAfterSamArgument.fir.kt.txt
new file mode 100644
index 00000000000..77f1971f85c
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/arrayAsVarargAfterSamArgument.fir.kt.txt
@@ -0,0 +1,68 @@
+fun test(fn: Function0<Unit>, r: Runnable, arr: Array<String>) {
+  error("") /* ERROR CALL */local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+  foo1(r = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, strs = [*arr]) /*~> Unit */
+  error("") /* ERROR CALL */fn; arr;
+  foo1(r = fn /*-> Runnable? */, strs = [*arr]) /*~> Unit */
+  foo1(r = r, strs = [""]) /*~> Unit */
+  error("") /* ERROR CALL */fn; arr;
+  foo1(r = fn /*-> Runnable? */, strs = [*arr]) /*~> Unit */
+  foo1(r = r, strs = [*arr]) /*~> Unit */
+  val i1: ErrorType /* ERROR */ = error("") /* ERROR CALL */local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+  val i2: Test = Test(r = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, strs = [*arr])
+  val i3: ErrorType /* ERROR */ = error("") /* ERROR CALL */local fun <anonymous>() {
+    return Unit
+  }
+; local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+  val i4: Test = Test(r1 = r, r2 = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, strs = [""])
+  val i5: Test = Test(r1 = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, r2 = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, strs = [*arr])
+  val i6: Test = Test(r1 = r, r2 = local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable? */, strs = [*arr])
+  error("") /* ERROR CALL */local fun <anonymous>() {
+    return Unit
+  }
+; local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+  error("") /* ERROR CALL */r; local fun <anonymous>() {
+    return Unit
+  }
+; "";
+  error("") /* ERROR CALL */local fun <anonymous>() {
+    return Unit
+  }
+; local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+  error("") /* ERROR CALL */r; local fun <anonymous>() {
+    return Unit
+  }
+; arr;
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/genericSamProjectedOut.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/genericSamProjectedOut.fir.kt.txt
new file mode 100644
index 00000000000..dbc03ed47f0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/genericSamProjectedOut.fir.kt.txt
@@ -0,0 +1,14 @@
+fun test(a: SomeJavaClass<out String>) {
+  a.someFunction(hello = local fun <anonymous>(it: String?) {
+    return Unit
+  }
+ /*-> Hello<Any?>? */)
+  a.plus(hello = local fun <anonymous>(it: String?) {
+    return Unit
+  }
+ /*-> Hello<Any?>? */)
+  a.get(hello = local fun <anonymous>(it: String?) {
+    return Unit
+  }
+ /*-> Hello<Any?>? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/genericSamSmartcast.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/genericSamSmartcast.fir.kt.txt
new file mode 100644
index 00000000000..869b1c4a1ec
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/genericSamSmartcast.fir.kt.txt
@@ -0,0 +1,9 @@
+fun f(x: Any): String {
+  when {
+    x is A<*> -> return x /*as A<*> */.call(block = local fun <anonymous>(y: Any?): String? {
+      return "OK"
+    }
+ /*-> I<Any?>? */) /*!! String */
+  }
+  return "Fail"
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samByProjectedType.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samByProjectedType.fir.kt.txt
new file mode 100644
index 00000000000..1aeceb64953
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samByProjectedType.fir.kt.txt
@@ -0,0 +1,6 @@
+fun test1() {
+  bar(j = local fun <anonymous>(x: Any): Any? {
+    return x
+  }
+ /*-> J<*>? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConstructors.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConstructors.fir.kt.txt
new file mode 100644
index 00000000000..0248a8a9153
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConstructors.fir.kt.txt
@@ -0,0 +1,24 @@
+fun test1(): Runnable {
+  return local fun <anonymous>() {
+    return Unit
+  }
+ /*-> Runnable */
+}
+
+fun test2(a: Function0<Unit>): Runnable {
+  return a /*-> Runnable */
+}
+
+fun foo() {
+}
+
+fun test3(): Runnable {
+  return ::foo /*-> Runnable */
+}
+
+fun test4(): Comparator<Int?> {
+  return local fun <anonymous>(a: Int?, b: Int?): Int {
+    return a.minus(other = b /*!! Int */)
+  }
+ /*-> Comparator<Int?> */
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..53195465e1f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall.fir.kt.txt
@@ -0,0 +1,8 @@
+fun test1(f: Function1<String, String>): C<String?> {
+  return C<String?>(jxx = f /*-> J<X?, X?>? */)
+}
+
+fun test2(x: Any) {
+  x as Function1<String, String> /*~> Unit */
+  C<String?>(jxx = x /*as Function1<String, String> */ /*-> J<X?, X?>? */) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall_NI.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall_NI.fir.kt.txt
new file mode 100644
index 00000000000..fcde5506071
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConversionInGenericConstructorCall_NI.fir.kt.txt
@@ -0,0 +1,42 @@
+fun test3(f1: Function1<String, String>, f2: Function1<Int, String>): D<Int?, String?> {
+  return C<String?>(jxx = f1 /*-> J<X?, X?>? */).D<Int?>(jxy = f2 /*-> J<String?, Y?>? */)
+}
+
+class Outer<T1 : Any?> {
+  constructor(j11: J<T1, T1>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val j11: J<T1, T1>
+    field = j11
+    get
+
+  inner class Inner<T2 : Any?> {
+    constructor(j12: J<T1, T2>) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val j12: J<T1, T2>
+      field = j12
+      get
+
+  }
+
+}
+
+fun test4(f: Function1<String, String>, g: Function1<Any, String>): Inner<Any?, String?> {
+  return Outer<String?>(j11 = f /*-> J<T1, T1> */).Inner<Any?>(j12 = g /*-> J<String?, T2> */)
+}
+
+fun testGenericJavaCtor1(f: Function1<String, Int>): G<String?> {
+  return G<String?, Int?>(x = f /*-> J<TCtor?, TClass?>? */)
+}
+
+fun testGenericJavaCtor2(x: Any) {
+  x as Function1<String, Int> /*~> Unit */
+  G<String?, Int?>(x = x /*as Function1<String, Int> */ /*-> J<TCtor?, TClass?>? */) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt
new file mode 100644
index 00000000000..d0245f2b431
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConversionToGeneric.fir.kt.txt
@@ -0,0 +1,51 @@
+fun test1(): J<String?> {
+  return local fun <anonymous>(x: String?): String? {
+    return x
+  }
+ /*-> J<String?> */
+}
+
+fun test2(): J<String?> {
+  return local fun <anonymous>(x: String): String {
+    return x
+  }
+ /*-> J<String?> */
+}
+
+fun test3() {
+  return bar<String?>(j = local fun <anonymous>(x: String): String {
+    return x
+  }
+ /*-> J<X?>? */)
+}
+
+fun test4(a: Any) {
+  a as J<String> /*~> Unit */
+  bar<String?>(j = a /*as J<String> */)
+}
+
+fun test5(a: Any) {
+  a as Function1<String, String> /*~> Unit */
+  bar<String?>(j = a /*as Function1<String, String> */ /*-> J<X?>? */)
+}
+
+fun <T : Any?> test6(a: Function1<T, T>) {
+  bar<T?>(j = a /*-> J<X?>? */)
+}
+
+fun <T : Any?> test7(a: Any) {
+  a as Function1<T, T> /*~> Unit */
+  bar<T?>(j = a /*as Function1<T, T> */ /*-> J<X?>? */)
+}
+
+fun test8(efn: @ExtensionFunctionType @ExtensionFunctionType Function1<String, String>): J<String?> {
+  return efn /*-> J<String?> */
+}
+
+fun test9(efn: @ExtensionFunctionType @ExtensionFunctionType Function1<String, String>) {
+  bar<String?>(j = efn /*-> J<X?>? */)
+}
+
+fun test10(fn: Function1<Int, String>) {
+  bar2x<Int?>(j2x = fn /*-> J2X<Y?>? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConversions.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversions.fir.kt.txt
new file mode 100644
index 00000000000..0c781d0237f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConversions.fir.kt.txt
@@ -0,0 +1,29 @@
+fun J.test0(a: Runnable) {
+  runStatic(r = a)
+  <this>.runIt(r = a)
+}
+
+fun test1() {
+  runStatic(r = local fun <anonymous>() {
+    test1()
+  }
+ /*-> Runnable? */)
+}
+
+fun J.test2() {
+  <this>.runIt(r = local fun <anonymous>() {
+    test1()
+  }
+ /*-> Runnable? */)
+}
+
+fun J.test3(a: Function0<Unit>) {
+  <this>.run2(r1 = a /*-> Runnable? */, r2 = a /*-> Runnable? */)
+}
+
+fun J.test4(a: Function0<Unit>, b: Function0<Unit>, flag: Boolean) {
+  <this>.runIt(r = when {
+    flag -> a
+    else -> b
+  } /*-> Runnable? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samConversionsWithSmartCasts.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samConversionsWithSmartCasts.fir.kt.txt
new file mode 100644
index 00000000000..cf210020075
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samConversionsWithSmartCasts.fir.kt.txt
@@ -0,0 +1,56 @@
+fun test1(a: Function0<Unit>) {
+  when {
+    a is Runnable -> runStatic(r = a /*as Runnable */)
+  }
+}
+
+fun test2(a: Function0<Unit>) {
+  when {
+    a is Runnable -> J().run1(r = a /*as Runnable */)
+  }
+}
+
+fun test3(a: Function0<Unit>) {
+  when {
+    a is Runnable -> J().run2(r1 = a /*as Runnable */, r2 = a /*as Runnable */)
+  }
+}
+
+fun test4(a: Function0<Unit>, b: Function0<Unit>) {
+  when {
+    a is Runnable -> J().run2(r1 = a /*as Runnable */, r2 = b /*-> Runnable? */)
+  }
+}
+
+fun test5(a: Any) {
+  when {
+    a is Runnable -> J().run1(r = a /*as Runnable */)
+  }
+}
+
+fun test5x(a: Any) {
+  when {
+    a is Runnable -> { // BLOCK
+      a /*as Runnable */ as Function0<Unit> /*~> Unit */
+      J().run1(r = a /*as Runnable */)
+    }
+  }
+}
+
+fun test6(a: Any) {
+  a as Function0<Unit> /*~> Unit */
+  J().run1(r = a /*as Function0<Unit> */ /*-> Runnable? */)
+}
+
+fun test7(a: Function1<Int, Int>) {
+  a as Function0<Unit> /*~> Unit */
+  error("") /* ERROR CALL */a /*as Function0<Unit> */;
+}
+
+fun test8(a: Function0<Unit>) {
+  error("") /* ERROR CALL */id<Function0<Unit>?>(x = a);
+}
+
+fun test9() {
+  J().run1(r = ::test9 /*-> Runnable? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/sam/samOperators.fir.kt.txt b/compiler/testData/ir/irText/expressions/sam/samOperators.fir.kt.txt
new file mode 100644
index 00000000000..3ec22f65775
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/sam/samOperators.fir.kt.txt
@@ -0,0 +1,17 @@
+fun f() {
+}
+
+fun J.test1() {
+  <this>.get(k = ::f /*-> Runnable? */)
+  <this>.get(k = ::f /*-> Runnable? */, m = ::f /*-> Runnable? */)
+}
+
+fun J.test2() {
+  <this>.set(k = ::f /*-> Runnable? */, v = ::f /*-> Runnable? */)
+  <this>.set(k = ::f /*-> Runnable? */, m = ::f /*-> Runnable? */, v = ::f /*-> Runnable? */)
+}
+
+fun J.test3() {
+  <this>.plusAssign(i = ::f /*-> Runnable? */)
+  <this>.minusAssign(i = ::f /*-> Runnable? */)
+}
diff --git a/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.fir.kt.txt b/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.fir.kt.txt
new file mode 100644
index 00000000000..6d79a354a8d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.fir.kt.txt
@@ -0,0 +1,16 @@
+class Derived : Base {
+  constructor() /* primary */ {
+    super/*Base*/()
+    /* <init>() */
+
+  }
+
+  fun setValue(v: Any) {
+    when {
+      v is String -> { // BLOCK
+        <this>.#value = v /*as String */
+      }
+    }
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_annotation.fir.kt.txt b/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_annotation.fir.kt.txt
new file mode 100644
index 00000000000..9acc6bebb01
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_annotation.fir.kt.txt
@@ -0,0 +1,6 @@
+package kotlin.internal
+
+annotation class ImplicitIntegerCoercion : Annotation {
+  constructor() /* primary */
+
+}
diff --git a/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_test.fir.kt.txt b/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_test.fir.kt.txt
new file mode 100644
index 00000000000..04c0939354d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/signedToUnsignedConversions_test.fir.kt.txt
@@ -0,0 +1,57 @@
+@ImplicitIntegerCoercion
+const val IMPLICIT_INT: Int
+  field = 255
+  get
+
+@ImplicitIntegerCoercion
+const val EXPLICIT_INT: Int
+  field = 255
+  get
+
+@ImplicitIntegerCoercion
+const val LONG_CONST: Long
+  field = 255L
+  get
+
+@ImplicitIntegerCoercion
+val NON_CONST: Int
+  field = 255
+  get
+
+@ImplicitIntegerCoercion
+const val BIGGER_THAN_UBYTE: Int
+  field = 256
+  get
+
+@ImplicitIntegerCoercion
+const val UINT_CONST: UInt
+  field = 42
+  get
+
+fun takeUByte(@ImplicitIntegerCoercion u: UByte) {
+}
+
+fun takeUShort(@ImplicitIntegerCoercion u: UShort) {
+}
+
+fun takeUInt(@ImplicitIntegerCoercion u: UInt) {
+}
+
+fun takeULong(@ImplicitIntegerCoercion u: ULong) {
+}
+
+fun takeUBytes(@ImplicitIntegerCoercion vararg u: UByte) {
+}
+
+fun takeLong(@ImplicitIntegerCoercion l: Long) {
+}
+
+fun test() {
+  error("") /* ERROR CALL */255;
+  error("") /* ERROR CALL */255;
+  error("") /* ERROR CALL */255;
+  error("") /* ERROR CALL */256;
+  error("") /* ERROR CALL */255;
+  error("") /* ERROR CALL */255;
+  error("") /* ERROR CALL */255; 255; 42;
+}
diff --git a/compiler/testData/ir/irText/expressions/simpleUnaryOperators.fir.kt.txt b/compiler/testData/ir/irText/expressions/simpleUnaryOperators.fir.kt.txt
new file mode 100644
index 00000000000..dd9a2cdcd72
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/simpleUnaryOperators.fir.kt.txt
@@ -0,0 +1,23 @@
+fun test1(x: Int): Int {
+  return x.unaryMinus()
+}
+
+fun test2(): Int {
+  return -42
+}
+
+fun test3(x: Int): Int {
+  return x.unaryPlus()
+}
+
+fun test4(): Int {
+  return 42
+}
+
+fun test5(x: Boolean): Boolean {
+  return x.not()
+}
+
+fun test6(): Boolean {
+  return false
+}
diff --git a/compiler/testData/ir/irText/expressions/smartCastsWithDestructuring.fir.kt.txt b/compiler/testData/ir/irText/expressions/smartCastsWithDestructuring.fir.kt.txt
new file mode 100644
index 00000000000..077e7fa05d0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/smartCastsWithDestructuring.fir.kt.txt
@@ -0,0 +1,24 @@
+interface I1 {
+
+}
+
+interface I2 {
+
+}
+
+operator fun I1.component1(): Int {
+  return 1
+}
+
+operator fun I2.component2(): String {
+  return ""
+}
+
+fun test(x: I1) {
+  when {
+    x !is I2 -> return Unit
+  }
+  val <destruct>: I2 = x /*as I2 */
+  val c1: Int = <destruct>.component1()
+  val c2: String = <destruct>.component2()
+}
diff --git a/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..1fea8c4a1aa
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.fir.kt.txt
@@ -0,0 +1,17 @@
+typealias IntAlias = Cell<Int>
+class Cell<T : Any?> {
+  constructor(value: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+}
+
+fun test(): Cell<Int> {
+  return Cell<Any?>(value = 42)
+}
diff --git a/compiler/testData/ir/irText/expressions/stringComparisons.fir.kt.txt b/compiler/testData/ir/irText/expressions/stringComparisons.fir.kt.txt
new file mode 100644
index 00000000000..b0e6c856350
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/stringComparisons.fir.kt.txt
@@ -0,0 +1,15 @@
+fun test1(a: String, b: String): Boolean {
+  return greater(arg0 = a.compareTo(other = b), arg1 = 0)
+}
+
+fun test2(a: String, b: String): Boolean {
+  return less(arg0 = a.compareTo(other = b), arg1 = 0)
+}
+
+fun test3(a: String, b: String): Boolean {
+  return greaterOrEqual(arg0 = a.compareTo(other = b), arg1 = 0)
+}
+
+fun test4(a: String, b: String): Boolean {
+  return lessOrEqual(arg0 = a.compareTo(other = b), arg1 = 0)
+}
diff --git a/compiler/testData/ir/irText/expressions/stringTemplates.fir.kt.txt b/compiler/testData/ir/irText/expressions/stringTemplates.fir.kt.txt
new file mode 100644
index 00000000000..25daa4ce302
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/stringTemplates.fir.kt.txt
@@ -0,0 +1,43 @@
+fun foo(): String {
+  return ""
+}
+
+val x: Int
+  field = 42
+  get
+
+val test1: String
+  field = ""
+  get
+
+val test2: String
+  field = "abc"
+  get
+
+val test3: String
+  field = ""
+  get
+
+val test4: String
+  field = "abc"
+  get
+
+val test5: String
+  field = "\nabc\n"
+  get
+
+val test6: String
+  field = <get-test1>().toString() + " " + foo().toString()
+  get
+
+val test7: String
+  field = <get-test1>().toString()
+  get
+
+val test8: String
+  field = foo().toString()
+  get
+
+val test9: String
+  field = <get-x>().toString()
+  get
diff --git a/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt
new file mode 100644
index 00000000000..58f8cee23af
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/suspendConversionOnArbitraryExpression.fir.kt.txt
@@ -0,0 +1,189 @@
+fun useSuspend(sfn: SuspendFunction0<Unit>) {
+}
+
+fun useSuspendExt(sfn: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<Int, Unit>) {
+}
+
+fun useSuspendArg(sfn: SuspendFunction1<Int, Unit>) {
+}
+
+fun <T : Any?> useSuspendArgT(sfn: SuspendFunction1<T, Unit>) {
+}
+
+fun <T : Any?> useSuspendExtT(sfn: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<T, Unit>) {
+}
+
+fun produceFun(): Function0<Unit> {
+  return local fun <anonymous>() {
+    return Unit
+  }
+
+}
+
+fun testSimple(fn: Function0<Unit>) {
+  useSuspend(sfn = { // BLOCK
+    local suspend fun Function0<Unit>.suspendConversion() {
+      callee.invoke()
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testSimpleNonVal() {
+  useSuspend(sfn = { // BLOCK
+    local suspend fun Function0<Unit>.suspendConversion() {
+      callee.invoke()
+    }
+
+    produceFun()::suspendConversion
+  })
+}
+
+fun testExtAsExt(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>) {
+  useSuspendExt(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>.suspendConversion(p0: Int) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testExtAsSimple(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>) {
+  useSuspendArg(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>.suspendConversion(p0: Int) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testSimpleAsExt(fn: Function1<Int, Unit>) {
+  useSuspendExt(sfn = { // BLOCK
+    local suspend fun Function1<Int, Unit>.suspendConversion(p0: Int) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testSimpleAsSimpleT(fn: Function1<Int, Unit>) {
+  useSuspendArgT<Int>(sfn = { // BLOCK
+    local suspend fun Function1<Int, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testSimpleAsExtT(fn: Function1<Int, Unit>) {
+  useSuspendExtT<Int>(sfn = { // BLOCK
+    local suspend fun Function1<Int, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testExtAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>) {
+  useSuspendArgT<Int>(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testExtAsExtT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>) {
+  useSuspendExtT<Int>(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<Int, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun <S : Any?> testSimpleSAsSimpleT(fn: Function1<S, Unit>) {
+  useSuspendArgT<S>(sfn = { // BLOCK
+    local suspend fun Function1<S, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun <S : Any?> testSimpleSAsExtT(fn: Function1<S, Unit>) {
+  useSuspendExtT<S>(sfn = { // BLOCK
+    local suspend fun Function1<S, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun <S : Any?> testExtSAsSimpleT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<S, Unit>) {
+  useSuspendArgT<S>(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<S, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun <S : Any?> testExtSAsExtT(fn: @ExtensionFunctionType @ExtensionFunctionType Function1<S, Unit>) {
+  useSuspendExtT<S>(sfn = { // BLOCK
+    local suspend fun @ExtensionFunctionType @ExtensionFunctionType Function1<S, Unit>.suspendConversion(p0: T) {
+      callee.invoke(p1 = p0)
+    }
+
+    fn::suspendConversion
+  })
+}
+
+fun testSmartCastWithSuspendConversion(a: Any) {
+  a as Function0<Unit> /*~> Unit */
+  useSuspend(sfn = { // BLOCK
+    local suspend fun Function0<Unit>.suspendConversion() {
+      callee.invoke()
+    }
+
+    a /*as Function0<Unit> */::suspendConversion
+  })
+}
+
+fun testSmartCastOnVarWithSuspendConversion(a: Any) {
+  var b: Any = a
+  b as Function0<Unit> /*~> Unit */
+  useSuspend(sfn = { // BLOCK
+    local suspend fun Function0<Unit>.suspendConversion() {
+      callee.invoke()
+    }
+
+    b /*as Function0<Unit> */::suspendConversion
+  })
+}
+
+fun testSmartCastVsSuspendConversion(a: Function0<Unit>) {
+  a as SuspendFunction0<Unit> /*~> Unit */
+  useSuspend(sfn = a /*as SuspendFunction0<Unit> */)
+}
+
+fun testSmartCastOnVarVsSuspendConversion(a: Function0<Unit>) {
+  var b: Function0<Unit> = a
+  b as SuspendFunction0<Unit> /*~> Unit */
+  useSuspend(sfn = b)
+}
+
+fun <T> testIntersectionVsSuspendConversion(x: T) where T : Function0<Unit>, T : SuspendFunction0<Unit> {
+  useSuspend(sfn = x)
+}
diff --git a/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.fir.kt.txt b/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.fir.kt.txt
new file mode 100644
index 00000000000..8019c9ab30b
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.fir.kt.txt
@@ -0,0 +1,28 @@
+val n: Any?
+  field = null
+  get
+
+open enum class En : Enum<En> {
+  private constructor(x: String?) /* primary */ {
+    super/*Enum*/<En>()
+    /* <init>() */
+
+  }
+
+  val x: String?
+    field = x
+    get
+
+  ENTRY = En(x = { // BLOCK
+    val tmp0_safe_receiver: Any? = <get-n>()
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.toString()
+    }
+  })
+
+  fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): En /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/expressions/thisOfGenericOuterClass.fir.kt.txt b/compiler/testData/ir/irText/expressions/thisOfGenericOuterClass.fir.kt.txt
new file mode 100644
index 00000000000..1f36002c48d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/thisOfGenericOuterClass.fir.kt.txt
@@ -0,0 +1,44 @@
+class Outer<T : Any?> {
+  constructor(x: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  open inner class Inner {
+    constructor(y: Int) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    val y: Int
+      field = y
+      get
+
+  }
+
+}
+
+fun Outer<Int>.test(): Inner<Int> {
+  return { // BLOCK
+    local class <no name provided> : Inner<Int> {
+      private constructor() /* primary */ {
+        <this>.super/*Inner*/(y = 42)
+        /* <init>() */
+
+      }
+
+      val xx: Int
+        field = <this>.<get-x>().plus(other = <this>.<get-y>())
+        get
+
+    }
+
+    <no name provided>()
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/thisRefToObjectInNestedClassConstructorCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/thisRefToObjectInNestedClassConstructorCall.fir.kt.txt
new file mode 100644
index 00000000000..17c69ed7c75
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/thisRefToObjectInNestedClassConstructorCall.fir.kt.txt
@@ -0,0 +1,39 @@
+open class Base {
+  constructor(x: Any) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Any
+    field = x
+    get
+
+}
+
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  class Derived1 : Base {
+    constructor() /* primary */ {
+      super/*Base*/(x = Host)
+      /* <init>() */
+
+    }
+
+  }
+
+  class Derived2 : Base {
+    constructor() /* primary */ {
+      super/*Base*/(x = Host)
+      /* <init>() */
+
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/thisReferenceBeforeClassDeclared.fir.kt.txt b/compiler/testData/ir/irText/expressions/thisReferenceBeforeClassDeclared.fir.kt.txt
new file mode 100644
index 00000000000..9231a19a63d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/thisReferenceBeforeClassDeclared.fir.kt.txt
@@ -0,0 +1,48 @@
+fun WithCompanion.test() {
+  val test1: <no name provided> = { // BLOCK
+    local class <no name provided> : WithCompanion {
+      private constructor() /* primary */ {
+        super/*WithCompanion*/(a = Companion)
+        /* <init>() */
+
+      }
+
+    }
+
+    <no name provided>()
+  }
+  val test2: <no name provided> = { // BLOCK
+    local class <no name provided> : WithCompanion {
+      private constructor() /* primary */ {
+        super/*WithCompanion*/(a = Companion.foo())
+        /* <init>() */
+
+      }
+
+    }
+
+    <no name provided>()
+  }
+}
+
+open class WithCompanion {
+  constructor(a: Companion) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  companion object Companion {
+    private constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+    fun foo(): Companion {
+      return <this>
+    }
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/expressions/throw.fir.kt.txt b/compiler/testData/ir/irText/expressions/throw.fir.kt.txt
new file mode 100644
index 00000000000..76bd6339f87
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/throw.fir.kt.txt
@@ -0,0 +1,9 @@
+fun test1() {
+  throw Throwable()
+}
+
+fun testImplicitCast(a: Any) {
+  when {
+    a is Throwable -> throw a /*as Throwable */
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/tryCatch.fir.kt.txt b/compiler/testData/ir/irText/expressions/tryCatch.fir.kt.txt
new file mode 100644
index 00000000000..c8bd8877a5a
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/tryCatch.fir.kt.txt
@@ -0,0 +1,20 @@
+fun test1() {
+  try println()
+  catch (e: Throwable)println()
+  finally println()
+}
+
+fun test2(): Int {
+  return try { // BLOCK
+    println()
+    42
+  }
+  catch (e: Throwable){ // BLOCK
+    println()
+    24
+  }
+  finally { // BLOCK
+    println()
+    555
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/tryCatchWithImplicitCast.fir.kt.txt b/compiler/testData/ir/irText/expressions/tryCatchWithImplicitCast.fir.kt.txt
new file mode 100644
index 00000000000..c5b32397587
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/tryCatchWithImplicitCast.fir.kt.txt
@@ -0,0 +1,8 @@
+fun testImplicitCast(a: Any) {
+  when {
+    a !is String -> return Unit
+  }
+  val t: String = try a /*as String */
+  catch (e: Throwable)""
+
+}
diff --git a/compiler/testData/ir/irText/expressions/typeAliasConstructorReference.fir.kt.txt b/compiler/testData/ir/irText/expressions/typeAliasConstructorReference.fir.kt.txt
new file mode 100644
index 00000000000..9dec7e45903
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/typeAliasConstructorReference.fir.kt.txt
@@ -0,0 +1,36 @@
+typealias CA = C
+typealias NA = Nested
+class C {
+  constructor(x: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object Host {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  class Nested {
+    constructor(x: Int) /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
+
+val test1: Function1<Int, C>
+  field = C::<init>
+  get
+
+val test2: Function1<Int, Nested>
+  field = Nested::<init>
+  get
diff --git a/compiler/testData/ir/irText/expressions/useImportedMember.fir.kt.txt b/compiler/testData/ir/irText/expressions/useImportedMember.fir.kt.txt
new file mode 100644
index 00000000000..987ce65d2a2
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/useImportedMember.fir.kt.txt
@@ -0,0 +1,102 @@
+interface I<G : Any?> {
+  fun <T : Any?> T.fromInterface(): T {
+    return <this>
+  }
+
+  fun genericFromSuper(g: G): G {
+    return g
+  }
+
+}
+
+open class BaseClass {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val <T : Any?> T.fromClass: T
+    get(): T {
+      return <this>
+    }
+
+}
+
+object C : BaseClass, I<String> {
+  private constructor() /* primary */ {
+    super/*BaseClass*/()
+    /* <init>() */
+
+  }
+
+  fun f(s: Int): Int {
+    return 1
+  }
+
+  fun f(s: String): Int {
+    return 2
+  }
+
+  fun Boolean.f(): Int {
+    return 3
+  }
+
+  var p: Int
+    field = 4
+    get
+    set
+
+  val Int.ext: Int
+    get(): Int {
+      return 6
+    }
+
+  fun <T : Any?> g1(t: T): T {
+    return t
+  }
+
+  val <T : Any?> T.g2: T
+    get(): T {
+      return <this>
+    }
+
+}
+
+fun box(): String {
+  when {
+    EQEQ(arg0 = C.f(s = 1), arg1 = 1).not() -> return "1"
+  }
+  when {
+    EQEQ(arg0 = C.f(s = "s"), arg1 = 2).not() -> return "2"
+  }
+  when {
+    EQEQ(arg0 = (C, true).f(), arg1 = 3).not() -> return "3"
+  }
+  when {
+    EQEQ(arg0 = C.<get-p>(), arg1 = 4).not() -> return "4"
+  }
+  C.<set-p>(<set-?> = 5)
+  when {
+    EQEQ(arg0 = C.<get-p>(), arg1 = 5).not() -> return "5"
+  }
+  when {
+    EQEQ(arg0 = (C, 5).<get-ext>(), arg1 = 6).not() -> return "6"
+  }
+  when {
+    EQEQ(arg0 = C.g1<String>(t = "7"), arg1 = "7").not() -> return "7"
+  }
+  when {
+    EQEQ(arg0 = (C, "8").<get-g2><String>(), arg1 = "8").not() -> return "8"
+  }
+  when {
+    EQEQ(arg0 = (C, 9).fromInterface<Int>(), arg1 = 9).not() -> return "9"
+  }
+  when {
+    EQEQ(arg0 = (C, "10").<get-fromClass><String>(), arg1 = "10").not() -> return "10"
+  }
+  when {
+    EQEQ(arg0 = C.genericFromSuper(g = "11"), arg1 = "11").not() -> return "11"
+  }
+  return "OK"
+}
diff --git a/compiler/testData/ir/irText/expressions/values.fir.kt.txt b/compiler/testData/ir/irText/expressions/values.fir.kt.txt
new file mode 100644
index 00000000000..0466612fce3
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/values.fir.kt.txt
@@ -0,0 +1,61 @@
+enum class Enum : Enum<Enum> {
+  private constructor() /* primary */ {
+    super/*Enum*/<Enum>()
+    /* <init>() */
+
+  }
+
+  A = Enum()
+
+  fun values(): Array<Enum> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Enum /* Synthetic body for ENUM_VALUEOF */
+
+}
+
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+val a: Int
+  field = 0
+  get
+
+class Z {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  companion object Companion {
+    private constructor() /* primary */ {
+      super/*Any*/()
+      /* <init>() */
+
+    }
+
+  }
+
+}
+
+fun test1(): Enum {
+  return Enum.A
+}
+
+fun test2(): A {
+  return A
+}
+
+fun test3(): Int {
+  return <get-a>()
+}
+
+fun test4(): Companion {
+  return Companion
+}
diff --git a/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt
new file mode 100644
index 00000000000..ec434a2a7e0
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/variableAsFunctionCall.fir.kt.txt
@@ -0,0 +1,34 @@
+fun String.k(): Function0<String> {
+  return local fun <anonymous>(): String {
+    return <this>
+  }
+
+}
+
+fun test1(f: Function0<Unit>) {
+  return f.invoke()
+}
+
+fun test2(f: @ExtensionFunctionType @ExtensionFunctionType Function1<String, Unit>) {
+  return f.invoke(p1 = "hello")
+}
+
+fun test3(): String {
+  return "hello".k().invoke()
+}
+
+fun test4(ns: String?): String? {
+  return { // BLOCK
+    val tmp1_safe_receiver: Function0<String>? = { // BLOCK
+      val tmp0_safe_receiver: String? = ns
+      when {
+        EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+        else -> tmp0_safe_receiver.k()
+      }
+    }
+    when {
+      EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+      else -> tmp1_safe_receiver.invoke()
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/variableAsFunctionCallWithGenerics.fir.kt.txt b/compiler/testData/ir/irText/expressions/variableAsFunctionCallWithGenerics.fir.kt.txt
new file mode 100644
index 00000000000..7e5a7758482
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/variableAsFunctionCallWithGenerics.fir.kt.txt
@@ -0,0 +1,23 @@
+val <T : CharSequence> T.gk: Function0<T>
+  get(): Function0<T> {
+    return local fun <anonymous>(): T {
+      return <this>
+    }
+
+  }
+
+fun testGeneric1(x: String): T {
+  return x.<get-gk><String>().invoke()
+}
+
+val <T : Any?> T.kt26531Val: Function0<T>
+  get(): Function0<T> {
+    return local fun <no name provided>(): T {
+      return <this>
+    }
+
+  }
+
+fun kt26531(): T {
+  return 7.<get-kt26531Val><Int>().invoke()
+}
diff --git a/compiler/testData/ir/irText/expressions/when.fir.kt.txt b/compiler/testData/ir/irText/expressions/when.fir.kt.txt
new file mode 100644
index 00000000000..b29edd7691a
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/when.fir.kt.txt
@@ -0,0 +1,63 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun testWithSubject(x: Any?): String {
+  return { // BLOCK
+    val tmp0_subject: Any? = x
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = null) -> "null"
+      EQEQ(arg0 = tmp0_subject, arg1 = A) -> "A"
+      tmp0_subject is String -> "String"
+      tmp0_subject !is Number -> "!Number"
+      setOf<Nothing>().contains<Any?>(element = tmp0_subject) -> "nothingness?"
+      else -> "something"
+    }
+  }
+}
+
+fun test(x: Any?): String {
+  return when {
+    EQEQ(arg0 = x, arg1 = null) -> "null"
+    EQEQ(arg0 = x /*as Any */, arg1 = A) -> "A"
+    x /*as Any */ is String -> "String"
+    x /*as Any */ !is Number -> "!Number"
+    setOf<Nothing>().contains<Number>(element = x /*as Number */) -> "nothingness?"
+    else -> "something"
+  }
+}
+
+fun testComma(x: Int): String {
+  return { // BLOCK
+    val tmp1_subject: Int = x
+    when {
+      when {
+        when {
+          when {
+            EQEQ(arg0 = tmp1_subject, arg1 = 1) -> true
+            else -> EQEQ(arg0 = tmp1_subject, arg1 = 2)
+          } -> true
+          else -> EQEQ(arg0 = tmp1_subject, arg1 = 3)
+        } -> true
+        else -> EQEQ(arg0 = tmp1_subject, arg1 = 4)
+      } -> "1234"
+      when {
+        when {
+          EQEQ(arg0 = tmp1_subject, arg1 = 5) -> true
+          else -> EQEQ(arg0 = tmp1_subject, arg1 = 6)
+        } -> true
+        else -> EQEQ(arg0 = tmp1_subject, arg1 = 7)
+      } -> "567"
+      when {
+        EQEQ(arg0 = tmp1_subject, arg1 = 8) -> true
+        else -> EQEQ(arg0 = tmp1_subject, arg1 = 9)
+      } -> "89"
+      else -> "?"
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/whenReturn.fir.kt.txt b/compiler/testData/ir/irText/expressions/whenReturn.fir.kt.txt
new file mode 100644
index 00000000000..bd39afe8f55
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/whenReturn.fir.kt.txt
@@ -0,0 +1,13 @@
+fun toString(grade: String): String {
+  { // BLOCK
+    val tmp0_subject: String = grade
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = "A") -> return "Excellent"
+      EQEQ(arg0 = tmp0_subject, arg1 = "B") -> return "Good"
+      EQEQ(arg0 = tmp0_subject, arg1 = "C") -> return "Mediocre"
+      EQEQ(arg0 = tmp0_subject, arg1 = "D") -> return "Fair"
+      else -> return "Failure"
+    }
+  }
+  return "???"
+}
diff --git a/compiler/testData/ir/irText/expressions/whenUnusedExpression.fir.kt.txt b/compiler/testData/ir/irText/expressions/whenUnusedExpression.fir.kt.txt
new file mode 100644
index 00000000000..30614dd0e9f
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/whenUnusedExpression.fir.kt.txt
@@ -0,0 +1,12 @@
+fun test(b: Boolean, i: Int) {
+  when {
+    b -> { // BLOCK
+      val tmp0_subject: Int = i
+      when {
+        EQEQ(arg0 = tmp0_subject, arg1 = 0) -> 1
+        else -> null
+      }
+    }
+    else -> null
+  } /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/expressions/whenWithSubjectVariable.fir.kt.txt b/compiler/testData/ir/irText/expressions/whenWithSubjectVariable.fir.kt.txt
new file mode 100644
index 00000000000..8a108d7366d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/whenWithSubjectVariable.fir.kt.txt
@@ -0,0 +1,17 @@
+fun foo(): Any {
+  return 1
+}
+
+fun test(): Int {
+  return { // BLOCK
+    val y: Any = foo()
+    when {
+      EQEQ(arg0 = y, arg1 = 42) -> 1
+      y is String -> y /*as String */.<get-length>()
+      y !is Int -> 2
+      error("") /* ERROR CALL */y;  -> 3
+      error("") /* ERROR CALL */y; .not() -> 4
+      else -> -1
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/expressions/whileDoWhile.fir.kt.txt b/compiler/testData/ir/irText/expressions/whileDoWhile.fir.kt.txt
new file mode 100644
index 00000000000..89dd728143d
--- /dev/null
+++ b/compiler/testData/ir/irText/expressions/whileDoWhile.fir.kt.txt
@@ -0,0 +1,39 @@
+fun test() {
+  var x: Int = 0
+  while (less(arg0 = x, arg1 = 0)) { // BLOCK
+  }
+  while (less(arg0 = x, arg1 = 5)) { // BLOCK
+    val <unary>: Int = x
+    x = <unary>.inc()
+    <unary>
+  }
+  while (less(arg0 = x, arg1 = 10)) { // BLOCK
+    val <unary>: Int = x
+    x = <unary>.inc()
+    <unary>
+  }
+  do// COMPOSITE {
+  // }  while (less(arg0 = x, arg1 = 0))
+  do{ // BLOCK
+    val <unary>: Int = x
+    x = <unary>.inc()
+    <unary>
+  }  while (less(arg0 = x, arg1 = 15))
+  do// COMPOSITE {
+  val <unary>: Int = x
+  x = <unary>.inc()
+  <unary>
+  // }  while (less(arg0 = x, arg1 = 20))
+}
+
+fun testSmartcastInCondition() {
+  val a: Any? = null
+  when {
+    a is Boolean -> { // BLOCK
+      while (a /*as Boolean */) { // BLOCK
+      }
+      do// COMPOSITE {
+      // }      while (a /*as Boolean */)
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/firProblems/AbstractMutableMap.fir.kt.txt b/compiler/testData/ir/irText/firProblems/AbstractMutableMap.fir.kt.txt
new file mode 100644
index 00000000000..f4df9b24968
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/AbstractMutableMap.fir.kt.txt
@@ -0,0 +1,17 @@
+class MyMap<K : Any, V : Any> : AbstractMutableMap<K, V> {
+  constructor() /* primary */ {
+    super/*AbstractMutableMap*/<K, V>()
+    /* <init>() */
+
+  }
+
+  override fun put(key: K, value: V): V? {
+    return null
+  }
+
+  override val entries: MutableSet<MutableEntry<K, V>>
+    override get(): MutableSet<MutableEntry<K, V>> {
+      return mutableSetOf<MutableEntry<K, V>>()
+    }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/AllCandidates.fir.kt.txt b/compiler/testData/ir/irText/firProblems/AllCandidates.fir.kt.txt
new file mode 100644
index 00000000000..7b048f664b7
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/AllCandidates.fir.kt.txt
@@ -0,0 +1,31 @@
+class ResolvedCall<C : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class MyCandidate {
+  constructor(resolvedCall: ResolvedCall<*>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val resolvedCall: ResolvedCall<*>
+    field = resolvedCall
+    get
+
+}
+
+private fun <A : Any?> allCandidatesResult(allCandidates: Collection<MyCandidate>): OverloadResolutionResultsImpl<A?>? {
+  return nameNotFound<A?>().apply<OverloadResolutionResultsImpl<A?>?>(block = local fun OverloadResolutionResultsImpl<A?>?.<anonymous>() {
+    <this>.setAllCandidates(allCandidates = allCandidates.map<MyCandidate, ResolvedCall<A>>(transform = local fun <anonymous>(it: MyCandidate): ResolvedCall<A> {
+      return it.<get-resolvedCall>() as ResolvedCall<A>
+    }
+))
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/firProblems/AnnotationInAnnotation.fir.kt.txt b/compiler/testData/ir/irText/firProblems/AnnotationInAnnotation.fir.kt.txt
new file mode 100644
index 00000000000..e5d0f36e470
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/AnnotationInAnnotation.fir.kt.txt
@@ -0,0 +1,29 @@
+annotation class Storage : Annotation {
+  constructor(value: String) /* primary */
+  val value: String
+    field = value
+    get
+
+}
+
+annotation class State : Annotation {
+  constructor(name: String, storages: Array<Storage>) /* primary */
+  val name: String
+    field = name
+    get
+
+  val storages: Array<Storage>
+    field = storages
+    get
+
+}
+
+@State(name = "1", storages = [Storage(value = "HELLO")])
+class Test {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/BaseFirBuilder.fir.kt.txt b/compiler/testData/ir/irText/firProblems/BaseFirBuilder.fir.kt.txt
new file mode 100644
index 00000000000..e40fd82c215
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/BaseFirBuilder.fir.kt.txt
@@ -0,0 +1,12 @@
+abstract class BaseFirBuilder<T : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  inline fun <T : Any?> withCapturedTypeParameters(block: Function0<T>): T {
+    return block.invoke()
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/ClashResolutionDescriptor.fir.kt.txt b/compiler/testData/ir/irText/firProblems/ClashResolutionDescriptor.fir.kt.txt
new file mode 100644
index 00000000000..fa763a44d20
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/ClashResolutionDescriptor.fir.kt.txt
@@ -0,0 +1,62 @@
+interface ComponentContainer {
+
+}
+
+interface PlatformSpecificExtension<S : PlatformSpecificExtension<S>> {
+
+}
+
+interface ComponentDescriptor {
+
+}
+
+abstract class PlatformExtensionsClashResolver<E : PlatformSpecificExtension<E>> {
+  constructor(applicableTo: Class<E>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val applicableTo: Class<E>
+    field = applicableTo
+    get
+
+}
+
+class ClashResolutionDescriptor<E : PlatformSpecificExtension<E>> {
+  constructor(container: ComponentContainer, resolver: PlatformExtensionsClashResolver<E>, clashedComponents: List<ComponentDescriptor>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  private val resolver: PlatformExtensionsClashResolver<E>
+    field = resolver
+    private get
+
+  private val clashedComponents: List<ComponentDescriptor>
+    field = clashedComponents
+    private get
+
+}
+
+private val registrationMap: HashMap<Type, Any>
+  field = hashMapOf<Type, Any>()
+  private get
+
+fun resolveClashesIfAny(container: ComponentContainer, clashResolvers: List<PlatformExtensionsClashResolver<*>>) {
+  { // BLOCK
+    val <iterator>: Iterator<PlatformExtensionsClashResolver<*>> = clashResolvers.iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val resolver: PlatformExtensionsClashResolver<*> = <iterator>.next()
+      val clashedComponents: Collection<ComponentDescriptor> = { // BLOCK
+        val <elvis>: Collection<ComponentDescriptor>? = <get-registrationMap>().get(p0 = resolver.<get-applicableTo>()) as? Collection<ComponentDescriptor>
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> continue
+          else -> <elvis> /*as Collection<ComponentDescriptor> */
+        }
+      }
+      val substituteDescriptor: ClashResolutionDescriptor<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out Any?>>>>>> = ClashResolutionDescriptor<PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out PlatformSpecificExtension<out Any?>>>>>>(container = container, resolver = resolver, clashedComponents = clashedComponents.toList<ComponentDescriptor>())
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/firProblems/DeepCopyIrTree.fir.kt.txt b/compiler/testData/ir/irText/firProblems/DeepCopyIrTree.fir.kt.txt
new file mode 100644
index 00000000000..fcf25423542
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/DeepCopyIrTree.fir.kt.txt
@@ -0,0 +1,77 @@
+interface IrType {
+
+}
+
+interface TypeRemapper {
+  abstract fun enterScope(irTypeParametersContainer: IrTypeParametersContainer)
+  abstract fun remapType(type: IrType): IrType
+  abstract fun leaveScope()
+
+}
+
+interface IrTypeParametersContainer : IrDeclaration, IrDeclarationParent {
+  abstract var typeParameters: List<IrTypeParameter>
+    abstract get
+    abstract set
+
+}
+
+interface IrDeclaration {
+
+}
+
+interface IrTypeParameter : IrDeclaration {
+  abstract val superTypes: MutableList<IrType>
+    abstract get
+
+}
+
+interface IrDeclarationParent {
+
+}
+
+class DeepCopyIrTreeWithSymbols {
+  constructor(typeRemapper: TypeRemapper) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  private val typeRemapper: TypeRemapper
+    field = typeRemapper
+    private get
+
+  private fun copyTypeParameter(declaration: IrTypeParameter): IrTypeParameter {
+    return declaration
+  }
+
+  fun IrTypeParametersContainer.copyTypeParametersFrom(other: IrTypeParametersContainer) {
+    <this>.<set-typeParameters>(<set-?> = other.<get-typeParameters>().map<IrTypeParameter, IrTypeParameter>(transform = local fun <anonymous>(it: IrTypeParameter): IrTypeParameter {
+      return <this>.copyTypeParameter(declaration = it)
+    }
+))
+    <this>.<get-typeRemapper>().withinScope<Unit>(irTypeParametersContainer = <this>, fn = local fun <anonymous>() {
+      { // BLOCK
+        val <iterator>: Iterator<Pair<IrTypeParameter, IrTypeParameter>> = <this>.<get-typeParameters>().zip<IrTypeParameter, IrTypeParameter>(other = other.<get-typeParameters>()).iterator()
+        while (<iterator>.hasNext()) { // BLOCK
+          val <destruct>: Pair<IrTypeParameter, IrTypeParameter> = <iterator>.next()
+          val thisTypeParameter: IrTypeParameter = <destruct>.component1()
+          val otherTypeParameter: IrTypeParameter = <destruct>.component2()
+          otherTypeParameter.<get-superTypes>().mapTo<IrType, IrType, MutableList<IrType>>(destination = thisTypeParameter.<get-superTypes>(), transform = local fun <anonymous>(it: IrType): IrType {
+            return <this>.<get-typeRemapper>().remapType(type = it)
+          }
+)
+        }
+      }
+    }
+)
+  }
+
+}
+
+inline fun <T : Any?> TypeRemapper.withinScope(irTypeParametersContainer: IrTypeParametersContainer, fn: Function0<T>): T {
+  <this>.enterScope(irTypeParametersContainer = irTypeParametersContainer)
+  val result: T = fn.invoke()
+  <this>.leaveScope()
+  return result
+}
diff --git a/compiler/testData/ir/irText/firProblems/DelegationAndInheritanceFromJava.fir.kt.txt b/compiler/testData/ir/irText/firProblems/DelegationAndInheritanceFromJava.fir.kt.txt
new file mode 100644
index 00000000000..fca16e0cd8d
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/DelegationAndInheritanceFromJava.fir.kt.txt
@@ -0,0 +1,60 @@
+class Impl : A, B {
+  constructor(b: B) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = b
+  }
+
+  override fun add(element: String?): Boolean {
+    return <this>.#<$$delegate_0>.add(element = element)
+  }
+
+  override fun addAll(elements: Collection<String?>): Boolean {
+    return <this>.#<$$delegate_0>.addAll(elements = elements)
+  }
+
+  override fun clear() {
+    <this>.#<$$delegate_0>.clear()
+  }
+
+  override operator fun iterator(): MutableIterator<String?> {
+    return <this>.#<$$delegate_0>.iterator()
+  }
+
+  override fun remove(element: String?): Boolean {
+    return <this>.#<$$delegate_0>.remove(element = element)
+  }
+
+  override fun removeAll(elements: Collection<String?>): Boolean {
+    return <this>.#<$$delegate_0>.removeAll(elements = elements)
+  }
+
+  override fun retainAll(elements: Collection<String?>): Boolean {
+    return <this>.#<$$delegate_0>.retainAll(elements = elements)
+  }
+
+  override operator fun contains(element: String?): Boolean {
+    return <this>.#<$$delegate_0>.contains(element = element)
+  }
+
+  override fun containsAll(elements: Collection<String?>): Boolean {
+    return <this>.#<$$delegate_0>.containsAll(elements = elements)
+  }
+
+  override fun isEmpty(): Boolean {
+    return <this>.#<$$delegate_0>.isEmpty()
+  }
+
+  override val size: Int
+    override get(): Int {
+      return <this>.#<$$delegate_0>.<get-size>()
+    }
+
+  local /*final field*/ val <$$delegate_0>: B
+
+}
+
+fun box(): String {
+  return "OK"
+}
diff --git a/compiler/testData/ir/irText/firProblems/FirBuilder.fir.kt.txt b/compiler/testData/ir/irText/firProblems/FirBuilder.fir.kt.txt
new file mode 100644
index 00000000000..62fa200f594
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/FirBuilder.fir.kt.txt
@@ -0,0 +1,17 @@
+open class BaseConverter : BaseFirBuilder<Any> {
+  constructor() /* primary */ {
+    super/*BaseFirBuilder*/<Any>()
+    /* <init>() */
+
+  }
+
+}
+
+class DeclarationsConverter : BaseConverter {
+  constructor() /* primary */ {
+    super/*BaseConverter*/()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/InnerClassInAnonymous.fir.kt.txt b/compiler/testData/ir/irText/firProblems/InnerClassInAnonymous.fir.kt.txt
new file mode 100644
index 00000000000..ed7485eda9e
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/InnerClassInAnonymous.fir.kt.txt
@@ -0,0 +1,49 @@
+fun box(): String {
+  val obj: <no name provided> = { // BLOCK
+    local class <no name provided> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      val end: String
+        field = "K"
+        get
+
+      fun foo(): String {
+        return <this>.Some(s = "O").bar()
+      }
+
+      local inner class Some : Base {
+        constructor(s: String) /* primary */ {
+          <this>.super/*Base*/(s = s)
+          /* <init>() */
+
+        }
+
+        fun bar(): String {
+          return <this>.<get-s>().plus(other = <this>.<get-end>())
+        }
+
+      }
+
+      local open inner class Base {
+        constructor(s: String) /* primary */ {
+          super/*Any*/()
+          /* <init>() */
+
+        }
+
+        val s: String
+          field = s
+          get
+
+      }
+
+    }
+
+    <no name provided>()
+  }
+  return obj.foo()
+}
diff --git a/compiler/testData/ir/irText/firProblems/MultiList.fir.kt.txt b/compiler/testData/ir/irText/firProblems/MultiList.fir.kt.txt
new file mode 100644
index 00000000000..7a96913bc62
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/MultiList.fir.kt.txt
@@ -0,0 +1,67 @@
+data class Some<T : Any?> {
+  constructor(value: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val value: T
+    field = value
+    get
+
+  fun component1(): T {
+    return <this>.#value
+  }
+
+  fun copy(value: T = <this>.#value): Some<T> {
+    return Some<Any>(value = value)
+  }
+
+  override fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is Some<T> -> return false
+    }
+    val tmp0_other_with_cast: Some<T> = other as Some<T>
+    when {
+      EQEQ(arg0 = <this>.#value, arg1 = tmp0_other_with_cast.#value).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return when {
+      EQEQ(arg0 = <this>.#value, arg1 = null) -> 0
+      else -> <this>.#value.hashCode()
+    }
+  }
+
+  override fun toString(): String {
+    return "Some(" + "value=" + <this>.#value + ")"
+  }
+
+}
+
+interface MyList<T : Any?> : List<Some<T>> {
+
+}
+
+open class SomeList<T : Any?> : MyList<T>, ArrayList<Some<T>> {
+  constructor() /* primary */ {
+    super/*ArrayList*/<Some<T>>()
+    /* <init>() */
+
+  }
+
+}
+
+class FinalList : SomeList<String> {
+  constructor() /* primary */ {
+    super/*SomeList*/<String>()
+    /* <init>() */
+
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/SameJavaFieldReferences.fir.kt.txt b/compiler/testData/ir/irText/firProblems/SameJavaFieldReferences.fir.kt.txt
new file mode 100644
index 00000000000..c4bde9f59c7
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/SameJavaFieldReferences.fir.kt.txt
@@ -0,0 +1,4 @@
+fun foo() {
+  val ref1: KProperty0<String?> = SomeJavaClass::someJavaField/*</* null */>()*/
+  val ref2: KProperty0<String?> = SomeJavaClass::someJavaField/*</* null */>()*/
+}
diff --git a/compiler/testData/ir/irText/firProblems/SignatureClash.fir.kt.txt b/compiler/testData/ir/irText/firProblems/SignatureClash.fir.kt.txt
new file mode 100644
index 00000000000..30ecc73057c
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/SignatureClash.fir.kt.txt
@@ -0,0 +1,79 @@
+typealias Some = Function1<Any, String?>
+object Factory {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun foo(a: String): String {
+    return "Alpha"
+  }
+
+  fun foo(a: String, f: Function1<Any, String?>): String {
+    return "Omega"
+  }
+
+}
+
+interface Base {
+
+}
+
+interface Delegate : Base {
+  abstract fun bar()
+
+}
+
+interface Derived : Delegate {
+
+}
+
+data class DataClass : Derived, Delegate {
+  constructor(delegate: Delegate) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = delegate
+  }
+
+  val delegate: Delegate
+    field = delegate
+    get
+
+  fun component1(): Delegate {
+    return <this>.#delegate
+  }
+
+  fun copy(delegate: Delegate = <this>.#delegate): DataClass {
+    return DataClass(delegate = delegate)
+  }
+
+  override fun bar() {
+    <this>.#<$$delegate_0>.bar()
+  }
+
+  local /*final field*/ val <$$delegate_0>: Delegate
+  override fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is DataClass -> return false
+    }
+    val tmp0_other_with_cast: DataClass = other as DataClass
+    when {
+      EQEQ(arg0 = <this>.#delegate, arg1 = tmp0_other_with_cast.#delegate).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    return <this>.#delegate.hashCode()
+  }
+
+  override fun toString(): String {
+    return "DataClass(" + "delegate=" + <this>.#delegate + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/candidateSymbol.fir.kt.txt b/compiler/testData/ir/irText/firProblems/candidateSymbol.fir.kt.txt
new file mode 100644
index 00000000000..1214db912fa
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/candidateSymbol.fir.kt.txt
@@ -0,0 +1,52 @@
+class Candidate {
+  constructor(symbol: AbstractFirBasedSymbol<*>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val symbol: AbstractFirBasedSymbol<*>
+    field = symbol
+    get
+
+}
+
+abstract class AbstractFirBasedSymbol<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  lateinit var fir: E
+    get
+    set
+
+}
+
+interface FirDeclaration {
+
+}
+
+interface FirSymbolOwner<E> where E : FirSymbolOwner<E>, E : FirDeclaration {
+  abstract val symbol: AbstractFirBasedSymbol<E>
+    abstract get
+
+}
+
+interface FirCallableMemberDeclaration<F : FirCallableMemberDeclaration<F>> : FirSymbolOwner<F>, FirDeclaration {
+  abstract override val symbol: AbstractFirBasedSymbol<F>
+    abstract override get
+
+}
+
+fun foo(candidate: Candidate) {
+  val me: FirSymbolOwner<out FirSymbolOwner<out FirSymbolOwner<out FirSymbolOwner<out FirSymbolOwner<out Any?>>>>> = candidate.<get-symbol>().<get-fir>()
+  when {
+    when {
+      me is FirCallableMemberDeclaration<*> -> EQEQ(arg0 = me /*as FirCallableMemberDeclaration<*> */.<get-symbol>(), arg1 = null).not()
+      else -> false
+    } -> { // BLOCK
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/firProblems/coercionToUnitForNestedWhen.fir.kt.txt b/compiler/testData/ir/irText/firProblems/coercionToUnitForNestedWhen.fir.kt.txt
new file mode 100644
index 00000000000..4cf9c1fb9dc
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/coercionToUnitForNestedWhen.fir.kt.txt
@@ -0,0 +1,39 @@
+private const val BACKSLASH: Char
+  field = '\\'
+  private get
+
+private fun Reader.nextChar(): Char? {
+  return { // BLOCK
+    val tmp0_safe_receiver: Int? = <this>.read().takeUnless<Int>(predicate = local fun <anonymous>(it: Int): Boolean {
+      return EQEQ(arg0 = it, arg1 = -1)
+    }
+)
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      else -> tmp0_safe_receiver.toChar()
+    }
+  }
+}
+
+fun Reader.consumeRestOfQuotedSequence(sb: StringBuilder, quote: Char) {
+  var ch: Char? = <this>.nextChar()
+  while (when {
+    EQEQ(arg0 = ch, arg1 = null).not() -> EQEQ(arg0 = ch /*as Char */, arg1 = quote).not()
+    else -> false
+  }) { // BLOCK
+    when {
+      EQEQ(arg0 = ch /*as Char */, arg1 = <get-BACKSLASH>()) -> { // BLOCK
+        val tmp1_safe_receiver: Char? = <this>.nextChar()
+        when {
+          EQEQ(arg0 = tmp1_safe_receiver, arg1 = null) -> null
+          else -> tmp1_safe_receiver.let<Char, StringBuilder?>(block = local fun <anonymous>(it: Char): StringBuilder? {
+            return sb.append(p0 = it)
+          }
+)
+        }
+      }
+      else -> sb.append(p0 = ch /*as Char */)
+    } /*~> Unit */
+    ch = <this>.nextChar()
+  }
+}
diff --git a/compiler/testData/ir/irText/firProblems/putIfAbsent.fir.kt.txt b/compiler/testData/ir/irText/firProblems/putIfAbsent.fir.kt.txt
new file mode 100644
index 00000000000..5e4cdba83e1
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/putIfAbsent.fir.kt.txt
@@ -0,0 +1,13 @@
+class Owner {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun <T : Any?> foo(x: T, y: T) {
+    val map: MutableMap<T, T> = mutableMapOf<T, T>()
+    map.putIfAbsent(p0 = x, p1 = y) /*~> Unit */
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/recursiveCapturedTypeInPropertyReference.fir.kt.txt b/compiler/testData/ir/irText/firProblems/recursiveCapturedTypeInPropertyReference.fir.kt.txt
new file mode 100644
index 00000000000..54c5833bc51
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/recursiveCapturedTypeInPropertyReference.fir.kt.txt
@@ -0,0 +1,22 @@
+interface Something {
+
+}
+
+interface Recursive<R> where R : Recursive<R>, R : Something {
+  abstract val symbol: AbstractSymbol<R>
+    abstract get
+
+}
+
+abstract class AbstractSymbol<E> where E : Recursive<E>, E : Something {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun foo(list: List<Any>) {
+    val result: List<AbstractSymbol<out Recursive<*>>> = list.filterIsInstance<Recursive<*>>().map<Recursive<*>, AbstractSymbol<out Recursive<*>>>(transform = Recursive::symbol)
+  }
+
+}
diff --git a/compiler/testData/ir/irText/firProblems/throwableStackTrace.fir.kt.txt b/compiler/testData/ir/irText/firProblems/throwableStackTrace.fir.kt.txt
new file mode 100644
index 00000000000..33e6667ac65
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/throwableStackTrace.fir.kt.txt
@@ -0,0 +1,3 @@
+fun foo(t: Throwable) {
+  t.setStackTrace(p0 = t.getStackTrace())
+}
diff --git a/compiler/testData/ir/irText/firProblems/v8arrayToList.fir.kt.txt b/compiler/testData/ir/irText/firProblems/v8arrayToList.fir.kt.txt
new file mode 100644
index 00000000000..4ce9775b538
--- /dev/null
+++ b/compiler/testData/ir/irText/firProblems/v8arrayToList.fir.kt.txt
@@ -0,0 +1,14 @@
+class V8Array {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun box(): String {
+  val array: V8Array = V8Array()
+  val list: List<String> = toList(array = array) as List<String>
+  return list.get(index = 0)
+}
diff --git a/compiler/testData/ir/irText/lambdas/anonymousFunction.fir.kt.txt b/compiler/testData/ir/irText/lambdas/anonymousFunction.fir.kt.txt
new file mode 100644
index 00000000000..ef19f0f61aa
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/anonymousFunction.fir.kt.txt
@@ -0,0 +1,6 @@
+val anonymous: Function0<Unit>
+  field = local fun <no name provided>() {
+    println()
+  }
+
+  get
diff --git a/compiler/testData/ir/irText/lambdas/destructuringInLambda.fir.kt.txt b/compiler/testData/ir/irText/lambdas/destructuringInLambda.fir.kt.txt
new file mode 100644
index 00000000000..801757a9b58
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/destructuringInLambda.fir.kt.txt
@@ -0,0 +1,65 @@
+data class A {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  fun component1(): Int {
+    return <this>.#x
+  }
+
+  fun component2(): Int {
+    return <this>.#y
+  }
+
+  fun copy(x: Int = <this>.#x, y: Int = <this>.#y): A {
+    return A(x = x, y = y)
+  }
+
+  override 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 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#y, arg1 = tmp0_other_with_cast.#y).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = <this>.#x.hashCode()
+    result = result.times(other = 31).plus(other = <this>.#y.hashCode())
+    return result
+  }
+
+  override fun toString(): String {
+    return "A(" + "x=" + <this>.#x + ", " + "y=" + <this>.#y + ")"
+  }
+
+}
+
+var fn: Function1<A, Int>
+  field = local fun <anonymous>(<destruct>: A): Int {
+    val _: Int = <destruct>.component1()
+    val y: Int = <destruct>.component2()
+    return 42.plus(other = y)
+  }
+
+  get
+  set
diff --git a/compiler/testData/ir/irText/lambdas/extensionLambda.fir.kt.txt b/compiler/testData/ir/irText/lambdas/extensionLambda.fir.kt.txt
new file mode 100644
index 00000000000..46b75238fa5
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/extensionLambda.fir.kt.txt
@@ -0,0 +1,6 @@
+fun test1(): Int {
+  return "42".run<String, Int>(block = local fun String.<anonymous>(): Int {
+    return <this>.<get-length>()
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/lambdas/localFunction.fir.kt.txt b/compiler/testData/ir/irText/lambdas/localFunction.fir.kt.txt
new file mode 100644
index 00000000000..051571a5ade
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/localFunction.fir.kt.txt
@@ -0,0 +1,10 @@
+fun outer() {
+  var x: Int = 0
+  local fun local() {
+    val <unary>: Int = x
+    x = <unary>.inc()
+    <unary> /*~> Unit */
+  }
+
+  local()
+}
diff --git a/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.kt.txt b/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.kt.txt
new file mode 100644
index 00000000000..ebb433fa9a2
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/multipleImplicitReceivers.fir.kt.txt
@@ -0,0 +1,45 @@
+object A {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+object B {
+  private constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+interface IFoo {
+  val A.foo: B
+    get(): B {
+      return B
+    }
+
+}
+
+interface IInvoke {
+  operator fun B.invoke(): Int {
+    return 42
+  }
+
+}
+
+fun test(fooImpl: IFoo, invokeImpl: IInvoke) {
+  with<A, Int>(receiver = A, block = local fun A.<anonymous>(): Int {
+    return with<IFoo, Int>(receiver = fooImpl, block = local fun IFoo.<anonymous>(): Int {
+      return with<IInvoke, Int>(receiver = invokeImpl, block = local fun IInvoke.<anonymous>(): Int {
+        return (<this>, (<this>, <this>).<get-foo>()).invoke()
+      }
+)
+    }
+)
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/lambdas/nonLocalReturn.fir.kt.txt b/compiler/testData/ir/irText/lambdas/nonLocalReturn.fir.kt.txt
new file mode 100644
index 00000000000..8792fe14792
--- /dev/null
+++ b/compiler/testData/ir/irText/lambdas/nonLocalReturn.fir.kt.txt
@@ -0,0 +1,50 @@
+fun test0() {
+  run<Nothing>(block = local fun <anonymous>(): Nothing {
+    return Unit
+  }
+)
+}
+
+fun test1() {
+  run<Unit>(block = local fun <anonymous>() {
+    return Unit
+  }
+)
+}
+
+fun test2() {
+  run<Unit>(block = local fun <anonymous>() {
+    return Unit
+  }
+)
+}
+
+fun test3() {
+  run<Unit>(block = local fun <anonymous>() {
+    return run<Nothing>(block = local fun <anonymous>(): Nothing {
+      return Unit
+    }
+)
+  }
+)
+}
+
+fun testLrmFoo1(ints: List<Int>) {
+  ints.forEach<Int>(action = local fun <anonymous>(it: Int) {
+    when {
+      EQEQ(arg0 = it, arg1 = 0) -> return Unit
+    }
+    print(message = it)
+  }
+)
+}
+
+fun testLrmFoo2(ints: List<Int>) {
+  ints.forEach<Int>(action = local fun <anonymous>(it: Int) {
+    when {
+      EQEQ(arg0 = it, arg1 = 0) -> return Unit
+    }
+    print(message = it)
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/regressions/coercionInLoop.fir.kt.txt b/compiler/testData/ir/irText/regressions/coercionInLoop.fir.kt.txt
new file mode 100644
index 00000000000..01ec6ae4577
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/coercionInLoop.fir.kt.txt
@@ -0,0 +1,14 @@
+fun box(): String {
+  val a: DoubleArray = DoubleArray(size = 5)
+  val x: DoubleIterator = a.iterator()
+  var i: Int = 0
+  while (x.hasNext()) { // BLOCK
+    when {
+      ieee754equals(arg0 = a.get(index = i), arg1 = x.next()).not() -> return "Fail " + i.toString()
+    }
+    val <unary>: Int = i
+    i = <unary>.inc()
+    <unary>
+  }
+  return "OK"
+}
diff --git a/compiler/testData/ir/irText/regressions/integerCoercionToT.fir.kt.txt b/compiler/testData/ir/irText/regressions/integerCoercionToT.fir.kt.txt
new file mode 100644
index 00000000000..f07bb0463ca
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/integerCoercionToT.fir.kt.txt
@@ -0,0 +1,41 @@
+typealias CInt32Var = CInt32VarX<Int>
+interface CPointed {
+
+}
+
+inline fun <reified T : CPointed> CPointed.reinterpret(): T {
+  return TODO()
+}
+
+class CInt32VarX<T : Any?> : CPointed {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+var <T_INT : Int> CInt32VarX<T_INT>.value: T_INT
+  get(): T_INT {
+    return TODO()
+  }
+  set(value: T_INT) {
+  }
+
+class IdType : CPointed {
+  constructor(value: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val value: Int
+    field = value
+    get
+
+}
+
+fun foo(value: IdType, cv: CInt32VarX<Int>) {
+  cv.<set-value><Int>(value = value.<get-value>())
+}
diff --git a/compiler/testData/ir/irText/regressions/kt24114.fir.kt.txt b/compiler/testData/ir/irText/regressions/kt24114.fir.kt.txt
new file mode 100644
index 00000000000..ea17afbee5a
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/kt24114.fir.kt.txt
@@ -0,0 +1,37 @@
+fun one(): Int {
+  return 1
+}
+
+fun two(): Int {
+  return 2
+}
+
+fun test1(): Int {
+  while (true) { // BLOCK
+    val tmp0_subject: Int = one()
+    when {
+      EQEQ(arg0 = tmp0_subject, arg1 = 1) -> { // BLOCK
+        val tmp1_subject: Int = two()
+        when {
+          EQEQ(arg0 = tmp1_subject, arg1 = 2) -> return 2
+        }
+      }
+      else -> return 3
+    }
+  }
+}
+
+fun test2(): Int {
+  while (true) { // BLOCK
+    val tmp2_subject: Int = one()
+    when {
+      EQEQ(arg0 = tmp2_subject, arg1 = 1) -> { // BLOCK
+        val tmp3_subject: Int = two()
+        when {
+          EQEQ(arg0 = tmp3_subject, arg1 = 2) -> return 2
+        }
+      }
+      else -> return 3
+    }
+  }
+}
diff --git a/compiler/testData/ir/irText/regressions/newInference/fixationOrder1.fir.kt.txt b/compiler/testData/ir/irText/regressions/newInference/fixationOrder1.fir.kt.txt
new file mode 100644
index 00000000000..6ae5f6007b2
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/newInference/fixationOrder1.fir.kt.txt
@@ -0,0 +1,20 @@
+fun <X : Any?, Y : Any?> foo(): Function1<X, Y> {
+  return TODO()
+}
+
+interface Inv2<A : Any?, B : Any?> {
+
+}
+
+fun <T : Any?, R : Any?> check(x: T, y: R, f: Function1<T, R>): Inv2<T, R> {
+  return TODO()
+}
+
+fun test(): Inv2<String, Int> {
+  return check<String, Int>(x = "", y = 1, f = foo<String, Int>())
+}
+
+fun box(): String {
+  val x: Inv2<String, Int> = test()
+  return "OK"
+}
diff --git a/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.fir.kt.txt b/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.fir.kt.txt
new file mode 100644
index 00000000000..4a917e950bc
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.fir.kt.txt
@@ -0,0 +1,19 @@
+typealias B<X : Any?> = A<X>
+typealias B2<T : Any?> = A<A<T>>
+class A<Q : Any?> {
+  constructor(q: Q) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val q: Q
+    field = q
+    get
+
+}
+
+fun bar() {
+  val b: A<Int> = A<Int>(q = 2)
+  val b2: A<A<Int>> = A<Int>(q = b)
+}
diff --git a/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.fir.kt.txt b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.fir.kt.txt
new file mode 100644
index 00000000000..df40c6ff4e0
--- /dev/null
+++ b/compiler/testData/ir/irText/regressions/typeParametersInImplicitCast.fir.kt.txt
@@ -0,0 +1,6 @@
+fun <T : Any?> problematic(lss: List<List<T>>): List<T> {
+  return lss.flatMap<List<T>, T>(transform = local fun <anonymous>(it: List<T>): Iterable<T> {
+    return id<T?>(v = it) /*!! List<T?> */
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/singletons/enumEntry.fir.kt.txt b/compiler/testData/ir/irText/singletons/enumEntry.fir.kt.txt
new file mode 100644
index 00000000000..29498bc733d
--- /dev/null
+++ b/compiler/testData/ir/irText/singletons/enumEntry.fir.kt.txt
@@ -0,0 +1,38 @@
+open enum class Z : Enum<Z> {
+  private constructor() /* primary */ {
+    super/*Enum*/<Z>()
+    /* <init>() */
+
+  }
+
+  ENTRY = ENTRY()
+  private enum entry class ENTRY : Z {
+    private constructor() /* primary */ {
+      super/*Z*/()
+      /* <init>() */
+
+    }
+
+    fun test() {
+    }
+
+    inner class A {
+      constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      fun test2() {
+        <this>.test()
+      }
+
+    }
+
+  }
+
+  fun values(): Array<Z> /* Synthetic body for ENUM_VALUES */
+
+  fun valueOf(value: String): Z /* Synthetic body for ENUM_VALUEOF */
+
+}
diff --git a/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt b/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt
new file mode 100644
index 00000000000..98510fbd27f
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/builtinMap.fir.kt.txt
@@ -0,0 +1,9 @@
+fun <K1 : Any?, V1 : Any?> Map<out K1, V1>.plus(pair: Pair<K1, V1>): Map<K1, V1> {
+  return when {
+    <this>.isEmpty() -> mapOf<K1, V1>(pair = pair)
+    else -> LinkedHashMap<K1?, V1?>(p0 = <this>).apply<LinkedHashMap<K1?, V1?>>(block = local fun LinkedHashMap<K1?, V1?>.<anonymous>() {
+      return <this>.put(p0 = pair.<get-first>(), p1 = pair.<get-second>()) /*~> Unit */
+    }
+)
+  }
+}
diff --git a/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m1.fir.kt.txt b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m1.fir.kt.txt
new file mode 100644
index 00000000000..75c23ef42be
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m1.fir.kt.txt
@@ -0,0 +1,21 @@
+abstract class Base<T : Any?> {
+  constructor(x: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T
+    field = x
+    get
+
+  abstract fun <Y : Any?> foo(y: Y): T
+  abstract var bar: T
+    abstract get
+    abstract set
+
+  abstract var <Z : Any?> Z.exn: T
+    abstract get
+    abstract set
+
+}
diff --git a/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.fir.kt.txt b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.fir.kt.txt
new file mode 100644
index 00000000000..09a09d03532
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.fir.kt.txt
@@ -0,0 +1,24 @@
+class Derived1<T : Any?> : Base<T> {
+  constructor(x: T) /* primary */ {
+    super/*Base*/<T>(x = x)
+    /* <init>() */
+
+  }
+
+  override fun <Y : Any?> foo(y: Y): T {
+    return <this>.<get-x>()
+  }
+
+  override var bar: T
+    field = x
+    override get
+    override set
+
+  override var <Z : Any?> Z.exn: T
+    override get(): T {
+      return <this>.<get-x>()
+    }
+    override set(value: T) {
+    }
+
+}
diff --git a/compiler/testData/ir/irText/stubs/javaConstructorWithTypeParameters.fir.kt.txt b/compiler/testData/ir/irText/stubs/javaConstructorWithTypeParameters.fir.kt.txt
new file mode 100644
index 00000000000..cc8b41cd181
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/javaConstructorWithTypeParameters.fir.kt.txt
@@ -0,0 +1,15 @@
+fun test1(): J1<Int?> {
+  return J1<Int?>()
+}
+
+fun test2(): J1<Int?> {
+  return J1<Int?, Int?>(x1 = 1)
+}
+
+fun test3(j1: J1<Any>): J2<Int?, Any> {
+  return j1.J2<Int?>()
+}
+
+fun test4(j1: J1<Any>): J2<Int?, Any> {
+  return j1.J2<Int?, Int?>(x2 = 1)
+}
diff --git a/compiler/testData/ir/irText/stubs/javaEnum.fir.kt.txt b/compiler/testData/ir/irText/stubs/javaEnum.fir.kt.txt
new file mode 100644
index 00000000000..1bd552f2499
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/javaEnum.fir.kt.txt
@@ -0,0 +1,3 @@
+val test: @FlexibleNullability JEnum
+  field = JEnum.ONE
+  get
diff --git a/compiler/testData/ir/irText/stubs/javaInnerClass.fir.kt.txt b/compiler/testData/ir/irText/stubs/javaInnerClass.fir.kt.txt
new file mode 100644
index 00000000000..e2eb3738043
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/javaInnerClass.fir.kt.txt
@@ -0,0 +1,12 @@
+class Test1 : J {
+  constructor() /* primary */ {
+    super/*J*/()
+    /* <init>() */
+
+  }
+
+  val test: JInner
+    field = <this>.JInner()
+    get
+
+}
diff --git a/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.kt.txt b/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.kt.txt
new file mode 100644
index 00000000000..51f64ae6b60
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/javaSyntheticProperty.fir.kt.txt
@@ -0,0 +1,3 @@
+val test: String?
+  field = J().getFoo()
+  get
diff --git a/compiler/testData/ir/irText/stubs/jdkClassSyntheticProperty.fir.kt.txt b/compiler/testData/ir/irText/stubs/jdkClassSyntheticProperty.fir.kt.txt
new file mode 100644
index 00000000000..7b992fe5683
--- /dev/null
+++ b/compiler/testData/ir/irText/stubs/jdkClassSyntheticProperty.fir.kt.txt
@@ -0,0 +1,4 @@
+val Class<*>.test: Array<out Field?>?
+  get(): Array<out Field?>? {
+    return <this>.getDeclaredFields()
+  }
diff --git a/compiler/testData/ir/irText/types/abbreviatedTypes.fir.kt.txt b/compiler/testData/ir/irText/types/abbreviatedTypes.fir.kt.txt
new file mode 100644
index 00000000000..4a01af01494
--- /dev/null
+++ b/compiler/testData/ir/irText/types/abbreviatedTypes.fir.kt.txt
@@ -0,0 +1,17 @@
+typealias I = Int
+typealias L<T : Any?> = List<T>
+fun test1(x: List<Int>): List<Int> {
+  return x
+}
+
+fun test2(x: List<List<Int>>): List<List<Int>> {
+  return x
+}
+
+fun test3(x: List<List<Int>>): List<List<Int>> {
+  return x
+}
+
+fun test4(x: List<List<Int>>): List<List<Int>> {
+  return x
+}
diff --git a/compiler/testData/ir/irText/types/asOnPlatformType.fir.kt.txt b/compiler/testData/ir/irText/types/asOnPlatformType.fir.kt.txt
new file mode 100644
index 00000000000..d79d5a6bf74
--- /dev/null
+++ b/compiler/testData/ir/irText/types/asOnPlatformType.fir.kt.txt
@@ -0,0 +1,16 @@
+fun test() {
+  val nullStr: String? = nullString()
+  val nonnullStr: String? = nonnullString()
+  nullStr.foo<String?>() /*~> Unit */
+  nonnullStr.foo<String?>() /*~> Unit */
+  nullStr.fooN<String?>() /*~> Unit */
+  nonnullStr.fooN<String?>() /*~> Unit */
+}
+
+inline fun <reified T : Any?> T.foo(): T {
+  return <this> as T
+}
+
+inline fun <reified T : Any?> T.fooN(): T? {
+  return <this> as T?
+}
diff --git a/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt
new file mode 100644
index 00000000000..7613c9da99e
--- /dev/null
+++ b/compiler/testData/ir/irText/types/castsInsideCoroutineInference.fir.kt.txt
@@ -0,0 +1,143 @@
+@OptIn(markerClass = [ExperimentalTypeInference::class])
+fun <R : Any?> scopedFlow(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2<CoroutineScope, FlowCollector<R>, Unit>): Flow<R> {
+  return flow<R>(block = local suspend fun FlowCollector<R>.<anonymous>() {
+    val collector: FlowCollector<ErrorType /* ERROR */> = <this>
+    flowScope<Unit>(block = local suspend fun CoroutineScope.<anonymous>() {
+      block.invoke(p1 = <this>, p2 = collector)
+    }
+)
+  }
+)
+}
+
+fun <T : Any?> Flow<T>.onCompletion(action: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2<FlowCollector<T>, Throwable?, Unit>): Flow<T> {
+  return unsafeFlow<T>(block = local suspend fun FlowCollector<T>.<anonymous>() {
+    val safeCollector: SafeCollector<ErrorType /* ERROR */> = SafeCollector<ErrorType /* ERROR */>(collector = <this>)
+    safeCollector.invokeSafely<T>(action = action)
+  }
+)
+}
+
+suspend fun <T : Any?> FlowCollector<T>.invokeSafely(action: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction2<FlowCollector<T>, Throwable?, Unit>) {
+}
+
+@OptIn(markerClass = [ExperimentalTypeInference::class])
+inline fun <T : Any?> unsafeFlow(@BuilderInference crossinline block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<FlowCollector<T>, Unit>): Flow<T> {
+  return TODO()
+}
+
+@Deprecated(message = "binary compatibility with a version w/o FlowCollector receiver", level = DeprecationLevel.HIDDEN)
+fun <T : Any?> Flow<T>.onCompletion(action: SuspendFunction1<Throwable?, Unit>): ErrorType /* ERROR */ {
+  return error("") /* ERROR CALL */local fun <anonymous>() {
+    action.invoke(p1 = error("") /* ERROR CALL */)
+  }
+;
+}
+
+private fun CoroutineScope.asFairChannel(flow: Flow<*>): ReceiveChannel<Any> {
+  return <this>.produce<Any>(block = local suspend fun ProducerScope<Any>.<anonymous>() {
+    val channel: ChannelCoroutine<Any> = <this>.<get-channel>() as ChannelCoroutine<Any>
+    flow.collect<Any?>(action = local suspend fun <anonymous>(value: Any?) {
+      return channel.sendFair(element = { // BLOCK
+        val <elvis>: Any? = value
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> Any()
+          else -> <elvis> /*as Any */
+        }
+      })
+    }
+)
+  }
+)
+}
+
+private fun CoroutineScope.asChannel(flow: Flow<*>): ReceiveChannel<Any> {
+  return <this>.produce<Any>(block = local suspend fun ProducerScope<Any>.<anonymous>() {
+    flow.collect<Any?>(action = local suspend fun <anonymous>(value: Any?) {
+      return <this>.<get-channel>().send(e = { // BLOCK
+        val <elvis>: Any? = value
+        when {
+          EQEQ(arg0 = <elvis>, arg1 = null) -> Any()
+          else -> <elvis> /*as Any */
+        }
+      })
+    }
+)
+  }
+)
+}
+
+class SafeCollector<T : Any?> : FlowCollector<T> {
+  constructor(collector: FlowCollector<T>) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  internal val collector: FlowCollector<T>
+    field = collector
+    internal get
+
+  override suspend fun emit(value: T) {
+  }
+
+}
+
+@OptIn(markerClass = [ExperimentalTypeInference::class])
+fun <T : Any?> flow(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<FlowCollector<T>, Unit>): Flow<T> {
+  return TODO()
+}
+
+@OptIn(markerClass = [ExperimentalTypeInference::class])
+suspend fun <R : Any?> flowScope(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<CoroutineScope, R>): R {
+  return TODO()
+}
+
+suspend inline fun <T : Any?> Flow<T>.collect(crossinline action: SuspendFunction1<T, Unit>) {
+}
+
+open class ChannelCoroutine<E : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  suspend fun sendFair(element: E) {
+  }
+
+}
+
+interface CoroutineScope {
+
+}
+
+interface Flow<out T : Any?> {
+  abstract suspend fun collect(collector: FlowCollector<T>)
+
+}
+
+interface FlowCollector<in T : Any?> {
+  abstract suspend fun emit(value: T)
+
+}
+
+interface ReceiveChannel<out E : Any?> {
+
+}
+
+@OptIn(markerClass = [ExperimentalTypeInference::class])
+fun <E : Any?> CoroutineScope.produce(@BuilderInference block: @ExtensionFunctionType @ExtensionFunctionType SuspendFunction1<ProducerScope<E>, Unit>): ReceiveChannel<E> {
+  return TODO()
+}
+
+interface ProducerScope<in E : Any?> : CoroutineScope, SendChannel<E> {
+  abstract val channel: SendChannel<E>
+    abstract get
+
+}
+
+interface SendChannel<in E : Any?> {
+  abstract suspend fun send(e: E)
+
+}
diff --git a/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.kt.txt b/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.kt.txt
new file mode 100644
index 00000000000..f7ebf840dfd
--- /dev/null
+++ b/compiler/testData/ir/irText/types/genericDelegatedDeepProperty.fir.kt.txt
@@ -0,0 +1,145 @@
+class Value<T : Any?, IT : IR<T>> {
+  constructor(value1: T, value2: IT) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var value1: T
+    field = value1
+    get
+    set
+
+  val value2: IT
+    field = value2
+    get
+
+}
+
+interface IDelegate1<T1 : Any?, R1 : Any?> {
+  abstract operator fun getValue(t: T1, p: KProperty<*>): R1
+
+}
+
+interface IDelegate2<T2 : Any?, R2 : Any?> {
+  abstract operator fun getValue(t: T2, p: KProperty<*>): R2
+
+}
+
+interface IR<R : Any?> {
+  abstract fun foo(): R
+
+}
+
+class CR<R : Any?> : IR<R> {
+  constructor(r: R) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val r: R
+    field = r
+    get
+
+  override fun foo(): R {
+    return <this>.<get-r>()
+  }
+
+}
+
+class P<P1 : Any?, P2 : Any?> {
+  constructor(p1: P1, p2: P2) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val p1: P1
+    field = p1
+    get
+
+  val p2: P2
+    field = p2
+    get
+
+}
+
+val <T : Any?> Value<T, CR<T>>.additionalText: P<T, T> /* by */
+  field = { // BLOCK
+    local class <no name provided> : IDelegate1<Value<T, CR<T>>, P<T, T>> {
+      private constructor() /* primary */ {
+        super/*Any*/()
+        /* <init>() */
+
+      }
+
+      fun <F11T : Any?> qux11(t: F11T): F11T {
+        return t
+      }
+
+      fun <F12T : IR<T>> qux12(t: F12T): T {
+        return t.foo()
+      }
+
+      private val Value<T, CR<T>>.deepO: T /* by */
+        field = { // BLOCK
+          local class <no name provided> : IDelegate1<Value<T, CR<T>>, T> {
+            private constructor() /* primary */ {
+              super/*Any*/()
+              /* <init>() */
+
+            }
+
+            override operator fun getValue(t: Value<T, CR<T>>, p: KProperty<*>): T {
+              return t.<get-value1>()
+            }
+
+            fun <F21T : Any?> qux21(t: F21T): F21T {
+              return t
+            }
+
+            fun <F22T : IR<T>> qux22(t: F22T): T {
+              return t.foo()
+            }
+
+          }
+
+          <no name provided>()
+        }
+        get(): T {
+          return <this>.#deepO$delegate.getValue(t = <this>, p = <no name provided>::deepO)
+        }
+
+      private val Value<T, CR<T>>.deepK: T /* by */
+        field = { // BLOCK
+          local class <no name provided> : IDelegate1<Value<T, CR<T>>, T> {
+            private constructor() /* primary */ {
+              super/*Any*/()
+              /* <init>() */
+
+            }
+
+            override operator fun getValue(t: Value<T, CR<T>>, p: KProperty<*>): T {
+              return t.<get-value2>().foo()
+            }
+
+          }
+
+          <no name provided>()
+        }
+        get(): T {
+          return <this>.#deepK$delegate.getValue(t = <this>, p = <no name provided>::deepK)
+        }
+
+      override operator fun getValue(t: Value<T, CR<T>>, p: KProperty<*>): P<T, T> {
+        return P<T, T>(p1 = (<this>, t).<get-deepO>(), p2 = (<this>, t).<get-deepK>())
+      }
+
+    }
+
+    <no name provided>()
+  }
+  get(): P<T, T> {
+    return #additionalText$delegate.getValue(t = <this>, p = ::additionalText/*</* null */>()*/)
+  }
diff --git a/compiler/testData/ir/irText/types/genericFunWithStar.fir.kt.txt b/compiler/testData/ir/irText/types/genericFunWithStar.fir.kt.txt
new file mode 100644
index 00000000000..71bcaecd4ee
--- /dev/null
+++ b/compiler/testData/ir/irText/types/genericFunWithStar.fir.kt.txt
@@ -0,0 +1,29 @@
+interface IBase {
+
+}
+
+interface IFoo : IBase {
+
+}
+
+interface IBar : IBase {
+
+}
+
+interface I<G> where G : IFoo, G : IBar {
+
+}
+
+abstract class Box<T> : IFoo, IBar where T : IFoo, T : IBar {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  abstract fun <F> foo(tSerializer: I<F>): I<Box<F>> where F : IFoo, F : IBar
+  fun bar(vararg serializers: I<*>): I<*> {
+    return <this>.foo<IFoo>(tSerializer = serializers.get(index = 0))
+  }
+
+}
diff --git a/compiler/testData/ir/irText/types/genericPropertyReferenceType.fir.kt.txt b/compiler/testData/ir/irText/types/genericPropertyReferenceType.fir.kt.txt
new file mode 100644
index 00000000000..4a847278e99
--- /dev/null
+++ b/compiler/testData/ir/irText/types/genericPropertyReferenceType.fir.kt.txt
@@ -0,0 +1,33 @@
+class C<T : Any?> {
+  constructor(x: T) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  var x: T
+    field = x
+    get
+    set
+
+}
+
+var <T : Any?> C<T>.y: T
+  get(): T {
+    return <this>.<get-x>()
+  }
+  set(v: T) {
+    <this>.<set-x>(<set-?> = v)
+  }
+
+fun use(p: KMutableProperty<String>) {
+}
+
+fun test1() {
+  use(p = C<String>(x = "abc")::y/*<String>()*/)
+}
+
+fun test2(a: Any) {
+  a as C<String> /*~> Unit */
+  use(p = a /*as C<String> */::y/*<String>()*/)
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType1_NI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType1_NI.fir.kt.txt
new file mode 100644
index 00000000000..654a8722f94
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType1_NI.fir.kt.txt
@@ -0,0 +1,26 @@
+class In<in I : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun <S : Any?> select(x: S, y: S): S {
+  return x
+}
+
+fun <T : Any?> foo(a: Array<In<T>>, b: Array<In<String>>): Boolean {
+  return select<Array<out In<T>>>(x = a, y = b).get(index = 0).ofType<Any?>(y = true)
+}
+
+inline fun <reified K : Any?> In<K>.ofType(y: Any?): Boolean {
+  return y is K
+}
+
+fun test() {
+  val a1: Array<In<Int>> = arrayOf<In<Int>>(elements = [In<Int>()])
+  val a2: Array<In<String>> = arrayOf<In<String>>(elements = [In<String>()])
+  foo<Int>(a = a1, b = a2) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType1_OI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType1_OI.fir.kt.txt
new file mode 100644
index 00000000000..654a8722f94
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType1_OI.fir.kt.txt
@@ -0,0 +1,26 @@
+class In<in I : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun <S : Any?> select(x: S, y: S): S {
+  return x
+}
+
+fun <T : Any?> foo(a: Array<In<T>>, b: Array<In<String>>): Boolean {
+  return select<Array<out In<T>>>(x = a, y = b).get(index = 0).ofType<Any?>(y = true)
+}
+
+inline fun <reified K : Any?> In<K>.ofType(y: Any?): Boolean {
+  return y is K
+}
+
+fun test() {
+  val a1: Array<In<Int>> = arrayOf<In<Int>>(elements = [In<Int>()])
+  val a2: Array<In<String>> = arrayOf<In<String>>(elements = [In<String>()])
+  foo<Int>(a = a1, b = a2) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType2_NI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType2_NI.fir.kt.txt
new file mode 100644
index 00000000000..5c3a035fec9
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType2_NI.fir.kt.txt
@@ -0,0 +1,42 @@
+interface A<out T : Any?> {
+
+}
+
+interface Foo {
+
+}
+
+open class B : Foo, A<B> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+open class C : Foo, A<C> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun <T : Any?> run(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun foo(): Any {
+  return run<Foo>(fn = local fun <anonymous>(): Foo {
+    val mm: B = B()
+    val nn: C = C()
+    val c: Foo = when {
+      true -> mm
+      else -> nn
+    }
+    return c
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType2_OI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType2_OI.fir.kt.txt
new file mode 100644
index 00000000000..5c3a035fec9
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType2_OI.fir.kt.txt
@@ -0,0 +1,42 @@
+interface A<out T : Any?> {
+
+}
+
+interface Foo {
+
+}
+
+open class B : Foo, A<B> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+open class C : Foo, A<C> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun <T : Any?> run(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun foo(): Any {
+  return run<Foo>(fn = local fun <anonymous>(): Foo {
+    val mm: B = B()
+    val nn: C = C()
+    val c: Foo = when {
+      true -> mm
+      else -> nn
+    }
+    return c
+  }
+)
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType3_NI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType3_NI.fir.kt.txt
new file mode 100644
index 00000000000..92532b9cf0f
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType3_NI.fir.kt.txt
@@ -0,0 +1,63 @@
+interface In<in T : Any?> {
+
+}
+
+inline fun <reified T : Any?> In<T>.isT(): Boolean {
+  return <this> is T
+}
+
+inline fun <reified T : Any?> In<T>.asT() {
+  <this> as T /*~> Unit */
+}
+
+fun <S : Any?> sel(x: S, y: S): S {
+  return x
+}
+
+interface A {
+
+}
+
+interface B {
+
+}
+
+interface A1 : A {
+
+}
+
+interface A2 : A {
+
+}
+
+interface Z1 : A, B {
+
+}
+
+interface Z2 : A, B {
+
+}
+
+fun testInIs1(x: In<A>, y: In<B>): Boolean {
+  return sel<In<A>>(x = x, y = y).isT<Any>()
+}
+
+fun testInIs2(x: In<Z1>, y: In<Z2>): Boolean {
+  return sel<In<Z1>>(x = x, y = y).isT<Any>()
+}
+
+fun testInIs3(x: In<A1>, y: In<A2>): Boolean {
+  return sel<In<A1>>(x = x, y = y).isT<A>()
+}
+
+fun testInAs1(x: In<A>, y: In<B>) {
+  return sel<In<A>>(x = x, y = y).asT<Any>()
+}
+
+fun testInAs2(x: In<Z1>, y: In<Z2>) {
+  return sel<In<Z1>>(x = x, y = y).asT<Any>()
+}
+
+fun testInAs3(x: In<A1>, y: In<A2>) {
+  return sel<In<A1>>(x = x, y = y).asT<A>()
+}
diff --git a/compiler/testData/ir/irText/types/intersectionType3_OI.fir.kt.txt b/compiler/testData/ir/irText/types/intersectionType3_OI.fir.kt.txt
new file mode 100644
index 00000000000..92532b9cf0f
--- /dev/null
+++ b/compiler/testData/ir/irText/types/intersectionType3_OI.fir.kt.txt
@@ -0,0 +1,63 @@
+interface In<in T : Any?> {
+
+}
+
+inline fun <reified T : Any?> In<T>.isT(): Boolean {
+  return <this> is T
+}
+
+inline fun <reified T : Any?> In<T>.asT() {
+  <this> as T /*~> Unit */
+}
+
+fun <S : Any?> sel(x: S, y: S): S {
+  return x
+}
+
+interface A {
+
+}
+
+interface B {
+
+}
+
+interface A1 : A {
+
+}
+
+interface A2 : A {
+
+}
+
+interface Z1 : A, B {
+
+}
+
+interface Z2 : A, B {
+
+}
+
+fun testInIs1(x: In<A>, y: In<B>): Boolean {
+  return sel<In<A>>(x = x, y = y).isT<Any>()
+}
+
+fun testInIs2(x: In<Z1>, y: In<Z2>): Boolean {
+  return sel<In<Z1>>(x = x, y = y).isT<Any>()
+}
+
+fun testInIs3(x: In<A1>, y: In<A2>): Boolean {
+  return sel<In<A1>>(x = x, y = y).isT<A>()
+}
+
+fun testInAs1(x: In<A>, y: In<B>) {
+  return sel<In<A>>(x = x, y = y).asT<Any>()
+}
+
+fun testInAs2(x: In<Z1>, y: In<Z2>) {
+  return sel<In<Z1>>(x = x, y = y).asT<Any>()
+}
+
+fun testInAs3(x: In<A1>, y: In<A2>) {
+  return sel<In<A1>>(x = x, y = y).asT<A>()
+}
diff --git a/compiler/testData/ir/irText/types/javaWildcardType.fir.kt.txt b/compiler/testData/ir/irText/types/javaWildcardType.fir.kt.txt
new file mode 100644
index 00000000000..cf408d1cdea
--- /dev/null
+++ b/compiler/testData/ir/irText/types/javaWildcardType.fir.kt.txt
@@ -0,0 +1,53 @@
+interface K {
+  abstract fun kf1(): Collection<out CharSequence>
+  abstract fun kf2(): Collection<CharSequence>
+  abstract fun kg1(c: Collection<out CharSequence>)
+  abstract fun kg2(c: Collection<CharSequence>)
+
+}
+
+class C : J, K {
+  constructor(j: J, k: K) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = j
+    <this>.#<$$delegate_1> = k
+  }
+
+  override fun jf1(): Collection<out CharSequence?>? {
+    return <this>.#<$$delegate_0>.jf1()
+  }
+
+  override fun jf2(): Collection<CharSequence?>? {
+    return <this>.#<$$delegate_0>.jf2()
+  }
+
+  override fun jg1(c: Collection<out CharSequence?>?) {
+    <this>.#<$$delegate_0>.jg1(c = c)
+  }
+
+  override fun jg2(c: Collection<CharSequence?>?) {
+    <this>.#<$$delegate_0>.jg2(c = c)
+  }
+
+  local /*final field*/ val <$$delegate_0>: J
+  override fun kf1(): Collection<out CharSequence> {
+    return <this>.#<$$delegate_1>.kf1()
+  }
+
+  override fun kf2(): Collection<CharSequence> {
+    return <this>.#<$$delegate_1>.kf2()
+  }
+
+  override fun kg1(c: Collection<out CharSequence>) {
+    <this>.#<$$delegate_1>.kg1(c = c)
+  }
+
+  override fun kg2(c: Collection<CharSequence>) {
+    <this>.#<$$delegate_1>.kg2(c = c)
+  }
+
+  local /*final field*/ val <$$delegate_1>: K
+
+}
diff --git a/compiler/testData/ir/irText/types/localVariableOfIntersectionType_NI.fir.kt.txt b/compiler/testData/ir/irText/types/localVariableOfIntersectionType_NI.fir.kt.txt
new file mode 100644
index 00000000000..b1cd9cd8e15
--- /dev/null
+++ b/compiler/testData/ir/irText/types/localVariableOfIntersectionType_NI.fir.kt.txt
@@ -0,0 +1,32 @@
+interface In<in T : Any?> {
+
+}
+
+interface Inv<T : Any?> {
+  abstract val t: T
+    abstract get
+
+}
+
+interface Z {
+  abstract fun <T : Any?> create(x: In<T>, y: In<T>): Inv<T>
+
+}
+
+interface IA {
+  abstract fun foo()
+
+}
+
+interface IB {
+  abstract fun bar()
+
+}
+
+fun test(a: In<IA>, b: In<IB>, z: Z) {
+  z.create<IA>(x = a, y = b).<get-t>().foo()
+  z.create<IA>(x = a, y = b).<get-t>().bar()
+  val t: IA = z.create<IA>(x = a, y = b).<get-t>()
+  t.foo()
+  t.bar()
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullability.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullability.fir.kt.txt
new file mode 100644
index 00000000000..a7dcb33a84d
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullability.fir.kt.txt
@@ -0,0 +1,35 @@
+fun use(s: String) {
+}
+
+fun testUse() {
+  use(s = notNullString() /*!! String */)
+}
+
+fun testLocalVal() {
+  val local: String = notNullString() /*!! String */
+}
+
+fun testReturnValue(): String {
+  return notNullString() /*!! String */
+}
+
+val testGlobalVal: String
+  field = notNullString() /*!! String */
+  get
+
+val testGlobalValGetter: String
+  get(): String {
+    return notNullString() /*!! String */
+  }
+
+fun testJUse() {
+  use(s = nullString())
+  use(s = notNullString())
+}
+
+fun testLocalVarUse() {
+  val ns: String? = nullString()
+  use(s = ns)
+  val nns: String = notNullString() /*!! String */
+  use(s = nns)
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt
new file mode 100644
index 00000000000..e9c15dc1d1e
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInDestructuringAssignment.fir.kt.txt
@@ -0,0 +1,87 @@
+fun use(x: Any, y: Any) {
+}
+
+class P {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  operator fun component1(): Int {
+    return <this>.<get-x>()
+  }
+
+  operator fun component2(): Int {
+    return <this>.<get-y>()
+  }
+
+}
+
+class Q<T1 : Any?, T2 : Any?> {
+  constructor(x: T1, y: T2) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: T1
+    field = x
+    get
+
+  val y: T2
+    field = y
+    get
+
+  operator fun component1(): T1 {
+    return <this>.<get-x>()
+  }
+
+  operator fun component2(): T2 {
+    return <this>.<get-y>()
+  }
+
+}
+
+fun test1() {
+  val <destruct>: P = notNullP() /*!! P */
+  val x: Int = <destruct>.component1()
+  val y: Int = <destruct>.component2()
+  use(x = x, y = y)
+}
+
+fun test2() {
+  val <destruct>: Q<@FlexibleNullability String, String?>? = notNullComponents()
+  val x: @FlexibleNullability String = <destruct>.component1()
+  val y: String? = <destruct>.component2()
+  use(x = x, y = y /*!! String */)
+}
+
+fun test2Desugared() {
+  val tmp: Q<@FlexibleNullability String, String?>? = notNullComponents()
+  val x: @FlexibleNullability String = tmp.component1()
+  val y: String? = tmp.component2()
+  use(x = x, y = y /*!! String */)
+}
+
+fun test3() {
+  val <destruct>: Q<@FlexibleNullability String, String?> = notNullQAndComponents() /*!! Q<@FlexibleNullability String, String?> */
+  val x: @FlexibleNullability String = <destruct>.component1()
+  val y: String? = <destruct>.component2()
+  use(x = x, y = y /*!! String */)
+}
+
+fun test4() {
+  val <destruct>: IndexedValue<P?> = listOfNotNull().withIndex<P?>().first<IndexedValue<P?>>()
+  val x: Int = <destruct>.component1()
+  val y: P? = <destruct>.component2()
+  use(x = x, y = y /*!! P */)
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.fir.kt.txt
new file mode 100644
index 00000000000..d450046e42d
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/enhancedNullabilityInForLoop.fir.kt.txt
@@ -0,0 +1,121 @@
+fun use(s: P) {
+}
+
+fun testForInListUnused() {
+  { // BLOCK
+    val <iterator>: MutableIterator<P?> = listOfNotNull().iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: P? = <iterator>.next()
+    }
+  }
+}
+
+fun testForInListDestructured() {
+  { // BLOCK
+    val <iterator>: MutableIterator<P?> = listOfNotNull().iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val <destruct>: P? = <iterator>.next()
+      val x: Int = <destruct>.component1()
+      val y: Int = <destruct>.component2()
+    }
+  }
+}
+
+fun testDesugaredForInList() {
+  val iterator: MutableIterator<P?> = listOfNotNull().iterator()
+  while (iterator.hasNext()) { // BLOCK
+    val x: P? = iterator.next()
+  }
+}
+
+fun testForInArrayUnused(j: J) {
+  { // BLOCK
+    val <iterator>: Iterator<P?> = j.arrayOfNotNull().iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: P? = <iterator>.next()
+    }
+  }
+}
+
+fun testForInListUse() {
+  { // BLOCK
+    val <iterator>: MutableIterator<P?> = listOfNotNull().iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: P? = <iterator>.next()
+      use(s = x /*!! P */)
+      use(s = x)
+    }
+  }
+}
+
+fun testForInArrayUse(j: J) {
+  { // BLOCK
+    val <iterator>: Iterator<P?> = j.arrayOfNotNull().iterator()
+    while (<iterator>.hasNext()) { // BLOCK
+      val x: P? = <iterator>.next()
+      use(s = x /*!! P */)
+      use(s = x)
+    }
+  }
+}
+
+interface K {
+  abstract fun arrayOfNotNull(): Array<P>
+
+}
+
+data class P {
+  constructor(x: Int, y: Int) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  val x: Int
+    field = x
+    get
+
+  val y: Int
+    field = y
+    get
+
+  fun component1(): Int {
+    return <this>.#x
+  }
+
+  fun component2(): Int {
+    return <this>.#y
+  }
+
+  fun copy(x: Int = <this>.#x, y: Int = <this>.#y): P {
+    return P(x = x, y = y)
+  }
+
+  override fun equals(other: Any?): Boolean {
+    when {
+      EQEQEQ(arg0 = <this>, arg1 = other) -> return true
+    }
+    when {
+      other !is P -> return false
+    }
+    val tmp0_other_with_cast: P = other as P
+    when {
+      EQEQ(arg0 = <this>.#x, arg1 = tmp0_other_with_cast.#x).not() -> return false
+    }
+    when {
+      EQEQ(arg0 = <this>.#y, arg1 = tmp0_other_with_cast.#y).not() -> return false
+    }
+    return true
+  }
+
+  override fun hashCode(): Int {
+    var result: Int = <this>.#x.hashCode()
+    result = result.times(other = 31).plus(other = <this>.#y.hashCode())
+    return result
+  }
+
+  override fun toString(): String {
+    return "P(" + "x=" + <this>.#x + ", " + "y=" + <this>.#y + ")"
+  }
+
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/explicitEqualsAndCompareToCallsOnPlatformTypeReceiver.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/explicitEqualsAndCompareToCallsOnPlatformTypeReceiver.fir.kt.txt
new file mode 100644
index 00000000000..32b0c63114c
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/explicitEqualsAndCompareToCallsOnPlatformTypeReceiver.fir.kt.txt
@@ -0,0 +1,23 @@
+fun JavaClass.testPlatformEqualsPlatform(): Boolean {
+  return <this>.null0().equals(other = <this>.null0())
+}
+
+fun JavaClass.testPlatformEqualsKotlin(): Boolean {
+  return <this>.null0().equals(other = 0.0D)
+}
+
+fun JavaClass.testKotlinEqualsPlatform(): Boolean {
+  return 0.0D.equals(other = <this>.null0())
+}
+
+fun JavaClass.testPlatformCompareToPlatform(): Int {
+  return <this>.null0().compareTo(other = <this>.null0() /*!! Double */)
+}
+
+fun JavaClass.testPlatformCompareToKotlin(): Int {
+  return <this>.null0().compareTo(other = 0.0D)
+}
+
+fun JavaClass.testKotlinCompareToPlatform(): Int {
+  return 0.0D.compareTo(other = <this>.null0() /*!! Double */)
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.kt.txt
new file mode 100644
index 00000000000..cb7cf8d81b9
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/implicitNotNullOnPlatformType.fir.kt.txt
@@ -0,0 +1,42 @@
+fun f(s: String) {
+}
+
+class MySet : Set<String> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override val size: Int
+    override get(): Int {
+      return TODO()
+    }
+
+  override operator fun contains(element: String): Boolean {
+    return TODO()
+  }
+
+  override fun containsAll(elements: Collection<String>): Boolean {
+    return TODO()
+  }
+
+  override fun isEmpty(): Boolean {
+    return TODO()
+  }
+
+  override operator fun iterator(): Iterator<String> {
+    return TODO()
+  }
+
+}
+
+fun test() {
+  f(s = s() /*!! String */)
+  f(s = #STRING /*!! String */)
+}
+
+fun testContains(m: MySet) {
+  m.contains(element = #STRING /*!! String */) /*~> Unit */
+  m.contains(element = "abc") /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsT.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsT.fir.kt.txt
new file mode 100644
index 00000000000..98dece364c2
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsT.fir.kt.txt
@@ -0,0 +1,10 @@
+fun <T : Any?> useT(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useT<String?>(fn = local fun <anonymous>(): String? {
+    return string()
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTAny.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTAny.fir.kt.txt
new file mode 100644
index 00000000000..c0ce810e64c
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTAny.fir.kt.txt
@@ -0,0 +1,10 @@
+fun <T : Any> useTAny(fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useTAny<String?>(fn = local fun <anonymous>(): String? {
+    return string()
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTConstrained.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTConstrained.fir.kt.txt
new file mode 100644
index 00000000000..f32e62d9a75
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTConstrained.fir.kt.txt
@@ -0,0 +1,10 @@
+fun <T : Any?> useTConstrained(xs: Array<T>, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testWithNullCheck(xs: Array<String>) {
+  useTConstrained<String>(xs = xs, fn = local fun <anonymous>(): String {
+    return string() /*!! String */
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXArray.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXArray.fir.kt.txt
new file mode 100644
index 00000000000..ab0c1e2394d
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXArray.fir.kt.txt
@@ -0,0 +1,10 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck(xs: Array<String>) {
+  useTX<Serializable?>(x = xs, fn = local fun <anonymous>(): String? {
+    return string()
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXString.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXString.fir.kt.txt
new file mode 100644
index 00000000000..29ddc0f90e3
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullCheckOnLambdaResult/stringVsTXString.fir.kt.txt
@@ -0,0 +1,10 @@
+fun <T : Any?> useTX(x: T, fn: Function0<T>): T {
+  return fn.invoke()
+}
+
+fun testNoNullCheck() {
+  useTX<String?>(x = "", fn = local fun <anonymous>(): String? {
+    return string()
+  }
+) /*~> Unit */
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt
new file mode 100644
index 00000000000..df7c948dfc6
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/nullabilityAssertionOnExtensionReceiver.fir.kt.txt
@@ -0,0 +1,22 @@
+fun String.extension() {
+}
+
+class C {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun String.memberExtension() {
+  }
+
+}
+
+fun testExt() {
+  s().extension()
+}
+
+fun C.testMemberExt() {
+  (<this>, s()).memberExtension()
+}
diff --git a/compiler/testData/ir/irText/types/nullChecks/platformTypeReceiver.fir.kt.txt b/compiler/testData/ir/irText/types/nullChecks/platformTypeReceiver.fir.kt.txt
new file mode 100644
index 00000000000..69a464ef835
--- /dev/null
+++ b/compiler/testData/ir/irText/types/nullChecks/platformTypeReceiver.fir.kt.txt
@@ -0,0 +1,7 @@
+fun test1(): Boolean {
+  return #BOOL_NULL.equals(other = null)
+}
+
+fun test2(): Boolean {
+  return boolNull().equals(other = null)
+}
diff --git a/compiler/testData/ir/irText/types/rawTypeInSignature.fir.kt.txt b/compiler/testData/ir/irText/types/rawTypeInSignature.fir.kt.txt
new file mode 100644
index 00000000000..3494329f26d
--- /dev/null
+++ b/compiler/testData/ir/irText/types/rawTypeInSignature.fir.kt.txt
@@ -0,0 +1,82 @@
+class GenericInv<T : Number> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class GenericIn<in T : Number> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+class GenericOut<out T : Number> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+}
+
+fun testReturnsRawGenericInv(j: JRaw): GenericInv<*>? {
+  return j.returnsRawGenericInv()
+}
+
+fun testReturnsRawGenericIn(j: JRaw): GenericIn<Nothing>? {
+  return j.returnsRawGenericIn()
+}
+
+fun testReturnsRawGenericOut(j: JRaw): GenericOut<*>? {
+  return j.returnsRawGenericOut()
+}
+
+class KRaw : JRaw {
+  constructor(j: JRaw) /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+    <this>.#<$$delegate_0> = j
+  }
+
+  override fun takesRawList(list: List<*>?) {
+    <this>.#<$$delegate_0>.takesRawList(list = list)
+  }
+
+  override fun returnsRawList(): List<*>? {
+    return <this>.#<$$delegate_0>.returnsRawList()
+  }
+
+  override fun takesRawGenericInv(g: GenericInv<*>?) {
+    <this>.#<$$delegate_0>.takesRawGenericInv(g = g)
+  }
+
+  override fun returnsRawGenericInv(): GenericInv<*>? {
+    return <this>.#<$$delegate_0>.returnsRawGenericInv()
+  }
+
+  override fun takesRawGenericIn(g: GenericIn<Nothing>?) {
+    <this>.#<$$delegate_0>.takesRawGenericIn(g = g)
+  }
+
+  override fun returnsRawGenericIn(): GenericIn<Nothing>? {
+    return <this>.#<$$delegate_0>.returnsRawGenericIn()
+  }
+
+  override fun takesRawGenericOut(g: GenericOut<*>?) {
+    <this>.#<$$delegate_0>.takesRawGenericOut(g = g)
+  }
+
+  override fun returnsRawGenericOut(): GenericOut<*>? {
+    return <this>.#<$$delegate_0>.returnsRawGenericOut()
+  }
+
+  local /*final field*/ val <$$delegate_0>: JRaw
+
+}
diff --git a/compiler/testData/ir/irText/types/receiverOfIntersectionType.fir.kt.txt b/compiler/testData/ir/irText/types/receiverOfIntersectionType.fir.kt.txt
new file mode 100644
index 00000000000..b646192135e
--- /dev/null
+++ b/compiler/testData/ir/irText/types/receiverOfIntersectionType.fir.kt.txt
@@ -0,0 +1,60 @@
+interface K {
+
+}
+
+interface I : K {
+  abstract fun ff()
+
+}
+
+interface J : K {
+
+}
+
+class A : I, J {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override fun ff() {
+  }
+
+}
+
+class B : I, J {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  override fun ff() {
+  }
+
+}
+
+fun testIntersection(a: A, b: B) {
+  val v: I = when {
+    true -> a
+    else -> b
+  }
+  v.ff()
+}
+
+fun testFlexible1() {
+  val v: I? = when {
+    true -> a()
+    else -> b()
+  }
+  v.ff()
+}
+
+fun testFlexible2(a: A, b: B) {
+  val v: I? = when {
+    true -> id<A?>(x = a)
+    else -> id<B?>(x = b)
+  }
+  v.ff()
+}
diff --git a/compiler/testData/ir/irText/types/smartCastOnFakeOverrideReceiver.fir.kt.txt b/compiler/testData/ir/irText/types/smartCastOnFakeOverrideReceiver.fir.kt.txt
new file mode 100644
index 00000000000..afc88bcfc37
--- /dev/null
+++ b/compiler/testData/ir/irText/types/smartCastOnFakeOverrideReceiver.fir.kt.txt
@@ -0,0 +1,85 @@
+open class A {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun f(): Int {
+    return 1
+  }
+
+  val aVal: Int
+    field = 42
+    get
+
+  fun testA1(x: Any): Int? {
+    return when {
+      x is B -> x /*as B */.f()
+      else -> null
+    }
+  }
+
+  fun testA2(x: Any): Int? {
+    return when {
+      x is B -> x /*as B */.<get-aVal>()
+      else -> null
+    }
+  }
+
+}
+
+class B : A {
+  constructor() /* primary */ {
+    super/*A*/()
+    /* <init>() */
+
+  }
+
+  fun testB1(x: Any): Int? {
+    return when {
+      x is B -> x /*as B */.f()
+      else -> null
+    }
+  }
+
+  fun testB2(x: Any): Int? {
+    return when {
+      x is B -> x /*as B */.<get-aVal>()
+      else -> null
+    }
+  }
+
+}
+
+open class GA<T : Any?> {
+  constructor() /* primary */ {
+    super/*Any*/()
+    /* <init>() */
+
+  }
+
+  fun f(): Int {
+    return 1
+  }
+
+  val aVal: Int
+    field = 42
+    get
+
+}
+
+class GB<T : Any?, S : Any?> : GA<T> {
+  constructor() /* primary */ {
+    super/*GA*/<T>()
+    /* <init>() */
+
+  }
+
+  fun testGB1(a: Any) {
+    a as GB<Int, String> /*~> Unit */
+    a /*as GB<Int, String> */.f() /*~> Unit */
+    a /*as GB<Int, String> */.<get-aVal>() /*~> Unit */
+  }
+
+}
diff --git a/compiler/testData/ir/irText/types/smartCastOnFieldReceiverOfGenericType.fir.kt.txt b/compiler/testData/ir/irText/types/smartCastOnFieldReceiverOfGenericType.fir.kt.txt
new file mode 100644
index 00000000000..9f4b5251168
--- /dev/null
+++ b/compiler/testData/ir/irText/types/smartCastOnFieldReceiverOfGenericType.fir.kt.txt
@@ -0,0 +1,10 @@
+fun testSetField(a: Any, b: Any) {
+  a as JCell<String> /*~> Unit */
+  b as String /*~> Unit */
+  a /*as JCell<String> */.#value = b /*as String */
+}
+
+fun testGetField(a: Any): String {
+  a as JCell<String> /*~> Unit */
+  return a /*as JCell<String> */.#value /*!! String */
+}