FilteredTraverser: a more consistent naming: regard/forceDisregard

SyntaxTraverser: move parents() to api

diff --git a/platform/core-api/src/com/intellij/psi/SyntaxTraverser.java b/platform/core-api/src/com/intellij/psi/SyntaxTraverser.java
index ab1cf6060cb7c8127b01a7671274b86923f6a8b5..6e7a1cca9f474154e6386efa742a13b878a619ab 100644 (file)
--- a/platform/core-api/src/com/intellij/psi/SyntaxTraverser.java
+++ b/platform/core-api/src/com/intellij/psi/SyntaxTraverser.java
@@ -106,22 +106,22 @@ public class SyntaxTraverser<T> extends FilteredTraverserBase<T, SyntaxTraverser
   }
 
   private UserDataHolder getUserDataHolder() {
-    return api instanceof LighterASTApi ? ((LighterASTApi)api).builder : (UserDataHolder)parents(getRoot()).last();
+    return api instanceof LighterASTApi ? ((LighterASTApi)api).builder : (UserDataHolder)api.parents(getRoot()).last();
   }
 
   @NotNull
-  public SyntaxTraverser<T> expandTypes(@NotNull Condition<? super IElementType> condition) {
-    return super.expand(compose(api.TO_TYPE(), condition));
+  public SyntaxTraverser<T> expandTypes(@NotNull Condition<? super IElementType> c) {
+    return super.expand(compose(api.TO_TYPE(), c));
   }
 
   @NotNull
-  public SyntaxTraverser<T> filterTypes(@NotNull Condition<? super IElementType> condition) {
-    return super.filter(compose(api.TO_TYPE(), condition));
+  public SyntaxTraverser<T> filterTypes(@NotNull Condition<? super IElementType> c) {
+    return super.filter(compose(api.TO_TYPE(), c));
   }
 
   @NotNull
-  public SyntaxTraverser<T> forceExpandAndSkipTypes(@NotNull Condition<? super IElementType> condition) {
-    return super.forceExpandAndSkip(compose(api.TO_TYPE(), condition));
+  public SyntaxTraverser<T> forceDisregardTypes(@NotNull Condition<? super IElementType> c) {
+    return super.forceDisregard(compose(api.TO_TYPE(), c));
   }
 
   @Nullable
@@ -135,16 +135,6 @@ public class SyntaxTraverser<T> extends FilteredTraverserBase<T, SyntaxTraverser
     return null;
   }
 
-  @NotNull
-  public JBIterable<T> parents(@Nullable final T element) {
-    return JBIterable.generate(element, new Function<T, T>() {
-      @Override
-      public T fun(T t) {
-        return api.parent(t);
-      }
-    });
-  }
-
   public abstract static class Api<T> implements Function<T, Iterable<? extends T>> {
     @NotNull
     public abstract IElementType typeOf(@NotNull T node);
@@ -166,6 +156,16 @@ public class SyntaxTraverser<T> extends FilteredTraverserBase<T, SyntaxTraverser
       return children(t);
     }
 
+    @NotNull
+    public JBIterable<T> parents(@Nullable final T element) {
+      return JBIterable.generate(element, new Function<T, T>() {
+        @Override
+        public T fun(T t) {
+          return parent(t);
+        }
+      });
+    }
+
     @NotNull
     public Function<T, IElementType> TO_TYPE() {
       return new Function<T, IElementType>() {

diff --git a/platform/platform-tests/testSrc/com/intellij/util/containers/TreeTraverserTest.java b/platform/platform-tests/testSrc/com/intellij/util/containers/TreeTraverserTest.java
index 48e0a4e0d04b09feab1279e7aa0e9a57557f2c4a..ef8d1df269387f80441652fdfcac0cfa9c520b95 100644 (file)
--- a/platform/platform-tests/testSrc/com/intellij/util/containers/TreeTraverserTest.java
+++ b/platform/platform-tests/testSrc/com/intellij/util/containers/TreeTraverserTest.java
@@ -16,7 +16,6 @@
 package com.intellij.util.containers;
 
 import com.intellij.openapi.util.Condition;
-import com.intellij.openapi.util.Conditions;
 import com.intellij.util.Consumer;
 import com.intellij.util.Function;
 import com.intellij.util.Functions;
@@ -26,6 +25,8 @@ import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
+import static com.intellij.openapi.util.Conditions.not;
+
 /**
  * @author gregsh
  */
@@ -297,22 +298,22 @@ public class TreeTraverserTest extends TestCase {
 
   public void testSkipExpandedDfs() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(2, 8, 9, 10, 4), t.withRoot(1).expand(IS_ODD).leavesDfsTraversal().toList());
+    assertEquals(Arrays.asList(2, 8, 9, 10, 4), t.withRoot(1).expand(IS_ODD).traverse(TreeTraversal.LEAVES_DFS).toList());
   }
 
   public void testRangeChildrenLeavesDfs() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), t.withRoot(1).children(Conditions.not(inRange(7, 10))).leavesDfsTraversal().toList());
+    assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), t.withRoot(1).regard(not(inRange(7, 10))).traverse(TreeTraversal.LEAVES_DFS).toList());
   }
 
   public void testRangeChildrenLeavesBfs() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), t.withRoot(1).children(Conditions.not(inRange(7, 10))).leavesDfsTraversal().toList());
