Rename foreignKotlinClass -> getOrCreateKotlinClass

Previously this cache contained only Java (hence 'foreign') classes, that is
not the case anymore

core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java

@@ -41,8 +41,8 @@ public class ReflectionFactoryImpl extends ReflectionFactory {
     }
 
     @Override
-    public KClass foreignKotlinClass(Class javaClass) {
-        return InternalPackage.foreignKotlinClass(javaClass);
+    public KClass getOrCreateKotlinClass(Class javaClass) {
+        return InternalPackage.getOrCreateKotlinClass(javaClass);
     }
 
     // Functions
@@ -85,4 +85,11 @@ public class ReflectionFactoryImpl extends ReflectionFactory {
         // TODO: support member extension property references
         return p;
     }
+
+    // Deprecated
+
+    @Override
+    public KClass foreignKotlinClass(Class javaClass) {
+        return getOrCreateKotlinClass(javaClass);
+    }
 }

core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt

@@ -24,12 +24,12 @@ import kotlin.reflect.jvm.internal.pcollections.HashPMap
 // Arrays are needed because the same class can be loaded by different class loaders, which results in different Class instances.
 // This variable is not volatile intentionally: we don't care if there's a data race on it and some KClass instances will be lost.
 // We do care however about general performance on read access to it, thus no synchronization is done here whatsoever
-private var FOREIGN_K_CLASSES = HashPMap.empty<String, Any>()
+private var K_CLASS_CACHE = HashPMap.empty<String, Any>()
 
 // This function is invoked on each reflection access to Java classes, properties, etc. Performance is critical here.
-fun <T : Any> foreignKotlinClass(jClass: Class<T>): KClassImpl<T> {
+fun <T : Any> getOrCreateKotlinClass(jClass: Class<T>): KClassImpl<T> {
     val name = jClass.getName()
-    val cached = FOREIGN_K_CLASSES[name]
+    val cached = K_CLASS_CACHE[name]
     if (cached is WeakReference<*>) {
         @Suppress("UNCHECKED_CAST")
         val kClass = cached.get() as KClassImpl<T>?
@@ -56,11 +56,11 @@ fun <T : Any> foreignKotlinClass(jClass: Class<T>): KClassImpl<T> {
         System.arraycopy(cached, 0, newArray, 0, size)
         val newKClass = KClassImpl(jClass)
         newArray[size] = WeakReference(newKClass)
-        FOREIGN_K_CLASSES = FOREIGN_K_CLASSES.plus(name, newArray)
+        K_CLASS_CACHE = K_CLASS_CACHE.plus(name, newArray)
         return newKClass
     }
 
     val newKClass = KClassImpl(jClass)
-    FOREIGN_K_CLASSES = FOREIGN_K_CLASSES.plus(name, WeakReference(newKClass))
+    K_CLASS_CACHE = K_CLASS_CACHE.plus(name, WeakReference(newKClass))
     return newKClass
 }