Minor refactoring

idea/idea-replacement-engine/src/org/jetbrains/kotlin/idea/replacement/CallKindHandler.kt

@@ -20,28 +20,28 @@ import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getQualifiedExpressionForSelectorOrThis
 
-interface CallKindHandler {
-    val elementToReplace: KtElement
+interface CallKindHandler<TCallElement : KtElement> {
+    fun elementToReplace(callElement: TCallElement): KtElement
 
     fun precheckReplacementPattern(pattern: ReplacementExpression): Boolean
 
-    fun wrapGeneratedExpression(expression: KtExpression): KtElement
+    fun wrapGeneratedExpression(expression: KtExpression): TCallElement
 
-    fun unwrapResult(result: KtElement): KtElement
+    fun unwrapResult(result: TCallElement): TCallElement
 }
 
-class CallExpressionHandler(callElement: KtExpression) : CallKindHandler {
-    override val elementToReplace = callElement.getQualifiedExpressionForSelectorOrThis()
+object CallExpressionHandler : CallKindHandler<KtExpression> {
+    override fun elementToReplace(callElement: KtExpression) = callElement.getQualifiedExpressionForSelectorOrThis()
 
     override fun precheckReplacementPattern(pattern: ReplacementExpression) = true
 
     override fun wrapGeneratedExpression(expression: KtExpression) = expression
 
-    override fun unwrapResult(result: KtElement) = result
+    override fun unwrapResult(result: KtExpression) = result
 }
 
-class AnnotationEntryHandler(annotationEntry: KtAnnotationEntry) : CallKindHandler {
-    override val elementToReplace = annotationEntry
+object AnnotationEntryHandler : CallKindHandler<KtAnnotationEntry> {
+    override fun elementToReplace(callElement: KtAnnotationEntry) = callElement
 
     override fun precheckReplacementPattern(pattern: ReplacementExpression): Boolean {
         //TODO
@@ -54,8 +54,7 @@ class AnnotationEntryHandler(annotationEntry: KtAnnotationEntry) : CallKindHandl
         return createByPattern("@Dummy($0)", expression) { KtPsiFactory(expression).createAnnotationEntry(it) }
     }
 
-    override fun unwrapResult(result: KtElement): KtAnnotationEntry {
-        result as KtAnnotationEntry
+    override fun unwrapResult(result: KtAnnotationEntry): KtAnnotationEntry {
         val text = result.valueArguments.single().getArgumentExpression()!!.text
         return result.replaced(KtPsiFactory(result).createAnnotationEntry("@" + text))
     }

idea/idea-replacement-engine/src/org/jetbrains/kotlin/idea/replacement/ReplacementEngine.kt

@@ -53,12 +53,12 @@ import org.jetbrains.kotlin.utils.addIfNotNull
 import java.util.*
 
 object ReplacementEngine {
-    fun performCallReplacement(
+    fun <TCallElement : KtElement> performCallReplacement(
             element: KtSimpleNameExpression,
             bindingContext: BindingContext,
             resolvedCall: ResolvedCall<out CallableDescriptor>,
-            callElement: KtElement,
-            callKindHandler: CallKindHandler,
+            callElement: TCallElement,
+            callKindHandler: CallKindHandler<TCallElement>,
             replacement: ReplacementExpression
     ): KtElement {
         val project = element.project
@@ -66,7 +66,7 @@ object ReplacementEngine {
         val descriptor = resolvedCall.resultingDescriptor
 
         val qualifiedExpression = callElement.getQualifiedExpressionForSelector()
-        val elementToBeReplaced = callKindHandler.elementToReplace
+        val elementToBeReplaced = callKindHandler.elementToReplace(callElement)
 
         val commentSaver = CommentSaver(elementToBeReplaced, saveLineBreaks = true)
 
@@ -142,7 +142,7 @@ object ReplacementEngine {
         commentSaver.restore(resultRange)
 
         @Suppress("UNCHECKED_CAST")
-        return callKindHandler.unwrapResult(resultRange.last as KtElement)
+        return callKindHandler.unwrapResult(resultRange.last as TCallElement)
     }
 
     private fun ConstructedExpressionWrapper.processValueParameterUsages(

idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt

@@ -46,15 +46,18 @@ class CallableUsageReplacementStrategy(
             }
             else {
                 // copy replacement expression because it is modified by performCallReplacement
-                ReplacementEngine.performCallReplacement(usage, bindingContext, resolvedCall, callElement, callTypeHandler, replacement.copy())
+                @Suppress("UNCHECKED_CAST")
+                ReplacementEngine.performCallReplacement(usage, bindingContext, resolvedCall, callElement,
+                                                         callTypeHandler as CallKindHandler<KtElement>,
+                                                         replacement.copy())
             }
         }
     }
 
-    private fun callTypeHandler(callElement: KtElement): CallKindHandler? {
+    private fun callTypeHandler(callElement: KtElement): CallKindHandler<*>? {
         return when (callElement) {
-            is KtExpression -> CallExpressionHandler(callElement)
-            is KtAnnotationEntry -> AnnotationEntryHandler(callElement)
+            is KtExpression -> CallExpressionHandler
+            is KtAnnotationEntry -> AnnotationEntryHandler
             else -> null
         }
     }