azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

core: cleanup 'public', property access syntax

Browse Source
This commit is contained in:
Dmitry Jemerov
2016-01-07 18:03:08 +01:00
parent 117a0d8b7b
commit 3870bd04b8
173 changed files with 1198 additions and 1240 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeErrorReporter.kt
+3 -3
View File
@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.serialization.deserialization.BinaryVersion
import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter
public object RuntimeErrorReporter : ErrorReporter {
object RuntimeErrorReporter : ErrorReporter {
// TODO: specialized exceptions
override fun reportIncompleteHierarchy(descriptor: ClassDescriptor, unresolvedSuperClasses: MutableList<String>) {
throw IllegalStateException("Incomplete hierarchy for class ${descriptor.getName()}, unresolved classes $unresolvedSuperClasses")
throw IllegalStateException("Incomplete hierarchy for class ${descriptor.name}, unresolved classes $unresolvedSuperClasses")
}
override fun reportIncompatibleAbiVersion(classId: ClassId, filePath: String, actualVersion: BinaryVersion) {
@@ -36,7 +36,7 @@ public object RuntimeErrorReporter : ErrorReporter {
override fun reportCannotInferVisibility(descriptor: CallableMemberDescriptor) {
// TODO: use DescriptorRenderer
throw IllegalStateException("Cannot infer visibility for class ${descriptor.getName()}")
throw IllegalStateException("Cannot infer visibility for class ${descriptor.name}")
}
override fun reportLoadingError(message: String, exception: Exception?) {
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/components/RuntimeSourceElementFactory.kt
+1 -1
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory
import org.jetbrains.kotlin.load.java.structure.JavaElement
import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaElement
public object RuntimeSourceElementFactory : JavaSourceElementFactory {
object RuntimeSourceElementFactory : JavaSourceElementFactory {
private class RuntimeSourceElement(override val javaElement: ReflectJavaElement) : JavaSourceElement {
override fun toString() = javaClass.name + ": " + javaElement.toString()
override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/reflect/ReflectJavaClassFinder.kt
+4 -4
View File
@@ -24,12 +24,12 @@ import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaClass
import org.jetbrains.kotlin.load.java.structure.reflect.ReflectJavaPackage
import org.jetbrains.kotlin.name.ClassId
public class ReflectJavaClassFinder(private val classLoader: ClassLoader) : JavaClassFinder {
class ReflectJavaClassFinder(private val classLoader: ClassLoader) : JavaClassFinder {
override fun findClass(classId: ClassId): JavaClass? {
val packageFqName = classId.getPackageFqName()
val relativeClassName = classId.getRelativeClassName().asString().replace('.', '$')
val packageFqName = classId.packageFqName
val relativeClassName = classId.relativeClassName.asString().replace('.', '$')
val name =
if (packageFqName.isRoot()) relativeClassName
if (packageFqName.isRoot) relativeClassName
else packageFqName.asString() + "." + relativeClassName
val klass = classLoader.tryLoadClass(name)
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaAnnotation.kt
+4 -4
View File
@@ -21,17 +21,17 @@ import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument
import org.jetbrains.kotlin.name.Name
import java.lang.reflect.Method
public class ReflectJavaAnnotation(private val annotation: Annotation) : ReflectJavaElement(), JavaAnnotation {
class ReflectJavaAnnotation(private val annotation: Annotation) : ReflectJavaElement(), JavaAnnotation {
override fun findArgument(name: Name): JavaAnnotationArgument? {
return getArgumentValue(annotation.annotationClass.java.getDeclaredMethod(name.asString()))
}
override fun getArguments(): Collection<JavaAnnotationArgument> {
return annotation.annotationClass.java.getDeclaredMethods().map { getArgumentValue(it) }
return annotation.annotationClass.java.declaredMethods.map { getArgumentValue(it) }
}
private fun getArgumentValue(argument: Method): ReflectJavaAnnotationArgument {
return argument.invoke(annotation).let { ReflectJavaAnnotationArgument.create(it, Name.identifier(argument.getName())) }
return argument.invoke(annotation).let { ReflectJavaAnnotationArgument.create(it, Name.identifier(argument.name)) }
}
override fun resolve() = ReflectJavaClass(annotation.annotationClass.java)
@@ -42,5 +42,5 @@ public class ReflectJavaAnnotation(private val annotation: Annotation) : Reflect
override fun hashCode() = annotation.hashCode()
override fun toString() = javaClass.getName() + ": " + annotation
override fun toString() = javaClass.name + ": " + annotation
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaAnnotationArguments.kt
+1 -1
View File
@@ -53,7 +53,7 @@ class ReflectJavaEnumValueAnnotationArgument(
) : ReflectJavaAnnotationArgument(name), JavaEnumValueAnnotationArgument {
override fun resolve(): ReflectJavaField {
val clazz = value.javaClass
val enumClass = if (clazz.isEnum()) clazz else clazz.getEnclosingClass()
val enumClass = if (clazz.isEnum) clazz else clazz.enclosingClass
return ReflectJavaField(enumClass.getDeclaredField(value.name))
}
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaAnnotationOwner.kt
+3 -3
View File
@@ -20,12 +20,12 @@ import org.jetbrains.kotlin.load.java.structure.JavaAnnotationOwner
import org.jetbrains.kotlin.name.FqName
import java.lang.reflect.AnnotatedElement
public interface ReflectJavaAnnotationOwner : JavaAnnotationOwner {
interface ReflectJavaAnnotationOwner : JavaAnnotationOwner {
val element: AnnotatedElement
override fun getAnnotations() = getAnnotations(element.getDeclaredAnnotations())
override fun getAnnotations() = getAnnotations(element.declaredAnnotations)
override fun findAnnotation(fqName: FqName) = findAnnotation(element.getDeclaredAnnotations(), fqName)
override fun findAnnotation(fqName: FqName) = findAnnotation(element.declaredAnnotations, fqName)
override fun isDeprecatedInJavaDoc() = false
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaArrayType.kt
+2 -2
View File
@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.load.java.structure.JavaArrayType
import java.lang.reflect.GenericArrayType
import java.lang.reflect.Type
public class ReflectJavaArrayType(override val type: Type) : ReflectJavaType(), JavaArrayType {
class ReflectJavaArrayType(override val type: Type) : ReflectJavaType(), JavaArrayType {
private val componentType: ReflectJavaType = with (type) {
when {
this is GenericArrayType -> ReflectJavaType.create(getGenericComponentType())
this is GenericArrayType -> ReflectJavaType.create(genericComponentType)
this is Class<*> && isArray() -> ReflectJavaType.create(getComponentType())
else -> throw IllegalArgumentException("Not an array type (${type.javaClass}): $type")
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt
+21 -21
View File
@@ -24,39 +24,39 @@ import org.jetbrains.kotlin.name.Name
import java.lang.reflect.Method
import java.util.Arrays
public class ReflectJavaClass(
class ReflectJavaClass(
private val klass: Class<*>
) : ReflectJavaElement(), ReflectJavaAnnotationOwner, ReflectJavaModifierListOwner, JavaClass {
override val element: Class<*> get() = klass
override val modifiers: Int get() = klass.getModifiers()
override val modifiers: Int get() = klass.modifiers
override fun getInnerClasses() = klass.getDeclaredClasses()
override fun getInnerClasses() = klass.declaredClasses
.asSequence()
.filterNot {
// getDeclaredClasses() returns anonymous classes sometimes, for example enums with specialized entries (which are in fact
// anonymous classes) or in case of a special anonymous class created for the synthetic accessor to a private nested class
// constructor accessed from the outer class
it.getSimpleName().isEmpty()
it.simpleName.isEmpty()
}
.map(::ReflectJavaClass)
.toList()
override fun getFqName() = klass.classId.asSingleFqName()
override fun getOuterClass() = klass.getDeclaringClass()?.let(::ReflectJavaClass)
override fun getOuterClass() = klass.declaringClass?.let(::ReflectJavaClass)
override fun getSupertypes(): Collection<JavaClassifierType> {
if (klass == Any::class.java) return emptyList()
return listOf(klass.genericSuperclass ?: Any::class.java, *klass.genericInterfaces).map(::ReflectJavaClassifierType)
}
override fun getMethods() = klass.getDeclaredMethods()
override fun getMethods() = klass.declaredMethods
.asSequence()
.filter { method ->
when {
method.isSynthetic() -> false
isEnum() -> !isEnumValuesOrValueOf(method)
method.isSynthetic -> false
isEnum -> !isEnumValuesOrValueOf(method)
else -> true
}
}
@@ -64,22 +64,22 @@ public class ReflectJavaClass(
.toList()
private fun isEnumValuesOrValueOf(method: Method): Boolean {
return when (method.getName()) {
"values" -> method.getParameterTypes().isEmpty()
"valueOf" -> Arrays.equals(method.getParameterTypes(), arrayOf(String::class.java))
return when (method.name) {
"values" -> method.parameterTypes.isEmpty()
"valueOf" -> Arrays.equals(method.parameterTypes, arrayOf(String::class.java))
else -> false
}
}
override fun getFields() = klass.getDeclaredFields()
override fun getFields() = klass.declaredFields
.asSequence()
.filter { field -> !field.isSynthetic() }
.filter { field -> !field.isSynthetic }
.map(::ReflectJavaField)
.toList()
override fun getConstructors() = klass.getDeclaredConstructors()
override fun getConstructors() = klass.declaredConstructors
.asSequence()
.filter { constructor -> !constructor.isSynthetic() }
.filter { constructor -> !constructor.isSynthetic }
.map(::ReflectJavaConstructor)
.toList()
@@ -90,17 +90,17 @@ public class ReflectJavaClass(
override fun createImmediateType(substitutor: JavaTypeSubstitutor): JavaType = throw UnsupportedOperationException()
override fun getName(): Name = Name.identifier(klass.getSimpleName())
override fun getName(): Name = Name.identifier(klass.simpleName)
override fun getTypeParameters() = klass.getTypeParameters().map { ReflectJavaTypeParameter(it) }
override fun getTypeParameters() = klass.typeParameters.map { ReflectJavaTypeParameter(it) }
override fun isInterface() = klass.isInterface()
override fun isAnnotationType() = klass.isAnnotation()
override fun isEnum() = klass.isEnum()
override fun isInterface() = klass.isInterface
override fun isAnnotationType() = klass.isAnnotation
override fun isEnum() = klass.isEnum
override fun equals(other: Any?) = other is ReflectJavaClass && klass == other.klass
override fun hashCode() = klass.hashCode()
override fun toString() = javaClass.getName() + ": " + klass
override fun toString() = javaClass.name + ": " + klass
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt
+2 -2
View File
@@ -22,13 +22,13 @@ import java.lang.reflect.ParameterizedType
import java.lang.reflect.Type
import java.lang.reflect.TypeVariable
public class ReflectJavaClassifierType(public override val type: Type) : ReflectJavaType(), JavaClassifierType {
class ReflectJavaClassifierType(public override val type: Type) : ReflectJavaType(), JavaClassifierType {
private val classifier: JavaClassifier = run {
val type = type
val classifier: JavaClassifier = when (type) {
is Class<*> -> ReflectJavaClass(type)
is TypeVariable<*> -> ReflectJavaTypeParameter(type)
is ParameterizedType -> ReflectJavaClass(type.getRawType() as Class<*>)
is ParameterizedType -> ReflectJavaClass(type.rawType as Class<*>)
else -> throw IllegalStateException("Not a classifier type (${type.javaClass}): $type")
}
classifier
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaConstructor.kt
+6 -6
View File
@@ -22,27 +22,27 @@ import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
import java.lang.reflect.Constructor
import java.lang.reflect.Modifier
public class ReflectJavaConstructor(override val member: Constructor<*>) : ReflectJavaMember(), JavaConstructor {
class ReflectJavaConstructor(override val member: Constructor<*>) : ReflectJavaMember(), JavaConstructor {
// TODO: test local/anonymous classes
override fun getValueParameters(): List<JavaValueParameter> {
val types = member.getGenericParameterTypes()
val types = member.genericParameterTypes
if (types.isEmpty()) return emptyList()
val klass = member.getDeclaringClass()
val klass = member.declaringClass
val realTypes = when {
klass.getDeclaringClass() != null && !Modifier.isStatic(klass.getModifiers()) -> types.copyOfRange(1, types.size)
klass.declaringClass != null && !Modifier.isStatic(klass.modifiers) -> types.copyOfRange(1, types.size)
else -> types
}
val annotations = member.getParameterAnnotations()
val annotations = member.parameterAnnotations
val realAnnotations = when {
annotations.size < realTypes.size -> throw IllegalStateException("Illegal generic signature: $member")
annotations.size > realTypes.size -> annotations.copyOfRange(annotations.size - realTypes.size, annotations.size)
else -> annotations
}
return getValueParameters(realTypes, realAnnotations, member.isVarArgs())
return getValueParameters(realTypes, realAnnotations, member.isVarArgs)
}
override fun getTypeParameters(): List<JavaTypeParameter> {
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaElement.kt
+1 -1
View File
@@ -18,4 +18,4 @@ package org.jetbrains.kotlin.load.java.structure.reflect
import org.jetbrains.kotlin.load.java.structure.JavaElement
public abstract class ReflectJavaElement : JavaElement
abstract class ReflectJavaElement : JavaElement
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaField.kt
+3 -3
View File
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.load.java.structure.reflect
import org.jetbrains.kotlin.load.java.structure.JavaField
import java.lang.reflect.Field
public class ReflectJavaField(override val member: Field) : ReflectJavaMember(), JavaField {
override fun isEnumEntry() = member.isEnumConstant()
class ReflectJavaField(override val member: Field) : ReflectJavaMember(), JavaField {
override fun isEnumEntry() = member.isEnumConstant
override fun getType() = ReflectJavaType.create(member.getGenericType())
override fun getType() = ReflectJavaType.create(member.genericType)
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaMember.kt
+6 -6
View File
@@ -26,16 +26,16 @@ import java.lang.reflect.Method
import java.lang.reflect.Type
import java.util.*
public abstract class ReflectJavaMember : ReflectJavaElement(), ReflectJavaAnnotationOwner, ReflectJavaModifierListOwner, JavaMember {
public abstract val member: Member
abstract class ReflectJavaMember : ReflectJavaElement(), ReflectJavaAnnotationOwner, ReflectJavaModifierListOwner, JavaMember {
abstract val member: Member
override val element: AnnotatedElement get() = member as AnnotatedElement
override val modifiers: Int get() = member.getModifiers()
override val modifiers: Int get() = member.modifiers
override fun getName() = member.getName()?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED
override fun getName() = member.name?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED
override fun getContainingClass() = ReflectJavaClass(member.getDeclaringClass())
override fun getContainingClass() = ReflectJavaClass(member.declaringClass)
protected fun getValueParameters(
parameterTypes: Array<Type>,
@@ -57,7 +57,7 @@ public abstract class ReflectJavaMember : ReflectJavaElement(), ReflectJavaAnnot
override fun hashCode() = member.hashCode()
override fun toString() = javaClass.getName() + ": " + member
override fun toString() = javaClass.name + ": " + member
}
private object Java8ParameterNamesLoader {
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaMethod.kt
+5 -5
View File
@@ -20,13 +20,13 @@ import org.jetbrains.kotlin.load.java.structure.JavaMethod
import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
import java.lang.reflect.Method
public class ReflectJavaMethod(override val member: Method) : ReflectJavaMember(), JavaMethod {
class ReflectJavaMethod(override val member: Method) : ReflectJavaMember(), JavaMethod {
override fun getValueParameters(): List<JavaValueParameter> =
getValueParameters(member.getGenericParameterTypes(), member.getParameterAnnotations(), member.isVarArgs())
getValueParameters(member.genericParameterTypes, member.parameterAnnotations, member.isVarArgs)
override fun getReturnType() = ReflectJavaType.create(member.getGenericReturnType())
override fun getReturnType() = ReflectJavaType.create(member.genericReturnType)
override fun hasAnnotationParameterDefaultValue() = member.getDefaultValue() != null
override fun hasAnnotationParameterDefaultValue() = member.defaultValue != null
override fun getTypeParameters() = member.getTypeParameters().map { ReflectJavaTypeParameter(it) }
override fun getTypeParameters() = member.typeParameters.map { ReflectJavaTypeParameter(it) }
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaModifierListOwner.kt
+1 -1
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.load.java.JavaVisibilities
import org.jetbrains.kotlin.load.java.structure.JavaModifierListOwner
import java.lang.reflect.Modifier
public interface ReflectJavaModifierListOwner : JavaModifierListOwner {
interface ReflectJavaModifierListOwner : JavaModifierListOwner {
/* protected // KT-3029 */ val modifiers: Int
override fun isAbstract() = Modifier.isAbstract(modifiers)
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPackage.kt
+2 -2
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.load.java.structure.JavaPackage
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
public class ReflectJavaPackage(private val fqName: FqName) : ReflectJavaElement(), JavaPackage {
class ReflectJavaPackage(private val fqName: FqName) : ReflectJavaElement(), JavaPackage {
override fun getFqName() = fqName
override fun getClasses(nameFilter: (Name) -> Boolean): Collection<JavaClass> {
@@ -38,5 +38,5 @@ public class ReflectJavaPackage(private val fqName: FqName) : ReflectJavaElement
override fun hashCode() = fqName.hashCode()
override fun toString() = javaClass.getName() + ": " + fqName
override fun toString() = javaClass.name + ": " + fqName
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPrimitiveType.kt
+2 -2
View File
@@ -19,8 +19,8 @@ package org.jetbrains.kotlin.load.java.structure.reflect
import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType
import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
public class ReflectJavaPrimitiveType(override val type: Class<*>) : ReflectJavaType(), JavaPrimitiveType {
class ReflectJavaPrimitiveType(override val type: Class<*>) : ReflectJavaType(), JavaPrimitiveType {
override fun getType() =
if (type == Void.TYPE) null
else JvmPrimitiveType.get(type.getName()).getPrimitiveType()
else JvmPrimitiveType.get(type.name).primitiveType
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt
+4 -4
View File
@@ -22,7 +22,7 @@ import java.lang.reflect.GenericArrayType
import java.lang.reflect.Type
import java.lang.reflect.WildcardType
public abstract class ReflectJavaType : JavaType {
abstract class ReflectJavaType : JavaType {
protected abstract val type: Type
override fun createArrayType(): JavaArrayType = throw UnsupportedOperationException()
@@ -30,8 +30,8 @@ public abstract class ReflectJavaType : JavaType {
companion object Factory {
fun create(type: Type): ReflectJavaType {
return when {
type is Class<*> && type.isPrimitive() -> ReflectJavaPrimitiveType(type)
type is GenericArrayType || type is Class<*> && type.isArray() -> ReflectJavaArrayType(type)
type is Class<*> && type.isPrimitive -> ReflectJavaPrimitiveType(type)
type is GenericArrayType || type is Class<*> && type.isArray -> ReflectJavaArrayType(type)
type is WildcardType -> ReflectJavaWildcardType(type)
else -> ReflectJavaClassifierType(type)
}
@@ -42,5 +42,5 @@ public abstract class ReflectJavaType : JavaType {
override fun hashCode() = type.hashCode()
override fun toString() = javaClass.getName() + ": " + type
override fun toString() = javaClass.name + ": " + type
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt
+6 -6
View File
@@ -25,17 +25,17 @@ import java.lang.reflect.Constructor
import java.lang.reflect.Method
import java.lang.reflect.TypeVariable
public class ReflectJavaTypeParameter(
public val typeVariable: TypeVariable<*>
class ReflectJavaTypeParameter(
val typeVariable: TypeVariable<*>
) : ReflectJavaElement(), JavaTypeParameter {
override fun getUpperBounds(): List<ReflectJavaClassifierType> {
val bounds = typeVariable.getBounds().map { bound -> ReflectJavaClassifierType(bound) }
val bounds = typeVariable.bounds.map { bound -> ReflectJavaClassifierType(bound) }
if (bounds.singleOrNull()?.type == Any::class.java) return emptyList()
return bounds
}
override fun getOwner(): JavaTypeParameterListOwner? {
val owner = typeVariable.getGenericDeclaration()
val owner = typeVariable.genericDeclaration
return when (owner) {
is Class<*> -> ReflectJavaClass(owner)
is Method -> ReflectJavaMethod(owner)
@@ -48,11 +48,11 @@ public class ReflectJavaTypeParameter(
override fun getTypeProvider(): JavaTypeProvider = throw UnsupportedOperationException()
override fun getName() = Name.identifier(typeVariable.getName())
override fun getName() = Name.identifier(typeVariable.name)
override fun equals(other: Any?) = other is ReflectJavaTypeParameter && typeVariable == other.typeVariable
override fun hashCode() = typeVariable.hashCode()
override fun toString() = javaClass.getName() + ": " + typeVariable
override fun toString() = javaClass.name + ": " + typeVariable
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaValueParameter.kt
+2 -2
View File
@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.name.Name.guess
public class ReflectJavaValueParameter(
class ReflectJavaValueParameter(
private val returnType: ReflectJavaType,
private val annotations: Array<Annotation>,
private val name: String?,
@@ -37,5 +37,5 @@ public class ReflectJavaValueParameter(
override fun getType() = returnType
override fun isVararg() = isVararg
override fun toString() = javaClass.getName() + ": " + (if (isVararg) "vararg " else "") + getName() + ": " + returnType
override fun toString() = javaClass.name + ": " + (if (isVararg) "vararg " else "") + getName() + ": " + returnType
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt
+4 -4
View File
@@ -20,10 +20,10 @@ import org.jetbrains.kotlin.load.java.structure.JavaTypeProvider
import org.jetbrains.kotlin.load.java.structure.JavaWildcardType
import java.lang.reflect.WildcardType
public class ReflectJavaWildcardType(override val type: WildcardType): ReflectJavaType(), JavaWildcardType {
class ReflectJavaWildcardType(override val type: WildcardType): ReflectJavaType(), JavaWildcardType {
override fun getBound(): ReflectJavaType? {
val upperBounds = type.getUpperBounds()
val lowerBounds = type.getLowerBounds()
val upperBounds = type.upperBounds
val lowerBounds = type.lowerBounds
if (upperBounds.size > 1 || lowerBounds.size > 1) {
throw UnsupportedOperationException("Wildcard types with many bounds are not yet supported: $type")
}
@@ -34,7 +34,7 @@ public class ReflectJavaWildcardType(override val type: WildcardType): ReflectJa
}
}
override fun isExtends() = type.getUpperBounds().firstOrNull() != Any::class.java
override fun isExtends() = type.upperBounds.firstOrNull() != Any::class.java
override fun getTypeProvider(): JavaTypeProvider = throw UnsupportedOperationException()
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/reflectClassUtil.kt
+11 -11
View File
@@ -21,33 +21,33 @@ import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import java.lang.reflect.Array
public val Class<*>.safeClassLoader: ClassLoader
val Class<*>.safeClassLoader: ClassLoader
get() = classLoader ?: ClassLoader.getSystemClassLoader()
public fun Class<*>.isEnumClassOrSpecializedEnumEntryClass(): Boolean =
fun Class<*>.isEnumClassOrSpecializedEnumEntryClass(): Boolean =
Enum::class.java.isAssignableFrom(this)
/**
* NOTE: does not perform a Java -> Kotlin mapping. If this is not expected, consider using KClassImpl#classId instead
*/
public val Class<*>.classId: ClassId
val Class<*>.classId: ClassId
get() = when {
isPrimitive() -> throw IllegalArgumentException("Can't compute ClassId for primitive type: $this")
isArray() -> throw IllegalArgumentException("Can't compute ClassId for array type: $this")
getEnclosingMethod() != null || getEnclosingConstructor() != null || getSimpleName().isEmpty() -> {
val fqName = FqName(getName())
isPrimitive -> throw IllegalArgumentException("Can't compute ClassId for primitive type: $this")
isArray -> throw IllegalArgumentException("Can't compute ClassId for array type: $this")
enclosingMethod != null || enclosingConstructor != null || simpleName.isEmpty() -> {
val fqName = FqName(name)
ClassId(fqName.parent(), FqName.topLevel(fqName.shortName()), /* local = */ true)
}
else -> getDeclaringClass()?.classId?.createNestedClassId(Name.identifier(getSimpleName())) ?: ClassId.topLevel(FqName(getName()))
else -> declaringClass?.classId?.createNestedClassId(Name.identifier(simpleName)) ?: ClassId.topLevel(FqName(name))
}
public val Class<*>.desc: String
val Class<*>.desc: String
get() {
if (this == Void.TYPE) return "V"
// This is a clever exploitation of a format returned by Class.getName(): for arrays, it's almost an internal name,
// but with '.' instead of '/'
return createArrayType().getName().substring(1).replace('.', '/')
return createArrayType().name.substring(1).replace('.', '/')
}
public fun Class<*>.createArrayType(): Class<*> =
fun Class<*>.createArrayType(): Class<*> =
Array.newInstance(this, 0).javaClass
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectAnnotationSource.kt
+1 -1
View File
@@ -19,6 +19,6 @@ package org.jetbrains.kotlin.load.kotlin.reflect
import org.jetbrains.kotlin.descriptors.SourceElement
import org.jetbrains.kotlin.descriptors.SourceFile
public class ReflectAnnotationSource(public val annotation: Annotation) : SourceElement {
class ReflectAnnotationSource(val annotation: Annotation) : SourceElement {
override fun getContainingFile(): SourceFile = SourceFile.NO_SOURCE_FILE
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClass.kt
+28 -28
View File
@@ -39,21 +39,21 @@ private val TYPES_ELIGIBLE_FOR_SIMPLE_VISIT = setOf<Class<*>>(
Class::class.java, String::class.java
)
public class ReflectKotlinClass private constructor(
public val klass: Class<*>,
class ReflectKotlinClass private constructor(
val klass: Class<*>,
private val classHeader: KotlinClassHeader
) : KotlinJvmBinaryClass {
companion object Factory {
public fun create(klass: Class<*>): ReflectKotlinClass? {
fun create(klass: Class<*>): ReflectKotlinClass? {
val headerReader = ReadKotlinClassHeaderAnnotationVisitor()
ReflectClassStructure.loadClassAnnotations(klass, headerReader)
return ReflectKotlinClass(klass, headerReader.createHeader() ?: return null)
}
}
override fun getLocation() = klass.getName().replace('.', '/') + ".class"
override fun getLocation() = klass.name.replace('.', '/') + ".class"
override fun getClassId() = klass.classId
@@ -71,12 +71,12 @@ public class ReflectKotlinClass private constructor(
override fun hashCode() = klass.hashCode()
override fun toString() = javaClass.getName() + ": " + klass
override fun toString() = javaClass.name + ": " + klass
}
private object ReflectClassStructure {
fun loadClassAnnotations(klass: Class<*>, visitor: KotlinJvmBinaryClass.AnnotationVisitor) {
for (annotation in klass.getDeclaredAnnotations()) {
for (annotation in klass.declaredAnnotations) {
processAnnotation(visitor, annotation)
}
visitor.visitEnd()
@@ -89,14 +89,14 @@ private object ReflectClassStructure {
}
private fun loadMethodAnnotations(klass: Class<*>, memberVisitor: KotlinJvmBinaryClass.MemberVisitor) {
for (method in klass.getDeclaredMethods()) {
val visitor = memberVisitor.visitMethod(Name.identifier(method.getName()), SignatureSerializer.methodDesc(method)) ?: continue
for (method in klass.declaredMethods) {
val visitor = memberVisitor.visitMethod(Name.identifier(method.name), SignatureSerializer.methodDesc(method)) ?: continue
for (annotation in method.getDeclaredAnnotations()) {
for (annotation in method.declaredAnnotations) {
processAnnotation(visitor, annotation)
}
for ((parameterIndex, annotations) in method.getParameterAnnotations().withIndex()) {
for ((parameterIndex, annotations) in method.parameterAnnotations.withIndex()) {
for (annotation in annotations) {
val annotationType = annotation.annotationClass.java
visitor.visitParameterAnnotation(parameterIndex, annotationType.classId, ReflectAnnotationSource(annotation))?.let {
@@ -110,14 +110,14 @@ private object ReflectClassStructure {
}
private fun loadConstructorAnnotations(klass: Class<*>, memberVisitor: KotlinJvmBinaryClass.MemberVisitor) {
for (constructor in klass.getDeclaredConstructors()) {
for (constructor in klass.declaredConstructors) {
val visitor = memberVisitor.visitMethod(Name.special("<init>"), SignatureSerializer.constructorDesc(constructor)) ?: continue
for (annotation in constructor.getDeclaredAnnotations()) {
for (annotation in constructor.declaredAnnotations) {
processAnnotation(visitor, annotation)
}
val parameterAnnotations = constructor.getParameterAnnotations()
val parameterAnnotations = constructor.parameterAnnotations
if (parameterAnnotations.isNotEmpty()) {
// Constructors of some classes have additional synthetic parameters:
// - inner classes have one parameter, instance of the outer class
@@ -125,7 +125,7 @@ private object ReflectClassStructure {
// - local/anonymous classes may have many parameters for captured values
// At the moment this seems like a working heuristic for computing number of synthetic parameters for Kotlin classes,
// although this is wrong and likely to change, see KT-6886
val shift = constructor.getParameterTypes().size - parameterAnnotations.size
val shift = constructor.parameterTypes.size - parameterAnnotations.size
for ((parameterIndex, annotations) in parameterAnnotations.withIndex()) {
for (annotation in annotations) {
@@ -144,10 +144,10 @@ private object ReflectClassStructure {
}
private fun loadFieldAnnotations(klass: Class<*>, memberVisitor: KotlinJvmBinaryClass.MemberVisitor) {
for (field in klass.getDeclaredFields()) {
val visitor = memberVisitor.visitField(Name.identifier(field.getName()), SignatureSerializer.fieldDesc(field), null) ?: continue
for (field in klass.declaredFields) {
val visitor = memberVisitor.visitField(Name.identifier(field.name), SignatureSerializer.fieldDesc(field), null) ?: continue
for (annotation in field.getDeclaredAnnotations()) {
for (annotation in field.declaredAnnotations) {
processAnnotation(visitor, annotation)
}
@@ -167,8 +167,8 @@ private object ReflectClassStructure {
annotation: Annotation,
annotationType: Class<*>
) {
for (method in annotationType.getDeclaredMethods()) {
processAnnotationArgumentValue(visitor, Name.identifier(method.getName()), method(annotation)!!)
for (method in annotationType.declaredMethods) {
processAnnotationArgumentValue(visitor, Name.identifier(method.name), method(annotation)!!)
}
visitor.visitEnd()
}
@@ -181,18 +181,18 @@ private object ReflectClassStructure {
}
clazz.isEnumClassOrSpecializedEnumEntryClass() -> {
// isEnum returns false for specialized enum constants (enum entries which are anonymous enum subclasses)
val classId = (if (clazz.isEnum()) clazz else clazz.getEnclosingClass()).classId
val classId = (if (clazz.isEnum) clazz else clazz.enclosingClass).classId
visitor.visitEnum(name, classId, Name.identifier((value as Enum<*>).name))
}
Annotation::class.java.isAssignableFrom(clazz) -> {
val annotationClass = clazz.getInterfaces().single()
val annotationClass = clazz.interfaces.single()
val v = visitor.visitAnnotation(name, annotationClass.classId) ?: return
processAnnotationArguments(v, value as Annotation, annotationClass)
}
clazz.isArray() -> {
clazz.isArray -> {
val v = visitor.visitArray(name) ?: return
val componentType = clazz.getComponentType()
if (componentType.isEnum()) {
val componentType = clazz.componentType
if (componentType.isEnum) {
val enumClassId = componentType.classId
for (element in value as Array<*>) {
v.visitEnum(enumClassId, Name.identifier((element as Enum<*>).name))
@@ -216,18 +216,18 @@ private object SignatureSerializer {
fun methodDesc(method: Method): String {
val sb = StringBuilder()
sb.append("(")
for (parameterType in method.getParameterTypes()) {
for (parameterType in method.parameterTypes) {
sb.append(parameterType.desc)
}
sb.append(")")
sb.append(method.getReturnType().desc)
sb.append(method.returnType.desc)
return sb.toString()
}
fun constructorDesc(constructor: Constructor<*>): String {
val sb = StringBuilder()
sb.append("(")
for (parameterType in constructor.getParameterTypes()) {
for (parameterType in constructor.parameterTypes) {
sb.append(parameterType.desc)
}
sb.append(")V")
@@ -235,6 +235,6 @@ private object SignatureSerializer {
}
fun fieldDesc(field: Field): String {
return field.getType().desc
return field.type.desc
}
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/ReflectKotlinClassFinder.kt
+4 -4
View File
@@ -22,7 +22,7 @@ import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass
import org.jetbrains.kotlin.name.ClassId
public class ReflectKotlinClassFinder(private val classLoader: ClassLoader) : KotlinClassFinder {
class ReflectKotlinClassFinder(private val classLoader: ClassLoader) : KotlinClassFinder {
private fun findKotlinClass(fqName: String): KotlinJvmBinaryClass? {
return classLoader.tryLoadClass(fqName)?.let { ReflectKotlinClass.create(it) }
}
@@ -31,11 +31,11 @@ public class ReflectKotlinClassFinder(private val classLoader: ClassLoader) : Ko
override fun findKotlinClass(javaClass: JavaClass): KotlinJvmBinaryClass? {
// TODO: go through javaClass's class loader
return findKotlinClass(javaClass.getFqName()?.asString() ?: return null)
return findKotlinClass(javaClass.fqName?.asString() ?: return null)
}
}
private fun ClassId.toRuntimeFqName(): String {
val className = getRelativeClassName().asString().replace('.', '$')
return if (getPackageFqName().isRoot()) className else "${getPackageFqName()}.$className"
val className = relativeClassName.asString().replace('.', '$')
return if (packageFqName.isRoot) className else "${packageFqName}.$className"
}
core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt
+4 -4
View File
@@ -40,12 +40,12 @@ import org.jetbrains.kotlin.serialization.deserialization.DeserializationCompone
import org.jetbrains.kotlin.serialization.deserialization.LocalClassResolver
import org.jetbrains.kotlin.storage.LockBasedStorageManager
public class RuntimeModuleData private constructor(public val deserialization: DeserializationComponents, val packageFacadeProvider: RuntimePackagePartProvider) {
public val module: ModuleDescriptor get() = deserialization.moduleDescriptor
public val localClassResolver: LocalClassResolver get() = deserialization.localClassResolver
class RuntimeModuleData private constructor(val deserialization: DeserializationComponents, val packageFacadeProvider: RuntimePackagePartProvider) {
val module: ModuleDescriptor get() = deserialization.moduleDescriptor
val localClassResolver: LocalClassResolver get() = deserialization.localClassResolver
companion object {
public fun create(classLoader: ClassLoader): RuntimeModuleData {
fun create(classLoader: ClassLoader): RuntimeModuleData {
val builtIns = JvmBuiltIns.Instance
val storageManager = LockBasedStorageManager()
val module = ModuleDescriptorImpl(Name.special("<runtime module for $classLoader>"), storageManager,