[K/N][Tests] Move codegen test sources cycles..innerClass

^KT-61259

native/native.tests/testData/codegen/funInterface/implIsNotFunction.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.funInterface.implIsNotFunction
+
+import kotlin.test.*
+
+fun interface Foo {
+    fun invoke(): String
+}
+
+fun foo(f: Foo) = f is Function<*>
+
+@Test
+fun test() {
+    assertFalse(foo { "zzz" })
+}

native/native.tests/testData/codegen/funInterface/kt43887.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright 2010-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+@file:OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
+package codegen.funInterface.kt43887
+
+import kotlin.test.*
+
+import kotlinx.cinterop.*
+typealias heap_t = IntVar
+fun heap_create(size: Long): CPointer<heap_t>? = null
+fun heap_alloc(heap: CPointer<heap_t>?, size: ULong): CPointer<*>? = null
+fun heap_free(heap: CPointer<heap_t>?, ptr: CPointer<*>?): CPointer<BooleanVar>? = null
+inline fun Heap(size: Long): CPointer<heap_t>? {
+    return heap_create(size)
+}
+inline fun <reified T : CVariable> CPointer<heap_t>?.use(f: (CPointer<T>) -> Unit) {
+    alloc<T>()
+            ?.also(f)
+            ?.also(::free)
+}
+inline fun <reified T : CVariable> CPointer<heap_t>?.alloc(): CPointer<T>? {
+    return heap_alloc(this, sizeOf<T>().toULong())?.reinterpret()
+}
+inline fun CPointer<heap_t>?.free(ptr: CPointer<*>?): Boolean {
+    return heap_free(this, ptr)?.pointed?.value ?: false
+}
+
+@Test
+fun runTest(): Unit = memScoped {
+    val heap = Heap(1024)
+
+    heap.use<IntVar> { ptr ->
+        ptr.pointed.value = 40
+        //println("PTR ${ptr.pointed}")
+    }
+}

native/native.tests/testData/codegen/funInterface/kt49384.kt

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.funInterface.kt49384
+
+import kotlin.test.*
+
+interface A<T>
+
+// https://youtrack.jetbrains.com/issue/KT-49384
+class B<T> {
+    init {
+        mutableListOf<A<out T>>()
+                .sortWith { _, _ -> 1 }
+    }
+}
+
+@Test
+fun test1() {
+    val b = B<Any>()
+    assertEquals(b, b) // Just to ensure B is not deleted by DCE
+}
+
+fun interface Foo<T> {
+    fun same(obj: T): T
+}
+
+fun getSame(obj: A<out Any>, foo: Foo<A<out Any>>) = foo.same(obj)
+
+@Test
+fun test2() {
+    val obj = object : A<Any> {}
+    assertSame(obj, getSame(obj) { it })
+}

native/native.tests/testData/codegen/funInterface/nonTrivialProjectionInSuperType.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the LICENSE file.
+ */
+
+package codegen.funInterface.nonTrivialProjectionInSuperType
+
+import kotlin.test.*
+
+fun <T> foo(comparator: kotlin.Comparator<in T>, a: T, b: T) = comparator.compare(a, b)
+
+fun bar(x: Int, y: Int) = foo<Int> ({ a, b -> a - b}, x, y)
+
+@Test
+fun test() {
+    assertTrue(bar(42, 117) < 0)
+}