replace duplicates on extract method with signature change: use folded values if present (IDEA-143613)

java/java-analysis-impl/src/com/intellij/refactoring/extractMethod/InputVariables.java

@@ -300,6 +300,10 @@ public class InputVariables {
     }
   }
 
+  public ParametersFolder getFolding() {
+    return myFolding;
+  }
+
   public void setFoldingAvailable(boolean foldingAvailable) {
     myFoldingAvailable = foldingAvailable;
 

java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodProcessor.java

@@ -23,8 +23,6 @@ import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil;
 import com.intellij.codeInsight.daemon.impl.quickfix.AnonymousTargetClassPreselectionUtil;
 import com.intellij.codeInsight.generation.GenerateMembersUtil;
 import com.intellij.codeInsight.highlighting.HighlightManager;
-import com.intellij.codeInsight.intention.impl.AddNotNullAnnotationFix;
-import com.intellij.codeInsight.intention.impl.AddNullableAnnotationFix;
 import com.intellij.codeInsight.intention.impl.AddNullableNotNullAnnotationFix;
 import com.intellij.codeInsight.navigation.NavigationUtil;
 import com.intellij.codeInspection.dataFlow.*;
@@ -1722,7 +1720,7 @@ public class ExtractMethodProcessor implements MatchProvider {
 
     if (myExtractedMethod != null) {
       final ExtractMethodSignatureSuggester suggester = new ExtractMethodSignatureSuggester(myProject, myExtractedMethod, myMethodCall, myVariableDatum);
-      duplicates = suggester.getDuplicates(myExtractedMethod, myMethodCall);
+      duplicates = suggester.getDuplicates(myExtractedMethod, myMethodCall, myInputVariables.getFolding());
       if (duplicates != null && !duplicates.isEmpty()) {
         myDuplicates      = duplicates;
         myExtractedMethod = suggester.getExtractedMethod();

java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodSignatureSuggester.java

@@ -89,8 +89,8 @@ public class ExtractMethodSignatureSuggester {
     myVariableData = variableDatum;
   }
 
-  public List<Match> getDuplicates(final PsiMethod method, final PsiMethodCallExpression methodCall) {
-    final List<Match> duplicates = findDuplicatesSignature(method);
+  public List<Match> getDuplicates(final PsiMethod method, final PsiMethodCallExpression methodCall, ParametersFolder folder) {
+    final List<Match> duplicates = findDuplicatesSignature(method, folder);
     if (duplicates != null && !duplicates.isEmpty()) {
       if (ApplicationManager.getApplication().isUnitTestMode() || 
           new PreviewDialog(method, myExtractedMethod, methodCall, myMethodCall, duplicates.size()).showAndGet()) {
@@ -127,7 +127,7 @@ public class ExtractMethodSignatureSuggester {
   }
 
   @Nullable
-  public List<Match> findDuplicatesSignature(final PsiMethod method) {
+  public List<Match> findDuplicatesSignature(final PsiMethod method, ParametersFolder folder) {
     final List<PsiExpression> copies = new ArrayList<PsiExpression>();
     final InputVariables variables = detectTopLevelExpressionsToReplaceWithParameters(copies);
     if (variables == null) {
@@ -148,7 +148,7 @@ public class ExtractMethodSignatureSuggester {
     List<Match> duplicates = finder.findDuplicates(method.getContainingClass());
 
     if (duplicates != null && !duplicates.isEmpty()) {
-      restoreRenamedParams(copies);
+      restoreRenamedParams(copies, folder);
       if (!myMethodCall.isValid()) {
         return null;
       }
@@ -255,17 +255,18 @@ public class ExtractMethodSignatureSuggester {
     return true;
   }
 
-  private void restoreRenamedParams(List<PsiExpression> copies) {
-    final Map<String, PsiVariable> renameMap = new HashMap<String, PsiVariable>();
+  private void restoreRenamedParams(List<PsiExpression> copies, ParametersFolder folder) {
+    final Map<String, String> renameMap = new HashMap<String, String>();
     for (VariableData data : myVariableData) {
-      if (!data.name.equals(data.variable.getName())) {
-        renameMap.put(data.name, data.variable);
+      final String replacement = folder.getGeneratedCallArgument(data);
+      if (!data.name.equals(replacement)) {
+        renameMap.put(data.name, replacement);
       }
     }
 
     if (!renameMap.isEmpty()) {
       for (PsiExpression currentExpression : copies) {
-        final Map<PsiReferenceExpression, PsiVariable> params = new HashMap<PsiReferenceExpression, PsiVariable>();
+        final Map<PsiReferenceExpression, String> params = new HashMap<PsiReferenceExpression, String>();
         currentExpression.accept(new JavaRecursiveElementWalkingVisitor() {
           @Override
           public void visitReferenceExpression(PsiReferenceExpression expression) {
@@ -273,7 +274,7 @@ public class ExtractMethodSignatureSuggester {
             final PsiElement resolve = expression.resolve();
             if (resolve instanceof PsiParameter && myExtractedMethod.equals(((PsiParameter)resolve).getDeclarationScope())) {
               final String name = ((PsiParameter)resolve).getName();
-              final PsiVariable variable = renameMap.get(name);
+              final String variable = renameMap.get(name);
               if (renameMap.containsKey(name)) {
                 params.put(expression, variable);
               }
@@ -281,8 +282,8 @@ public class ExtractMethodSignatureSuggester {
           }
         });
         for (PsiReferenceExpression expression : params.keySet()) {
-          final PsiVariable var = params.get(expression);
-          expression.replace(myElementFactory.createExpressionFromText(var.getName(), expression));
+          final String var = params.get(expression);
+          expression.replace(myElementFactory.createExpressionFromText(var, expression));
         }
       }
     }

java/java-tests/testData/refactoring/extractMethod/SuggestChangeSignatureWithFolding.java

@@ -0,0 +1,6 @@
+class Test {
+  public static void main(String[] args, int i) {
+    System.out.println("hi");
+    <selection>System.out.println("world, " + args[i]);</selection>
+  }
+}

java/java-tests/testData/refactoring/extractMethod/SuggestChangeSignatureWithFolding_after.java

@@ -0,0 +1,10 @@
+class Test {
+  public static void main(String[] args, int i) {
+      newMethod("hi");
+      newMethod("world, " + args[i]);
+  }
+
+    private static void newMethod(String x) {
+        System.out.println(x);
+    }
+}

java/java-tests/testSrc/com/intellij/refactoring/ExtractMethodTest.java

@@ -672,6 +672,10 @@ public class ExtractMethodTest extends LightCodeInsightTestCase {
     doDuplicatesTest();
   }
 
+  public void testSuggestChangeSignatureWithFolding() throws Exception {
+    doDuplicatesTest();
+  }
+
   public void testSuggestChangeSignatureWithChangedParameterName() throws Exception {
     configureByFile(BASE_PATH + getTestName(false) + ".java");
     boolean success = performExtractMethod(true, true, getEditor(), getFile(), getProject(), false, null, false, "p");