[K2/N] Export C adapters for non-root packages

^KT-56182

Merge-request: KT-MR-10160
Merged-by: Vladimir Sukharev <Vladimir.Sukharev@jetbrains.com>

kotlin-native/backend.native/tests/interop/kt56182_package1lvl/knlibrary.kt

@@ -0,0 +1,18 @@
+// This test is similar to kt42397, just everything is doubled: in "package knlibrary" and the root package
+
+package knlibrary
+
+import kotlin.native.Platform
+
+// The following 2 singletons are unused. However, since we are generating C bindings for them,
+// they should be marked as used, so that the code generator emits their deinitialization.
+
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}

kotlin-native/backend.native/tests/interop/kt56182_package1lvl/test.cpp

@@ -0,0 +1,28 @@
+#include "testlib_api.h"
+
+#include <thread>
+
+int main() {
+    auto t = std::thread([] {
+        auto lib = testlib_symbols();
+
+        lib->kotlin.root.knlibrary.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a = lib->kotlin.root.knlibrary.A._instance();
+        auto bCompanion = lib->kotlin.root.knlibrary.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion.pinned);
+        lib->DisposeStablePointer(a.pinned);
+
+        // A and B.Companion now are owned by the global references only.
+    });
+
+    // This causes Kotlin runtime full deinitialization, because `t` is the only thread
+    // with the Kotlin runtime. So, all the globals will get deinitialized and memory
+    // leak checker will get executed (because .kt code is compiled with -g).
+    t.join();
+
+    return 0;
+}

kotlin-native/backend.native/tests/interop/kt56182_root/knlibrary.kt

@@ -0,0 +1,16 @@
+// This test is similar to kt42397, just everything is in root package instead of "package knlibrary"
+
+import kotlin.native.Platform
+
+// The following 2 singletons are unused. However, since we are generating C bindings for them,
+// they should be marked as used, so that the code generator emits their deinitialization.
+
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}

kotlin-native/backend.native/tests/interop/kt56182_root/test.cpp

@@ -0,0 +1,28 @@
+#include "testlib_api.h"
+
+#include <thread>
+
+int main() {
+    auto t = std::thread([] {
+        auto lib = testlib_symbols();
+
+        lib->kotlin.root.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a = lib->kotlin.root.A._instance();
+        auto bCompanion = lib->kotlin.root.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion.pinned);
+        lib->DisposeStablePointer(a.pinned);
+
+        // A and B.Companion now are owned by the global references only.
+    });
+
+    // This causes Kotlin runtime full deinitialization, because `t` is the only thread
+    // with the Kotlin runtime. So, all the globals will get deinitialized and memory
+    // leak checker will get executed (because .kt code is compiled with -g).
+    t.join();
+
+    return 0;
+}

kotlin-native/backend.native/tests/interop/kt56182_root_package1lvl/knlibrary.kt

@@ -0,0 +1,30 @@
+// This test is similar to kt42397, just everything is doubled: in "package knlibrary.subpackage" and the root package
+
+// FILE: FirstLevelPackage.kt
+package knlibrary
+
+import kotlin.native.Platform
+
+// The following 2 singletons are unused. However, since we are generating C bindings for them,
+// they should be marked as used, so that the code generator emits their deinitialization.
+
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}
+
+// FILE: rootPackage.kt
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}

kotlin-native/backend.native/tests/interop/kt56182_root_package1lvl/test.cpp

@@ -0,0 +1,39 @@
+#include "testlib_api.h"
+
+#include <thread>
+
+int main() {
+    auto t = std::thread([] {
+        auto lib = testlib_symbols();
+
+        lib->kotlin.root.knlibrary.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a = lib->kotlin.root.knlibrary.A._instance();
+        auto bCompanion = lib->kotlin.root.knlibrary.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion.pinned);
+        lib->DisposeStablePointer(a.pinned);
+
+        // A and B.Companion now are owned by the global references only.
+
+        // Now same actions for objects in the root package
+        lib->kotlin.root.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a2 = lib->kotlin.root.A._instance();
+        auto bCompanion2 = lib->kotlin.root.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion2.pinned);
+        lib->DisposeStablePointer(a2.pinned);
+    });
+
+    // This causes Kotlin runtime full deinitialization, because `t` is the only thread
+    // with the Kotlin runtime. So, all the globals will get deinitialized and memory
+    // leak checker will get executed (because .kt code is compiled with -g).
+    t.join();
+
+    return 0;
+}

