1 files changed, 54 insertions, 54 deletions

diff --git a/src/main/java/com/google/devtools/build/lib/query2/engine/QueryUtil.java b/src/main/java/com/google/devtools/build/lib/query2/engine/QueryUtil.java
index afb4192128..2d7be2ed74 100644
--- a/src/main/java/com/google/devtools/build/lib/query2/engine/QueryUtil.java
+++ b/src/main/java/com/google/devtools/build/lib/query2/engine/QueryUtil.java
@@ -13,13 +13,11 @@
 // limitations under the License.
 package com.google.devtools.build.lib.query2.engine;
 
+
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.MapMaker;
-import com.google.common.collect.Sets;
 import com.google.devtools.build.lib.collect.CompactHashSet;
-import com.google.devtools.build.lib.query2.engine.QueryEnvironment.QueryTaskCallable;
-import com.google.devtools.build.lib.query2.engine.QueryEnvironment.QueryTaskFuture;
 import java.util.Collections;
 import java.util.Set;
 
@@ -30,18 +28,17 @@ public final class QueryUtil {
 
   /** A {@link Callback} that can aggregate all the partial results into one set. */
   public interface AggregateAllCallback<T> extends Callback<T> {
-    /** Returns a (mutable) set of all the results. */
     Set<T> getResult();
   }
 
-  /** A {@link OutputFormatterCallback} that is also a {@link AggregateAllCallback}. */
+  /** A {@link OutputFormatterCallback} that can aggregate all the partial results into one set. */
   public abstract static class AggregateAllOutputFormatterCallback<T>
-      extends ThreadSafeOutputFormatterCallback<T> implements AggregateAllCallback<T>  {
+      extends OutputFormatterCallback<T> implements AggregateAllCallback<T>  {
   }
 
   private static class AggregateAllOutputFormatterCallbackImpl<T>
       extends AggregateAllOutputFormatterCallback<T> {
-    private final Set<T> result = Sets.newConcurrentHashSet();
+    private final Set<T> result = CompactHashSet.create();
 
     @Override
     public final void processOutput(Iterable<T> partialResult) {
@@ -54,64 +51,65 @@ public final class QueryUtil {
     }
   }
 
-  private static class OrderedAggregateAllOutputFormatterCallbackImpl<T>
-      extends AggregateAllOutputFormatterCallback<T> {
-    private final Set<T> result = CompactHashSet.create();
-
-    @Override
-    public final synchronized void processOutput(Iterable<T> partialResult) {
-      Iterables.addAll(result, partialResult);
-    }
-
-    @Override
-    public synchronized Set<T> getResult() {
-      return result;
-    }
-  }
-
   /**
-   * Returns a fresh {@link AggregateAllOutputFormatterCallback} instance whose
-   * {@link AggregateAllCallback#getResult} returns all the elements of the result in the order they
-   * were processed.
+   * Returns a fresh {@link AggregateAllOutputFormatterCallback} that can aggregate all the partial
+   * results into one set.
+   *
+   * <p>Intended to be used by top-level evaluation of {@link QueryExpression}s; contrast with
+   * {@link #newAggregateAllCallback}.
    */
   public static <T> AggregateAllOutputFormatterCallback<T>
-      newOrderedAggregateAllOutputFormatterCallback() {
-    return new OrderedAggregateAllOutputFormatterCallbackImpl<>();
+      newAggregateAllOutputFormatterCallback() {
+    return new AggregateAllOutputFormatterCallbackImpl<>();
   }
 
-  /** Returns a fresh {@link AggregateAllCallback} instance. */
+  /**
+   * Returns a fresh {@link AggregateAllCallback}.
+   *
+   * <p>Intended to be used by {@link QueryExpression} implementations; contrast with
+   * {@link #newAggregateAllOutputFormatterCallback}.
+   */
   public static <T> AggregateAllCallback<T> newAggregateAllCallback() {
     return new AggregateAllOutputFormatterCallbackImpl<>();
   }
 
   /**
-   * Returns a {@link QueryTaskFuture} representing the evaluation of {@code expr} as a (mutable)
-   * {@link Set} comprised of all the results.
+   * Fully evaluate a {@code QueryExpression} and return a set with all the results.
    *
    * <p>Should only be used by QueryExpressions when it is the only way of achieving correctness.
    */
-  public static <T> QueryTaskFuture<Set<T>> evalAll(
-      QueryEnvironment<T> env, VariableContext<T> context, QueryExpression expr) {
-    final AggregateAllCallback<T> callback = newAggregateAllCallback();
-    return env.whenSucceedsCall(
-        env.eval(expr, context, callback),
-        new QueryTaskCallable<Set<T>>() {
-          @Override
-          public Set<T> call() {
-            return callback.getResult();
-          }
-        });
+  public static <T> Set<T> evalAll(
+      QueryEnvironment<T> env, VariableContext<T> context, QueryExpression expr)
+          throws QueryException, InterruptedException {
+    AggregateAllCallback<T> callback = newAggregateAllCallback();
+    env.eval(expr, context, callback);
+    return callback.getResult();
   }
 
   /** A trivial {@link Uniquifier} base class. */
-  public abstract static class AbstractUniquifier<T, K> implements Uniquifier<T> {
-    private final Set<K> alreadySeen;
+  public abstract static class AbstractUniquifier<T, K>
+      extends AbstractUniquifierBase<T, K> {
+    private final CompactHashSet<K> alreadySeen = CompactHashSet.create();
 
-    protected AbstractUniquifier() {
-      this(/*concurrencyLevel=*/ 1);
+    @Override
+    public final boolean unique(T element) {
+      return alreadySeen.add(extractKey(element));
     }
 
-    protected AbstractUniquifier(int concurrencyLevel) {
+    /**
+     * Extracts an unique key that can be used to dedupe the given {@code element}.
+     *
+     * <p>Depending on the choice of {@code K}, this enables potential memory optimizations.
+     */
+    protected abstract K extractKey(T element);
+  }
+
+  /** A trivial {@link ThreadSafeUniquifier} base class. */
+  public abstract static class AbstractThreadSafeUniquifier<T, K>
+      extends AbstractUniquifierBase<T, K> implements ThreadSafeUniquifier<T> {
+    private final Set<K> alreadySeen;
+
+    protected AbstractThreadSafeUniquifier(int concurrencyLevel) {
       this.alreadySeen = Collections.newSetFromMap(
           new MapMaker().concurrencyLevel(concurrencyLevel).<K, Boolean>makeMap());
     }
@@ -121,6 +119,15 @@ public final class QueryUtil {
       return alreadySeen.add(extractKey(element));
     }
 
+    /**
+     * Extracts an unique key that can be used to dedupe the given {@code element}.
+     *
+     * <p>Depending on the choice of {@code K}, this enables potential memory optimizations.
+     */
+    protected abstract K extractKey(T element);
+  }
+
+  private abstract static class AbstractUniquifierBase<T, K> implements Uniquifier<T> {
     @Override
     public final ImmutableList<T> unique(Iterable<T> newElements) {
       ImmutableList.Builder<T> result = ImmutableList.builder();
@@ -131,12 +138,5 @@ public final class QueryUtil {
       }
       return result.build();
     }
-
-    /**
-     * Extracts an unique key that can be used to dedupe the given {@code element}.
-     *
-     * <p>Depending on the choice of {@code K}, this enables potential memory optimizations.
-     */
-    protected abstract K extractKey(T element);
   }
-}
\ No newline at end of file
+}