provide this(); fix when constructor requires super call (IDEA-151335)

java/java-analysis-api/src/com/intellij/codeInsight/intention/QuickFixFactory.java

@@ -172,6 +172,8 @@ public abstract class QuickFixFactory {
 
   @NotNull public abstract IntentionAction createInsertSuperFix(@NotNull PsiMethod constructor);
 
+  @NotNull public abstract IntentionAction createInsertThisFix(@NotNull PsiMethod constructor);
+  
   @NotNull public abstract IntentionAction createChangeMethodSignatureFromUsageFix(@NotNull PsiMethod targetMethod,
                                       @NotNull PsiExpression[] expressions,
                                       @NotNull PsiSubstitutor substitutor,

java/java-analysis-impl/src/com/intellij/codeInsight/daemon/impl/analysis/HighlightMethodUtil.java

@@ -1316,6 +1316,7 @@ public class HighlightMethodUtil {
     HighlightInfo info = HighlightClassUtil.checkBaseClassDefaultConstructorProblem(aClass, refCountHolder, resolveHelper, textRange, handledExceptions);
     if (info != null) {
       QuickFixAction.registerQuickFixAction(info, QUICK_FIX_FACTORY.createInsertSuperFix(constructor));
+      QuickFixAction.registerQuickFixAction(info, QUICK_FIX_FACTORY.createInsertThisFix(constructor));
       QuickFixAction.registerQuickFixAction(info, QUICK_FIX_FACTORY.createAddDefaultConstructorFix(aClass.getSuperClass()));
     }
     return info;

java/java-analysis-impl/src/com/intellij/codeInsight/intention/EmptyQuickFixFactory.java

@@ -383,6 +383,12 @@ public class EmptyQuickFixFactory extends QuickFixFactory {
     return QuickFixes.EMPTY_FIX;
   }
 
+  @NotNull
+  @Override
+  public IntentionAction createInsertThisFix(@NotNull PsiMethod constructor) {
+    return QuickFixes.EMPTY_FIX;
+  }
+
   @NotNull
   @Override
   public IntentionAction createInsertSuperFix(@NotNull PsiMethod psiMethod) {

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InsertConstructorCallFix.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2000-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.codeInsight.daemon.impl.quickfix;
+
+import com.intellij.codeInsight.daemon.QuickFixBundle;
+import com.intellij.codeInsight.intention.HighPriorityAction;
+import com.intellij.codeInsight.intention.IntentionAction;
+import com.intellij.openapi.command.undo.UndoUtil;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.*;
+import com.intellij.psi.util.PsiMatcherImpl;
+import com.intellij.psi.util.PsiMatchers;
+import org.jetbrains.annotations.NotNull;
+
+public class InsertConstructorCallFix implements IntentionAction, HighPriorityAction {
+  protected final PsiMethod myConstructor;
+  private final String myCall;
+
+  public InsertConstructorCallFix(@NotNull PsiMethod constructor, String call) {
+    myConstructor = constructor;
+    myCall = call;
+  }
+
+  @Override
+  @NotNull
+  public String getText() {
+    return QuickFixBundle.message("insert.super.constructor.call.text", myCall);
+  }
+
+  @Override
+  @NotNull
+  public String getFamilyName() {
+    return QuickFixBundle.message("insert.super.constructor.call.family");
+  }
+
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+    return myConstructor.isValid()
+        && myConstructor.getBody() != null
+        && myConstructor.getBody().getLBrace() != null
+        && myConstructor.getManager().isInProject(myConstructor)
+    ;
+  }
+
+  @NotNull
+  @Override
+  public PsiElement getElementToMakeWritable(@NotNull PsiFile file) {
+    return myConstructor;
+  }
+
+  @Override
+  public void invoke(@NotNull Project project, Editor editor, PsiFile file) {
+    PsiStatement superCall =
+      JavaPsiFacade.getInstance(myConstructor.getProject()).getElementFactory().createStatementFromText(myCall,null);
+
+    PsiCodeBlock body = myConstructor.getBody();
+    PsiJavaToken lBrace = body.getLBrace();
+    body.addAfter(superCall, lBrace);
+    lBrace = (PsiJavaToken) new PsiMatcherImpl(body)
+              .firstChild(PsiMatchers.hasClass(PsiExpressionStatement.class))
+              .firstChild(PsiMatchers.hasClass(PsiMethodCallExpression.class))
+              .firstChild(PsiMatchers.hasClass(PsiExpressionList.class))
+              .firstChild(PsiMatchers.hasClass(PsiJavaToken.class))
+              .dot(PsiMatchers.hasText("("))
+              .getElement();
+    editor.getCaretModel().moveToOffset(lBrace.getTextOffset()+1);
+    UndoUtil.markPsiFileForUndo(file);
+  }
+
+  @Override
+  public boolean startInWriteAction() {
+    return true;
+  }
+
+}

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InsertSuperFix.java

@@ -15,73 +15,12 @@
  */
 package com.intellij.codeInsight.daemon.impl.quickfix;
 
-import com.intellij.codeInsight.daemon.QuickFixBundle;
-import com.intellij.codeInsight.intention.HighPriorityAction;
-import com.intellij.codeInsight.intention.IntentionAction;
-import com.intellij.openapi.command.undo.UndoUtil;
-import com.intellij.openapi.editor.Editor;
-import com.intellij.openapi.project.Project;
-import com.intellij.psi.*;
-import com.intellij.psi.util.PsiMatcherImpl;
-import com.intellij.psi.util.PsiMatchers;
+import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
 
-public class InsertSuperFix implements IntentionAction, HighPriorityAction {
-  private final PsiMethod myConstructor;
+public class InsertSuperFix extends InsertConstructorCallFix {
 
   public InsertSuperFix(@NotNull PsiMethod constructor) {
-    myConstructor = constructor;
+    super(constructor, "super();");
   }
-
-  @Override
-  @NotNull
-  public String getText() {
-    return QuickFixBundle.message("insert.super.constructor.call.text");
-  }
-
-  @Override
-  @NotNull
-  public String getFamilyName() {
-    return QuickFixBundle.message("insert.super.constructor.call.family");
-  }
-
-  @Override
-  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
-    return myConstructor.isValid()
-        && myConstructor.getBody() != null
-        && myConstructor.getBody().getLBrace() != null
-        && myConstructor.getManager().isInProject(myConstructor)
-    ;
-  }
-
-  @NotNull
-  @Override
-  public PsiElement getElementToMakeWritable(@NotNull PsiFile file) {
-    return myConstructor;
-  }
-
-  @Override
-  public void invoke(@NotNull Project project, Editor editor, PsiFile file) {
-    PsiStatement superCall =
-      JavaPsiFacade.getInstance(myConstructor.getProject()).getElementFactory().createStatementFromText("super();",null);
-
-    PsiCodeBlock body = myConstructor.getBody();
-    PsiJavaToken lBrace = body.getLBrace();
-    body.addAfter(superCall, lBrace);
-    lBrace = (PsiJavaToken) new PsiMatcherImpl(body)
-              .firstChild(PsiMatchers.hasClass(PsiExpressionStatement.class))
-              .firstChild(PsiMatchers.hasClass(PsiMethodCallExpression.class))
-              .firstChild(PsiMatchers.hasClass(PsiExpressionList.class))
-              .firstChild(PsiMatchers.hasClass(PsiJavaToken.class))
-              .dot(PsiMatchers.hasText("("))
-              .getElement();
-    editor.getCaretModel().moveToOffset(lBrace.getTextOffset()+1);
-    UndoUtil.markPsiFileForUndo(file);
-  }
-
-  @Override
-  public boolean startInWriteAction() {
-    return true;
-  }
-
 }

java/java-impl/src/com/intellij/codeInsight/daemon/impl/quickfix/InsertThisFix.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2000-2017 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.intellij.codeInsight.daemon.impl.quickfix;
+
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiMethod;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Arrays;
+
+public class InsertThisFix extends InsertConstructorCallFix {
+
+  public InsertThisFix(@NotNull PsiMethod constructor) {
+    super(constructor, "this();");
+  }
+
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
+    return super.isAvailable(project, editor, file) && hasConstructorToDelegate();
+  }
+
+  private boolean hasConstructorToDelegate() {
+    PsiClass containingClass = myConstructor.getContainingClass();
+    if (containingClass == null) return false;
+    return Arrays.stream(containingClass.getConstructors()).anyMatch(constructor -> constructor != myConstructor);
+  }
+}

java/java-impl/src/com/intellij/codeInsight/generation/GenerateConstructorHandler.java

@@ -183,7 +183,11 @@ public class GenerateConstructorHandler extends GenerateMembersHandlerBase {
         baseConstructor = GenerateMembersUtil.substituteGenericMethod(baseConstructor, substitutor, aClass);
         constructors.add(new PsiGenerationInfo<>(generateConstructorPrototype(aClass, baseConstructor, myCopyJavadoc, fields)));
       }
-      return filterOutAlreadyInsertedConstructors(aClass, constructors);
+      List<? extends GenerationInfo> constructorsToCreate = filterOutAlreadyInsertedConstructors(aClass, constructors);
+      if (!constructorsToCreate.isEmpty()) {
+        //allow to create constructor not matching super
+        return constructorsToCreate;
+      }
     }
     final List<GenerationInfo> constructors =
       Collections.singletonList(new PsiGenerationInfo<>(generateConstructorPrototype(aClass, null, false, fields)));

java/java-impl/src/com/intellij/codeInsight/intention/impl/config/QuickFixFactoryImpl.java

@@ -452,6 +452,12 @@ public class QuickFixFactoryImpl extends QuickFixFactory {
     return new InsertSuperFix(constructor);
   }
 
+  @NotNull
+  @Override
+  public IntentionAction createInsertThisFix(@NotNull PsiMethod constructor) {
+    return new InsertThisFix(constructor);
+  }
+
   @NotNull
   @Override
   public IntentionAction createChangeMethodSignatureFromUsageFix(@NotNull PsiMethod targetMethod,

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/insertSuper/afterThis.java

@@ -0,0 +1,16 @@
+// "Insert 'this();'" "true"
+import java.io.*;
+
+class c {
+ public c(int i) {
+ }
+}
+class a extends c {
+  a(int i) {
+    super(i);
+  }
+ a() {
+     this(<caret>);
+ }
+}
+

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/insertSuper/beforeThis.java

@@ -0,0 +1,15 @@
+// "Insert 'this();'" "true"
+import java.io.*;
+
+class c {
+ public c(int i) {
+ }
+}
+class a extends c {
+  a(int i) {
+    super(i);
+  }
+ <caret>a() {
+ }
+}
+

resources-en/src/messages/QuickFixBundle.properties

@@ -111,7 +111,7 @@ implement.methods.fix=Implement methods
 import.class.fix=Import class
 insert.new.fix=Insert new
 insert.super.constructor.call.family=Base Ctr call
-insert.super.constructor.call.text=Insert 'super();'
+insert.super.constructor.call.text=Insert ''{0}''
 make.class.an.interface.family=Make Class an Interface
 make.class.an.interface.text=Make ''{0}'' an interface
 make.interface.an.class.text=Make ''{0}'' a class