Reformat: search\ideaExtensions package

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/DefaultAnnotationMethodKotlinImplicitReferenceSearcher.kt

@@ -34,7 +34,8 @@ import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.idea.references.KotlinDefaultAnnotationMethodImplicitReferenceContributor.ReferenceImpl as ImplicitReference
 
-class DefaultAnnotationMethodKotlinImplicitReferenceSearcher : QueryExecutorBase<PsiReference, MethodReferencesSearch.SearchParameters>(true) {
+class DefaultAnnotationMethodKotlinImplicitReferenceSearcher :
+    QueryExecutorBase<PsiReference, MethodReferencesSearch.SearchParameters>(true) {
     private val PsiMethod.isDefaultAnnotationMethod: Boolean
         get() = PsiUtil.isAnnotationMethod(this) && name == PsiAnnotation.DEFAULT_REFERENCED_METHOD_NAME && parameterList.parametersCount == 0
 

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt

@@ -72,10 +72,12 @@ class KotlinAnnotatedElementsSearcher : QueryExecutor<PsiModifierListOwner, Anno
     companion object {
         private val LOG = Logger.getInstance("#com.intellij.psi.impl.search.AnnotatedMembersSearcher")
 
-        fun processAnnotatedMembers(annClass: PsiClass,
+        fun processAnnotatedMembers(
-                                    useScope: SearchScope,
+            annClass: PsiClass,
-                                    preFilter: (KtAnnotationEntry) -> Boolean = { true },
+            useScope: SearchScope,
-                                    consumer: (KtDeclaration) -> Boolean): Boolean {
+            preFilter: (KtAnnotationEntry) -> Boolean = { true },
+            consumer: (KtDeclaration) -> Boolean
+        ): Boolean {
             assert(annClass.isAnnotationType) { "Annotation type should be passed to annotated members search" }
 
             val psiBasedClassResolver = PsiBasedClassResolver.getInstance(annClass)

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt

@@ -36,13 +36,12 @@ class KotlinClassesWithAnnotatedMembersSearcher : ScopedQueryExecutor<PsiClass,
         val processed = hashSetOf<KtClassOrObject>()
         return KotlinAnnotatedElementsSearcher.processAnnotatedMembers(queryParameters.annotationClass,
                                                                        queryParameters.scope,
-                                                                       { it.getNonStrictParentOfType<KtClassOrObject>() !in processed}) { declaration ->
+                                                                       { it.getNonStrictParentOfType<KtClassOrObject>() !in processed }) { declaration ->
             val ktClass = declaration.getNonStrictParentOfType<KtClassOrObject>()
             if (ktClass != null && processed.add(ktClass)) {
                 val lightClass = ktClass.toLightClass()
                 if (lightClass != null) consumer.process(lightClass) else true
-            }
+            } else
-            else
                 true
         }
     }

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinConventionMethodReferencesSearcher.kt

@@ -25,11 +25,11 @@ import org.jetbrains.kotlin.idea.search.usagesSearch.operators.OperatorReference
 class KotlinConventionMethodReferencesSearcher : QueryExecutorBase<PsiReference, MethodReferencesSearch.SearchParameters>(true) {
     override fun processQuery(queryParameters: MethodReferencesSearch.SearchParameters, consumer: ExecutorProcessor<PsiReference>) {
         val operatorSearcher = OperatorReferenceSearcher.create(
-                queryParameters.method,
+            queryParameters.method,
-                queryParameters.effectiveSearchScope,
+            queryParameters.effectiveSearchScope,
-                consumer,
+            consumer,
-                queryParameters.optimizer,
+            queryParameters.optimizer,
-                KotlinReferencesSearchOptions(acceptCallableOverrides = true)
+            KotlinReferencesSearchOptions(acceptCallableOverrides = true)
         )
         operatorSearcher?.run()
     }

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDefinitionsSearcher.kt

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.idea.search.ideaExtensions
 
-import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import com.intellij.psi.PsiMethod
 import com.intellij.psi.search.GlobalSearchScope
@@ -110,21 +109,22 @@ class KotlinDefinitionsSearcher : QueryExecutor<PsiElement, DefinitionsScopedSea
             return ContainerUtil.process(ClassInheritorsSearch.search(psiClass, true), consumer)
         }
 
-        private fun processLightClassLocalImplementations(psiClass: KtLightClass,
+        private fun processLightClassLocalImplementations(
-                                                          searchScope: LocalSearchScope,
+            psiClass: KtLightClass,
-                                                          consumer: Processor<PsiElement>): Boolean {
+            searchScope: LocalSearchScope,
+            consumer: Processor<PsiElement>
+        ): Boolean {
             // workaround for IDEA optimization that uses Java PSI traversal to locate inheritors in local search scope
             val virtualFiles = searchScope.scope.mapTo(HashSet()) { it.containingFile.virtualFile }
             val globalScope = GlobalSearchScope.filesScope(psiClass.project, virtualFiles)
-            return ContainerUtil.process(ClassInheritorsSearch.search(psiClass, globalScope, true), Processor<PsiClass> { candidate ->
+            return ContainerUtil.process(ClassInheritorsSearch.search(psiClass, globalScope, true)) { candidate ->
                 val candidateOrigin = candidate.unwrapped ?: candidate
                 if (candidateOrigin in searchScope) {
                     consumer.process(candidate)
-                }
+                } else {
-                else {
                     true
                 }
-            })
+            }
         }
 
         private fun processFunctionImplementations(function: KtFunction, scope: SearchScope, consumer: Processor<PsiElement>): Boolean {
@@ -133,7 +133,11 @@ class KotlinDefinitionsSearcher : QueryExecutor<PsiElement, DefinitionsScopedSea
             }
         }
 
-        private fun processPropertyImplementations(declaration: KtNamedDeclaration, scope: SearchScope, consumer: Processor<PsiElement>): Boolean {
+        private fun processPropertyImplementations(
+            declaration: KtNamedDeclaration,
+            scope: SearchScope,
+            consumer: Processor<PsiElement>
+        ): Boolean {
             return runReadAction {
                 processPropertyImplementationsMethods(declaration.toPossiblyFakeLightMethods(), scope, consumer)
             }
@@ -146,7 +150,11 @@ class KotlinDefinitionsSearcher : QueryExecutor<PsiElement, DefinitionsScopedSea
             }
         }
 
-        fun processPropertyImplementationsMethods(accessors: Iterable<PsiMethod>, scope: SearchScope, consumer: Processor<PsiElement>): Boolean {
+        fun processPropertyImplementationsMethods(
+            accessors: Iterable<PsiMethod>,
+            scope: SearchScope,
+            consumer: Processor<PsiElement>
+        ): Boolean {
             return accessors.all { method ->
                 method.forEachOverridingMethod(scope) { implementation ->
                     if (isDelegated(implementation)) return@forEachOverridingMethod true

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinDirectInheritorsSearcher.kt

@@ -49,11 +49,11 @@ open class KotlinDirectInheritorsSearcher : QueryExecutorBase<PsiClass, DirectCl
         fun searchForTypeAliasesRecursively(typeName: String) {
             ProgressManager.checkCanceled()
             typeAliasIndex[typeName, project, scope].asSequence()
-                    .map { it.name }
+                .map { it.name }
-                    .filterNotNull()
+                .filterNotNull()
-                    .filter { it !in names }
+                .filter { it !in names }
-                    .onEach { names.add(it) }
+                .onEach { names.add(it) }
-                    .forEach(::searchForTypeAliasesRecursively)
+                .forEach(::searchForTypeAliasesRecursively)
         }
 
         searchForTypeAliasesRecursively(name)
@@ -63,10 +63,10 @@ open class KotlinDirectInheritorsSearcher : QueryExecutorBase<PsiClass, DirectCl
 
             names.forEach { name ->
                 KotlinSuperClassIndex.getInstance()
-                        .get(name, baseClass.project, noLibrarySourceScope).asSequence()
+                    .get(name, baseClass.project, noLibrarySourceScope).asSequence()
-                        .mapNotNull { candidate -> candidate.toLightClassWithBuiltinMapping() ?: KtFakeLightClass(candidate) }
+                    .mapNotNull { candidate -> candidate.toLightClassWithBuiltinMapping() ?: KtFakeLightClass(candidate) }
-                        .filter { candidate -> candidate.isInheritor(baseClass, false) }
+                    .filter { candidate -> candidate.isInheritor(baseClass, false) }
-                        .forEach { candidate -> consumer.process(candidate) }
+                    .forEach { candidate -> consumer.process(candidate) }
             }
         }
     }

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodReferenceSearcher.kt

@@ -63,22 +63,29 @@ class KotlinOverridingMethodReferenceSearcher : MethodUsagesSearcher() {
             val nameCandidates = getPropertyNamesCandidatesByAccessorName(Name.identifier(method.name))
             for (name in nameCandidates) {
                 p.optimizer.searchWord(
-                        name.asString(),
+                    name.asString(),
-                        searchScope,
+                    searchScope,
-                        UsageSearchContext.IN_CODE,
+                    UsageSearchContext.IN_CODE,
-                        true,
+                    true,
-                        method,
+                    method,
-                        getTextOccurrenceProcessor(arrayOf(method), containingClass, false)
+                    getTextOccurrenceProcessor(arrayOf(method), containingClass, false)
                 )
             }
         }
     }
 
-    override fun getTextOccurrenceProcessor(methods: Array<out PsiMethod>,
+    override fun getTextOccurrenceProcessor(
-                                            aClass: PsiClass,
+        methods: Array<out PsiMethod>,
-                                            strictSignatureSearch: Boolean): MethodTextOccurrenceProcessor {
+        aClass: PsiClass,
-        return object: MethodTextOccurrenceProcessor(aClass, strictSignatureSearch, *methods) {
+        strictSignatureSearch: Boolean
-            override fun processInexactReference(ref: PsiReference, refElement: PsiElement?, method: PsiMethod, consumer: ExecutorProcessor<PsiReference>): Boolean {
+    ): MethodTextOccurrenceProcessor {
+        return object : MethodTextOccurrenceProcessor(aClass, strictSignatureSearch, *methods) {
+            override fun processInexactReference(
+                ref: PsiReference,
+                refElement: PsiElement?,
+                method: PsiMethod,
+                consumer: ExecutorProcessor<PsiReference>
+            ): Boolean {
                 val isGetter = JvmAbi.isGetterName(method.name)
 
                 fun isWrongAccessorReference(): Boolean {

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinPropertyAccessorsReferenceSearcher.kt

@@ -42,11 +42,12 @@ class KotlinPropertyAccessorsReferenceSearcher : QueryExecutorBase<PsiReference,
         val propertyName = propertyName(method) ?: return
 
         queryParameters.optimizer!!.searchWord(
-                propertyName,
+            propertyName,
-                onlyKotlinFiles,
+            onlyKotlinFiles,
-                UsageSearchContext.IN_CODE,
+            UsageSearchContext.IN_CODE,
-                true,
+            true,
-                method)
+            method
+        )
     }
 
     private fun propertyName(method: PsiMethod): String? {

idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinTodoSearcher.kt

@@ -27,7 +27,8 @@ import org.jetbrains.kotlin.compatibility.ExecutorProcessor
 import org.jetbrains.kotlin.psi.KtCallExpression
 import org.jetbrains.kotlin.psi.KtTreeVisitorVoid
 
-data class KotlinTodoOccurrence(private val _file: PsiFile, private val _textRange: TextRange, private val _pattern: IndexPattern) : IndexPatternOccurrence {
+data class KotlinTodoOccurrence(private val _file: PsiFile, private val _textRange: TextRange, private val _pattern: IndexPattern) :
+    IndexPatternOccurrence {
     override fun getFile() = _file
     override fun getPattern() = _pattern
     override fun getTextRange() = _textRange
@@ -46,8 +47,8 @@ class KotlinTodoSearcher : QueryExecutorBase<IndexPatternOccurrence, IndexPatter
         val cacheManager = TodoCacheManager.SERVICE.getInstance(file.project)
         val patternProvider = queryParameters.patternProvider
         val count = if (patternProvider != null) {
-            cacheManager.getTodoCount(file.virtualFile, patternProvider)}
+            cacheManager.getTodoCount(file.virtualFile, patternProvider)
-        else
+        } else
             cacheManager.getTodoCount(file.virtualFile, pattern)
         if (count == 0) return