Extract Function: Exclude unused parameters (jump-based control flow)

idea/src/org/jetbrains/jet/plugin/refactoring/extractFunction/extractFunctionUtils.kt

@@ -365,6 +365,8 @@ private class MutableParameter(
     private val defaultTypes = HashSet<JetType>()
     private val typePredicates = HashSet<TypePredicate>()
 
+    var refCount: Int = 0
+
     fun addDefaultType(jetType: JetType) {
         assert(writable, "Can't add type to non-writable parameter $name")
         defaultTypes.add(jetType)
@@ -402,7 +404,8 @@ private fun ExtractionData.inferParametersInfo(
         bindingContext: BindingContext,
         modifiedVarDescriptors: Set<VariableDescriptor>,
         replacementMap: MutableMap<Int, Replacement>,
-        parameters: MutableSet<Parameter>,
+        originalRefToParameter: MutableMap<JetSimpleNameExpression, MutableParameter>,
+        parameters: MutableSet<MutableParameter>,
         typeParameters: MutableSet<TypeParameter>,
         nonDenotableTypes: MutableSet<JetType>
 ): ErrorMessage? {
@@ -497,6 +500,9 @@ private fun ExtractionData.inferParametersInfo(
                     MutableParameter(argumentText, descriptorToExtract, parameterName, mirrorVarName, extractThis)
                 }
 
+                parameter.refCount++
+                originalRefToParameter[originalRef] = parameter
+
                 parameter.addDefaultType(parameterType)
                 parameter.addTypePredicate(parameterTypePredicate)
 
@@ -586,11 +592,12 @@ fun ExtractionData.performAnalysis(): AnalysisResult {
     val modifiedVarDescriptors = localInstructions.getModifiedVarDescriptors(bindingContext)
 
     val replacementMap = HashMap<Int, Replacement>()
-    val parameters = HashSet<Parameter>()
+    val originalRefToParameter = HashMap<JetSimpleNameExpression, MutableParameter>()
+    val parameters = HashSet<MutableParameter>()
     val typeParameters = HashSet<TypeParameter>()
     val nonDenotableTypes = HashSet<JetType>()
     val parameterError = inferParametersInfo(
-            commonParent, pseudocode, bindingContext, modifiedVarDescriptors, replacementMap, parameters, typeParameters, nonDenotableTypes
+            commonParent, pseudocode, bindingContext, modifiedVarDescriptors, replacementMap, originalRefToParameter, parameters, typeParameters, nonDenotableTypes
     )
     if (parameterError != null) {
         return AnalysisResult(null, Status.CRITICAL_ERROR, listOf(parameterError))
@@ -623,16 +630,27 @@ fun ExtractionData.performAnalysis(): AnalysisResult {
             )
     val functionName = JetNameSuggester.suggestNames(controlFlow.returnType, functionNameValidator, DEFAULT_FUNCTION_NAME).first()
 
-    val receiverCandidates = parameters.filterTo(HashSet<Parameter>()) { it.receiverCandidate }
+    if (controlFlow is JumpBasedControlFlow) {
+        controlFlow.elementToInsertAfterCall.accept(
+                object: JetTreeVisitorVoid() {
+                    override fun visitSimpleNameExpression(expression: JetSimpleNameExpression) {
+                        originalRefToParameter[expression]?.let { it.refCount-- }
+                    }
+                }
+        )
+    }
+    val adjustedParameters = parameters.filterTo(HashSet<Parameter>()) { it.refCount > 0 }
+
+    val receiverCandidates = adjustedParameters.filterTo(HashSet<Parameter>()) { it.receiverCandidate }
     val receiverParameter = if (receiverCandidates.size == 1) receiverCandidates.first() else null
-    receiverParameter?.let { parameters.remove(it) }
+    receiverParameter?.let { adjustedParameters.remove(it) }
 
     return AnalysisResult(
             ExtractionDescriptor(
                     this,
                     functionName,
                     "",
-                    parameters.sortBy { it.name },
+                    adjustedParameters.sortBy { it.name },
                     receiverParameter,
                     typeParameters.sortBy { it.originalDeclaration.getName()!! },
                     replacementMap,

idea/testData/refactoring/extractFunction/parameters/misc/reducedParameterList.kt

@@ -0,0 +1,7 @@
+// PARAM_TYPES: kotlin.Int
+// PARAM_DESCRIPTOR: value-parameter val a: kotlin.Int defined in foo
+// SIBLING:
+fun foo(a: Int, b: Int): Int {
+    <selection>if (a > 0) return a + b</selection>
+    return 0
+}

idea/testData/refactoring/extractFunction/parameters/misc/reducedParameterList.kt.after

@@ -0,0 +1,12 @@
+// PARAM_TYPES: kotlin.Int
+// PARAM_DESCRIPTOR: value-parameter val a: kotlin.Int defined in foo
+// SIBLING:
+fun foo(a: Int, b: Int): Int {
+    if (b(a)) return a + b
+    return 0
+}
+
+fun b(a: Int): Boolean {
+    if (a > 0) return true
+    return false
+}

idea/tests/org/jetbrains/jet/plugin/refactoring/introduce/introduceVariable/JetExtractionTestGenerated.java

@@ -16,14 +16,17 @@
 
 package org.jetbrains.jet.plugin.refactoring.introduce.introduceVariable;
 
+import junit.framework.Assert;
 import junit.framework.Test;
 import junit.framework.TestSuite;
+
+import java.io.File;
+import java.util.regex.Pattern;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.test.InnerTestClasses;
 import org.jetbrains.jet.test.TestMetadata;
 
-import java.io.File;
+import org.jetbrains.jet.plugin.refactoring.introduce.introduceVariable.AbstractJetExtractionTest;
-import java.util.regex.Pattern;
 
 /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */
 @SuppressWarnings("all")
@@ -1169,6 +1172,11 @@ public class JetExtractionTestGenerated extends AbstractJetExtractionTest {
                     doExtractFunctionTest("idea/testData/refactoring/extractFunction/parameters/misc/qualifiedTypeRef.kt");
                 }
                 
+                @TestMetadata("reducedParameterList.kt")
+                public void testReducedParameterList() throws Exception {
+                    doExtractFunctionTest("idea/testData/refactoring/extractFunction/parameters/misc/reducedParameterList.kt");
+                }
+                
                 @TestMetadata("typeRef.kt")
                 public void testTypeRef() throws Exception {
                     doExtractFunctionTest("idea/testData/refactoring/extractFunction/parameters/misc/typeRef.kt");