Convert Java model to Kotlin, put in several files

Also move JavaPropertyInitializerEvaluator to ../components/

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaAnnotation.kt

@@ -18,19 +18,20 @@ package org.jetbrains.kotlin.load.java.structure.reflect
 
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotation
 import org.jetbrains.kotlin.load.java.structure.JavaAnnotationArgument
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
 class ReflectJavaAnnotation(val annotation: Annotation) : ReflectJavaElement(), JavaAnnotation {
-    override fun getArguments(): Collection<JavaAnnotationArgument> {
-        return annotation.annotationClass.java.declaredMethods.map { method ->
+    override val arguments: Collection<JavaAnnotationArgument>
+        get() = annotation.annotationClass.java.declaredMethods.map { method ->
             ReflectJavaAnnotationArgument.create(method.invoke(annotation), Name.identifier(method.name))
         }
-    }
+
+    override val classId: ClassId
+        get() = annotation.annotationClass.java.classId
 
     override fun resolve() = ReflectJavaClass(annotation.annotationClass.java)
 
-    override fun getClassId() = annotation.annotationClass.java.classId
-
     override fun equals(other: Any?) = other is ReflectJavaAnnotation && annotation == other.annotation
 
     override fun hashCode() = annotation.hashCode()

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaAnnotationOwner.kt

@@ -23,11 +23,14 @@ import java.lang.reflect.AnnotatedElement
 interface ReflectJavaAnnotationOwner : JavaAnnotationOwner {
     val element: AnnotatedElement?
 
-    override fun getAnnotations() = element?.declaredAnnotations?.getAnnotations() ?: emptyList()
+    override val annotations: List<ReflectJavaAnnotation>
+        get() = element?.declaredAnnotations?.getAnnotations() ?: emptyList()
 
-    override fun findAnnotation(fqName: FqName) = element?.declaredAnnotations?.findAnnotation(fqName)
+    override fun findAnnotation(fqName: FqName) =
+            element?.declaredAnnotations?.findAnnotation(fqName)
 
-    override fun isDeprecatedInJavaDoc() = false
+    override val isDeprecatedInJavaDoc: Boolean
+        get() = false
 }
 
 fun Array<Annotation>.getAnnotations(): List<ReflectJavaAnnotation> {

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaArrayType.kt

@@ -20,14 +20,12 @@ import org.jetbrains.kotlin.load.java.structure.JavaArrayType
 import java.lang.reflect.GenericArrayType
 import java.lang.reflect.Type
 
-class ReflectJavaArrayType(override val type: Type) : ReflectJavaType(), JavaArrayType {
-    private val componentType: ReflectJavaType = with (type) {
+class ReflectJavaArrayType(override val reflectType: Type) : ReflectJavaType(), JavaArrayType {
+    override val componentType: ReflectJavaType = with (reflectType) {
         when {
             this is GenericArrayType -> ReflectJavaType.create(genericComponentType)
             this is Class<*> && isArray() -> ReflectJavaType.create(getComponentType())
-            else -> throw IllegalArgumentException("Not an array type (${type.javaClass}): $type")
+            else -> throw IllegalArgumentException("Not an array type (${reflectType.javaClass}): $reflectType")
         }
     }
-
-    override fun getComponentType() = componentType
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClass.kt

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.load.java.structure.reflect
 
 import org.jetbrains.kotlin.load.java.structure.JavaClass
 import org.jetbrains.kotlin.load.java.structure.JavaClassifierType
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import java.lang.reflect.Method
 import java.util.*
@@ -29,37 +30,42 @@ class ReflectJavaClass(
 
     override val modifiers: Int get() = klass.modifiers
 
-    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.simpleName.isEmpty()
-            }
-            .map(::ReflectJavaClass)
-            .toList()
-
-    override fun getFqName() = klass.classId.asSingleFqName()
-
-    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.declaredMethods
-            .asSequence()
-            .filter { method ->
-                when {
-                    method.isSynthetic -> false
-                    isEnum -> !isEnumValuesOrValueOf(method)
-                    else -> true
+    override val innerClasses: List<ReflectJavaClass>
+        get() = 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.simpleName.isEmpty()
                 }
-            }
-            .map(::ReflectJavaMethod)
-            .toList()
+                .map(::ReflectJavaClass)
+                .toList()
+
+    override val fqName: FqName
+        get() = klass.classId.asSingleFqName()
+
+    override val outerClass: ReflectJavaClass?
+        get() = klass.declaringClass?.let(::ReflectJavaClass)
+
+    override val supertypes: Collection<JavaClassifierType>
+        get() {
+            if (klass == Any::class.java) return emptyList()
+            return listOf(klass.genericSuperclass ?: Any::class.java, *klass.genericInterfaces).map(::ReflectJavaClassifierType)
+        }
+
+    override val methods: List<ReflectJavaMethod>
+        get() = klass.declaredMethods
+                .asSequence()
+                .filter { method ->
+                    when {
+                        method.isSynthetic -> false
+                        isEnum -> !isEnumValuesOrValueOf(method)
+                        else -> true
+                    }
+                }
+                .map(::ReflectJavaMethod)
+                .toList()
 
     private fun isEnumValuesOrValueOf(method: Method): Boolean {
         return when (method.name) {
@@ -69,27 +75,35 @@ class ReflectJavaClass(
         }
     }
 
-    override fun getFields() = klass.declaredFields
-            .asSequence()
-            .filter { field -> !field.isSynthetic }
-            .map(::ReflectJavaField)
-            .toList()
+    override val fields: List<ReflectJavaField>
+        get() = klass.declaredFields
+                .asSequence()
+                .filter { field -> !field.isSynthetic }
+                .map(::ReflectJavaField)
+                .toList()
 
-    override fun getConstructors() = klass.declaredConstructors
-            .asSequence()
-            .filter { constructor -> !constructor.isSynthetic }
-            .map(::ReflectJavaConstructor)
-            .toList()
+    override val constructors: List<ReflectJavaConstructor>
+        get() = klass.declaredConstructors
+                .asSequence()
+                .filter { constructor -> !constructor.isSynthetic }
+                .map(::ReflectJavaConstructor)
+                .toList()
 
-    override fun isKotlinLightClass() = false
+    override val isKotlinLightClass: Boolean
+        get() = false
 
-    override fun getName() = Name.identifier(klass.simpleName)
+    override val name: Name
+        get() = Name.identifier(klass.simpleName)
 
-    override fun getTypeParameters() = klass.typeParameters.map { ReflectJavaTypeParameter(it) }
+    override val typeParameters: List<ReflectJavaTypeParameter>
+        get() = klass.typeParameters.map { ReflectJavaTypeParameter(it) }
 
-    override fun isInterface() = klass.isInterface
-    override fun isAnnotationType() = klass.isAnnotation
-    override fun isEnum() = klass.isEnum
+    override val isInterface: Boolean
+        get() = klass.isInterface
+    override val isAnnotationType: Boolean
+        get() = klass.isAnnotation
+    override val isEnum: Boolean
+        get() = klass.isEnum
 
     override fun equals(other: Any?) = other is ReflectJavaClass && klass == other.klass
 

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaClassifierType.kt

@@ -25,9 +25,9 @@ import java.lang.reflect.ParameterizedType
 import java.lang.reflect.Type
 import java.lang.reflect.TypeVariable
 
-class ReflectJavaClassifierType(public override val type: Type) : ReflectJavaType(), JavaClassifierType {
-    private val classifier: JavaClassifier = run {
-        val type = type
+class ReflectJavaClassifierType(public override val reflectType: Type) : ReflectJavaType(), JavaClassifierType {
+    override val classifier: JavaClassifier = run {
+        val type = reflectType
         val classifier: JavaClassifier = when (type) {
             is Class<*> -> ReflectJavaClass(type)
             is TypeVariable<*> -> ReflectJavaTypeParameter(type)
@@ -37,25 +37,26 @@ class ReflectJavaClassifierType(public override val type: Type) : ReflectJavaTyp
         classifier
     }
 
-    override fun getClassifier(): JavaClassifier = classifier
+    override val presentableText: String
+        get() = reflectType.toString()
 
-    override fun getPresentableText(): String = type.toString()
+    override val isRaw: Boolean
+        get() = with(reflectType) { this is Class<*> && getTypeParameters().isNotEmpty() }
 
-    override fun isRaw(): Boolean = with(type) { this is Class<*> && getTypeParameters().isNotEmpty() }
-
-    override fun getTypeArguments(): List<JavaType> {
-        return generateSequence({type as? ParameterizedType}, { it.ownerType as? ParameterizedType }).flatMap {
+    override val typeArguments: List<JavaType>
+        get() = generateSequence({ reflectType as? ParameterizedType }, { it.ownerType as? ParameterizedType }).flatMap {
             it.actualTypeArguments.asSequence().map { ReflectJavaType.create(it) }
         }.toList()
-    }
 
-    override fun getAnnotations(): Collection<JavaAnnotation> {
-        return emptyList() // TODO
-    }
+    override val annotations: Collection<JavaAnnotation>
+        get() {
+            return emptyList() // TODO
+        }
 
     override fun findAnnotation(fqName: FqName): JavaAnnotation? {
         return null // TODO
     }
 
-    override fun isDeprecatedInJavaDoc() = false
+    override val isDeprecatedInJavaDoc: Boolean
+        get() = false
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaConstructor.kt

@@ -17,33 +17,34 @@
 package org.jetbrains.kotlin.load.java.structure.reflect
 
 import org.jetbrains.kotlin.load.java.structure.JavaConstructor
-import org.jetbrains.kotlin.load.java.structure.JavaTypeParameter
 import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
 import java.lang.reflect.Constructor
 import java.lang.reflect.Modifier
 
 class ReflectJavaConstructor(override val member: Constructor<*>) : ReflectJavaMember(), JavaConstructor {
     // TODO: test local/anonymous classes
-    override fun getValueParameters(): List<JavaValueParameter> {
-        val types = member.genericParameterTypes
-        if (types.isEmpty()) return emptyList()
+    override val valueParameters: List<JavaValueParameter>
+        get() {
+            val types = member.genericParameterTypes
+            if (types.isEmpty()) return emptyList()
 
-        val klass = member.declaringClass
+            val klass = member.declaringClass
 
-        val realTypes = when {
-            klass.declaringClass != null && !Modifier.isStatic(klass.modifiers) -> types.copyOfRange(1, types.size)
-            else -> types
+            val realTypes = when {
+                klass.declaringClass != null && !Modifier.isStatic(klass.modifiers) -> types.copyOfRange(1, types.size)
+                else -> types
+            }
+
+            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)
         }
 
-        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)
-    }
-
-    override fun getTypeParameters() = member.typeParameters.map { ReflectJavaTypeParameter(it) }
+    override val typeParameters: List<ReflectJavaTypeParameter>
+        get() = member.typeParameters.map { ReflectJavaTypeParameter(it) }
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaField.kt

@@ -20,7 +20,9 @@ import org.jetbrains.kotlin.load.java.structure.JavaField
 import java.lang.reflect.Field
 
 class ReflectJavaField(override val member: Field) : ReflectJavaMember(), JavaField {
-    override fun isEnumEntry() = member.isEnumConstant
+    override val isEnumEntry: Boolean
+        get() = member.isEnumConstant
 
-    override fun getType() = ReflectJavaType.create(member.genericType)
+    override val type: ReflectJavaType
+        get() = ReflectJavaType.create(member.genericType)
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaMember.kt

@@ -33,9 +33,11 @@ abstract class ReflectJavaMember : ReflectJavaElement(), ReflectJavaAnnotationOw
 
     override val modifiers: Int get() = member.modifiers
 
-    override fun getName() = member.name?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED
+    override val name: Name
+        get() = member.name?.let { Name.identifier(it) } ?: SpecialNames.NO_NAME_PROVIDED
 
-    override fun getContainingClass() = ReflectJavaClass(member.declaringClass)
+    override val containingClass: ReflectJavaClass
+        get() = ReflectJavaClass(member.declaringClass)
 
     protected fun getValueParameters(
             parameterTypes: Array<Type>,

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaMethod.kt

@@ -21,12 +21,15 @@ import org.jetbrains.kotlin.load.java.structure.JavaValueParameter
 import java.lang.reflect.Method
 
 class ReflectJavaMethod(override val member: Method) : ReflectJavaMember(), JavaMethod {
-    override fun getValueParameters(): List<JavaValueParameter> =
-            getValueParameters(member.genericParameterTypes, member.parameterAnnotations, member.isVarArgs)
+    override val valueParameters: List<JavaValueParameter>
+        get() = getValueParameters(member.genericParameterTypes, member.parameterAnnotations, member.isVarArgs)
 
-    override fun getReturnType() = ReflectJavaType.create(member.genericReturnType)
+    override val returnType: ReflectJavaType
+        get() = ReflectJavaType.create(member.genericReturnType)
 
-    override fun hasAnnotationParameterDefaultValue() = member.defaultValue != null
+    override val hasAnnotationParameterDefaultValue: Boolean
+        get() = member.defaultValue != null
 
-    override fun getTypeParameters() = member.typeParameters.map { ReflectJavaTypeParameter(it) }
+    override val typeParameters: List<ReflectJavaTypeParameter>
+        get() = member.typeParameters.map { ReflectJavaTypeParameter(it) }
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaModifierListOwner.kt

@@ -25,18 +25,24 @@ import java.lang.reflect.Modifier
 interface ReflectJavaModifierListOwner : JavaModifierListOwner {
     /* protected // KT-3029 */ val modifiers: Int
 
-    override fun isAbstract() = Modifier.isAbstract(modifiers)
-    override fun isStatic() = Modifier.isStatic(modifiers)
-    override fun isFinal() = Modifier.isFinal(modifiers)
+    override val isAbstract: Boolean
+        get() = Modifier.isAbstract(modifiers)
 
-    override fun getVisibility(): Visibility = modifiers.let { modifiers ->
-        when {
-            Modifier.isPublic(modifiers) -> Visibilities.PUBLIC
-            Modifier.isPrivate(modifiers) -> Visibilities.PRIVATE
-            Modifier.isProtected(modifiers) ->
-                if (Modifier.isStatic(modifiers)) JavaVisibilities.PROTECTED_STATIC_VISIBILITY
-                else JavaVisibilities.PROTECTED_AND_PACKAGE
-            else -> JavaVisibilities.PACKAGE_VISIBILITY
+    override val isStatic: Boolean
+        get() = Modifier.isStatic(modifiers)
+
+    override val isFinal: Boolean
+        get() = Modifier.isFinal(modifiers)
+
+    override val visibility: Visibility
+        get() = modifiers.let { modifiers ->
+            when {
+                Modifier.isPublic(modifiers) -> Visibilities.PUBLIC
+                Modifier.isPrivate(modifiers) -> Visibilities.PRIVATE
+                Modifier.isProtected(modifiers) ->
+                    if (Modifier.isStatic(modifiers)) JavaVisibilities.PROTECTED_STATIC_VISIBILITY
+                    else JavaVisibilities.PROTECTED_AND_PACKAGE
+                else -> JavaVisibilities.PACKAGE_VISIBILITY
+            }
         }
-    }
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPackage.kt

@@ -21,18 +21,17 @@ import org.jetbrains.kotlin.load.java.structure.JavaPackage
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
-class ReflectJavaPackage(private val fqName: FqName) : ReflectJavaElement(), JavaPackage {
-    override fun getFqName() = fqName
-
+class ReflectJavaPackage(override val fqName: FqName) : ReflectJavaElement(), JavaPackage {
     override fun getClasses(nameFilter: (Name) -> Boolean): Collection<JavaClass> {
         // A package at runtime can't know what classes it has and has not
         return listOf()
     }
 
-    override fun getSubPackages(): Collection<JavaPackage> {
-        // A package at runtime can't know what sub packages it has and has not
-        return listOf()
-    }
+    override val subPackages: Collection<JavaPackage>
+        get() {
+            // A package at runtime can't know what sub packages it has and has not
+            return listOf()
+        }
 
     override fun equals(other: Any?) = other is ReflectJavaPackage && fqName == other.fqName
 

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaPrimitiveType.kt

@@ -16,11 +16,14 @@
 
 package org.jetbrains.kotlin.load.java.structure.reflect
 
+import org.jetbrains.kotlin.builtins.PrimitiveType
 import org.jetbrains.kotlin.load.java.structure.JavaPrimitiveType
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
-class ReflectJavaPrimitiveType(override val type: Class<*>) : ReflectJavaType(), JavaPrimitiveType {
-    override fun getType() =
-            if (type == Void.TYPE) null
-            else JvmPrimitiveType.get(type.name).primitiveType
+class ReflectJavaPrimitiveType(override val reflectType: Class<*>) : ReflectJavaType(), JavaPrimitiveType {
+    override val type: PrimitiveType?
+        get() = if (reflectType == Void.TYPE)
+            null
+        else
+            JvmPrimitiveType.get(reflectType.name).primitiveType
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaType.kt

@@ -22,7 +22,7 @@ import java.lang.reflect.Type
 import java.lang.reflect.WildcardType
 
 abstract class ReflectJavaType : JavaType {
-    protected abstract val type: Type
+    protected abstract val reflectType: Type
 
     companion object Factory {
         fun create(type: Type): ReflectJavaType {
@@ -35,9 +35,9 @@ abstract class ReflectJavaType : JavaType {
         }
     }
 
-    override fun equals(other: Any?) = other is ReflectJavaType && type == other.type
+    override fun equals(other: Any?) = other is ReflectJavaType && reflectType == other.reflectType
 
-    override fun hashCode() = type.hashCode()
+    override fun hashCode() = reflectType.hashCode()
 
-    override fun toString() = javaClass.name + ": " + type
+    override fun toString() = javaClass.name + ": " + reflectType
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaTypeParameter.kt

@@ -24,17 +24,19 @@ import java.lang.reflect.TypeVariable
 class ReflectJavaTypeParameter(
         val typeVariable: TypeVariable<*>
 ) : ReflectJavaElement(), JavaTypeParameter, ReflectJavaAnnotationOwner {
-    override fun getUpperBounds(): List<ReflectJavaClassifierType> {
-        val bounds = typeVariable.bounds.map { bound -> ReflectJavaClassifierType(bound) }
-        if (bounds.singleOrNull()?.type == Any::class.java) return emptyList()
-        return bounds
-    }
+    override val upperBounds: List<ReflectJavaClassifierType>
+        get() {
+            val bounds = typeVariable.bounds.map { bound -> ReflectJavaClassifierType(bound) }
+            if (bounds.singleOrNull()?.reflectType == Any::class.java) return emptyList()
+            return bounds
+        }
 
     override val element: AnnotatedElement?
         // TypeVariable is AnnotatedElement only in JDK8
         get() = typeVariable as? AnnotatedElement
 
-    override fun getName() = Name.identifier(typeVariable.name)
+    override val name: Name
+        get() = Name.identifier(typeVariable.name)
 
     override fun equals(other: Any?) = other is ReflectJavaTypeParameter && typeVariable == other.typeVariable
 

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaValueParameter.kt

@@ -21,20 +21,22 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 
 class ReflectJavaValueParameter(
-        private val returnType: ReflectJavaType,
-        private val annotations: Array<Annotation>,
-        private val name: String?,
-        private val isVararg: Boolean
+        override val type: ReflectJavaType,
+        private val reflectAnnotations: Array<Annotation>,
+        private val reflectName: String?,
+        override val isVararg: Boolean
 ) : ReflectJavaElement(), JavaValueParameter {
-    override fun getAnnotations() = annotations.getAnnotations()
+    override val annotations: List<ReflectJavaAnnotation>
+        get() = reflectAnnotations.getAnnotations()
 
-    override fun findAnnotation(fqName: FqName) = annotations.findAnnotation(fqName)
+    override fun findAnnotation(fqName: FqName) =
+            reflectAnnotations.findAnnotation(fqName)
 
-    override fun isDeprecatedInJavaDoc() = false
+    override val isDeprecatedInJavaDoc: Boolean
+        get() = false
 
-    override fun getName() = name?.let(Name::guessByFirstCharacter)
-    override fun getType() = returnType
-    override fun isVararg() = isVararg
+    override val name: Name?
+        get() = reflectName?.let(Name::guessByFirstCharacter)
 
-    override fun toString() = javaClass.name + ": " + (if (isVararg) "vararg " else "") + getName() + ": " + returnType
+    override fun toString() = javaClass.name + ": " + (if (isVararg) "vararg " else "") + name + ": " + type
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaWildcardType.kt

@@ -19,19 +19,21 @@ package org.jetbrains.kotlin.load.java.structure.reflect
 import org.jetbrains.kotlin.load.java.structure.JavaWildcardType
 import java.lang.reflect.WildcardType
 
-class ReflectJavaWildcardType(override val type: WildcardType): ReflectJavaType(), JavaWildcardType {
-    override fun getBound(): ReflectJavaType? {
-        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")
+class ReflectJavaWildcardType(override val reflectType: WildcardType): ReflectJavaType(), JavaWildcardType {
+    override val bound: ReflectJavaType?
+        get() {
+            val upperBounds = reflectType.upperBounds
+            val lowerBounds = reflectType.lowerBounds
+            if (upperBounds.size > 1 || lowerBounds.size > 1) {
+                throw UnsupportedOperationException("Wildcard types with many bounds are not yet supported: $reflectType")
+            }
+            return when {
+                lowerBounds.size == 1 -> ReflectJavaType.create(lowerBounds.single())
+                upperBounds.size == 1 -> upperBounds.single().let { ub -> if (ub != Any::class.java) ReflectJavaType.create(ub) else null }
+                else -> null
+            }
         }
-        return when {
-            lowerBounds.size == 1 -> ReflectJavaType.create(lowerBounds.single())
-            upperBounds.size == 1 -> upperBounds.single().let { ub -> if (ub != Any::class.java) ReflectJavaType.create(ub) else null }
-            else -> null
-        }
-    }
 
-    override fun isExtends() = type.upperBounds.firstOrNull() != Any::class.java
+    override val isExtends: Boolean
+        get() = reflectType.upperBounds.firstOrNull() != Any::class.java
 }

core/descriptors.runtime/src/org/jetbrains/kotlin/load/kotlin/reflect/RuntimeModuleData.kt

@@ -27,7 +27,6 @@ import org.jetbrains.kotlin.load.java.lazy.JavaResolverComponents
 import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider
 import org.jetbrains.kotlin.load.java.lazy.SingleModuleClassResolver
 import org.jetbrains.kotlin.load.java.reflect.ReflectJavaClassFinder
-import org.jetbrains.kotlin.load.java.structure.JavaPropertyInitializerEvaluator
 import org.jetbrains.kotlin.load.kotlin.BinaryClassAnnotationAndConstantLoaderImpl
 import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava
 import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver