invert boolean api: simplification following IDEA-CR-4608
authorAnna Kozlova <anna.kozlova@jetbrains.com>
Fri, 28 Aug 2015 11:58:37 +0000 (14:58 +0300)
committerAnna Kozlova <anna.kozlova@jetbrains.com>
Fri, 28 Aug 2015 15:33:17 +0000 (18:33 +0300)
java/java-impl/src/com/intellij/refactoring/invertBoolean/JavaInvertBooleanDelegate.java
platform/lang-impl/src/com/intellij/refactoring/invertBoolean/InvertBooleanDelegate.java
platform/lang-impl/src/com/intellij/refactoring/invertBoolean/InvertBooleanProcessor.java
python/src/com/jetbrains/python/refactoring/invertBoolean/PyInvertBooleanDelegate.java

index 281629dbe9c946592bc8d468f82e383f7c70ccb4..8b09aec1f86795fe67ddc9e6931f006cf35d5344 100644 (file)
@@ -108,13 +108,6 @@ public class JavaInvertBooleanDelegate extends InvertBooleanDelegate {
         elementsToInvert.add(refElement);
       }
     }
-    
-    if (namedElement instanceof PsiVariable) {
-      final PsiExpression initializer = ((PsiVariable)namedElement).getInitializer();
-      if (initializer != null) {
-        elementsToInvert.add(initializer);
-      }
-    }
   }
 
   public PsiElement getElementToInvert(PsiElement namedElement, PsiElement element) {
@@ -172,16 +165,21 @@ public class JavaInvertBooleanDelegate extends InvertBooleanDelegate {
   }
 
   @Override
-  public void invertDefaultElementInitializer(final PsiElement element) {
+  public void invertElementInitializer(final PsiElement element) {
     if (element instanceof PsiField && ((PsiField)element).getInitializer() == null) {
       ((PsiField)element).setInitializer(JavaPsiFacade.getElementFactory(element.getProject()).createExpressionFromText("true", element));
+    } else if (element instanceof PsiVariable) {
+      final PsiExpression initializer = ((PsiVariable)element).getInitializer();
+      if (initializer != null) {
+        replaceWithNegatedExpression(initializer);
+      }
     }
   }
 
   public void collectRefElements(final PsiElement element,
-                                 final Collection<PsiElement> elementsToInvert,
                                  final RenameProcessor renameProcessor,
-                                 @NotNull final String newName) {
+                                 @NotNull final String newName,
+                                 final Collection<PsiElement> elementsToInvert) {
     collectRefsToInvert(element, elementsToInvert);
 
     if (element instanceof PsiMethod) {
@@ -255,7 +253,7 @@ public class JavaInvertBooleanDelegate extends InvertBooleanDelegate {
   }
 
   @Override
-  public void findConflicts(MultiMap<PsiElement, String> conflicts, UsageInfo[] usageInfos) {
+  public void findConflicts(UsageInfo[] usageInfos, MultiMap<PsiElement, String> conflicts) {
     for (UsageInfo info : usageInfos) {
       final PsiElement element = info.getElement();
       if (element instanceof PsiMethodReferenceExpression) {
index f6cc85567dc36bf63f7a5f5b4834d81ff91f2549..5fdc05ff7175ad2a57374a5c49c12170cc6ef94f 100644 (file)
@@ -64,24 +64,24 @@ public abstract class InvertBooleanDelegate {
 
   /**
    * Eventually collect additional elements to rename, e.g. override methods
-   * and find expressions which need to be inverted
+   * and find expressions which need to be inverted, e.g. return method statements inside the method itself, etc
    * 
    * @param renameProcessor null if element is not named or name was not changed
    */
   public abstract void collectRefElements(PsiElement element,
-                                          Collection<PsiElement> elementsToInvert,
                                           @Nullable RenameProcessor renameProcessor,
-                                          @NotNull String newName);
+                                          @NotNull String newName,
+                                          Collection<PsiElement> elementsToInvert);
 
   /**
-   * Invoked from {@link #getForeignElementToInvert(com.intellij.psi.PsiElement, com.intellij.psi.PsiElement, com.intellij.lang.Language)};
+   * Invoked from {@link #getForeignElementToInvert(PsiElement, PsiElement, Language)};
    * should be used to reject usages for elements from foreign language to be refactored
    * @return null, if reference should not be reverted
    */
   public abstract PsiElement getElementToInvert(PsiElement namedElement, PsiElement expression);
 
   /**
-   * Should be called from {@link #collectRefElements(PsiElement, Collection, RenameProcessor, String)}
+   * Should be called from {@link #collectRefElements(PsiElement, RenameProcessor, String, Collection)}
    * to process found usages in foreign languages
    */
   protected static PsiElement getForeignElementToInvert(PsiElement namedElement,
@@ -98,18 +98,18 @@ public abstract class InvertBooleanDelegate {
 
   /**
    * Replace expression with created negation
-   * @param expression to be inverted, found in {@link #collectRefElements(PsiElement, Collection, RenameProcessor, String)}
+   * @param expression to be inverted, found in {@link #collectRefElements(PsiElement, RenameProcessor, String, Collection)}
    */
   public abstract void replaceWithNegatedExpression(PsiElement expression);
 
   /**
-   * Initialize variable with negated default initializer when default was initially omitted
+   * Initialize variable with negated default initializer when default was initially omitted,
+   * or invert variable initializer
    */
-  public void invertDefaultElementInitializer(PsiElement var) {}
+  public abstract void invertElementInitializer(PsiElement var);
   
   /**
    * Detect usages which can't be inverted
    */
-  public void findConflicts(MultiMap<PsiElement, String> conflicts,
-                            UsageInfo[] usageInfos) {}
+  public void findConflicts(UsageInfo[] usageInfos, MultiMap<PsiElement, String> conflicts) {}
 }
index 1950f3fa015e26947ec9386a43c98ecbabe47441..d2814b92a79ea863459ef24ec2b9cb6c94f4f6d9 100644 (file)
@@ -70,7 +70,7 @@ public class InvertBooleanProcessor extends BaseRefactoringProcessor {
   @Override
   protected boolean preprocessUsages(@NotNull Ref<UsageInfo[]> refUsages) {
     final MultiMap<PsiElement, String> conflicts = new MultiMap<PsiElement, String>();
-    myDelegate.findConflicts(conflicts, refUsages.get());
+    myDelegate.findConflicts(refUsages.get(), conflicts);
     
     if (!conflicts.isEmpty())  {
       return showConflicts(conflicts, null);
@@ -89,7 +89,7 @@ public class InvertBooleanProcessor extends BaseRefactoringProcessor {
     final List<SmartPsiElementPointer> toInvert = new ArrayList<SmartPsiElementPointer>();
 
     final LinkedHashSet<PsiElement> elementsToInvert = new LinkedHashSet<PsiElement>();
-    myDelegate.collectRefElements(myElement, elementsToInvert, myRenameProcessor, myNewName);
+    myDelegate.collectRefElements(myElement, myRenameProcessor, myNewName, elementsToInvert);
     for (PsiElement element : elementsToInvert) {
       toInvert.add(mySmartPointerManager.createSmartPsiElementPointer(element));
     }
@@ -170,7 +170,7 @@ public class InvertBooleanProcessor extends BaseRefactoringProcessor {
       }
     }
 
-    myDelegate.invertDefaultElementInitializer(myElement);
+    myDelegate.invertElementInitializer(myElement);
   }
 
   @Override
index 3222cb567564cb5f752398eb0882990ac885b724..4e79f9f2688a4146222928060b12a650fbc637d9 100644 (file)
@@ -86,9 +86,9 @@ public class PyInvertBooleanDelegate extends InvertBooleanDelegate {
 
   @Override
   public void collectRefElements(PsiElement psiElement,
-                                 Collection<PsiElement> elementsToInvert,
                                  @Nullable RenameProcessor renameProcessor,
-                                 @NotNull String newName) {
+                                 @NotNull String newName,
+                                 Collection<PsiElement> elementsToInvert) {
     final Collection<PsiReference> refs = ReferencesSearch.search(psiElement).findAll();
 
     for (PsiReference ref : refs) {
@@ -101,13 +101,6 @@ public class PyInvertBooleanDelegate extends InvertBooleanDelegate {
         ContainerUtil.addIfNotNull(elementsToInvert, getForeignElementToInvert(psiElement, refElement, PythonLanguage.getInstance()));
       }
     }
-    
-    if (psiElement instanceof PyNamedParameter) {
-      PyExpression defaultValue = ((PyNamedParameter)psiElement).getDefaultValue();
-      if (defaultValue != null) {
-        elementsToInvert.add(defaultValue);
-      }
-    }
   }
 
   public PsiElement getElementToInvert(PsiElement namedElement, PsiElement element) {
@@ -129,6 +122,16 @@ public class PyInvertBooleanDelegate extends InvertBooleanDelegate {
     return null;
   }
 
+  @Override
+  public void invertElementInitializer(PsiElement psiElement) {
+    if (psiElement instanceof PyNamedParameter) {
+      final PyExpression defaultValue = ((PyNamedParameter)psiElement).getDefaultValue();
+      if (defaultValue != null) {
+        replaceWithNegatedExpression(defaultValue);
+      }
+    }
+  }
+
   @Override
   public void replaceWithNegatedExpression(PsiElement expression) {
     if (expression != null && PsiTreeUtil.getParentOfType(expression, PyImportStatementBase.class, false) == null) {