Update box tests to 1.2.0-rc-39

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor1.kt

@@ -0,0 +1,24 @@
+interface IFoo {
+    fun foo(): String
+}
+
+interface IBar {
+    fun bar(): String
+}
+
+abstract class Base(val x: IFoo)
+
+enum class Test : IFoo, IBar {
+    FOO {
+        // FOO referenced from inner class constructor with uninitialized 'this'
+        inner class Inner : Base(FOO)
+
+        val z = Inner()
+
+        override fun foo() = "OK"
+
+        override fun bar() = z.x.foo()
+    }
+}
+
+fun box() = Test.FOO.bar()

backend.native/tests/external/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor2.kt

@@ -0,0 +1,24 @@
+interface IFoo {
+    fun foo(): String
+}
+
+interface IBar {
+    fun bar(): String
+}
+
+enum class Test : IFoo, IBar {
+    FOO {
+        // FOO referenced from inner class constructor with initialized 'this'
+        inner class Inner {
+            val fooFoo = FOO.foo()
+        }
+
+        val z = Inner()
+
+        override fun foo() = "OK"
+
+        override fun bar() = z.fooFoo
+    }
+}
+
+fun box() = Test.FOO.bar()

backend.native/tests/external/codegen/box/enum/enumEntryReferenceFromInnerClassConstructor3.kt

@@ -0,0 +1,23 @@
+interface IFoo {
+    fun foo(): String
+}
+
+interface IBar {
+    fun bar(): String
+}
+
+enum class Test : IFoo, IBar {
+    FOO {
+        // FOO referenced from inner class constructor with initialized 'this',
+        // in delegate initializer
+        inner class Inner : IFoo by FOO
+
+        val z = Inner()
+
+        override fun foo() = "OK"
+
+        override fun bar() = z.foo()
+    }
+}
+
+fun box() = Test.FOO.bar()

backend.native/tests/external/codegen/box/enum/innerClassInEnumEntryClass.kt

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

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/codegen/box/enum/kt20651.kt

@@ -0,0 +1,14 @@
+enum class Test(val x: String, val closure1: () -> String) {
+    FOO("O", { FOO.x }) {
+        override val y: String = "K"
+        val closure2 = { y } // Implicit 'FOO'
+        override val z: String = closure2()
+    };
+
+    abstract val y: String
+    abstract val z: String
+
+    fun test() = closure1() + z
+}
+
+fun box() = Test.FOO.test()

backend.native/tests/external/codegen/box/enum/kt20651_inlineLambda.kt

@@ -0,0 +1,14 @@
+enum class Test(val x: String, val closure1: () -> String) {
+    FOO("O", run { { FOO.x } }) {
+        override val y: String = "K"
+        val closure2 = { y } // Implicit 'FOO'
+        override val z: String = closure2()
+    };
+
+    abstract val y: String
+    abstract val z: String
+
+    fun test() = closure1() + z
+}
+
+fun box() = Test.FOO.test()

backend.native/tests/external/codegen/box/enum/kt20651a.kt

@@ -0,0 +1,8 @@
+enum class Foo(
+        val x: String,
+        val callback: () -> String
+) {
+    FOO("OK", { FOO.x })
+}
+
+fun box() = Foo.FOO.callback()

backend.native/tests/external/codegen/box/enum/kt20651b.kt

@@ -0,0 +1,17 @@
+interface Callback {
+    fun invoke(): String
+}
+
+enum class Foo(
+        val x: String,
+        val callback: Callback
+) {
+    FOO(
+            "OK",
+            object : Callback {
+                override fun invoke() = FOO.x
+            }
+    )
+}
+
+fun box() = Foo.FOO.callback.invoke()

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/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()

backend.native/tests/external/codegen/box/enum/kt7257_boundReferenceWithImplicitReceiver.kt

@@ -0,0 +1,15 @@
+// LANGUAGE_VERSION: 1.2
+
+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

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/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

backend.native/tests/external/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