ReplacementPerformer: implement ReplacementPerformer for KtSuperTypeCallEntry

#KT-37849

idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt

@@ -74,18 +74,20 @@ fun KtLambdaArgument.getLambdaArgumentName(bindingContext: BindingContext): Name
 
 fun KtLambdaArgument.moveInsideParenthesesAndReplaceWith(
     replacement: KtExpression,
-    functionLiteralArgumentName: Name?
+    functionLiteralArgumentName: Name?,
+    withNameCheck: Boolean = true,
 ): KtCallExpression {
     val oldCallExpression = parent as KtCallExpression
     val newCallExpression = oldCallExpression.copy() as KtCallExpression
 
     val psiFactory = KtPsiFactory(project)
 
-    val argument = if (shouldLambdaParameterBeNamed(newCallExpression.getValueArgumentsInParentheses(), oldCallExpression)) {
+    val argument =
-        psiFactory.createArgument(replacement, functionLiteralArgumentName)
+        if (withNameCheck && shouldLambdaParameterBeNamed(newCallExpression.getValueArgumentsInParentheses(), oldCallExpression)) {
-    } else {
+            psiFactory.createArgument(replacement, functionLiteralArgumentName)
-        psiFactory.createArgument(replacement)
+        } else {
-    }
+            psiFactory.createArgument(replacement)
+        }
 
     val functionLiteralArgument = newCallExpression.lambdaArguments.firstOrNull()!!
     val valueArgumentList = newCallExpression.valueArgumentList ?: psiFactory.createCallArguments("()")

idea/src/org/jetbrains/kotlin/idea/codeInliner/ReplacementPerformer.kt

@@ -1,17 +1,6 @@
 /*
- * Copyright 2010-2016 JetBrains s.r.o.
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- *
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
  */
 
 package org.jetbrains.kotlin.idea.codeInliner
@@ -23,6 +12,7 @@ import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.idea.caches.resolve.analyze
 import org.jetbrains.kotlin.idea.core.canDropBraces
 import org.jetbrains.kotlin.idea.core.dropBraces
+import org.jetbrains.kotlin.idea.core.moveInsideParenthesesAndReplaceWith
 import org.jetbrains.kotlin.idea.core.replaced
 import org.jetbrains.kotlin.idea.intentions.ConvertToBlockBodyIntention
 import org.jetbrains.kotlin.psi.*
@@ -43,26 +33,43 @@ internal abstract class ReplacementPerformer<TElement : KtElement>(
     abstract fun doIt(postProcessing: (PsiChildRange) -> PsiChildRange): TElement?
 }
 
-internal class AnnotationEntryReplacementPerformer(
+internal abstract class AbstractSimpleReplacementPerformer<TElement : KtElement>(
     codeToInline: MutableCodeToInline,
-    elementToBeReplaced: KtAnnotationEntry
+    elementToBeReplaced: TElement
-) : ReplacementPerformer<KtAnnotationEntry>(codeToInline, elementToBeReplaced) {
+) : ReplacementPerformer<TElement>(codeToInline, elementToBeReplaced) {
+    protected abstract fun createDummyElement(mainExpression: KtExpression): TElement
 
-    override fun doIt(postProcessing: (PsiChildRange) -> PsiChildRange): KtAnnotationEntry {
+    protected open fun rangeToElement(range: PsiChildRange): TElement {
-        assert(codeToInline.mainExpression != null)
+        assert(range.first == range.last)
+
+        @Suppress("UNCHECKED_CAST")
+        return range.first as TElement
+    }
+
+    final override fun doIt(postProcessing: (PsiChildRange) -> PsiChildRange): TElement {
         assert(codeToInline.statementsBefore.isEmpty())
+        val mainExpression = codeToInline.mainExpression ?: error("mainExpression mustn't be null")
 
-        val useSiteTarget = elementToBeReplaced.useSiteTarget?.getAnnotationUseSiteTarget()
+        val dummyElement = createDummyElement(mainExpression)
-        val useSiteTargetText = useSiteTarget?.renderName?.let { "$it:" } ?: ""
+        val replaced = elementToBeReplaced.replace(dummyElement)
-        val isFileUseSiteTarget = useSiteTarget == AnnotationUseSiteTarget.FILE
-
-        val dummyAnnotationEntry = createByPattern("@Dummy($0)", codeToInline.mainExpression!!) { psiFactory.createAnnotationEntry(it) }
-        val replaced = elementToBeReplaced.replace(dummyAnnotationEntry)
 
         codeToInline.performPostInsertionActions(listOf(replaced))
 
-        var range = PsiChildRange.singleElement(replaced)
+        return rangeToElement(postProcessing(PsiChildRange.singleElement(replaced)))
-        range = postProcessing(range)
+    }
+}
+
+internal class AnnotationEntryReplacementPerformer(
+    codeToInline: MutableCodeToInline,
+    elementToBeReplaced: KtAnnotationEntry
+) : AbstractSimpleReplacementPerformer<KtAnnotationEntry>(codeToInline, elementToBeReplaced) {
+    override fun createDummyElement(mainExpression: KtExpression): KtAnnotationEntry =
+        createByPattern("@Dummy($0)", mainExpression) { psiFactory.createAnnotationEntry(it) }
+
+    override fun rangeToElement(range: PsiChildRange): KtAnnotationEntry {
+        val useSiteTarget = elementToBeReplaced.useSiteTarget?.getAnnotationUseSiteTarget()
+        val useSiteTargetText = useSiteTarget?.renderName?.let { "$it:" } ?: ""
+        val isFileUseSiteTarget = useSiteTarget == AnnotationUseSiteTarget.FILE
 
         assert(range.first == range.last)
         assert(range.first is KtAnnotationEntry)
@@ -76,12 +83,39 @@ internal class AnnotationEntryReplacementPerformer(
     }
 }
 
+internal class SuperTypeCallEntryReplacementPerformer(
+    codeToInline: MutableCodeToInline,
+    elementToBeReplaced: KtSuperTypeCallEntry
+) : AbstractSimpleReplacementPerformer<KtSuperTypeCallEntry>(codeToInline, elementToBeReplaced) {
+    override fun createDummyElement(mainExpression: KtExpression): KtSuperTypeCallEntry {
+        val text = if (mainExpression is KtCallExpression && mainExpression.lambdaArguments.isNotEmpty()) {
+            callWithoutLambdaArguments(mainExpression)
+        } else {
+            mainExpression.text
+        }
+
+        return psiFactory.createSuperTypeCallEntry(text)
+    }
+}
+
+private fun callWithoutLambdaArguments(callExpression: KtCallExpression): String {
+    val copy = callExpression.copy() as KtCallExpression
+    val lambdaArgument = copy.lambdaArguments.first()
+
+    val argumentExpression = lambdaArgument.getArgumentExpression() ?: return callExpression.text
+    return lambdaArgument.moveInsideParenthesesAndReplaceWith(
+        replacement = argumentExpression,
+        functionLiteralArgumentName = null,
+        withNameCheck = false
+    ).text ?: callExpression.text
+}
+
 internal class ExpressionReplacementPerformer(
     codeToInline: MutableCodeToInline,
     expressionToBeReplaced: KtExpression
 ) : ReplacementPerformer<KtExpression>(codeToInline, expressionToBeReplaced) {
 
-    fun KtExpression.replacedWithStringTemplate(templateExpression: KtStringTemplateExpression): KtExpression? {
+    private fun KtExpression.replacedWithStringTemplate(templateExpression: KtStringTemplateExpression): KtExpression? {
         val parent = this.parent
 
         return if (parent is KtStringTemplateEntryWithExpression