+    assertEquals(Arrays.asList(5, 6, 3, 11, 12, 13), t.withRoot(1).regard(not(inRange(7, 10))).traverse(TreeTraversal.LEAVES_DFS).toList());
   }
 
   public void testSkipExpandedBfs() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(2, 4, 8, 9, 10), t.withRoot(1).expand(IS_ODD).leavesBfsTraversal().toList());
+    assertEquals(Arrays.asList(2, 4, 8, 9, 10), t.withRoot(1).expand(IS_ODD).traverse(TreeTraversal.LEAVES_BFS).toList());
   }
 
   public void testExpandSkipFilterReset() {
@@ -323,22 +324,22 @@ public class TreeTraverserTest extends TestCase {
 
   public void testForceExlcudeReset() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(1, 2, 6, 4, 12), t.withRoot(1).forceExclude(IS_ODD).reset().toList());
+    assertEquals(Arrays.asList(1, 2, 6, 4, 12), t.withRoot(1).forceIgnore(IS_ODD).reset().toList());
   }
 
   public void testForceSkipReset() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(1, 2, 6, 8, 10, 4, 12), t.withRoot(1).forceExpandAndSkip(IS_ODD).reset().toList());
+    assertEquals(Arrays.asList(1, 2, 6, 8, 10, 4, 12), t.withRoot(1).forceDisregard(IS_ODD).reset().toList());
   }
 
   public void testForceSkipLeavesDfs() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(6, 8, 10, 12), t.withRoot(1).forceExpandAndSkip(IS_ODD).leavesDfsTraversal().toList());
+    assertEquals(Arrays.asList(6, 8, 10, 12), t.withRoot(1).forceDisregard(IS_ODD).traverse(TreeTraversal.LEAVES_DFS).toList());
   }
 
   public void testFilterChildren() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    assertEquals(Arrays.asList(1, 5, 7, 3, 9, 11, 13), t.withRoot(1).children(IS_ODD).toList());
