hide actions from popups, leave access through shortcut (IDEA-141474, IDEA-77602)

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

@@ -91,13 +91,7 @@ public class GenerateEqualsHandler extends GenerateMembersHandlerBase {
         return null;
       }
     }
-    boolean hasNonStaticFields = false;
-    for (PsiField field : aClass.getFields()) {
-      if (!field.hasModifierProperty(PsiModifier.STATIC)) {
-        hasNonStaticFields = true;
-        break;
-      }
-    }
+    boolean hasNonStaticFields = hasNonStaticFields(aClass);
     if (!hasNonStaticFields) {
       HintManager.getInstance().showErrorHint(editor, "No fields to include in equals/hashCode have been found");
       return null;
@@ -113,6 +107,20 @@ public class GenerateEqualsHandler extends GenerateMembersHandlerBase {
     return DUMMY_RESULT;
   }
 
+  private static boolean hasNonStaticFields(PsiClass aClass) {
+    for (PsiField field : aClass.getFields()) {
+      if (!field.hasModifierProperty(PsiModifier.STATIC)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  protected boolean hasMembers(@NotNull PsiClass aClass) {
+    return hasNonStaticFields(aClass);
+  }
+
   @Override
   @NotNull
   protected List<? extends GenerationInfo> generateMemberPrototypes(PsiClass aClass, ClassMember[] originalMembers) throws IncorrectOperationException {

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

@@ -74,6 +74,11 @@ public abstract class GenerateGetterSetterHandlerBase extends GenerateMembersHan
     super(chooserTitle);
   }
 
+  @Override
+  protected boolean hasMembers(@NotNull PsiClass aClass) {
+    return !GenerateAccessorProviderRegistrar.getEncapsulatableClassMembers(aClass).isEmpty();
+  }
+
   @Override
   protected String getHelpId() {
     return "Getter and Setter Templates Dialog";

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

@@ -23,6 +23,8 @@ import com.intellij.codeInsight.template.TemplateEditingAdapter;
 import com.intellij.codeInsight.template.TemplateManager;
 import com.intellij.codeInspection.ex.GlobalInspectionContextBase;
 import com.intellij.ide.util.MemberChooser;
+import com.intellij.lang.ContextAwareActionHandler;
+import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.Result;
 import com.intellij.openapi.command.WriteCommandAction;
@@ -47,7 +49,7 @@ import javax.swing.*;
 import java.util.ArrayList;
 import java.util.List;
 
-public abstract class GenerateMembersHandlerBase implements CodeInsightActionHandler {
+public abstract class GenerateMembersHandlerBase implements CodeInsightActionHandler, ContextAwareActionHandler {
   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInsight.generation.GenerateMembersHandlerBase");
 
   private final String myChooserTitle;
@@ -57,6 +59,16 @@ public abstract class GenerateMembersHandlerBase implements CodeInsightActionHan
     myChooserTitle = chooserTitle;
   }
 
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, false);
+    return aClass != null && hasMembers(aClass);
+  }
+
+  protected boolean hasMembers(@NotNull PsiClass aClass) {
+    return true;
+  }
+
   @Override
   public final void invoke(@NotNull final Project project, @NotNull final Editor editor, @NotNull PsiFile file) {
     if (!CodeInsightUtilBase.prepareEditorForWrite(editor)) return;

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

@@ -16,7 +16,9 @@
 package com.intellij.codeInsight.generation;
 
 import com.intellij.codeInsight.hint.HintManager;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.lang.LanguageCodeInsightActionHandler;
+import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiClass;
@@ -29,15 +31,14 @@ import org.jetbrains.annotations.NotNull;
 /**
  * @author yole
  */
-public class JavaImplementMethodsHandler implements LanguageCodeInsightActionHandler {
+public class JavaImplementMethodsHandler implements ContextAwareActionHandler, LanguageCodeInsightActionHandler {
   @Override
   public boolean isValidFor(final Editor editor, final PsiFile file) {
     if (!(file instanceof PsiJavaFile) && !(file instanceof PsiCodeFragment)) {
       return false;
     }
 
-    PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, PsiUtil.isLanguageLevel8OrHigher(file));
-    return aClass != null && !OverrideImplementUtil.getMethodSignaturesToImplement(aClass).isEmpty();
+    return OverrideImplementUtil.getContextClass(file.getProject(), editor, file, PsiUtil.isLanguageLevel8OrHigher(file)) != null;
   }
 
   @Override
@@ -57,4 +58,10 @@ public class JavaImplementMethodsHandler implements LanguageCodeInsightActionHan
   public boolean startInWriteAction() {
     return false;
   }
+
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, PsiUtil.isLanguageLevel8OrHigher(file));
+    return aClass != null && !OverrideImplementUtil.getMethodSignaturesToImplement(aClass).isEmpty();
+  }
 }

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

@@ -16,7 +16,9 @@
 package com.intellij.codeInsight.generation;
 
 import com.intellij.codeInsight.hint.HintManager;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.lang.LanguageCodeInsightActionHandler;
+import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiClass;
@@ -28,15 +30,14 @@ import org.jetbrains.annotations.NotNull;
 /**
  * @author yole
  */
-public class JavaOverrideMethodsHandler implements LanguageCodeInsightActionHandler {
+public class JavaOverrideMethodsHandler implements ContextAwareActionHandler, LanguageCodeInsightActionHandler {
   @Override
   public boolean isValidFor(final Editor editor, final PsiFile file) {
     if (!(file instanceof PsiJavaFile) && !(file instanceof PsiCodeFragment)) {
       return false;
     }
 
-    PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, true);
-    return aClass != null && !OverrideImplementUtil.getMethodSignaturesToOverride(aClass).isEmpty();
+    return OverrideImplementUtil.getContextClass(file.getProject(), editor, file, true) != null;
   }
 
   @Override
@@ -55,4 +56,10 @@ public class JavaOverrideMethodsHandler implements LanguageCodeInsightActionHand
   public boolean startInWriteAction() {
     return false;
   }
+
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    PsiClass aClass = OverrideImplementUtil.getContextClass(file.getProject(), editor, file, true);
+    return aClass != null && !OverrideImplementUtil.getMethodSignaturesToOverride(aClass).isEmpty();
+  }
 }

java/java-impl/src/com/intellij/refactoring/IntroduceHandlerBase.java

@@ -15,6 +15,7 @@
  */
 package com.intellij.refactoring;
 
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
@@ -23,6 +24,7 @@ import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
+import com.intellij.refactoring.extractMethod.ExtractMethodHandler;
 import com.intellij.refactoring.introduce.inplace.AbstractInplaceIntroducer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
@@ -30,9 +32,15 @@ import org.jetbrains.annotations.TestOnly;
 /**
  * @author dsl
  */
-public abstract class IntroduceHandlerBase implements RefactoringActionHandler {
+public abstract class IntroduceHandlerBase implements RefactoringActionHandler, ContextAwareActionHandler {
   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.IntroduceHandlerBase");
 
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiElement[] elements = ExtractMethodHandler.getElements(file.getProject(), editor, file);
+    return elements != null && elements.length > 0;
+  }
+
   public void invoke(@NotNull Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
     LOG.assertTrue(elements.length >= 1 && elements[0] instanceof PsiExpression, "incorrect invoke() parameters");
     final PsiElement tempExpr = elements[0];

java/java-impl/src/com/intellij/refactoring/extractMethod/ExtractMethodHandler.java

@@ -18,6 +18,7 @@ package com.intellij.refactoring.extractMethod;
 import com.intellij.codeInsight.CodeInsightUtil;
 import com.intellij.codeInsight.daemon.impl.analysis.JavaHighlightUtil;
 import com.intellij.codeInsight.highlighting.HighlightManager;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.actionSystem.LangDataKeys;
@@ -56,7 +57,7 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
-public class ExtractMethodHandler implements RefactoringActionHandler {
+public class ExtractMethodHandler implements RefactoringActionHandler, ContextAwareActionHandler {
   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.extractMethod.ExtractMethodHandler");
 
   public static final String REFACTORING_NAME = RefactoringBundle.message("extract.method.title");
@@ -103,10 +104,21 @@ public class ExtractMethodHandler implements RefactoringActionHandler {
       }
     }
 
+    PsiDocumentManager.getInstance(project).commitAllDocuments();
+
+    callback.pass(getElements(project, editor, file));
+  }
+
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiElement[] elements = getElements(file.getProject(), editor, file);
+    return elements != null && elements.length > 0;
+  }
+
+  public static PsiElement[] getElements(@NotNull Project project, @NotNull Editor editor, @NotNull PsiFile file) {
     int startOffset = editor.getSelectionModel().getSelectionStart();
     int endOffset = editor.getSelectionModel().getSelectionEnd();
 
-    PsiDocumentManager.getInstance(project).commitAllDocuments();
 
     PsiElement[] elements;
     PsiExpression expr = CodeInsightUtil.findExpressionInRange(file, startOffset, endOffset);
@@ -125,7 +137,7 @@ public class ExtractMethodHandler implements RefactoringActionHandler {
         }
       }
     }
-    callback.pass(elements);
+    return elements;
   }
 
   private static void invokeOnElements(final Project project, final Editor editor, PsiFile file, PsiElement[] elements) {

java/java-impl/src/com/intellij/refactoring/extractMethodObject/ExtractMethodObjectHandler.java

@@ -20,6 +20,7 @@
  */
 package com.intellij.refactoring.extractMethodObject;
 
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.command.CommandProcessor;
@@ -42,7 +43,7 @@ import com.intellij.refactoring.util.duplicates.DuplicatesImpl;
 import com.intellij.util.IncorrectOperationException;
 import org.jetbrains.annotations.NotNull;
 
-public class ExtractMethodObjectHandler implements RefactoringActionHandler {
+public class ExtractMethodObjectHandler implements RefactoringActionHandler, ContextAwareActionHandler {
   private static final Logger LOG = Logger.getInstance("#" + ExtractMethodObjectHandler.class.getName());
 
   public void invoke(@NotNull final Project project, final Editor editor, final PsiFile file, final DataContext dataContext) {
@@ -53,6 +54,12 @@ public class ExtractMethodObjectHandler implements RefactoringActionHandler {
     });
   }
 
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiElement[] elements = ExtractMethodHandler.getElements(file.getProject(), editor, file);
+    return elements != null && elements.length > 0;
+  }
+
   private static void invokeOnElements(@NotNull final Project project,
                                        @NotNull final Editor editor,
                                        @NotNull PsiFile file,

java/java-impl/src/com/intellij/refactoring/introduceparameterobject/IntroduceParameterObjectHandler.java

@@ -16,10 +16,9 @@
 package com.intellij.refactoring.introduceparameterobject;
 
 import com.intellij.ide.util.SuperMethodWarningUtil;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.CommonDataKeys;
 import com.intellij.openapi.actionSystem.DataContext;
-import com.intellij.openapi.actionSystem.LangDataKeys;
-import com.intellij.openapi.actionSystem.PlatformDataKeys;
 import com.intellij.openapi.editor.CaretModel;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.ScrollType;
@@ -34,12 +33,33 @@ import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.refactoring.util.CommonRefactoringUtil;
 import org.jetbrains.annotations.NotNull;
 
-public class IntroduceParameterObjectHandler implements RefactoringActionHandler {
+public class IntroduceParameterObjectHandler implements RefactoringActionHandler, ContextAwareActionHandler {
   private static final String REFACTORING_NAME = RefactorJBundle.message("introduce.parameter.object");
 
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiMethod selectedMethod = getSelectedMethod(editor, file, dataContext);
+    if (selectedMethod != null) {
+      final PsiMethod[] deepestSuperMethods = selectedMethod.findDeepestSuperMethods();
+      return deepestSuperMethods.length > 0 || getErrorMessage(selectedMethod) == null;
+    }
+    return false;
+  }
+
   public void invoke(@NotNull Project project, Editor editor, PsiFile file, DataContext dataContext) {
     final ScrollingModel scrollingModel = editor.getScrollingModel();
     scrollingModel.scrollToCaret(ScrollType.MAKE_VISIBLE);
+    PsiMethod selectedMethod = getSelectedMethod(editor, file, dataContext);
+    if (selectedMethod == null) {
+      final String message = RefactorJBundle.message("cannot.perform.the.refactoring") +
+                             RefactorJBundle.message("the.caret.should.be.positioned.at.the.name.of.the.method.to.be.refactored");
+      CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
+      return;
+    }
+    invoke(project, selectedMethod, editor);
+  }
+
+  private static PsiMethod getSelectedMethod(Editor editor, PsiFile file, DataContext dataContext) {
     final PsiElement element = CommonDataKeys.PSI_ELEMENT.getData(dataContext);
     PsiMethod selectedMethod = null;
     if (element instanceof PsiMethod) {
@@ -63,13 +83,7 @@ public class IntroduceParameterObjectHandler implements RefactoringActionHandler
         }
       }
     }
-    if (selectedMethod == null) {
-      final String message = RefactorJBundle.message("cannot.perform.the.refactoring") +
-                             RefactorJBundle.message("the.caret.should.be.positioned.at.the.name.of.the.method.to.be.refactored");
-      CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
-      return;
-    }
-    invoke(project, selectedMethod, editor);
+    return selectedMethod;
   }
 
   public void invoke(@NotNull Project project, @NotNull PsiElement[] elements, DataContext dataContext) {
@@ -87,20 +101,26 @@ public class IntroduceParameterObjectHandler implements RefactoringActionHandler
   private static void invoke(final Project project, final PsiMethod selectedMethod, Editor editor) {
     PsiMethod newMethod = SuperMethodWarningUtil.checkSuperMethod(selectedMethod, RefactoringBundle.message("to.refactor"));
     if (newMethod == null) return;
-    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, newMethod)) return;
-
-    final PsiParameter[] parameters = newMethod.getParameterList().getParameters();
-    if (parameters.length == 0) {
-      final String message =
-        RefactorJBundle.message("cannot.perform.the.refactoring") + RefactorJBundle.message("method.selected.has.no.parameters");
+    final String message = getErrorMessage(newMethod);
+    if (message != null) {
       CommonRefactoringUtil.showErrorHint(project, editor, message, REFACTORING_NAME, HelpID.IntroduceParameterObject);
       return;
     }
-    if (newMethod instanceof PsiCompiledElement) {
-      CommonRefactoringUtil.showErrorHint(project, editor, RefactorJBundle.message("cannot.perform.the.refactoring") + RefactorJBundle.message(
-          "the.selected.method.cannot.be.wrapped.because.it.is.defined.in.a.non.project.class"), REFACTORING_NAME, HelpID.IntroduceParameterObject);
-      return;
-    }
+    if (!CommonRefactoringUtil.checkReadOnlyStatus(project, newMethod)) return;
+
     new IntroduceParameterObjectDialog(newMethod).show();
   }
+
+  private static String getErrorMessage(PsiMethod newMethod) {
+    final PsiParameter[] parameters = newMethod.getParameterList().getParameters();
+    if (parameters.length == 0) {
+     return RefactorJBundle.message("cannot.perform.the.refactoring") +
+            RefactorJBundle.message("method.selected.has.no.parameters");
+    }
+    if (newMethod instanceof PsiCompiledElement) {
+      return RefactorJBundle.message("cannot.perform.the.refactoring") +
+             RefactorJBundle.message("the.selected.method.cannot.be.wrapped.because.it.is.defined.in.a.non.project.class");
+    }
+    return null;
+  }
 }

java/java-impl/src/com/intellij/refactoring/util/duplicates/MethodDuplicatesHandler.java

@@ -20,6 +20,7 @@ import com.intellij.analysis.AnalysisUIOptions;
 import com.intellij.analysis.BaseAnalysisActionDialog;
 import com.intellij.history.LocalHistory;
 import com.intellij.history.LocalHistoryAction;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.DataContext;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.application.ApplicationNamesInfo;
@@ -55,10 +56,16 @@ import java.util.*;
 /**
  * @author dsl
  */
-public class MethodDuplicatesHandler implements RefactoringActionHandler {
+public class MethodDuplicatesHandler implements RefactoringActionHandler, ContextAwareActionHandler {
   public static final String REFACTORING_NAME = RefactoringBundle.message("replace.method.code.duplicates.title");
   private static final Logger LOG = Logger.getInstance("#" + MethodDuplicatesHandler.class.getName());
 
+  @Override
+  public boolean isAvailableForQuickList(@NotNull Editor editor, @NotNull PsiFile file, @NotNull DataContext dataContext) {
+    final PsiElement element = file.findElementAt(editor.getCaretModel().getOffset());
+    return getCannotRefactorMessage(PsiTreeUtil.getParentOfType(element, PsiMember.class)) == null;
+  }
+
   @Override
   public void invoke(@NotNull final Project project, final Editor editor, PsiFile file, DataContext dataContext) {
     final int offset = editor.getCaretModel().getOffset();

java/java-tests/testSrc/com/intellij/codeInsight/OverrideImplement15Test.java

@@ -20,6 +20,7 @@ import com.intellij.codeInsight.generation.OverrideImplementUtil;
 import com.intellij.codeInsight.generation.PsiMethodMember;
 import com.intellij.codeInsight.intention.impl.ImplementAbstractMethodHandler;
 import com.intellij.lang.java.JavaLanguage;
+import com.intellij.openapi.actionSystem.impl.SimpleDataContext;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
 import com.intellij.psi.codeStyle.CodeStyleSettings;
@@ -29,6 +30,7 @@ import com.intellij.psi.util.MethodSignature;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.psi.util.TypeConversionUtil;
 import com.intellij.testFramework.LightCodeInsightTestCase;
+import com.intellij.testFramework.MapDataContext;
 import com.intellij.util.FunctionUtil;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.Nullable;
@@ -134,7 +136,9 @@ public class OverrideImplement15Test extends LightCodeInsightTestCase {
     PsiElement context = getFile().findElementAt(offset);
     final PsiClass aClass = PsiTreeUtil.getParentOfType(context, PsiClass.class);
     assertTrue(aClass != null && aClass.isAnnotationType());
-    assertFalse(new JavaOverrideMethodsHandler().isValidFor(getEditor(), getFile()));
+    final JavaOverrideMethodsHandler handler = new JavaOverrideMethodsHandler();
+    assertTrue(handler.isValidFor(getEditor(), getFile()));
+    assertFalse(handler.isAvailableForQuickList(getEditor(), getFile(), new MapDataContext()));
   }
 
   private void doTest(boolean copyJavadoc) { doTest(copyJavadoc, null); }

java/openapi/src/com/intellij/codeInsight/generation/actions/BaseGenerateAction.java

@@ -18,8 +18,10 @@ package com.intellij.codeInsight.generation.actions;
 
 import com.intellij.codeInsight.CodeInsightActionHandler;
 import com.intellij.codeInsight.actions.CodeInsightAction;
+import com.intellij.lang.ContextAwareActionHandler;
 import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
@@ -34,6 +36,19 @@ public class BaseGenerateAction extends CodeInsightAction implements GenerateAct
     myHandler = handler;
   }
 
+  @Override
+  protected void update(@NotNull Presentation presentation,
+                        @NotNull Project project,
+                        @NotNull Editor editor,
+                        @NotNull PsiFile file,
+                        @NotNull DataContext dataContext,
+                        @Nullable String actionPlace) {
+    super.update(presentation, project, editor, file, dataContext, actionPlace);
+    if (myHandler instanceof ContextAwareActionHandler && presentation.isEnabled()) {
+      presentation.setEnabled(((ContextAwareActionHandler)myHandler).isAvailableForQuickList(editor, file, dataContext));
+    }
+  }
+
   @Nullable
   public AnAction createEditTemplateAction(DataContext dataContext) {
     return null;