Remove kotlin reflect & workaround performance issue

This should fix realm#1544

See this PR that was the inspiration: realm#1851

Author: LouisCAD

packages/library-base/build.gradle.kts

@@ -52,7 +52,6 @@ kotlin {
         val commonMain by getting {
             dependencies {
                 implementation(kotlin("stdlib-common"))
-                implementation(kotlin("reflect"))
                 // If runtimeapi is merged with cinterop then we will be exposing both to the users
                 // Runtime holds annotations, etc. that has to be exposed to users
                 // Cinterop does not hold anything required by users

packages/library-base/src/jvm/kotlin/io/realm/kotlin/internal/platform/RealmObject.kt

@@ -18,16 +18,53 @@ package io.realm.kotlin.internal.platform
 
 import io.realm.kotlin.internal.RealmObjectCompanion
 import io.realm.kotlin.types.BaseRealmObject
+import java.util.concurrent.ConcurrentHashMap
 import kotlin.reflect.KClass
-import kotlin.reflect.full.companionObjectInstance
 
 // TODO OPTIMIZE Can we eliminate the reflective approach? Maybe by embedding the information
 //  through the compiler plugin or something similar to the Native findAssociatedObject
 @PublishedApi
-internal actual fun <T : Any> realmObjectCompanionOrNull(clazz: KClass<T>): RealmObjectCompanion? =
-    if (clazz.companionObjectInstance is RealmObjectCompanion) {
-        clazz.companionObjectInstance as RealmObjectCompanion
-    } else null
+internal actual fun <T : Any> realmObjectCompanionOrNull(clazz: KClass<T>): RealmObjectCompanion? {
+    // The implementation of this method was changed for performance reasons as it was using
+    // kotlin.reflect.full before, and getting companion objects this way on Android is very slow.
+    // See this PR: https://github.com/realm/realm-kotlin/pull/1851
+    //
+    // 1. We optimized this function for the case where it'd be called with `clazz` being a
+    // primitive type (boxed or not)
+    //
+    // 2. We cache the value even if there's no companion object,to avoid calling `Class.forName(…)`
+    // too often, because it's still slow reflection (though less slow than what we're replacing).
+    //
+    // 3. used `ConcurrentHashMap` because we didn't check this function can never be called
+    // concurrently, and if it was, the consequences would be tough, surprising, and hard to
+    // diagnose, granted it was a basic (and NOT thread-safe `HashMap`).
+    // It's not just about doing the lookup twice, but about infinite loops while iterating, i.e.,
+    // tough consequences.
+
+    val cachedClass = reflectionCache[clazz]
+    if (cachedClass != null) return cachedClass as? RealmObjectCompanion
+
+    if (clazz.javaPrimitiveType != null) error("Ahem")
+
+    val newValue: Any = clazz.javaPrimitiveType ?: (try {
+        Class.forName("${clazz.java.name}\$Companion").kotlin
+    } catch (_: ClassNotFoundException) {
+        try {
+            // For Parcelable classes
+            Class.forName("${clazz.java.name}\$CREATOR").kotlin
+        } catch (_: ClassNotFoundException) {
+            null
+        }
+    }?.objectInstance as? RealmObjectCompanion) ?: clazz
+
+    reflectionCache[clazz] = newValue
+
+    return newValue as? RealmObjectCompanion
+}
+
+// Since ConcurrentHashMap doesn't accept null values, we can't use `RealmObjectCompanion?`,
+// so we use `Any`, and we actually put a class, or a `RealmObjectCompanion` instance inside.
+private val reflectionCache = ConcurrentHashMap<KClass<*>, Any>()
 
 @PublishedApi
 internal actual fun <T : BaseRealmObject> realmObjectCompanionOrThrow(clazz: KClass<T>): RealmObjectCompanion =