inline parameter: safely inline recursive calls (IDEA-55529)

java/java-impl/src/com/intellij/refactoring/inline/InlineParameterHandler.java

@@ -99,8 +99,7 @@ public class InlineParameterHandler extends JavaInlineActionHandler {
             else if (!isSameConstant(argument, refConstantInitializer.get())) {
               return false;
             }
-          }
-          else {
+          } else if (!isRecursiveReferencedParameter(argument, psiParameter)) {
             if (!refConstantInitializer.isNull()) return false;
             refInitializer.set(argument);
             refMethodCall.set(methodCall);
@@ -228,6 +227,16 @@ public class InlineParameterHandler extends JavaInlineActionHandler {
     return null;
   }
 
+  private static boolean isRecursiveReferencedParameter(final PsiExpression argument, final PsiParameter param) {
+    if (argument instanceof PsiReferenceExpression) {
+      final PsiElement element = ((PsiReferenceExpression)argument).resolve();
+      if (element instanceof PsiParameter) {
+        return element.equals(param);
+      }
+    }
+    return false;
+  }
+
   private static boolean isSameConstant(final PsiExpression expr1, final PsiExpression expr2) {
     boolean expr1Null = InlineToAnonymousConstructorProcessor.ourNullPattern.accepts(expr1);
     boolean expr2Null = InlineToAnonymousConstructorProcessor.ourNullPattern.accepts(expr2);

java/java-tests/testData/refactoring/inlineParameter/CantInlineRecursive.java

@@ -0,0 +1,18 @@
+import java.lang.Integer;
+import java.util.*;
+import java.util.ArrayList;
+
+public class ExpData {
+   private final List<Integer> myResult = new ArrayList<Integer>();
+  {
+    m(10, myResult);
+  }
+
+  private void m(int i, List<Integer> re<caret>sult) {
+    if (i > 0) {
+      m(i - 1, result);
+    }
+    result.add(i);
+    m(2, new ArrayList<Integer>());
+  }
+}

java/java-tests/testData/refactoring/inlineParameter/InlineRecursive.java

@@ -0,0 +1,15 @@
+import java.util.*;
+
+public class ExpData {
+   private final List<Integer> myResult = new ArrayList<Integer>();
+  {
+    m(10, myResult);
+  }
+
+  private void m(int i, List<Integer> re<caret>sult) {
+    if (i > 0) {
+      m(i - 1, result);
+    }
+    result.add(i);
+  }
+}

java/java-tests/testData/refactoring/inlineParameter/InlineRecursive.java.after

@@ -0,0 +1,15 @@
+import java.util.*;
+
+public class ExpData {
+   private final List<Integer> myResult = new ArrayList<Integer>();
+  {
+    m(10);
+  }
+
+  private void m(int i) {
+    if (i > 0) {
+      m(i - 1);
+    }
+    myResult.add(i);
+  }
+}

java/java-tests/testSrc/com/intellij/refactoring/inline/InlineParameterTest.java

@@ -250,6 +250,21 @@ public class InlineParameterTest extends LightCodeInsightTestCase {
     doTest(false);
   }
 
+  public void testInlineRecursive() throws Exception {
+    doTest(false);
+  }
+
+  public void testCantInlineRecursive() throws Exception {
+    try {
+      doTest(false);
+    }
+    catch (CommonRefactoringUtil.RefactoringErrorHintException e) {
+      assertEquals("Cannot find constant initializer for parameter", e.getMessage());
+      return;
+    }
+    fail("Initializer shoul not be found");
+  }
+
   public void testParameterDefWithWriteAccess()  throws Exception {
     try {
       doTest(false);