inline this() as method inside the constructor for non chained constructors (IDEA-87111)

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

@@ -22,6 +22,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.ReadonlyStatusHandler;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
+import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.refactoring.HelpID;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
@@ -87,10 +88,14 @@ class InlineMethodHandler extends JavaInlineActionHandler {
         CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_CONSTRUCTOR);
         return;
       }
-      if (!isChainingConstructor(method)) {
-        String message = RefactoringBundle.message("refactoring.cannot.be.applied.to.inline.non.chaining.constructors", REFACTORING_NAME);
-        CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_CONSTRUCTOR);
-        return;
+      final boolean chainingConstructor = isChainingConstructor(method);
+      if (!chainingConstructor) {
+        if (!isThisReference(reference)) {
+          String message = RefactoringBundle.message("refactoring.cannot.be.applied.to.inline.non.chaining.constructors", REFACTORING_NAME);
+          CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.INLINE_CONSTRUCTOR);
+          return;
+        }
+        allowInlineThisOnly = true;
       }
       if (reference != null) {
         final PsiElement refElement = reference.getElement();
@@ -148,4 +153,16 @@ class InlineMethodHandler extends JavaInlineActionHandler {
 
     return false;
   }
+
+  public static boolean isThisReference(PsiReference reference) {
+    if (reference != null) {
+      final PsiElement referenceElement = reference.getElement();
+      if (referenceElement instanceof PsiJavaCodeReferenceElement &&
+          referenceElement.getParent() instanceof PsiMethodCallExpression &&
+          "this".equals(((PsiJavaCodeReferenceElement)referenceElement).getReferenceName())) {
+        return true;
+      }
+    }
+    return false;
+  }
 }

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

@@ -324,7 +324,7 @@ public class InlineMethodProcessor extends BaseRefactoringProcessor {
   private void doRefactoring(UsageInfo[] usages) {
     try {
       if (myInlineThisOnly) {
-        if (myMethod.isConstructor()) {
+        if (myMethod.isConstructor() && InlineMethodHandler.isChainingConstructor(myMethod)) {
           PsiCall constructorCall = RefactoringUtil.getEnclosingConstructorCall(myReference);
           if (constructorCall != null) {
             inlineConstructorCall(constructorCall);

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

@@ -83,8 +83,13 @@ public class InlineToAnonymousClassHandler extends JavaInlineActionHandler {
     return inheritors.size() == 0;
   }
 
-  public boolean canInlineElementInEditor(PsiElement element) {
-    return canInlineElement(element);
+  @Override
+  public boolean canInlineElementInEditor(PsiElement element, Editor editor) {
+    if (canInlineElement(element)) {
+      PsiReference reference = editor != null ? TargetElementUtilBase.findReference(editor, editor.getCaretModel().getOffset()) : null;
+      return !InlineMethodHandler.isThisReference(reference);
+    }
+    return false;
   }
 
   public void inlineElement(final Project project, final Editor editor, final PsiElement psiElement) {

java/java-tests/testData/refactoring/inlineMethod/ChainedConstructor.java

@@ -0,0 +1,21 @@
+public class InlineThis {
+    public InlineThis() {
+        System.out.println("code block here");
+    }
+
+    public InlineThis(int i) {
+        th<caret>is();
+    }
+
+    public InlineThis(String str) {
+        this(Integer.parseInt(str));
+    }
+
+
+
+
+    public static void main(String[] args) {
+        InlineThis aInlineThis = new InlineThis();
+        InlineThis aInlineThis1 = new InlineThis(1);
+    }
+}

java/java-tests/testData/refactoring/inlineMethod/ChainedConstructor.java.after

@@ -0,0 +1,21 @@
+public class InlineThis {
+    public InlineThis() {
+        System.out.println("code block here");
+    }
+
+    public InlineThis(int i) {
+        System.out.println("code block here");
+    }
+
+    public InlineThis(String str) {
+        this(Integer.parseInt(str));
+    }
+
+
+
+
+    public static void main(String[] args) {
+        InlineThis aInlineThis = new InlineThis();
+        InlineThis aInlineThis1 = new InlineThis(1);
+    }
+}

java/java-tests/testData/refactoring/inlineMethod/ChainedConstructor1.java

@@ -0,0 +1,21 @@
+public class InlineThis {
+    public InlineThis() {
+        System.out.println("code block here");
+    }
+
+    public InlineThis(int i) {
+        this();
+    }
+
+    public InlineThis(String str) {
+        th<caret>is(Integer.parseInt(str));
+    }
+
+
+
+
+    public static void main(String[] args) {
+        InlineThis aInlineThis = new InlineThis();
+        InlineThis aInlineThis1 = new InlineThis(1);
+    }
+}

java/java-tests/testData/refactoring/inlineMethod/ChainedConstructor1.java.after

@@ -0,0 +1,17 @@
+public class InlineThis {
+    public InlineThis() {
+        System.out.println("code block here");
+    }
+
+    public InlineThis(String str) {
+        this();
+    }
+
+
+
+
+    public static void main(String[] args) {
+        InlineThis aInlineThis = new InlineThis();
+        InlineThis aInlineThis1 = new InlineThis();
+    }
+}

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

@@ -176,6 +176,14 @@ public class InlineMethodTest extends LightRefactoringTestCase {
     doTest();
   }
 
+  public void testChainedConstructor() throws Exception {
+    doTestInlineThisOnly();
+  }
+
+  public void testChainedConstructor1() throws Exception {
+    doTest();
+  }
+
   public void testMethodUsedInJavadoc() throws Exception {
     try {
       doTest();
@@ -187,6 +195,10 @@ public class InlineMethodTest extends LightRefactoringTestCase {
   }
 
   public void testInlineRunnableRun() throws Exception {
+    doTestInlineThisOnly();
+  }
+
+  private void doTestInlineThisOnly() {
     @NonNls String fileName = "/refactoring/inlineMethod/" + getTestName(false) + ".java";
     configureByFile(fileName);
     performAction(new MockInlineMethodOptions(){

platform/lang-api/src/com/intellij/lang/refactoring/InlineActionHandler.java

@@ -47,7 +47,7 @@ public abstract class InlineActionHandler {
 
   public abstract boolean canInlineElement(PsiElement element);
 
-  public boolean canInlineElementInEditor(PsiElement element) {
+  public boolean canInlineElementInEditor(PsiElement element, Editor editor) {
     return canInlineElement(element);
   }
 

platform/lang-impl/src/com/intellij/refactoring/inline/InlineRefactoringActionHandler.java

@@ -72,7 +72,7 @@ public class InlineRefactoringActionHandler implements RefactoringActionHandler
     }
     if (element != null) {
       for(InlineActionHandler handler: Extensions.getExtensions(InlineActionHandler.EP_NAME)) {
-        if (handler.canInlineElementInEditor(element)) {
+        if (handler.canInlineElementInEditor(element, editor)) {
           handler.inlineElement(project, editor, element);
           return;
         }