diff --git a/compiler/testData/ir/irText/classes/classes.kt.txt b/compiler/testData/ir/irText/classes/classes.kt.txt
index e1e793454e9..e92e77ca60b 100644
--- a/compiler/testData/ir/irText/classes/classes.kt.txt
+++ b/compiler/testData/ir/irText/classes/classes.kt.txt
@@ -27,7 +27,7 @@ annotation class TestAnnotationClass : Annotation {
 
 enum class TestEnumClass : Enum<TestEnumClass> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnumClass>()
         /* InstanceInitializerCall */
 
   }
diff --git a/compiler/testData/ir/irText/classes/enum.kt.txt b/compiler/testData/ir/irText/classes/enum.kt.txt
index b8ac6ed26ab..37cbf03ac13 100644
--- a/compiler/testData/ir/irText/classes/enum.kt.txt
+++ b/compiler/testData/ir/irText/classes/enum.kt.txt
@@ -1,11 +1,13 @@
 enum class TestEnum1 : Enum<TestEnum1> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum1>()
         /* InstanceInitializerCall */
 
   }
 
-  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")
+  TEST1 = TestEnum1()
+
+  TEST2 = TestEnum1()
 
   fun values(): Array<TestEnum1> /* Synthetic body for ENUM_VALUES */
 
@@ -15,7 +17,7 @@ enum class TestEnum1 : Enum<TestEnum1> {
 
 enum class TestEnum2 : Enum<TestEnum2> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum2>()
         /* InstanceInitializerCall */
 
   }
