Cleanup: KotlinSafeDeleteProcessor

idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt

@@ -51,7 +51,6 @@ import org.jetbrains.kotlin.idea.refactoring.isTrueJavaMethod
 import org.jetbrains.kotlin.idea.references.KtReference
 import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchOptions
 import org.jetbrains.kotlin.idea.search.ideaExtensions.KotlinReferencesSearchParameters
-import org.jetbrains.kotlin.idea.search.usagesSearch.constructor
 import org.jetbrains.kotlin.idea.search.usagesSearch.processDelegationCallConstructorUsages
 import org.jetbrains.kotlin.idea.util.actualsForExpected
 import org.jetbrains.kotlin.idea.util.liftToExpected
@@ -91,15 +90,17 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         fun getSearchInfo(element: PsiElement) = NonCodeUsageSearchInfo(getIgnoranceCondition(), element)
 
         fun searchKotlinDeclarationReferences(declaration: KtDeclaration): Sequence<PsiReference> {
-            val elementsToSearch = if (declaration is KtParameter) declaration.withExpectedActuals() else listOf(declaration)
+            val elementsToSearch = when (declaration) {
+                is KtParameter -> declaration.withExpectedActuals()
+                else -> listOf(declaration)
+            }
             return elementsToSearch.asSequence().flatMap {
                 val searchParameters = KotlinReferencesSearchParameters(
                     it,
                     it.useScope,
                     kotlinOptions = KotlinReferencesSearchOptions(acceptCallableOverrides = true)
                 )
-                ReferencesSearch.search(searchParameters)
+                ReferencesSearch.search(searchParameters).asSequence()
-                        .asSequence()
                     .filterNot { reference -> getIgnoranceCondition().value(reference.element) }
             }
         }
@@ -143,7 +144,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             val elementToPassToJava = when (element) {
                 is KtLightFieldImpl<*> -> object : KtLightField by element {
                     // Suppress walking through initializer compiled PSI (it doesn't contain any reference expressions anyway)
-                    override fun getInitializer() = null
+                    override fun getInitializer(): PsiExpression? = null
                 }
                 else -> element
             }
@@ -180,7 +181,11 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
                                     usageElement.getNonStrictParentOfType<KtImportDirective>()?.let { importDirective ->
                                         SafeDeleteImportDirectiveUsageInfo(importDirective, element)
                                     } ?: usageElement.getParentOfTypeAndBranch<KtSuperTypeEntry> { typeReference }?.let {
-                                        if (element is PsiClass && element.isInterface) SafeDeleteSuperTypeUsageInfo(it, element) else usageInfo
+                                        if (element is PsiClass && element.isInterface) {
+                                            SafeDeleteSuperTypeUsageInfo(it, element)
+                                        } else {
+                                            usageInfo
+                                        }
                                     } ?: if (forceReferencedElementUnwrapping) {
                                         SafeDeleteReferenceJavaDeleteUsageInfo(usageElement, element.unwrapped, usageInfo.isSafeDelete)
                                     } else usageInfo
@@ -196,8 +201,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         }
 
         fun findUsagesByJavaProcessor(elements: Sequence<PsiElement>, insideDeleted: Condition<PsiElement>): Condition<PsiElement> =
-                elements
+            elements.mapNotNull { element -> findUsagesByJavaProcessor(element, true)?.insideDeletedCondition }
-                        .mapNotNull { element -> findUsagesByJavaProcessor(element, true)?.insideDeletedCondition }
                 .fold(insideDeleted) { condition1, condition2 -> Conditions.or(condition1, condition2) }
 
         fun findUsagesByJavaProcessor(ktDeclaration: KtDeclaration): NonCodeUsageSearchInfo {
@@ -270,13 +274,11 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             is KtNamedFunction -> {
                 if (element.isLocal) {
                     findKotlinDeclarationUsages(element)
-                }
+                } else {
-                else {
                     val lightMethods = element.toLightMethods()
                     if (lightMethods.isNotEmpty()) {
                         lightMethods.map { method -> findUsagesByJavaProcessor(method, false) }.firstOrNull()
-                    }
+                    } else {
-                    else {
                         findKotlinDeclarationUsages(element)
                     }
                 }
@@ -293,8 +295,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             is KtProperty -> {
                 if (element.isLocal) {
                     findKotlinDeclarationUsages(element)
-                }
+                } else {
-                else {
                     findUsagesByJavaProcessor(element)
                 }
             }
@@ -383,8 +384,7 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             element.actualsForExpected().forEach {
                 if (it is KtParameter) {
                     (it.parent as? KtParameterList)?.removeParameter(it)
-                }
+                } else {
-                else {
                     it.removeModifier(KtTokens.IMPL_KEYWORD)
                     it.removeModifier(KtTokens.ACTUAL_KEYWORD)
                 }
@@ -437,11 +437,11 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
             is KtParameter -> {
                 val expectParameter = element.liftToExpected() as? KtParameter
                 if (expectParameter != null && expectParameter != element) {
-                    if (shouldAllowPropagationToExpected(element)) {
+                    return if (shouldAllowPropagationToExpected(element)) {
-                        return listOf(expectParameter)
+                        listOf(expectParameter)
                     } else {
                         element.ownerFunction?.dropActualModifier = true
-                        return listOf(element)
+                        listOf(element)
                     }
                 }
 
@@ -457,8 +457,10 @@ class KotlinSafeDeleteProcessor : JavaSafeDeleteProcessor() {
         if (ApplicationManager.getApplication()!!.isUnitTestMode) return Collections.singletonList(element)
 
         return when (element) {
-            is KtNamedFunction, is KtProperty -> checkSuperMethods(element as KtDeclaration, allElementsToDelete, "delete (with usage search)")
+            is KtNamedFunction, is KtProperty ->
-            else -> super.getElementsToSearch(element, module, allElementsToDelete)
+                checkSuperMethods(element as KtDeclaration, allElementsToDelete, "delete (with usage search)")
+            else ->
+                super.getElementsToSearch(element, module, allElementsToDelete)
         }
     }
 }