From 0fc9bb3f4a8f3c04c0bca5997ce27cc3952d43ef Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Wed, 20 Jun 2018 16:10:56 +0300 Subject: [PATCH] Minor. Reformat LazyJavaClassMemberScope.kt --- .../descriptors/LazyJavaClassMemberScope.kt | 313 +++++++++--------- 1 file changed, 160 insertions(+), 153 deletions(-) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 991ae71e83e..63833307cc5 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -59,9 +59,9 @@ import org.jetbrains.kotlin.utils.ifEmpty import java.util.* class LazyJavaClassMemberScope( - c: LazyJavaResolverContext, - override val ownerDescriptor: ClassDescriptor, - private val jClass: JavaClass + c: LazyJavaResolverContext, + override val ownerDescriptor: ClassDescriptor, + private val jClass: JavaClass ) : LazyJavaScope(c) { override fun computeMemberIndex() = ClassDeclaredMemberIndex(jClass, { !it.isStatic }) @@ -83,8 +83,8 @@ class LazyJavaClassMemberScope( } c.components.signatureEnhancement.enhanceSignatures( - c, - result.ifEmpty { listOfNotNull(createDefaultConstructor()) } + c, + result.ifEmpty { listOfNotNull(createDefaultConstructor()) } ).toList() } @@ -94,22 +94,19 @@ class LazyJavaClassMemberScope( } private fun isVisibleAsFunctionInCurrentClass(function: SimpleFunctionDescriptor): Boolean { - if (getPropertyNamesCandidatesByAccessorName(function.name).any { - propertyName -> - getPropertiesFromSupertypes(propertyName).any { - property -> - doesClassOverridesProperty(property) { - accessorName -> - // This lambda should return property accessors available in this class by their name - // If 'accessorName' is current function we return only it just because we check exactly - // that current method is override of accessor - if (function.name == accessorName) - listOf(function) - else - searchMethodsByNameWithoutBuiltinMagic(accessorName) + searchMethodsInSupertypesWithoutBuiltinMagic(accessorName) - } && (property.isVar || !JvmAbi.isSetterName(function.name.asString())) - } - }) return false + if (getPropertyNamesCandidatesByAccessorName(function.name).any { propertyName -> + getPropertiesFromSupertypes(propertyName).any { property -> + doesClassOverridesProperty(property) { accessorName -> + // This lambda should return property accessors available in this class by their name + // If 'accessorName' is current function we return only it just because we check exactly + // that current method is override of accessor + if (function.name == accessorName) + listOf(function) + else + searchMethodsByNameWithoutBuiltinMagic(accessorName) + searchMethodsInSupertypesWithoutBuiltinMagic(accessorName) + } && (property.isVar || !JvmAbi.isSetterName(function.name.asString())) + } + }) return false return !function.doesOverrideRenamedBuiltins() && !function.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters() } @@ -124,31 +121,30 @@ class LazyJavaClassMemberScope( private fun SimpleFunctionDescriptor.shouldBeVisibleAsOverrideOfBuiltInWithErasedValueParameters(): Boolean { if (!name.sameAsBuiltinMethodWithErasedValueParameters) return false val candidatesToOverride = - getFunctionsFromSupertypes(name).mapNotNull { - BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) - } + getFunctionsFromSupertypes(name).mapNotNull { + BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) + } - return candidatesToOverride.any { - candidate -> + return candidatesToOverride.any { candidate -> hasSameJvmDescriptorButDoesNotOverride(candidate) } } private fun searchMethodsByNameWithoutBuiltinMagic(name: Name): Collection = - declaredMemberIndex().findMethodsByName(name).map { resolveMethodToFunctionDescriptor(it) } + declaredMemberIndex().findMethodsByName(name).map { resolveMethodToFunctionDescriptor(it) } private fun searchMethodsInSupertypesWithoutBuiltinMagic(name: Name): Collection = - getFunctionsFromSupertypes(name).filterNot { - it.doesOverrideBuiltinWithDifferentJvmName() - || BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) != null - } + getFunctionsFromSupertypes(name).filterNot { + it.doesOverrideBuiltinWithDifferentJvmName() + || BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it) != null + } private fun SimpleFunctionDescriptor.doesOverrideRenamedBuiltins(): Boolean { return BuiltinMethodsWithDifferentJvmName.getBuiltinFunctionNamesByJvmName(name).any { // e.g. 'removeAt' or 'toInt' - builtinName -> + builtinName -> val builtinSpecialFromSuperTypes = - getFunctionsFromSupertypes(builtinName).filter { it.doesOverrideBuiltinWithDifferentJvmName() } + getFunctionsFromSupertypes(builtinName).filter { it.doesOverrideBuiltinWithDifferentJvmName() } if (builtinSpecialFromSuperTypes.isEmpty()) return@any false val methodDescriptor = this.createRenamedCopy(builtinName) @@ -158,15 +154,15 @@ class LazyJavaClassMemberScope( } private fun SimpleFunctionDescriptor.createRenamedCopy(builtinName: Name): SimpleFunctionDescriptor = - this.newCopyBuilder().apply { - setName(builtinName) - setSignatureChange() - setPreserveSourceElement() - }.build()!! + this.newCopyBuilder().apply { + setName(builtinName) + setSignatureChange() + setPreserveSourceElement() + }.build()!! private fun doesOverrideRenamedDescriptor( - superDescriptor: SimpleFunctionDescriptor, - subDescriptor: FunctionDescriptor + superDescriptor: SimpleFunctionDescriptor, + subDescriptor: FunctionDescriptor ): Boolean { // if we check 'removeAt', get original sub-descriptor to distinct `remove(int)` and `remove(E)` in Java val subDescriptorToCheck = if (superDescriptor.isRemoveAtByIndex) subDescriptor.original else subDescriptor @@ -176,15 +172,16 @@ class LazyJavaClassMemberScope( private fun CallableDescriptor.doesOverride(superDescriptor: CallableDescriptor): Boolean { val commonOverridabilityResult = - OverridingUtil.DEFAULT.isOverridableByWithoutExternalConditions(superDescriptor, this, true).result + OverridingUtil.DEFAULT.isOverridableByWithoutExternalConditions(superDescriptor, this, true).result return commonOverridabilityResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE && - !JavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds( - superDescriptor, this) + !JavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds( + superDescriptor, this + ) } private fun PropertyDescriptor.findGetterOverride( - functions: (Name) -> Collection + functions: (Name) -> Collection ): SimpleFunctionDescriptor? { val overriddenBuiltinProperty = getter?.getOverriddenBuiltinWithDifferentJvmName() val specialGetterName = overriddenBuiltinProperty?.getBuiltinSpecialPropertyGetterName() @@ -198,11 +195,10 @@ class LazyJavaClassMemberScope( } private fun PropertyDescriptor.findGetterByName( - getterName: String, - functions: (Name) -> Collection + getterName: String, + functions: (Name) -> Collection ): SimpleFunctionDescriptor? { - return functions(Name.identifier(getterName)).firstNotNullResult factory@{ - descriptor -> + return functions(Name.identifier(getterName)).firstNotNullResult factory@{ descriptor -> if (descriptor.valueParameters.size != 0) return@factory null descriptor.takeIf { KotlinTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@takeIf false, type) } @@ -210,10 +206,9 @@ class LazyJavaClassMemberScope( } private fun PropertyDescriptor.findSetterOverride( - functions: (Name) -> Collection + functions: (Name) -> Collection ): SimpleFunctionDescriptor? { - return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{ - descriptor -> + return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{ descriptor -> if (descriptor.valueParameters.size != 1) return@factory null if (!KotlinBuiltIns.isUnit(descriptor.returnType ?: return@factory null)) return@factory null @@ -222,8 +217,8 @@ class LazyJavaClassMemberScope( } private fun doesClassOverridesProperty( - property: PropertyDescriptor, - functions: (Name) -> Collection + property: PropertyDescriptor, + functions: (Name) -> Collection ): Boolean { if (property.isJavaField) return false val getter = property.findGetterOverride(functions) @@ -241,9 +236,10 @@ class LazyJavaClassMemberScope( if (!name.sameAsRenamedInJvmBuiltin && !name.sameAsBuiltinMethodWithErasedValueParameters) { // Simple fast path in case of name is not suspicious (i.e. name is not one of builtins that have different signature in Java) addFunctionFromSupertypes( - result, name, - functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) }, - isSpecialBuiltinName = false) + result, name, + functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) }, + isSpecialBuiltinName = false + ) return } @@ -251,57 +247,58 @@ class LazyJavaClassMemberScope( // Merge functions with same signatures val mergedFunctionFromSuperTypes = resolveOverridesForNonStaticMembers( - name, functionsFromSupertypes, emptyList(), ownerDescriptor, ErrorReporter.DO_NOTHING) + name, functionsFromSupertypes, emptyList(), ownerDescriptor, ErrorReporter.DO_NOTHING + ) // add declarations addOverriddenBuiltinMethods( - name, result, mergedFunctionFromSuperTypes, result, - this::searchMethodsByNameWithoutBuiltinMagic) + name, result, mergedFunctionFromSuperTypes, result, + this::searchMethodsByNameWithoutBuiltinMagic + ) // add from super types addOverriddenBuiltinMethods( - name, result, mergedFunctionFromSuperTypes, specialBuiltinsFromSuperTypes, - this::searchMethodsInSupertypesWithoutBuiltinMagic) + name, result, mergedFunctionFromSuperTypes, specialBuiltinsFromSuperTypes, + this::searchMethodsInSupertypesWithoutBuiltinMagic + ) val visibleFunctionsFromSupertypes = - functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) } + specialBuiltinsFromSuperTypes + functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) } + specialBuiltinsFromSuperTypes addFunctionFromSupertypes(result, name, visibleFunctionsFromSupertypes, isSpecialBuiltinName = true) } private fun addFunctionFromSupertypes( - result: MutableCollection, - name: Name, - functionsFromSupertypes: Collection, - isSpecialBuiltinName: Boolean + result: MutableCollection, + name: Name, + functionsFromSupertypes: Collection, + isSpecialBuiltinName: Boolean ) { val additionalOverrides = resolveOverridesForNonStaticMembers( - name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter + name, functionsFromSupertypes, result, ownerDescriptor, c.components.errorReporter ) if (!isSpecialBuiltinName) { result.addAll(additionalOverrides) - } - else { + } else { val allDescriptors = result + additionalOverrides result.addAll( - additionalOverrides.map { - resolvedOverride -> - val overriddenBuiltin = resolvedOverride.getOverriddenSpecialBuiltin() - ?: return@map resolvedOverride + additionalOverrides.map { resolvedOverride -> + val overriddenBuiltin = resolvedOverride.getOverriddenSpecialBuiltin() + ?: return@map resolvedOverride - resolvedOverride.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, allDescriptors) - }) + resolvedOverride.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, allDescriptors) + }) } } private fun addOverriddenBuiltinMethods( - name: Name, - alreadyDeclaredFunctions: Collection, - candidatesForOverride: Collection, - result: MutableCollection, - functions: (Name) -> Collection + name: Name, + alreadyDeclaredFunctions: Collection, + candidatesForOverride: Collection, + result: MutableCollection, + functions: (Name) -> Collection ) { for (descriptor in candidatesForOverride) { val overriddenBuiltin = descriptor.getOverriddenBuiltinWithDifferentJvmName() ?: continue @@ -312,7 +309,8 @@ class LazyJavaClassMemberScope( if (doesOverrideRenamedDescriptor(overriddenBuiltin, renamedCopy)) { result.add( - renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)) + renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions) + ) break } } @@ -320,11 +318,10 @@ class LazyJavaClassMemberScope( for (descriptor in candidatesForOverride) { val overriddenBuiltin = - BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(descriptor) - ?: continue + BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(descriptor) + ?: continue - createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let { - override -> + createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let { override -> if (isVisibleAsFunctionInCurrentClass(override)) { result.add(override.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)) } @@ -339,8 +336,8 @@ class LazyJavaClassMemberScope( // so when someone calls CharBuffer.get it results in invoking java method CharBuffer.get // But we still have the way to call 'charAt' java method by upcasting CharBuffer to kotlin.CharSequence private fun SimpleFunctionDescriptor.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden( - specialBuiltin: CallableDescriptor, - alreadyDeclaredFunctions: Collection + specialBuiltin: CallableDescriptor, + alreadyDeclaredFunctions: Collection ): SimpleFunctionDescriptor = if (alreadyDeclaredFunctions.none { this != it && it.initialSignatureDescriptor == null && it.doesOverride(specialBuiltin) }) this @@ -348,17 +345,19 @@ class LazyJavaClassMemberScope( newCopyBuilder().setHiddenToOvercomeSignatureClash().build()!! private fun createOverrideForBuiltinFunctionWithErasedParameterIfNeeded( - overridden: FunctionDescriptor, - functions: (Name) -> Collection + overridden: FunctionDescriptor, + functions: (Name) -> Collection ): SimpleFunctionDescriptor? { return functions(overridden.name).firstOrNull { it.hasSameJvmDescriptorButDoesNotOverride(overridden) - }?.let { - override -> + }?.let { override -> override.newCopyBuilder().apply { - setValueParameters(copyValueParameters( + setValueParameters( + copyValueParameters( overridden.valueParameters.map { ValueParameterData(it.type, it.declaresDefaultValue()) }, - override.valueParameters, overridden)) + override.valueParameters, overridden + ) + ) setSignatureChange() setPreserveSourceElement() }.build() @@ -387,14 +386,17 @@ class LazyJavaClassMemberScope( searchMethodsInSupertypesWithoutBuiltinMagic(it) } - result.addAll(resolveOverridesForNonStaticMembers( - name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter)) + result.addAll( + resolveOverridesForNonStaticMembers( + name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter + ) + ) } private fun addPropertyOverrideByMethod( - propertiesFromSupertypes: Set, - result: MutableCollection, - functions: (Name) -> Collection + propertiesFromSupertypes: Set, + result: MutableCollection, + functions: (Name) -> Collection ) { for (property in propertiesFromSupertypes) { val newProperty = createPropertyDescriptorByMethods(property, functions) @@ -411,14 +413,14 @@ class LazyJavaClassMemberScope( } private fun createPropertyDescriptorWithDefaultGetter( - method: JavaMethod, givenType: KotlinType? = null, modality: Modality + method: JavaMethod, givenType: KotlinType? = null, modality: Modality ): JavaPropertyDescriptor { val annotations = c.resolveAnnotations(method) val propertyDescriptor = JavaPropertyDescriptor.create( - ownerDescriptor, annotations, modality, method.visibility, - /* isVar = */ false, method.name, c.components.sourceElementFactory.source(method), - /* isStaticFinal = */ false + ownerDescriptor, annotations, modality, method.visibility, + /* isVar = */ false, method.name, c.components.sourceElementFactory.source(method), + /* isStaticFinal = */ false ) val getter = DescriptorFactory.createDefaultGetter(propertyDescriptor, Annotations.EMPTY) @@ -432,42 +434,43 @@ class LazyJavaClassMemberScope( } private fun createPropertyDescriptorByMethods( - overriddenProperty: PropertyDescriptor, - functions: (Name) -> Collection + overriddenProperty: PropertyDescriptor, + functions: (Name) -> Collection ): JavaPropertyDescriptor? { if (!doesClassOverridesProperty(overriddenProperty, functions)) return null val getterMethod = overriddenProperty.findGetterOverride(functions)!! val setterMethod = - if (overriddenProperty.isVar) - overriddenProperty.findSetterOverride(functions)!! - else - null + if (overriddenProperty.isVar) + overriddenProperty.findSetterOverride(functions)!! + else + null assert(setterMethod?.let { it.modality == getterMethod.modality } ?: true) { "Different accessors modalities when creating overrides for $overriddenProperty in $ownerDescriptor" + - "for getter is ${getterMethod.modality}, but for setter is ${setterMethod?.modality}" + "for getter is ${getterMethod.modality}, but for setter is ${setterMethod?.modality}" } val propertyDescriptor = JavaPropertyDescriptor.create( - ownerDescriptor, Annotations.EMPTY, getterMethod.modality, getterMethod.visibility, - /* isVar = */ setterMethod != null, overriddenProperty.name, getterMethod.source, - /* isStaticFinal = */ false + ownerDescriptor, Annotations.EMPTY, getterMethod.modality, getterMethod.visibility, + /* isVar = */ setterMethod != null, overriddenProperty.name, getterMethod.source, + /* isStaticFinal = */ false ) propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as KotlinType?) val getter = DescriptorFactory.createGetter( - propertyDescriptor, getterMethod.annotations, /* isDefault = */false, - /* isExternal = */ false, /* isInline = */ false, getterMethod.source + propertyDescriptor, getterMethod.annotations, /* isDefault = */false, + /* isExternal = */ false, /* isInline = */ false, getterMethod.source ).apply { initialSignatureDescriptor = getterMethod initialize(propertyDescriptor.type) } val setter = setterMethod?.let { setterMethod -> - DescriptorFactory.createSetter(propertyDescriptor, setterMethod.annotations, /* isDefault = */false, - /* isExternal = */ false, /* isInline = */ false, setterMethod.visibility, setterMethod.source + DescriptorFactory.createSetter( + propertyDescriptor, setterMethod.annotations, /* isDefault = */false, + /* isExternal = */ false, /* isInline = */ false, setterMethod.visibility, setterMethod.source ).apply { initialSignatureDescriptor = setterMethod } @@ -483,39 +486,43 @@ class LazyJavaClassMemberScope( } override fun resolveMethodSignature( - method: JavaMethod, methodTypeParameters: List, returnType: KotlinType, - valueParameters: List + method: JavaMethod, methodTypeParameters: List, returnType: KotlinType, + valueParameters: List ): LazyJavaScope.MethodSignatureData { val propagated = c.components.signaturePropagator.resolvePropagatedSignature( - method, ownerDescriptor, returnType, null, valueParameters, methodTypeParameters + method, ownerDescriptor, returnType, null, valueParameters, methodTypeParameters ) return LazyJavaScope.MethodSignatureData( - propagated.returnType, propagated.receiverType, propagated.valueParameters, propagated.typeParameters, - propagated.hasStableParameterNames(), propagated.errors + propagated.returnType, propagated.receiverType, propagated.valueParameters, propagated.typeParameters, + propagated.hasStableParameterNames(), propagated.errors ) } private fun SimpleFunctionDescriptor.hasSameJvmDescriptorButDoesNotOverride( - builtinWithErasedParameters: FunctionDescriptor + builtinWithErasedParameters: FunctionDescriptor ): Boolean { return computeJvmDescriptor(withReturnType = false) == - builtinWithErasedParameters.original.computeJvmDescriptor(withReturnType = false) - && !doesOverride(builtinWithErasedParameters) + builtinWithErasedParameters.original.computeJvmDescriptor(withReturnType = false) + && !doesOverride(builtinWithErasedParameters) } private fun resolveConstructor(constructor: JavaConstructor): JavaClassConstructorDescriptor { val classDescriptor = ownerDescriptor val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor( - classDescriptor, c.resolveAnnotations(constructor), /* isPrimary = */ false, c.components.sourceElementFactory.source(constructor) + classDescriptor, + c.resolveAnnotations(constructor), /* isPrimary = */ + false, + c.components.sourceElementFactory.source(constructor) ) - val c = c.childForMethod(constructorDescriptor, constructor, typeParametersIndexOffset = classDescriptor.declaredTypeParameters.size) + val c = + c.childForMethod(constructorDescriptor, constructor, typeParametersIndexOffset = classDescriptor.declaredTypeParameters.size) val valueParameters = resolveValueParameters(c, constructorDescriptor, constructor.valueParameters) val constructorTypeParameters = - classDescriptor.declaredTypeParameters + - constructor.typeParameters.map { p -> c.typeParameterResolver.resolveTypeParameter(p)!! } + classDescriptor.declaredTypeParameters + + constructor.typeParameters.map { p -> c.typeParameterResolver.resolveTypeParameter(p)!! } constructorDescriptor.initialize(valueParameters.descriptors, constructor.visibility, constructorTypeParameters) constructorDescriptor.setHasStableParameterNames(false) @@ -535,10 +542,10 @@ class LazyJavaClassMemberScope( val classDescriptor = ownerDescriptor val constructorDescriptor = JavaClassConstructorDescriptor.createJavaConstructor( - classDescriptor, Annotations.EMPTY, /* isPrimary = */ true, c.components.sourceElementFactory.source(jClass) + classDescriptor, Annotations.EMPTY, /* isPrimary = */ true, c.components.sourceElementFactory.source(jClass) ) val valueParameters = if (isAnnotation) createAnnotationConstructorParameters(constructorDescriptor) - else Collections.emptyList() + else Collections.emptyList() constructorDescriptor.setHasSynthesizedParameterNames(false) constructorDescriptor.initialize(valueParameters, getConstructorVisibility(classDescriptor)) @@ -562,8 +569,7 @@ class LazyJavaClassMemberScope( val attr = TypeUsage.COMMON.toAttributes(isForAnnotationParameter = true) - val (methodsNamedValue, otherMethods) = methods. - partition { it.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME } + val (methodsNamedValue, otherMethods) = methods.partition { it.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME } assert(methodsNamedValue.size <= 1) { "There can't be more than one method named 'value' in annotation class: $jClass" } val methodNamedValue = methodsNamedValue.firstOrNull() @@ -571,8 +577,10 @@ class LazyJavaClassMemberScope( val parameterNamedValueJavaType = methodNamedValue.returnType val (parameterType, varargType) = if (parameterNamedValueJavaType is JavaArrayType) - Pair(c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true), - c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr)) + Pair( + c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true), + c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr) + ) else Pair(c.typeResolver.transformJavaType(parameterNamedValueJavaType, attr), null) @@ -589,13 +597,14 @@ class LazyJavaClassMemberScope( } private fun MutableList.addAnnotationValueParameter( - constructor: ConstructorDescriptor, - index: Int, - method: JavaMethod, - returnType: KotlinType, - varargElementType: KotlinType? + constructor: ConstructorDescriptor, + index: Int, + method: JavaMethod, + returnType: KotlinType, + varargElementType: KotlinType? ) { - add(ValueParameterDescriptorImpl( + add( + ValueParameterDescriptorImpl( constructor, null, index, @@ -609,7 +618,8 @@ class LazyJavaClassMemberScope( // Nulls are not allowed in annotation arguments in Java varargElementType?.let { TypeUtils.makeNotNullable(it) }, c.components.sourceElementFactory.source(method) - )) + ) + ) } private val nestedClassIndex = c.storageManager.createLazyValue { @@ -620,8 +630,7 @@ class LazyJavaClassMemberScope( jClass.fields.filter { it.isEnumEntry }.associateBy { f -> f.name } } - private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues { - name: Name -> + private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues { name: Name -> if (name !in nestedClassIndex()) { val field = enumEntryIndex()[name] if (field != null) { @@ -629,22 +638,20 @@ class LazyJavaClassMemberScope( getFunctionNames() + getVariableNames() } EnumEntrySyntheticClassDescriptor.create( - c.storageManager, ownerDescriptor, name, enumMemberNames, c.resolveAnnotations(field), - c.components.sourceElementFactory.source(field) + c.storageManager, ownerDescriptor, name, enumMemberNames, c.resolveAnnotations(field), + c.components.sourceElementFactory.source(field) ) - } - else null - } - else { + } else null + } else { c.components.finder.findClass(ownerDescriptor.classId!!.createNestedClassId(name))?.let { LazyJavaClassDescriptor(c, ownerDescriptor, it) - .also(c.components.javaClassesTracker::reportClass) + .also(c.components.javaClassesTracker::reportClass) } } } override fun getDispatchReceiverParameter(): ReceiverParameterDescriptor? = - DescriptorUtils.getDispatchReceiverParameterIfNeeded(ownerDescriptor) + DescriptorUtils.getDispatchReceiverParameterIfNeeded(ownerDescriptor) override fun getContributedClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? { recordLookup(name, location) @@ -661,8 +668,8 @@ class LazyJavaClassMemberScope( return super.getContributedVariables(name, location) } - override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set - = nestedClassIndex() + enumEntryIndex().keys + override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set = + nestedClassIndex() + enumEntryIndex().keys override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set { if (jClass.isAnnotationType) return getFunctionNames()