@@ -24,7 +26,11 @@ enum class TestEnum2 : Enum<TestEnum2> {
     field = x
     get
 
-  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  TEST3 init = TODO("IrEnumConstructorCall")
+  TEST1 = TestEnum2(x = 1)
+
+  TEST2 = TestEnum2(x = 2)
+
+  TEST3 = TestEnum2(x = 3)
 
   fun values(): Array<TestEnum2> /* Synthetic body for ENUM_VALUES */
 
@@ -34,12 +40,26 @@ enum class TestEnum2 : Enum<TestEnum2> {
 
 abstract enum class TestEnum3 : Enum<TestEnum3> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum3>()
         /* InstanceInitializerCall */
 
   }
 
-  TEST init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+  TEST = TEST()
+  private enum entry class TEST : TestEnum3 {
+    private constructor() /* primary */ {
+      super/*TestEnum3*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+      println(message = "Hello, world!")
+    }
+
+  }
+
+  abstract fun foo() 
 
   fun values(): Array<TestEnum3> /* Synthetic body for ENUM_VALUES */
 
@@ -49,7 +69,7 @@ abstract enum class TestEnum3 : Enum<TestEnum3> {
 
 abstract enum class TestEnum4 : Enum<TestEnum4> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum4>()
         /* InstanceInitializerCall */
 
   }
@@ -58,7 +78,42 @@ abstract enum class TestEnum4 : Enum<TestEnum4> {
     field = x
     get
 
-  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+  TEST1 = TEST1()
+  private enum entry class TEST1 : TestEnum4 {
+    private constructor() /* primary */ {
+      super/*TestEnum4*/(x = 1) /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+      println(message = TestEnum4)
+    }
+
+  }
+
+  TEST2 = TEST2()
+  private enum entry class TEST2 : TestEnum4 {
+    private constructor() /* primary */ {
+      super/*TestEnum4*/(x = 2) /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    val z: Int
+      get
+
+    init {
+      #z = <this>.<get-x>()
+    }
+
+    override fun foo() {
+      println(message = TestEnum4)
+    }
+
+  }
+
+  abstract fun foo() 
 
   fun values(): Array<TestEnum4> /* Synthetic body for ENUM_VALUES */
 
@@ -68,7 +123,7 @@ abstract enum class TestEnum4 : Enum<TestEnum4> {
 
 enum class TestEnum5 : Enum<TestEnum5> {
   private constructor(x: Int = 0) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum5>()
         /* InstanceInitializerCall */
 
   }
@@ -77,7 +132,11 @@ enum class TestEnum5 : Enum<TestEnum5> {
     field = x
     get
 
-  TEST1 init = TODO("IrEnumConstructorCall")  TEST2 init = TODO("IrEnumConstructorCall")  TEST3 init = TODO("IrEnumConstructorCall")
+  TEST1 = TestEnum5()
+
+  TEST2 = TestEnum5()
+
+  TEST3 = TestEnum5(x = 0)
 
   fun values(): Array<TestEnum5> /* Synthetic body for ENUM_VALUES */
 
@@ -91,7 +150,7 @@ fun f(): Int {
 
 enum class TestEnum6 : Enum<TestEnum6> {
   private constructor(x: Int, y: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum6>()
         /* InstanceInitializerCall */
 
   }
@@ -104,10 +163,10 @@ enum class TestEnum6 : Enum<TestEnum6> {
     field = y
     get
 
-  TEST init = { // BLOCK
+  TEST = { // BLOCK
     val tmp0_y: Int = f()
     val tmp1_x: Int = f()
-    TODO("IrEnumConstructorCall")
+    TestEnum6(x = tmp1_x, y = tmp0_y)
   }
 
   fun values(): Array<TestEnum6> /* Synthetic body for ENUM_VALUES */
diff --git a/compiler/testData/ir/irText/classes/enumClassModality.kt.txt b/compiler/testData/ir/irText/classes/enumClassModality.kt.txt
index 4443fe2d8a7..df83a07a71b 100644
--- a/compiler/testData/ir/irText/classes/enumClassModality.kt.txt
+++ b/compiler/testData/ir/irText/classes/enumClassModality.kt.txt
@@ -1,11 +1,11 @@
 enum class TestFinalEnum1 : Enum<TestFinalEnum1> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestFinalEnum1>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")
+  X1 = TestFinalEnum1()
 
   fun values(): Array<TestFinalEnum1> /* Synthetic body for ENUM_VALUES */
 
@@ -15,7 +15,7 @@ enum class TestFinalEnum1 : Enum<TestFinalEnum1> {
 
 enum class TestFinalEnum2 : Enum<TestFinalEnum2> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestFinalEnum2>()
         /* InstanceInitializerCall */
 
   }
@@ -24,7 +24,7 @@ enum class TestFinalEnum2 : Enum<TestFinalEnum2> {
     field = x
     get
 
-  X1 init = TODO("IrEnumConstructorCall")
+  X1 = TestFinalEnum2(x = 1)
 
   fun values(): Array<TestFinalEnum2> /* Synthetic body for ENUM_VALUES */
 
@@ -34,12 +34,14 @@ enum class TestFinalEnum2 : Enum<TestFinalEnum2> {
 
 enum class TestFinalEnum3 : Enum<TestFinalEnum3> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestFinalEnum3>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")  fun doStuff() {
+  X1 = TestFinalEnum3()
+
+  fun doStuff() {
   }
 
   fun values(): Array<TestFinalEnum3> /* Synthetic body for ENUM_VALUES */
@@ -50,12 +52,24 @@ enum class TestFinalEnum3 : Enum<TestFinalEnum3> {
 
 open enum class TestOpenEnum1 : Enum<TestOpenEnum1> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestOpenEnum1>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")
+  X1 = X1()
+  private enum entry class X1 : TestOpenEnum1 {
+    private constructor() /* primary */ {
+      super/*TestOpenEnum1*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun toString(): String {
+      return "X1"
+    }
+
+  }
 
   fun values(): Array<TestOpenEnum1> /* Synthetic body for ENUM_VALUES */
 
@@ -65,12 +79,25 @@ open enum class TestOpenEnum1 : Enum<TestOpenEnum1> {
 
 open enum class TestOpenEnum2 : Enum<TestOpenEnum2> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestOpenEnum2>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")  open fun foo() {
+  X1 = X1()
+  private enum entry class X1 : TestOpenEnum2 {
+    private constructor() /* primary */ {
+      super/*TestOpenEnum2*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
+
+  open fun foo() {
   }
 
   fun values(): Array<TestOpenEnum2> /* Synthetic body for ENUM_VALUES */
@@ -81,12 +108,25 @@ open enum class TestOpenEnum2 : Enum<TestOpenEnum2> {
 
 abstract enum class TestAbstractEnum1 : Enum<TestAbstractEnum1> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestAbstractEnum1>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")  abstract fun foo() 
+  X1 = X1()
+  private enum entry class X1 : TestAbstractEnum1 {
+    private constructor() /* primary */ {
+      super/*TestAbstractEnum1*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
+
+  abstract fun foo() 
 
   fun values(): Array<TestAbstractEnum1> /* Synthetic body for ENUM_VALUES */
 
@@ -101,12 +141,23 @@ interface IFoo {
 
 abstract enum class TestAbstractEnum2 : Enum<TestAbstractEnum2>, IFoo {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestAbstractEnum2>()
         /* InstanceInitializerCall */
 
   }
 
-  X1 init = TODO("IrEnumConstructorCall")
+  X1 = X1()
+  private enum entry class X1 : TestAbstractEnum2 {
+    private constructor() /* primary */ {
+      super/*TestAbstractEnum2*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+    }
+
+  }
 
   fun values(): Array<TestAbstractEnum2> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt.txt b/compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt.txt
index fc478384828..b32cb50bb3c 100644
--- a/compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt.txt
+++ b/compiler/testData/ir/irText/classes/enumWithMultipleCtors.kt.txt
@@ -1,5 +1,23 @@
 open enum class A : Enum<A> {
-  X init = TODO("IrEnumConstructorCall")  Y init = TODO("IrEnumConstructorCall")  Z init = TODO("IrEnumConstructorCall")  val prop1: String
+  X = A(arg = "asd")
+
+  Y = Y()
+  private enum entry class Y : A {
+    private constructor() /* primary */ {
+      super/*A*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun f(): String {
+      return super.f().plus(other = "#Y")
+    }
+
+  }
+
+  Z = A(x = 5)
+
+  val prop1: String
     get
 
   val prop2: String
@@ -12,14 +30,14 @@ open enum class A : Enum<A> {
     set
 
   private constructor(arg: String) {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<A>()
         /* InstanceInitializerCall */
 
     #prop1 = arg
   }
 
   private constructor() {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<A>()
         /* InstanceInitializerCall */
 
     #prop1 = "default"
diff --git a/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt.txt b/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt.txt
index 995c4521e02..263a8dd14b0 100644
--- a/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt.txt
+++ b/compiler/testData/ir/irText/classes/enumWithSecondaryCtor.kt.txt
@@ -1,6 +1,6 @@
 enum class Test0 : Enum<Test0> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<Test0>()
         /* InstanceInitializerCall */
 
   }
@@ -9,7 +9,9 @@ enum class Test0 : Enum<Test0> {
     field = x
     get
 
-  ZERO init = TODO("IrEnumConstructorCall")  private constructor() {
+  ZERO = Test0()
+
+  private constructor() {
     this/*Test0*/(x = 0)
   }
 
@@ -21,7 +23,7 @@ enum class Test0 : Enum<Test0> {
 
 enum class Test1 : Enum<Test1> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<Test1>()
         /* InstanceInitializerCall */
 
   }
@@ -30,7 +32,11 @@ enum class Test1 : Enum<Test1> {
     field = x
     get
 
-  ZERO init = TODO("IrEnumConstructorCall")  ONE init = TODO("IrEnumConstructorCall")  private constructor() {
+  ZERO = Test1()
+
+  ONE = Test1(x = 1)
+
+  private constructor() {
     this/*Test1*/(x = 0)
   }
 
@@ -42,7 +48,7 @@ enum class Test1 : Enum<Test1> {
 
 abstract enum class Test2 : Enum<Test2> {
   private constructor(x: Int) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<Test2>()
         /* InstanceInitializerCall */
 
   }
@@ -51,7 +57,35 @@ abstract enum class Test2 : Enum<Test2> {
     field = x
     get
 
-  ZERO init = TODO("IrEnumConstructorCall")  ONE init = TODO("IrEnumConstructorCall")  private constructor() {
+  ZERO = ZERO()
+  private enum entry class ZERO : Test2 {
+    private constructor() /* primary */ {
+      super/*Test2*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+      println(message = "ZERO")
+    }
+
+  }
+
+  ONE = ONE()
+  private enum entry class ONE : Test2 {
+    private constructor() /* primary */ {
+      super/*Test2*/(x = 1) /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    override fun foo() {
+      println(message = "ONE")
+    }
+
+  }
+
+  private constructor() {
     this/*Test2*/(x = 0)
   }
 
diff --git a/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt.txt b/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt.txt
index 534e06beef1..d847caba86d 100644
--- a/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt.txt
+++ b/compiler/testData/ir/irText/declarations/annotations/classesWithAnnotations.kt.txt
@@ -53,7 +53,7 @@ class Host {
 @TestAnn(x = "enum")
 enum class TestEnum : Enum<TestEnum> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum>()
         /* InstanceInitializerCall */
 
   }
diff --git a/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt.txt b/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt.txt
index 02edbb448d9..c75c1884183 100644
--- a/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt.txt
+++ b/compiler/testData/ir/irText/declarations/annotations/enumEntriesWithAnnotations.kt.txt
@@ -8,14 +8,29 @@ annotation class TestAnn : Annotation {
 
 open enum class TestEnum : Enum<TestEnum> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<TestEnum>()
         /* InstanceInitializerCall */
 
   }
 
   @TestAnn(x = "ENTRY1")
-  ENTRY1 init = TODO("IrEnumConstructorCall")  @TestAnn(x = "ENTRY2")
-  ENTRY2 init = TODO("IrEnumConstructorCall")
+  ENTRY1 = TestEnum()
+
+  @TestAnn(x = "ENTRY2")
+  ENTRY2 = ENTRY2()
+  @TestAnn(x = "ENTRY2")
+  private enum entry class ENTRY2 : TestEnum {
+    private constructor() /* primary */ {
+      super/*TestEnum*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    val x: Int
+      field = 42
+      get
+
+  }
 
   fun values(): Array<TestEnum> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt.txt b/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt.txt
index d65b4df9e6d..d242b9165bf 100644
--- a/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt.txt
+++ b/compiler/testData/ir/irText/declarations/annotations/enumsInAnnotationArguments.kt.txt
@@ -1,11 +1,17 @@
 enum class En : Enum<En> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<En>()
         /* InstanceInitializerCall */
 
   }
 
-  A init = TODO("IrEnumConstructorCall")  B init = TODO("IrEnumConstructorCall")  C init = TODO("IrEnumConstructorCall")  D init = TODO("IrEnumConstructorCall")
+  A = En()
+
+  B = En()
+
+  C = En()
+
+  D = En()
 
   fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt.txt b/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt.txt
index 8dc5853177d..c7f3b5d4ed7 100644
--- a/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt.txt
+++ b/compiler/testData/ir/irText/declarations/multiplatform/expectedEnumClass.kt.txt
@@ -1,5 +1,6 @@
 expect enum class MyEnum : Enum<MyEnum> {
   FOO
+
   BAR
 
   fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
@@ -10,12 +11,16 @@ expect enum class MyEnum : Enum<MyEnum> {
 
 enum class MyEnum : Enum<MyEnum> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<MyEnum>()
         /* InstanceInitializerCall */
 
   }
 
-  FOO init = TODO("IrEnumConstructorCall")  BAR init = TODO("IrEnumConstructorCall")  BAZ init = TODO("IrEnumConstructorCall")
+  FOO = MyEnum()
+
+  BAR = MyEnum()
+
+  BAZ = MyEnum()
 
   fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.kt.txt b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.kt.txt
index e28e71ff06a..34bf34fce0e 100644
--- a/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.kt.txt
+++ b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.kt.txt
@@ -1,11 +1,32 @@
 abstract enum class X : Enum<X> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<X>()
         /* InstanceInitializerCall */
 
   }
 
-  B init = TODO("IrEnumConstructorCall")  abstract val value: Function0<String>
+  B = B()
+  private enum entry class B : X {
+    private constructor() /* primary */ {
+      super/*X*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    val value2: String
+      field = "OK"
+      get
+
+    override val value: Function0<String>
+      field =       local fun <anonymous>(): String {
+        return B.<get-value2>()
+      }
+
+      override get
+
+  }
+
+  abstract val value: Function0<String>
     abstract get
 
   fun values(): Array<X> /* Synthetic body for ENUM_VALUES */
diff --git a/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.kt.txt b/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.kt.txt
index 054127a2884..7aa56b4715f 100644
--- a/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.kt.txt
+++ b/compiler/testData/ir/irText/expressions/enumEntryReferenceFromEnumEntryClass.kt.txt
@@ -1,11 +1,65 @@
 open enum class MyEnum : Enum<MyEnum> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<MyEnum>()
         /* InstanceInitializerCall */
 
   }
 
-  Z init = TODO("IrEnumConstructorCall")
+  Z = Z()
+  private enum entry class Z : MyEnum {
+    private constructor() /* primary */ {
+      super/*MyEnum*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    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>() {
+        Z.<set-counter>(<set-?> = 1)
+        Z.foo()
+      }
+
+      get
+
+    val anObject: Any
+      field = { // BLOCK
+        local class <no name provided> {
+          constructor() /* primary */ {
+            super/*Any*/()
+                        /* InstanceInitializerCall */
+
+          }
+
+          init {
+            Z.<set-counter>(<set-?> = 1)
+            Z.foo()
+          }
+
+          fun test() {
+            Z.<set-counter>(<set-?> = 1)
+            Z.foo()
+          }
+
+        }
+
+        <no name provided>()
+      }
+      get
+
+  }
 
   fun values(): Array<MyEnum> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt.txt b/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt.txt
index 7c80a404e92..0b8c3ca9914 100644
--- a/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt.txt
+++ b/compiler/testData/ir/irText/expressions/exhaustiveWhenElseBranch.kt.txt
@@ -1,11 +1,11 @@
 enum class A : Enum<A> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<A>()
         /* InstanceInitializerCall */
 
   }
 
-  V1 init = TODO("IrEnumConstructorCall")
+  V1 = A()
 
   fun values(): Array<A> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/expressions/objectAsCallable.kt.txt b/compiler/testData/ir/irText/expressions/objectAsCallable.kt.txt
index 3d214de2022..4db230c91ce 100644
--- a/compiler/testData/ir/irText/expressions/objectAsCallable.kt.txt
+++ b/compiler/testData/ir/irText/expressions/objectAsCallable.kt.txt
@@ -9,12 +9,12 @@ object A {
 
 enum class En : Enum<En> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<En>()
         /* InstanceInitializerCall */
 
   }
 
-  X init = TODO("IrEnumConstructorCall")
+  X = En()
 
   fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.kt.txt b/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.kt.txt
index 54533111596..512cf347e1e 100644
--- a/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.kt.txt
+++ b/compiler/testData/ir/irText/expressions/temporaryInEnumEntryInitializer.kt.txt
@@ -4,7 +4,7 @@ val n: Any?
 
 enum class En : Enum<En> {
   private constructor(x: String?) /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<En>()
         /* InstanceInitializerCall */
 
   }
@@ -13,7 +13,13 @@ enum class En : Enum<En> {
     field = x
     get
 
-  ENTRY init = TODO("IrEnumConstructorCall")
+  ENTRY = En(x = { // BLOCK
+    val tmp0_safe_receiver: Any? = <get-n>()
+    when {
+      EQEQ(arg0 = tmp0_safe_receiver, arg1 = null) -> null
+      true -> tmp0_safe_receiver.toString()
+    }
+  })
 
   fun values(): Array<En> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/expressions/values.kt.txt b/compiler/testData/ir/irText/expressions/values.kt.txt
index 98c2fc9ffe1..67145c6a26c 100644
--- a/compiler/testData/ir/irText/expressions/values.kt.txt
+++ b/compiler/testData/ir/irText/expressions/values.kt.txt
@@ -1,11 +1,11 @@
 enum class Enum : Enum<Enum> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<Enum>()
         /* InstanceInitializerCall */
 
   }
 
-  A init = TODO("IrEnumConstructorCall")
+  A = Enum()
 
   fun values(): Array<Enum> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/firProblems/FirBuilder.kt.txt b/compiler/testData/ir/irText/firProblems/FirBuilder.kt.txt
index ab83025d3a4..a8dfae53657 100644
--- a/compiler/testData/ir/irText/firProblems/FirBuilder.kt.txt
+++ b/compiler/testData/ir/irText/firProblems/FirBuilder.kt.txt
@@ -5,10 +5,6 @@ open class BaseConverter : BaseFirBuilder<Any> {
 
   }
 
-
-
-
-
 }
 
 class DeclarationsConverter : BaseConverter {
@@ -18,9 +14,5 @@ class DeclarationsConverter : BaseConverter {
 
   }
 
-
-
-
-
 }
 
diff --git a/compiler/testData/ir/irText/singletons/enumEntry.kt.txt b/compiler/testData/ir/irText/singletons/enumEntry.kt.txt
index 6a61e578825..8aa4260c3f1 100644
--- a/compiler/testData/ir/irText/singletons/enumEntry.kt.txt
+++ b/compiler/testData/ir/irText/singletons/enumEntry.kt.txt
@@ -1,11 +1,35 @@
 open enum class Z : Enum<Z> {
   private constructor() /* primary */ {
-    TODO("IrEnumConstructorCall")
+    super/*Enum*/<Z>()
         /* InstanceInitializerCall */
 
   }
 
-  ENTRY init = TODO("IrEnumConstructorCall")
+  ENTRY = ENTRY()
+  private enum entry class ENTRY : Z {
+    private constructor() /* primary */ {
+      super/*Z*/() /*~> Unit */
+            /* InstanceInitializerCall */
+
+    }
+
+    fun test() {
+    }
+
+    inner class A {
+      constructor() /* primary */ {
+        super/*Any*/()
+                /* InstanceInitializerCall */
+
+      }
+
+      fun test2() {
+        ENTRY.test()
+      }
+
+    }
+
+  }
 
   fun values(): Array<Z> /* Synthetic body for ENUM_VALUES */
 
diff --git a/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.kt.txt b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.kt.txt
index 53407fa0166..76e949db83f 100644
--- a/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.kt.txt
+++ b/compiler/testData/ir/irText/stubs/genericClassInDifferentModule_m2.kt.txt
@@ -21,8 +21,5 @@ class Derived1<T : Any?> : Base<T> {
     override set(value: T) {
     }
 
-
-
-
 }