extract method: ensure folded replacement uses correct names, ensure invalid elements are skipped (IDEA-157519)

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

@@ -229,9 +229,7 @@ public class InputVariables {
     if (!myFoldingAvailable) return expression;
 
     boolean update = elements[0] == expression;
-    for (VariableData inputVariable : myInputVariables) {
-      myFolding.foldParameterUsagesInBody(inputVariable, elements, myScope);
-    }
+    myFolding.foldParameterUsagesInBody(myInputVariables, elements, myScope);
     return update ? (PsiExpression)elements[0] : expression;
   }
 

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

@@ -83,27 +83,37 @@ public class ParametersFolder {
     return false;
   }
 
-  public void foldParameterUsagesInBody(@NotNull VariableData data, PsiElement[] elements, SearchScope scope) {
-    if (myDeleted.contains(data.variable)) return;
-    final PsiExpression psiExpression = myExpressions.get(data.variable);
-    if (psiExpression == null) return;
-    final Set<PsiExpression> eqExpressions = new HashSet<PsiExpression>();
-    for (PsiReference reference : ReferencesSearch.search(data.variable, scope)) {
-      final PsiExpression expression = findEquivalent(psiExpression, reference.getElement());
-      if (expression != null && expression.isValid()) {
-        eqExpressions.add(expression);
+  public void foldParameterUsagesInBody(@NotNull List<VariableData> datum, PsiElement[] elements, SearchScope scope) {
+    Map<VariableData, Set<PsiExpression>> equivalentExpressions = new HashMap<>();
+    for (VariableData data : datum) {
+      if (myDeleted.contains(data.variable)) continue;
+      final PsiExpression psiExpression = myExpressions.get(data.variable);
+      if (psiExpression == null) continue;
+
+      final Set<PsiExpression> eqExpressions = new HashSet<PsiExpression>();
+      for (PsiReference reference : ReferencesSearch.search(data.variable, scope)) {
+        final PsiExpression expression = findEquivalent(psiExpression, reference.getElement());
+        if (expression != null && expression.isValid()) {
+          eqExpressions.add(expression);
+        }
       }
+
+      equivalentExpressions.put(data, eqExpressions);
     }
 
-    for (PsiExpression expression : eqExpressions) {
-      final PsiExpression refExpression =
-        JavaPsiFacade.getElementFactory(expression.getProject()).createExpressionFromText(data.variable.getName(), expression);
-      final PsiElement replaced = expression.replace(refExpression);
-      for (int i = 0, psiElementsLength = elements.length; i < psiElementsLength; i++) {
-        PsiElement psiElement = elements[i];
-        if (expression == psiElement) {
-          elements[i] = replaced;
-          break;
+    for (VariableData data : equivalentExpressions.keySet()) {
+      final Set<PsiExpression> eqExpressions = equivalentExpressions.get(data);
+      for (PsiExpression expression : eqExpressions) {
+        if (!expression.isValid()) continue; //was replaced on previous step
+        final PsiExpression refExpression =
+          JavaPsiFacade.getElementFactory(expression.getProject()).createExpressionFromText(data.name, expression);
+        final PsiElement replaced = expression.replace(refExpression);
+        for (int i = 0, psiElementsLength = elements.length; i < psiElementsLength; i++) {
+          PsiElement psiElement = elements[i];
+          if (expression == psiElement) {
+            elements[i] = replaced;
+            break;
+          }
         }
       }
     }

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

@@ -0,0 +1,7 @@
+class Test {
+  void h(int i, String[] s, String[] t) {
+    <selection>System.out.println(t[i]);
+    final String s1 = s[t[i].length()];</selection>
+    System.out.println(s1);
+  }
+}

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

@@ -0,0 +1,11 @@
+class Test {
+  void h(int i, String[] s, String[] t) {
+      final String s1 = newMethod(t[i], s[x.length()]);
+    System.out.println(s1);
+  }
+
+    private String newMethod(String x, String s) {
+        System.out.println(x);
+        return s;
+    }
+}

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

@@ -370,6 +370,10 @@ public class ExtractMethodTest extends LightCodeInsightTestCase {
     doTest();
   }
 
+  public void testFoldedWithNestedExpressions() throws Exception {
+    doTest();
+  }
+
   public void testFoldingWithFieldInvolved() throws Exception {
     doTest();
   }