kotlin-native/backend.native/tests/interop/kt56182_root_subpackage2lvl/knlibrary.kt

@@ -0,0 +1,30 @@
+// This test is similar to kt42397, just everything is doubled: in "package knlibrary.subpackage" and the root package
+
+// FILE: SecondLevelPackage.kt
+package knlibrary.subpackage
+
+import kotlin.native.Platform
+
+// The following 2 singletons are unused. However, since we are generating C bindings for them,
+// they should be marked as used, so that the code generator emits their deinitialization.
+
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}
+
+// FILE: rootPackage.kt
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}

kotlin-native/backend.native/tests/interop/kt56182_root_subpackage2lvl/test.cpp

@@ -0,0 +1,39 @@
+#include "testlib_api.h"
+
+#include <thread>
+
+int main() {
+    auto t = std::thread([] {
+        auto lib = testlib_symbols();
+
+        lib->kotlin.root.knlibrary.subpackage.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a = lib->kotlin.root.knlibrary.subpackage.A._instance();
+        auto bCompanion = lib->kotlin.root.knlibrary.subpackage.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion.pinned);
+        lib->DisposeStablePointer(a.pinned);
+
+        // A and B.Companion now are owned by the global references only.
+
+        // Now same actions for objects in the root package
+        lib->kotlin.root.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a2 = lib->kotlin.root.A._instance();
+        auto bCompanion2 = lib->kotlin.root.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion2.pinned);
+        lib->DisposeStablePointer(a2.pinned);
+    });
+
+    // This causes Kotlin runtime full deinitialization, because `t` is the only thread
+    // with the Kotlin runtime. So, all the globals will get deinitialized and memory
+    // leak checker will get executed (because .kt code is compiled with -g).
+    t.join();
+
+    return 0;
+}

kotlin-native/backend.native/tests/interop/kt56182_subpackage2lvl/knlibrary.kt

@@ -0,0 +1,17 @@
+// This test is similar to kt42397, just everything is in "package knlibrary.subpackage" instead of "package knlibrary"
+package knlibrary.subpackage
+
+import kotlin.native.Platform
+
+// The following 2 singletons are unused. However, since we are generating C bindings for them,
+// they should be marked as used, so that the code generator emits their deinitialization.
+
+object A {}
+
+class B {
+    companion object {}
+}
+
+fun enableMemoryChecker() {
+    Platform.isMemoryLeakCheckerActive = true
+}

kotlin-native/backend.native/tests/interop/kt56182_subpackage2lvl/test.cpp

@@ -0,0 +1,28 @@
+#include "testlib_api.h"
+
+#include <thread>
+
+int main() {
+    auto t = std::thread([] {
+        auto lib = testlib_symbols();
+
+        lib->kotlin.root.knlibrary.subpackage.enableMemoryChecker();
+
+        // Initialize A and B.Companion and get their stable pointers.
+        auto a = lib->kotlin.root.knlibrary.subpackage.A._instance();
+        auto bCompanion = lib->kotlin.root.knlibrary.subpackage.B.Companion._instance();
+
+        // Now, dispose of the stable pointers.
+        lib->DisposeStablePointer(bCompanion.pinned);
+        lib->DisposeStablePointer(a.pinned);
+
+        // A and B.Companion now are owned by the global references only.
+    });
+
+    // This causes Kotlin runtime full deinitialization, because `t` is the only thread
+    // with the Kotlin runtime. So, all the globals will get deinitialized and memory
+    // leak checker will get executed (because .kt code is compiled with -g).
+    t.join();
+
+    return 0;
+}