From e8e04ca98ea40e176593367160e7416c22816e1c Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 31 Oct 2019 14:46:53 +0100 Subject: [PATCH] Do not use new stdlib API in reflection implementation Otherwise this brings incompatibility between kotlin-reflect 1.3.70+ and kotlin-stdlib 1.3.60-. This commit reverts the relevant parts of c164745301, 5c89f2fa54 and 896512f7cd. --- .../runtime/structure/reflectClassUtil.kt | 12 ++++ .../src/kotlin/reflect/full/KClasses.kt | 14 +++-- .../kotlin/reflect/jvm/internal/KClassImpl.kt | 61 ++++++++++++++----- 3 files changed, 65 insertions(+), 22 deletions(-) diff --git a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/reflectClassUtil.kt b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/reflectClassUtil.kt index 251e2bd2643..fba5e29b020 100644 --- a/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/reflectClassUtil.kt +++ b/core/descriptors.runtime/src/org/jetbrains/kotlin/descriptors/runtime/structure/reflectClassUtil.kt @@ -40,6 +40,18 @@ val Class<*>.primitiveByWrapper: Class<*>? val Class<*>.wrapperByPrimitive: Class<*>? get() = PRIMITIVE_TO_WRAPPER[this] +private val FUNCTION_CLASSES = + listOf( + Function0::class.java, Function1::class.java, Function2::class.java, Function3::class.java, Function4::class.java, + Function5::class.java, Function6::class.java, Function7::class.java, Function8::class.java, Function9::class.java, + Function10::class.java, Function11::class.java, Function12::class.java, Function13::class.java, Function14::class.java, + Function15::class.java, Function16::class.java, Function17::class.java, Function18::class.java, Function19::class.java, + Function20::class.java, Function21::class.java, Function22::class.java + ).mapIndexed { i, clazz -> clazz to i }.toMap() + +val Class<*>.functionClassArity: Int? + get() = FUNCTION_CLASSES[this] + /** * NOTE: does not perform a Java -> Kotlin mapping. If this is not expected, consider using KClassImpl#classId instead */ diff --git a/core/reflection.jvm/src/kotlin/reflect/full/KClasses.kt b/core/reflection.jvm/src/kotlin/reflect/full/KClasses.kt index 34980b72cfb..886d837d8cf 100644 --- a/core/reflection.jvm/src/kotlin/reflect/full/KClasses.kt +++ b/core/reflection.jvm/src/kotlin/reflect/full/KClasses.kt @@ -24,8 +24,11 @@ import org.jetbrains.kotlin.types.TypeSubstitutor import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.utils.DFS import kotlin.reflect.* -import kotlin.reflect.jvm.internal.* -import kotlin.reflect.safeCast as commonSafeCast +import kotlin.reflect.jvm.internal.KCallableImpl +import kotlin.reflect.jvm.internal.KClassImpl +import kotlin.reflect.jvm.internal.KFunctionImpl +import kotlin.reflect.jvm.internal.KTypeImpl +import kotlin.reflect.jvm.internal.KotlinReflectionInternalError /** * Returns the primary constructor of this class, or `null` if this class has no primary constructor. @@ -250,7 +253,6 @@ fun KClass<*>.isSuperclassOf(derived: KClass<*>): Boolean = */ @SinceKotlin("1.1") fun KClass.cast(value: Any?): T { - // Note: can't use kotlin.reflect.cast because it throws ClassCastException. if (!isInstance(value)) throw TypeCastException("Value cannot be cast to $qualifiedName") return value as T } @@ -263,9 +265,9 @@ fun KClass.cast(value: Any?): T { * @see [KClass.cast] */ @SinceKotlin("1.1") -fun KClass.safeCast(value: Any?): T? = - @UseExperimental(ExperimentalStdlibApi::class) - commonSafeCast(value) +fun KClass.safeCast(value: Any?): T? { + return if (isInstance(value)) value as T else null +} /** diff --git a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt index 6b779b871d6..f0cc00577b3 100644 --- a/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt +++ b/core/reflection.jvm/src/kotlin/reflect/jvm/internal/KClassImpl.kt @@ -19,7 +19,6 @@ package kotlin.reflect.jvm.internal import org.jetbrains.kotlin.builtins.CompanionObjectMapping import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.descriptors.runtime.components.ReflectKotlinClass import org.jetbrains.kotlin.incremental.components.NoLookupLocation import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader @@ -33,10 +32,13 @@ import org.jetbrains.kotlin.resolve.scopes.MemberScope import org.jetbrains.kotlin.serialization.deserialization.MemberDeserializer import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedClassDescriptor import org.jetbrains.kotlin.utils.compact -import kotlin.jvm.internal.ClassReference +import kotlin.jvm.internal.TypeIntrinsics import kotlin.reflect.* import kotlin.reflect.jvm.internal.KDeclarationContainerImpl.MemberBelonginess.DECLARED import kotlin.reflect.jvm.internal.KDeclarationContainerImpl.MemberBelonginess.INHERITED +import org.jetbrains.kotlin.descriptors.runtime.components.ReflectKotlinClass +import org.jetbrains.kotlin.descriptors.runtime.structure.functionClassArity +import org.jetbrains.kotlin.descriptors.runtime.structure.wrapperByPrimitive internal class KClassImpl(override val jClass: Class) : KDeclarationContainerImpl(), KClass, KClassifierImpl { inner class Data : KDeclarationContainerImpl.Data() { @@ -53,6 +55,37 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration val annotations: List by ReflectProperties.lazySoft { descriptor.computeAnnotations() } + val simpleName: String? by ReflectProperties.lazySoft { + if (jClass.isAnonymousClass) return@lazySoft null + + val classId = classId + when { + classId.isLocal -> calculateLocalClassName(jClass) + else -> classId.shortClassName.asString() + } + } + + val qualifiedName: String? by ReflectProperties.lazySoft { + if (jClass.isAnonymousClass) return@lazySoft null + + val classId = classId + when { + classId.isLocal -> null + else -> classId.asSingleFqName().asString() + } + } + + private fun calculateLocalClassName(jClass: Class<*>): String { + val name = jClass.simpleName + jClass.enclosingMethod?.let { method -> + return name.substringAfter(method.name + "$") + } + jClass.enclosingConstructor?.let { constructor -> + return name.substringAfter(constructor.name + "$") + } + return name.substringAfter('$') + } + @Suppress("UNCHECKED_CAST") val constructors: Collection> by ReflectProperties.lazySoft { constructorDescriptors.map { descriptor -> @@ -147,17 +180,7 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration override val annotations: List get() = data().annotations - private val classId: ClassId - get() = RuntimeTypeMapper.mapJvmClassToKotlinClassId(jClass).also { result -> - if (!jClass.isAnonymousClass && !jClass.isLocalClass) { - assert(result.asSingleFqName().asString() == qualifiedName) { - "Incorrect class name computed for class ${jClass.name}. Result: $result. Expected qualified name $qualifiedName" - } - assert(result.shortClassName.asString() == simpleName) { - "Incorrect class name computed for class ${jClass.name}. Result: $result. Expected simple name $simpleName" - } - } - } + private val classId: ClassId get() = RuntimeTypeMapper.mapJvmClassToKotlinClassId(jClass) // Note that we load members from the container's default type, which might be confusing. For example, a function declared in a // generic class "A" would have "A" as the receiver parameter even if a concrete type like "A" was specified @@ -205,9 +228,9 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration } } - override val simpleName: String? get() = ClassReference.getClassSimpleName(jClass) + override val simpleName: String? get() = data().simpleName - override val qualifiedName: String? get() = ClassReference.getClassQualifiedName(jClass) + override val qualifiedName: String? get() = data().qualifiedName override val constructors: Collection> get() = data().constructors @@ -215,7 +238,13 @@ internal class KClassImpl(override val jClass: Class) : KDeclaration override val objectInstance: T? get() = data().objectInstance - override fun isInstance(value: Any?): Boolean = ClassReference.isInstance(value, jClass) + override fun isInstance(value: Any?): Boolean { + // TODO: use Kotlin semantics for mutable/read-only collections once KT-11754 is supported (see TypeIntrinsics) + jClass.functionClassArity?.let { arity -> + return TypeIntrinsics.isFunctionOfArity(value, arity) + } + return (jClass.wrapperByPrimitive ?: jClass).isInstance(value) + } override val typeParameters: List get() = data().typeParameters