Minor. Reformat LazyJavaClassMemberScope.kt

core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt

@@ -94,12 +94,9 @@ class LazyJavaClassMemberScope(
     }
 
     private fun isVisibleAsFunctionInCurrentClass(function: SimpleFunctionDescriptor): Boolean {
-        if (getPropertyNamesCandidatesByAccessorName(function.name).any {
+        if (getPropertyNamesCandidatesByAccessorName(function.name).any { propertyName ->
-            propertyName ->
+                getPropertiesFromSupertypes(propertyName).any { property ->
-            getPropertiesFromSupertypes(propertyName).any {
+                    doesClassOverridesProperty(property) { accessorName ->
-                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
@@ -128,8 +125,7 @@ class LazyJavaClassMemberScope(
                 BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(it)
             }
 
-        return candidatesToOverride.any {
+        return candidatesToOverride.any { candidate ->
-            candidate ->
             hasSameJvmDescriptorButDoesNotOverride(candidate)
         }
     }
@@ -180,7 +176,8 @@ class LazyJavaClassMemberScope(
 
         return commonOverridabilityResult == OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE &&
                 !JavaIncompatibilityRulesOverridabilityCondition.doesJavaOverrideHaveIncompatibleValueParameterKinds(
-                            superDescriptor, this)
+                    superDescriptor, this
+                )
     }
 
     private fun PropertyDescriptor.findGetterOverride(
@@ -201,8 +198,7 @@ class LazyJavaClassMemberScope(
         getterName: String,
         functions: (Name) -> Collection<SimpleFunctionDescriptor>
     ): SimpleFunctionDescriptor? {
-        return functions(Name.identifier(getterName)).firstNotNullResult factory@{
+        return functions(Name.identifier(getterName)).firstNotNullResult factory@{ descriptor ->
-            descriptor ->
             if (descriptor.valueParameters.size != 0) return@factory null
 
             descriptor.takeIf { KotlinTypeChecker.DEFAULT.isSubtypeOf(descriptor.returnType ?: return@takeIf false, type) }
@@ -212,8 +208,7 @@ class LazyJavaClassMemberScope(
     private fun PropertyDescriptor.findSetterOverride(
         functions: (Name) -> Collection<SimpleFunctionDescriptor>
     ): SimpleFunctionDescriptor? {
-        return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{
+        return functions(Name.identifier(JvmAbi.setterName(name.asString()))).firstNotNullResult factory@{ descriptor ->
-            descriptor ->
             if (descriptor.valueParameters.size != 1) return@factory null
 
             if (!KotlinBuiltIns.isUnit(descriptor.returnType ?: return@factory null)) return@factory null
@@ -243,7 +238,8 @@ class LazyJavaClassMemberScope(
             addFunctionFromSupertypes(
                 result, name,
                 functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) },
-                    isSpecialBuiltinName = false)
+                isSpecialBuiltinName = false
+            )
             return
         }
 
@@ -251,17 +247,20 @@ 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)
+            this::searchMethodsByNameWithoutBuiltinMagic
+        )
 
         // add from super types
         addOverriddenBuiltinMethods(
             name, result, mergedFunctionFromSuperTypes, specialBuiltinsFromSuperTypes,
-                this::searchMethodsInSupertypesWithoutBuiltinMagic)
+            this::searchMethodsInSupertypesWithoutBuiltinMagic
+        )
 
         val visibleFunctionsFromSupertypes =
             functionsFromSupertypes.filter { isVisibleAsFunctionInCurrentClass(it) } + specialBuiltinsFromSuperTypes
@@ -282,12 +281,10 @@ class LazyJavaClassMemberScope(
 
         if (!isSpecialBuiltinName) {
             result.addAll(additionalOverrides)
-        }
+        } else {
-        else {
             val allDescriptors = result + additionalOverrides
             result.addAll(
-                    additionalOverrides.map {
+                additionalOverrides.map { resolvedOverride ->
-                        resolvedOverride ->
                     val overriddenBuiltin = resolvedOverride.getOverriddenSpecialBuiltin()
                             ?: return@map resolvedOverride
 
@@ -312,7 +309,8 @@ class LazyJavaClassMemberScope(
 
                 if (doesOverrideRenamedDescriptor(overriddenBuiltin, renamedCopy)) {
                     result.add(
-                            renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions))
+                        renamedCopy.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions)
+                    )
                     break
                 }
             }
@@ -323,8 +321,7 @@ class LazyJavaClassMemberScope(
                 BuiltinMethodsWithSpecialGenericSignature.getOverriddenBuiltinFunctionWithErasedValueParametersInJava(descriptor)
                         ?: continue
 
-            createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let {
+            createOverrideForBuiltinFunctionWithErasedParameterIfNeeded(overriddenBuiltin, functions)?.let { override ->
-                override ->
                 if (isVisibleAsFunctionInCurrentClass(override)) {
                     result.add(override.createHiddenCopyIfBuiltinAlreadyAccidentallyOverridden(overriddenBuiltin, alreadyDeclaredFunctions))
                 }
@@ -353,12 +350,14 @@ class LazyJavaClassMemberScope(
     ): SimpleFunctionDescriptor? {
         return functions(overridden.name).firstOrNull {
             it.hasSameJvmDescriptorButDoesNotOverride(overridden)
-        }?.let {
+        }?.let { override ->
-            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,8 +386,11 @@ class LazyJavaClassMemberScope(
             searchMethodsInSupertypesWithoutBuiltinMagic(it)
         }
 
-        result.addAll(resolveOverridesForNonStaticMembers(
+        result.addAll(
-                name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter))
+            resolveOverridesForNonStaticMembers(
+                name, propertiesFromSupertypes + propertiesOverridesFromSuperTypes, result, ownerDescriptor, c.components.errorReporter
+            )
+        )
     }
 
     private fun addPropertyOverrideByMethod(
@@ -466,7 +468,8 @@ class LazyJavaClassMemberScope(
         }
 
         val setter = setterMethod?.let { setterMethod ->
-            DescriptorFactory.createSetter(propertyDescriptor, setterMethod.annotations, /* isDefault = */false,
+            DescriptorFactory.createSetter(
+                propertyDescriptor, setterMethod.annotations, /* isDefault = */false,
                 /* isExternal = */ false, /* isInline = */ false, setterMethod.visibility, setterMethod.source
             ).apply {
                 initialSignatureDescriptor = setterMethod
@@ -507,11 +510,15 @@ class LazyJavaClassMemberScope(
         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 +
@@ -562,8 +569,7 @@ class LazyJavaClassMemberScope(
 
         val attr = TypeUsage.COMMON.toAttributes(isForAnnotationParameter = true)
 
-        val (methodsNamedValue, otherMethods) = methods.
+        val (methodsNamedValue, otherMethods) = methods.partition { it.name == JvmAnnotationNames.DEFAULT_ANNOTATION_MEMBER_NAME }
-                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),
+                        Pair(
-                             c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr))
+                            c.typeResolver.transformArrayType(parameterNamedValueJavaType, attr, isVararg = true),
+                            c.typeResolver.transformJavaType(parameterNamedValueJavaType.componentType, attr)
+                        )
                     else
                         Pair(c.typeResolver.transformJavaType(parameterNamedValueJavaType, attr), null)
 
@@ -595,7 +603,8 @@ class LazyJavaClassMemberScope(
         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 {
+    private val nestedClasses = c.storageManager.createMemoizedFunctionWithNullableValues { name: Name ->
-        name: Name ->
         if (name !in nestedClassIndex()) {
             val field = enumEntryIndex()[name]
             if (field != null) {
@@ -632,10 +641,8 @@ class LazyJavaClassMemberScope(
                     c.storageManager, ownerDescriptor, name, enumMemberNames, c.resolveAnnotations(field),
                     c.components.sourceElementFactory.source(field)
                 )
-            }
+            } else null
-            else null
+        } else {
-        }
-        else {
             c.components.finder.findClass(ownerDescriptor.classId!!.createNestedClassId(name))?.let {
                 LazyJavaClassDescriptor(c, ownerDescriptor, it)
                     .also(c.components.javaClassesTracker::reportClass)
@@ -661,8 +668,8 @@ class LazyJavaClassMemberScope(
         return super.getContributedVariables(name, location)
     }
 
-    override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name>
+    override fun computeClassNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> =
-            = nestedClassIndex() + enumEntryIndex().keys
+        nestedClassIndex() + enumEntryIndex().keys
 
     override fun computePropertyNames(kindFilter: DescriptorKindFilter, nameFilter: ((Name) -> Boolean)?): Set<Name> {
         if (jClass.isAnnotationType) return getFunctionNames()