From 37c36f806a1bb62aa8d80b4c200fcdcb1833e901 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 8 Oct 2015 16:21:41 +0300 Subject: [PATCH] Rename foreignKotlinClass -> getOrCreateKotlinClass Previously this cache contained only Java (hence 'foreign') classes, that is not the case anymore --- .../org/jetbrains/kotlin/codegen/AsmUtil.java | 5 ++- .../jvm/internal/ReflectionFactoryImpl.java | 11 ++++-- .../{foreignKClasses.kt => kClassCache.kt} | 10 +++--- .../src/kotlin/jvm/internal/Reflection.java | 36 +++++++++++++------ .../jvm/internal/ReflectionFactory.java | 9 ++++- 5 files changed, 50 insertions(+), 21 deletions(-) rename core/reflection.jvm/src/kotlin/reflect/jvm/internal/{foreignKClasses.kt => kClassCache.kt} (89%) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index 1d80a957d5a..267d1b4328b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -905,12 +905,11 @@ public class AsmUtil { } public static void wrapJavaClassIntoKClass(@NotNull InstructionAdapter v) { - v.invokestatic(REFLECTION, "foreignKotlinClass", Type.getMethodDescriptor(K_CLASS_TYPE, getType(Class.class)), false); + v.invokestatic(REFLECTION, "getOrCreateKotlinClass", Type.getMethodDescriptor(K_CLASS_TYPE, getType(Class.class)), false); } - public static void wrapJavaClassesIntoKClasses(@NotNull InstructionAdapter v) { - v.invokestatic(REFLECTION, "foreignKotlinClasses", Type.getMethodDescriptor(K_CLASS_ARRAY_TYPE, getType(Class[].class)), false); + v.invokestatic(REFLECTION, "getOrCreateKotlinClasses", Type.getMethodDescriptor(K_CLASS_ARRAY_TYPE, getType(Class[].class)), false); } public static int getReceiverIndex(@NotNull CodegenContext context, @NotNull CallableMemberDescriptor descriptor) { diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java index 4f6ed10574c..3fd875cea75 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/ReflectionFactoryImpl.java +++ b/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); + } } diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/foreignKClasses.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt similarity index 89% rename from core/reflection.jvm/src/kotlin/reflect/jvm/internal/foreignKClasses.kt rename to core/reflection.jvm/src/kotlin/reflect/jvm/internal/kClassCache.kt index 1a4177aced5..7b7b32cd584 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/foreignKClasses.kt +++ b/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() +private var K_CLASS_CACHE = HashPMap.empty() // This function is invoked on each reflection access to Java classes, properties, etc. Performance is critical here. -fun foreignKotlinClass(jClass: Class): KClassImpl { +fun getOrCreateKotlinClass(jClass: Class): KClassImpl { 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? @@ -56,11 +56,11 @@ fun foreignKotlinClass(jClass: Class): KClassImpl { 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 } diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java b/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java index 4cdf824e9d0..d5c09b82b54 100644 --- a/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java +++ b/core/runtime.jvm/src/kotlin/jvm/internal/Reflection.java @@ -39,18 +39,12 @@ public class Reflection { factory = impl != null ? impl : new ReflectionFactory(); } + private static final KClass[] EMPTY_K_CLASS_ARRAY = new KClass[0]; + public static KClass createKotlinClass(Class javaClass) { return factory.createKotlinClass(javaClass); } - public static KClass[] foreignKotlinClasses(Class[] javaClasses) { - KClass[] kClasses = new KClass[javaClasses.length]; - for (int i = 0; i < javaClasses.length; i++) { - kClasses[i] = foreignKotlinClass(javaClasses[i]); - } - return kClasses; - } - public static KPackage createKotlinPackage(Class javaClass) { return factory.createKotlinPackage(javaClass); } @@ -59,8 +53,18 @@ public class Reflection { return factory.createKotlinPackage(javaClass, moduleName); } - public static KClass foreignKotlinClass(Class javaClass) { - return factory.foreignKotlinClass(javaClass); + public static KClass getOrCreateKotlinClass(Class javaClass) { + return factory.getOrCreateKotlinClass(javaClass); + } + + public static KClass[] getOrCreateKotlinClasses(Class[] javaClasses) { + int size = javaClasses.length; + if (size == 0) return EMPTY_K_CLASS_ARRAY; + KClass[] kClasses = new KClass[size]; + for (int i = 0; i < size; i++) { + kClasses[i] = getOrCreateKotlinClass(javaClasses[i]); + } + return kClasses; } // Functions @@ -94,4 +98,16 @@ public class Reflection { public static KMutableProperty2 mutableProperty2(MutablePropertyReference2 p) { return factory.mutableProperty2(p); } + + // Deprecated + + @Deprecated + public static KClass foreignKotlinClass(Class javaClass) { + return getOrCreateKotlinClass(javaClass); + } + + @Deprecated + public static KClass[] foreignKotlinClasses(Class[] javaClasses) { + return getOrCreateKotlinClasses(javaClasses); + } } diff --git a/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java b/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java index 88aae99ba33..2eb48eefc66 100644 --- a/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java +++ b/core/runtime.jvm/src/kotlin/jvm/internal/ReflectionFactory.java @@ -31,7 +31,7 @@ public class ReflectionFactory { return null; } - public KClass foreignKotlinClass(Class javaClass) { + public KClass getOrCreateKotlinClass(Class javaClass) { return new ClassReference(javaClass); } @@ -66,4 +66,11 @@ public class ReflectionFactory { public KMutableProperty2 mutableProperty2(MutablePropertyReference2 p) { return p; } + + // Deprecated + + @Deprecated + public KClass foreignKotlinClass(Class javaClass) { + return new ClassReference(javaClass); + } }