intention to set default value to the parameter (IDEA-63040)

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

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2000-2011 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.intention.IntentionAction;
+import com.intellij.codeInsight.intention.PsiElementBaseIntentionAction;
+import com.intellij.codeInsight.template.Template;
+import com.intellij.codeInsight.template.TemplateBuilderImpl;
+import com.intellij.codeInsight.template.impl.TextExpression;
+import com.intellij.openapi.editor.Editor;
+import com.intellij.openapi.editor.RangeMarker;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.IconLoader;
+import com.intellij.openapi.util.Iconable;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.*;
+import com.intellij.psi.codeStyle.CodeStyleManager;
+import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.util.Function;
+import com.intellij.util.IncorrectOperationException;
+import org.jetbrains.annotations.NotNull;
+
+import javax.swing.*;
+
+/**
+ * User: anna
+ */
+public class DelegateWithDefaultParamValueIntentionAction extends PsiElementBaseIntentionAction implements Iconable {
+   public static final Icon REFACTORING_BULB = IconLoader.getIcon("/actions/refactoringBulb.png");
+  @Override
+  public boolean isAvailable(@NotNull Project project, Editor editor, @NotNull PsiElement element) {
+    final PsiParameter parameter = PsiTreeUtil.getParentOfType(element, PsiParameter.class);
+    if (parameter != null) {
+      final PsiElement declarationScope = parameter.getDeclarationScope();
+      if (declarationScope instanceof PsiMethod) {
+        final PsiMethod method = (PsiMethod)declarationScope;
+        final PsiClass containingClass = method.getContainingClass();
+        if (containingClass != null && !containingClass.isInterface()) {
+          return containingClass.findMethodBySignature(generateMethodPrototype(method, parameter), false) == null;
+        }
+      }
+    }
+    return false;
+  }
+
+  @Override
+  public Icon getIcon(int flags) {
+    return REFACTORING_BULB;
+  }
+
+  private static PsiMethod generateMethodPrototype(PsiMethod method, PsiParameter param) {
+    final PsiMethod prototype = (PsiMethod)method.copy();
+    final PsiCodeBlock body = prototype.getBody();
+    if (body != null) {
+      for (PsiStatement psiStatement : body.getStatements()) {
+        psiStatement.delete();
+      }
+    }
+    final int parameterIndex = method.getParameterList().getParameterIndex(param);
+    prototype.getParameterList().getParameters()[parameterIndex].delete();
+    return prototype;
+  }
+
+  @Override
+  public void invoke(Project project, Editor editor, PsiElement element) throws IncorrectOperationException {
+    final PsiParameter parameter = PsiTreeUtil.getParentOfType(element, PsiParameter.class);
+    final PsiMethod method = (PsiMethod)parameter.getDeclarationScope();
+    final PsiMethod prototype = (PsiMethod)method.getContainingClass().addBefore(generateMethodPrototype(method, parameter), method);
+
+    TemplateBuilderImpl builder = new TemplateBuilderImpl(prototype);
+
+    PsiCodeBlock body = prototype.getBody();
+    final String callArgs =
+      "(" + StringUtil.join(method.getParameterList().getParameters(), new Function<PsiParameter, String>() {
+        @Override
+        public String fun(PsiParameter psiParameter) {
+          if (psiParameter.equals(parameter)) return "IntelliJIDEARulezzz";
+          return psiParameter.getName();
+        }
+      }, ",") + ");";
+    final String methodCall;
+    if (method.getReturnType() == null) {
+      methodCall = "this";
+    } else if (method.getReturnType() != PsiType.VOID) {
+      methodCall = "return " + method.getName();
+    } else {
+      methodCall = method.getName();
+    }
+    body.add(JavaPsiFacade.getElementFactory(project).createStatementFromText(methodCall + callArgs, method));
+    body = (PsiCodeBlock)CodeStyleManager.getInstance(project).reformat(body);
+    final PsiStatement stmt = body.getStatements()[0];
+    PsiExpression expr = null;
+    if (stmt instanceof PsiReturnStatement) {
+      expr = ((PsiReturnStatement)stmt).getReturnValue();
+    } else if (stmt instanceof PsiExpressionStatement) {
+      expr = ((PsiExpressionStatement)stmt).getExpression();
+    }
+    if (expr instanceof PsiMethodCallExpression) {
+      PsiMethodCallExpression methodCallExp = (PsiMethodCallExpression)expr;
+      RangeMarker rangeMarker = editor.getDocument().createRangeMarker(prototype.getTextRange());
+      final PsiExpression exprToBeDefault =
+        methodCallExp.getArgumentList().getExpressions()[method.getParameterList().getParameterIndex(parameter)];
+      builder.replaceElement(exprToBeDefault, new TextExpression(""));
+      Template template = builder.buildTemplate();
+      editor.getCaretModel().moveToOffset(rangeMarker.getStartOffset());
+
+      PsiDocumentManager.getInstance(project).doPostponedOperationsAndUnblockDocument(editor.getDocument());
+      editor.getDocument().deleteString(rangeMarker.getStartOffset(), rangeMarker.getEndOffset());
+
+      rangeMarker.dispose();
+
+      CreateFromUsageBaseFix.startTemplate(editor, template, project);
+    }
+  }
+
+  @NotNull
+  @Override
+  public String getText() {
+    return "Generate delegated method with default parameter value";
+  }
+
+  @NotNull
+  @Override
+  public String getFamilyName() {
+    return getText();
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/after1.java

@@ -0,0 +1,9 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    void foo() {
+      foo(<caret>);
+  }
+
+    void foo(int ii){
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/afterConstructor.java

@@ -0,0 +1,8 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    Test() {
+      this(<caret>);
+  }
+
+    Test(int ii){}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/afterReturnValue.java

@@ -0,0 +1,10 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    int foo() {
+      return foo(<caret>);
+  }
+
+    int foo(int ii){
+    return 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/afterTypeParams.java

@@ -0,0 +1,10 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    <T> int foo(boolean... args) {
+      return foo(<caret>, args);
+  }
+
+    <T> int foo(T ii, boolean... args){
+    return 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/afterVarargs.java

@@ -0,0 +1,10 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+    int foo(boolean... args) {
+      return foo(<caret>, args);
+  }
+
+    int foo(int ii, boolean... args){
+    return 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/before1.java

@@ -0,0 +1,5 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  void foo(int i<caret>i){
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeConstructor.java

@@ -0,0 +1,4 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  Test(int i<caret>i){}
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeExistinMethod.java

@@ -0,0 +1,6 @@
+// "Generate delegated method with default parameter value" "false"
+class Test {
+  void foo(){}
+  void foo(int i<caret>i){
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeInterface.java

@@ -0,0 +1,4 @@
+// "Generate delegated method with default parameter value" "false"
+interface Test {
+  void foo(int i<caret>i);
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeReturnValue.java

@@ -0,0 +1,6 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  int foo(int i<caret>i){
+    return 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeTypeParams.java

@@ -0,0 +1,6 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  <T> int foo(T i<caret>i, boolean... args){
+    return 1;
+  }
+}

java/java-tests/testData/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue/beforeVarargs.java

@@ -0,0 +1,6 @@
+// "Generate delegated method with default parameter value" "true"
+class Test {
+  int foo(int i<caret>i, boolean... args){
+    return 1;
+  }
+}

java/java-tests/testSrc/com/intellij/codeInsight/daemon/quickFix/DelegateWithDefaultParamValueTest.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2000-2011 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.quickFix;
+
+import com.intellij.codeInsight.template.impl.TemplateManagerImpl;
+import com.intellij.codeInsight.template.impl.TemplateState;
+
+/**
+ * @author anna
+ */
+public class DelegateWithDefaultParamValueTest extends LightQuickFixTestCase {
+  @Override
+  protected void doAction(String text, boolean actionShouldBeAvailable, String testFullPath, String testName)
+    throws Exception {
+    try {
+      ((TemplateManagerImpl)TemplateManagerImpl.getInstance(getProject())).setTemplateTesting(true);
+      super.doAction(text, actionShouldBeAvailable, testFullPath, testName);
+
+      if (actionShouldBeAvailable) {
+        TemplateState state = TemplateManagerImpl.getTemplateState(getEditor());
+        assert state != null;
+        state.gotoEnd(false);
+      }
+    } finally {
+      ((TemplateManagerImpl)TemplateManagerImpl.getInstance(getProject())).setTemplateTesting(false);
+    }
+  }
+
+  public void test() throws Exception {
+    doAllTests();
+
+  }
+
+  @Override
+  protected String getBasePath() {
+    return "/codeInsight/daemonCodeAnalyzer/quickFix/delegateWithDefaultValue";
+  }
+}

platform/platform-resources/src/META-INF/LangExtensions.xml

@@ -475,6 +475,11 @@
     <className>com.intellij.refactoring.changeSignature.ChangeSignatureDetectorAction</className>
   </intentionAction>
 
+  <intentionAction>
+    <className>com.intellij.codeInsight.daemon.impl.quickfix.DelegateWithDefaultParamValueIntentionAction</className>
+    <category>Declaration</category>
+  </intentionAction>
+
   <!-- CodeInsightSettings -->
   <editorActionHandler action="EditorEnter" implementationClass="com.intellij.codeInsight.editorActions.EnterHandler" id="editorEnter"/>
   <editorActionHandler action="EditorLineEnd" implementationClass="com.intellij.codeInsight.editorActions.EndHandler"/>

resources-en/src/intentionDescriptions/DelegateWithDefaultParamValueIntentionAction/after.java.template

@@ -0,0 +1,8 @@
+class Test {
+  void foo(int a) {
+    foo(a, <spot>|</spot>);
+  }
+  void foo(int a, int b){
+    //do smth
+  }
+}

resources-en/src/intentionDescriptions/DelegateWithDefaultParamValueIntentionAction/before.java.template

@@ -0,0 +1,5 @@
+class Test {
+  void foo(int a, int <spot>b</spot>){
+    //do smth
+  }
+}

resources-en/src/intentionDescriptions/DelegateWithDefaultParamValueIntentionAction/description.html

@@ -0,0 +1,5 @@
+<html>
+<body>
+This intention generates method which delegates to the current one setting the selected parameter the default value.
+</body>
+</html>