+    assertEquals(Arrays.asList(1, 5, 7, 3, 9, 11, 13), t.withRoot(1).regard(IS_ODD).toList());
   }
 
   public void testEndlessGraph() {
@@ -367,7 +368,7 @@ public class TreeTraverserTest extends TestCase {
 
   public void testEdgeFilter() {
     FilteredTraverser<Integer> t = filteredTraverser();
-    JBIterable<Integer> it = t.children(new FilteredTraverserBase.EdgeFilter<Integer>() {
+    JBIterable<Integer> it = t.regard(new FilteredTraverserBase.EdgeFilter<Integer>() {
       @Override
       public boolean value(Integer integer) {
         return (integer / curParent) % 2 == 0;
@@ -389,10 +390,10 @@ public class TreeTraverserTest extends TestCase {
       }
     }
 
-    JBIterable<Integer> it = t.children(new F(true)).withRoot(1).traverse();
+    JBIterable<Integer> it = t.regard(new F(true)).withRoot(1).traverse();
     assertEquals(Arrays.asList(1, 5, 6, 7, 3, 9, 10, 4, 12, 13), it.toList());
     assertEquals(Arrays.asList(1, 5, 6, 7, 3, 9, 10, 4, 12, 13), it.toList());
-    assertEquals(it.toList(), t.forceExpandAndSkip(new F(false)).withRoot(1).reset().traverse().toList());
+    assertEquals(it.toList(), t.forceDisregard(new F(false)).withRoot(1).reset().traverse().toList());
   }
 
 }

diff --git a/platform/util/src/com/intellij/util/containers/FilteredTraverserBase.java b/platform/util/src/com/intellij/util/containers/FilteredTraverserBase.java
index 6b721e211ecba63720cccbedf55bf5f8cdf2e5c6..0c5726bf661d8ec5cf803ad4b041fa4d92ddc41c 100644 (file)
--- a/platform/util/src/com/intellij/util/containers/FilteredTraverserBase.java
+++ b/platform/util/src/com/intellij/util/containers/FilteredTraverserBase.java
@@ -63,7 +63,7 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
         return children(t);
       }
     };
-    return traversal.traversal(getRoots(), adjusted).filter(meta.resultFilter.AND());
+    return traversal.traversal(getRoots(), adjusted).filter(meta.filter.AND());
   }
 
   @NotNull
@@ -81,11 +81,6 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
     return traverse(TreeTraversal.POST_ORDER_DFS);
   }
 
-  @NotNull
-  public final JBIterable<T> leavesDfsTraversal() {
-    return traverse(TreeTraversal.LEAVES_DFS);
-  }
-
   @NotNull
   public final JBIterable<T> bfsTraversal() {
     return traverse(TreeTraversal.PLAIN_BFS);
@@ -96,11 +91,6 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
     return traverse(TreeTraversal.TRACING_BFS);
   }
 
-  @NotNull
-  public final JBIterable<T> leavesBfsTraversal() {
-    return traverse(TreeTraversal.LEAVES_BFS);
-  }
-
   @NotNull
   public Self reset() {
     return newInstance(meta.reset());
@@ -122,28 +112,28 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
   }
 
   @NotNull
-  public Self expand(@NotNull Condition<? super T> filter) {
-    return newInstance(meta.expand(filter));
+  public Self expand(@NotNull Condition<? super T> c) {
+    return newInstance(meta.expand(c));
   }
 
   @NotNull
-  public Self expandAndFilter(Condition<? super T> filter) {
-    return newInstance(meta.expand(filter).filter(filter));
+  public Self regard(@NotNull Condition<? super T> c) {
+    return newInstance(meta.regard(c));
   }
 
   @NotNull
-  public Self expandAndSkip(Condition<? super T> filter) {
-    return newInstance(meta.expand(filter).filter(not(filter)));
+  public Self expandAndFilter(Condition<? super T> c) {
+    return newInstance(meta.expand(c).filter(c));
   }
 
   @NotNull
-  public Self children(@NotNull Condition<? super T> filter) {
-    return newInstance(meta.children(filter));
+  public Self expandAndSkip(Condition<? super T> c) {
+    return newInstance(meta.expand(c).filter(not(c)));
   }
 
   @NotNull
-  public Self filter(@NotNull Condition<? super T> filter) {
-    return newInstance(meta.filter(filter));
+  public Self filter(@NotNull Condition<? super T> c) {
+    return newInstance(meta.filter(c));
   }
 
   @NotNull
@@ -152,13 +142,13 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
   }
 
   @NotNull
-  public Self forceExclude(@NotNull Condition<? super T> filter) {
-    return newInstance(meta.forceExclude(filter));
+  public Self forceIgnore(@NotNull Condition<? super T> c) {
+    return newInstance(meta.forceIgnore(c));
   }
 
   @NotNull
-  public Self forceExpandAndSkip(@NotNull Condition<? super T> filter) {
-    return newInstance(meta.forceExpandAndSkip(filter));
+  public Self forceDisregard(@NotNull Condition<? super T> c) {
+    return newInstance(meta.forceDisregard(c));
   }
 
   @NotNull
@@ -166,8 +156,8 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
     if (isAlwaysLeaf(node)) {
       return JBIterable.empty();
     }
-    else if (meta.childFilter.next == null && meta.forceExpandAndSkip.next == null) {
-      return JBIterable.from(tree.fun(node)).filter(not(meta.forceExclude.OR()));
+    else if (meta.regard.next == null && meta.forceDisregard.next == null) {
+      return JBIterable.from(tree.fun(node)).filter(not(meta.forceIgnore.OR()));
     }
     else {
       // traverse subtree to select accepted children
@@ -176,7 +166,7 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
   }
 
   protected boolean isAlwaysLeaf(@NotNull T node) {
-    return !meta.expandFilter.valueAnd(node);
+    return !meta.expand.valueAnd(node);
   }
 
   @NotNull
@@ -199,60 +189,59 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
   protected static class Meta<T> {
     final Iterable<? extends T> roots;
     final TreeTraversal traversal;
-    final Cond<T> expandFilter;
-    final Cond<T> childFilter;
-    final Cond<T> resultFilter;
+    final Cond<T> expand;
+    final Cond<T> regard;
+    final Cond<T> filter;
 
-    final Cond<T> forceExclude;
-    final Cond<T> forceExpandAndSkip;
+    final Cond<T> forceIgnore;
+    final Cond<T> forceDisregard;
 
     public Meta(@NotNull Iterable<? extends T> roots,
                 @NotNull TreeTraversal traversal,
-                @NotNull Cond<T> expandFilter,
-                @NotNull Cond<T> childFilter,
-                @NotNull Cond<T> resultFilter,
-                @NotNull Cond<T> forceExclude,
-                @NotNull Cond<T> forceExpandAndSkip) {
+                @NotNull Cond<T> expand,
+                @NotNull Cond<T> regard,
+                @NotNull Cond<T> filter,
+                @NotNull Cond<T> forceIgnore,
+                @NotNull Cond<T> forceDisregard) {
       this.roots = roots;
       this.traversal = traversal;
-      this.expandFilter = expandFilter;
-      this.childFilter = childFilter;
-      this.resultFilter = resultFilter;
-      this.forceExclude = forceExclude;
-      this.forceExpandAndSkip = forceExpandAndSkip;
+      this.expand = expand;
+      this.regard = regard;
+      this.filter = filter;
+      this.forceIgnore = forceIgnore;
+      this.forceDisregard = forceDisregard;
     }
 
     public Meta<T> reset() {
-      return new Meta<T>(roots, TreeTraversal.PRE_ORDER_DFS, Cond.TRUE, Cond.TRUE, Cond.TRUE, forceExclude, forceExpandAndSkip);
+      return new Meta<T>(roots, TreeTraversal.PRE_ORDER_DFS, Cond.TRUE, Cond.TRUE, Cond.TRUE, forceIgnore, forceDisregard);
     }
 
     public Meta<T> withRoots(@NotNull Iterable<? extends T> roots) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter, resultFilter, forceExclude, forceExpandAndSkip);
+      return new Meta<T>(roots, traversal, expand, regard, filter, forceIgnore, forceDisregard);
     }
 
     public Meta<T> withTraversal(TreeTraversal traversal) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter, resultFilter, forceExclude, forceExpandAndSkip);
+      return new Meta<T>(roots, traversal, expand, regard, filter, forceIgnore, forceDisregard);
     }
 
-    public Meta<T> expand(@NotNull Condition<? super T> filter) {
-      return new Meta<T>(roots, traversal, expandFilter.append(filter), childFilter, resultFilter, forceExclude, forceExpandAndSkip);
+    public Meta<T> expand(@NotNull Condition<? super T> c) {
+      return new Meta<T>(roots, traversal, expand.append(c), regard, this.filter, forceIgnore, forceDisregard);
     }
 
-    public Meta<T> children(@NotNull Condition<? super T> filter) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter.append(filter), resultFilter, forceExclude, forceExpandAndSkip);
+    public Meta<T> regard(@NotNull Condition<? super T> c) {
+      return new Meta<T>(roots, traversal, expand, regard.append(c), this.filter, forceIgnore, forceDisregard);
     }
 
-    public Meta<T> filter(@NotNull Condition<? super T> filter) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter, resultFilter.append(filter), forceExclude, forceExpandAndSkip);
+    public Meta<T> filter(@NotNull Condition<? super T> c) {
+      return new Meta<T>(roots, traversal, expand, regard, this.filter.append(c), forceIgnore, forceDisregard);
     }
 
-    // forceExclude and forceSkip filter is always accumulated
-    public Meta<T> forceExclude(Condition<? super T> filter) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter, resultFilter, forceExclude.append(filter), forceExpandAndSkip);
+    public Meta<T> forceIgnore(Condition<? super T> c) {
+      return new Meta<T>(roots, traversal, expand, regard, this.filter, forceIgnore.append(c), forceDisregard);
     }
 
-    public Meta<T> forceExpandAndSkip(Condition<? super T> filter) {
-      return new Meta<T>(roots, traversal, expandFilter, childFilter, resultFilter, forceExclude, forceExpandAndSkip.append(filter));
+    public Meta<T> forceDisregard(Condition<? super T> c) {
+      return new Meta<T>(roots, traversal, expand, regard, this.filter, forceIgnore, forceDisregard.append(c));
     }
 
     Function.Mono<TreeTraversal.GuidedIt<T>> createChildrenGuide(final T parent) {
@@ -274,7 +263,7 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
 
     private void doPerformChildrenGuidance(TreeTraversal.GuidedIt<T> it, Condition<? super T> expand) {
       if (it.curChild == null) return;
-      if (forceExclude.valueOr(it.curChild)) return;
+      if (forceIgnore.valueOr(it.curChild)) return;
       if (it.curParent == null || expand.value(it.curChild)) {
         it.queueNext(it.curChild);
       }
@@ -284,11 +273,11 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
     }
 
     private Condition<? super T> buildExpandConditionForChildren(T parent) {
-      // implement: or2(forceExpandAndSkip, not(childFilter));
-      // and handle JBIterable.StatefulTransform and EdgeFilter conditions
+      // implements: or2(forceExpandAndSkip, not(childFilter));
+      // and handles JBIterable.StatefulTransform and EdgeFilter conditions
       Cond copy = null;
       boolean invert = true;
-      Cond c = childFilter;
+      Cond c = regard;
       while (c != null) {
         Condition impl = JBIterable.Stateful.copy(c.impl);
         if (impl != (invert ? Condition.TRUE : Condition.FALSE)) {
@@ -298,7 +287,7 @@ public abstract class FilteredTraverserBase<T, Self extends FilteredTraverserBas
           }
         }
         if (c.next == null) {
-          c = invert ? forceExpandAndSkip : null;
+          c = invert ? forceDisregard : null;
           invert = false;
         }
         else {