Fix enum entry reference from enum entry initialization context

Enum entries are "special" kind of singletons that should be
referenced as a captured 'this' instance inside during entry
initialization, because corresponding static fields in enum class
are not initialized yet.

 #KT-7257 Fixed

compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass.kt

@@ -0,0 +1,24 @@
+// LANGUAGE_VERSION: 1.2
+
+enum class A {
+    X {
+        val x = "OK"
+
+        inner class Inner {
+            inner class Inner2 {
+                inner class Inner3 {
+                    val y = x
+                }
+            }
+        }
+
+        val z = Inner().Inner2().Inner3()
+
+        override val test: String
+            get() = z.y
+    };
+
+    abstract val test: String
+}
+
+fun box() = A.X.test

compiler/testData/codegen/box/enum/deepInnerClassInEnumEntryClass2.kt

@@ -0,0 +1,23 @@
+// LANGUAGE_VERSION: 1.2
+
+enum class A {
+    X {
+        val k = "K"
+
+        val anonObject = object {
+            inner class Inner {
+                val x = "O" + k
+            }
+
+            val innerX = Inner().x
+
+            override fun toString() = innerX
+        }
+
+        override val test = anonObject.toString()
+    };
+
+    abstract val test: String
+}
+
+fun box() = A.X.test

compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass.kt

@@ -0,0 +1,19 @@
+// LANGUAGE_VERSION: 1.2
+
+enum class A {
+    X {
+        val x = "OK"
+
+        inner class Inner {
+            fun foo() = x
+        }
+
+        val z = Inner()
+
+        override val test = z.foo()
+    };
+
+    abstract val test: String
+}
+
+fun box() = A.X.test

compiler/testData/codegen/box/enum/innerClassMethodInEnumEntryClass2.kt

@@ -0,0 +1,19 @@
+// LANGUAGE_VERSION: 1.2
+
+enum class A {
+    X {
+        val x = "OK"
+
+        inner class Inner {
+            fun foo() = this@X.x
+        }
+
+        val z = Inner()
+
+        override val test = z.foo()
+    };
+
+    abstract val test: String
+}
+
+fun box() = A.X.test

compiler/testData/codegen/box/enum/kt7257.kt

@@ -0,0 +1,10 @@
+enum class X {
+    B {
+        val value2 = "K"
+        override val value = "O".let { it + value2 }
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_anonObjectInit.kt

@@ -0,0 +1,17 @@
+enum class X {
+    B {
+        val value2 = "K"
+
+        val anonObject = object {
+            val value3 = "O" + value2
+
+            override fun toString(): String = value3
+        }
+
+        override val value = anonObject.toString()
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt

@@ -0,0 +1,16 @@
+enum class X {
+    B {
+        val value2 = "K"
+
+        val anonObject = object {
+            override fun toString(): String =
+                    "O" + value2
+        }
+
+        override val value = anonObject.toString()
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_boundReference1.kt

@@ -0,0 +1,21 @@
+// LANGUAGE_VERSION: 1.2
+
+enum class X {
+    B {
+        val k = "K"
+
+        inner class Inner {
+            fun foo() = "O" + k
+        }
+
+        val inner = Inner()
+
+        val bmr = inner::foo
+
+        override val value = bmr.invoke()
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_boundReference2.kt

@@ -0,0 +1,18 @@
+enum class X {
+    B {
+
+        override val value = "OK"
+
+        val bmr = B::value.get()
+
+        override fun foo(): String {
+            return bmr
+        }
+    };
+
+    abstract val value: String
+
+    abstract fun foo(): String
+}
+
+fun box() = X.B.foo()

compiler/testData/codegen/box/enum/kt7257_boundReferenceWithImplicitReceiver.kt

@@ -0,0 +1,16 @@
+// LANGUAGE_VERSION: 1.2
+// IGNORE_BACKEND: JS
+
+enum class X {
+    B {
+        override val value = "OK"
+
+        override val test = ::value.get()
+    };
+
+    abstract val value: String
+
+    abstract val test: String
+}
+
+fun box() = X.B.test

compiler/testData/codegen/box/enum/kt7257_explicitReceiver.kt

@@ -0,0 +1,11 @@
+enum class X {
+    B {
+        override val value2 = "K"
+        override val value = "O" + B.value2
+    };
+
+    abstract val value2: String
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_fullyQualifiedReceiver.kt

@@ -0,0 +1,11 @@
+enum class X {
+    B {
+        override val value2 = "K"
+        override val value = "O" + X.B.value2
+    };
+
+    abstract val value2: String
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_namedLocalFun.kt

@@ -0,0 +1,17 @@
+enum class X {
+    B {
+        val value2 = "K"
+
+        val value3: String
+        init {
+            fun foo() = value2
+            value3 = "O" + foo()
+        }
+
+        override val value = value3
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value

compiler/testData/codegen/box/enum/kt7257_notInline.kt

@@ -0,0 +1,13 @@
+fun <T, R> T.letNoInline(fn: (T) -> R) =
+        fn(this)
+
+enum class X {
+    B {
+        val value2 = "K"
+        override val value = "O".letNoInline { it + value2 }
+    };
+
+    abstract val value: String
+}
+
+fun box() = X.B.value