Fix validation bug for composite filters.

Author: ehsannas

firebase-firestore/src/androidTest/java/com/google/firebase/firestore/QueryTest.java

@@ -364,6 +364,75 @@ public void testCanListenForQueryMetadataChanges() {
     listener2.remove();
   }
 
+  /*
+  // TODO(orquery): Re-enable this test once the `where` API is public.
+  @Test
+  public void testInvalidQueryFilters() {
+    CollectionReference collection = testCollection();
+    // Multiple inequalities, one of which is inside a nested composite filter.
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          Query query =
+              collection
+                  .where(
+                      or(
+                          and(equalTo("a", "b"), greaterThan("c", "d")),
+                          and(equalTo("e", "f"), equalTo("g", "h"))))
+                  .where(greaterThan("r", "s"));
+        });
+    // OrderBy and inequality on different fields. Inequality inside a nested composite filter.
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          Query query =
+              collection
+                  .where(
+                      or(
+                          and(equalTo("a", "b"), greaterThan("c", "d")),
+                          and(equalTo("e", "f"), equalTo("g", "h"))))
+                  .orderBy("r");
+        });
+    // Conflicting operations within a composite filter.
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          Query query =
+              collection.where(
+                  or(
+                      and(equalTo("a", "b"), inArray("c", Arrays.asList("d", "e"))),
+                      and(equalTo("e", "f"), notInArray("c", Arrays.asList("d", "e")))));
+        });
+    // Conflicting operations between a field filter and a composite filter.
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          Query query =
+              collection
+                  .where(
+                      or(
+                          and(equalTo("a", "b"), inArray("c", Arrays.asList("d", "e"))),
+                          and(equalTo("e", "f"), equalTo("g", "h"))))
+                  .where(notInArray("c", Arrays.asList("d", "e")));
+        });
+    // Conflicting operations between two composite filters.
+    assertThrows(
+        IllegalArgumentException.class,
+        () -> {
+          Query query =
+              collection
+                  .where(
+                      or(
+                          and(equalTo("a", "b"), inArray("c", Arrays.asList("d", "e"))),
+                          and(equalTo("e", "f"), equalTo("g", "h"))))
+                  .where(
+                      or(
+                          and(equalTo("a", "b"), notInArray("c", Arrays.asList("d", "e"))),
+                          and(equalTo("e", "f"), equalTo("g", "h"))));
+        });
+  }
+  */
+
   @Test
   public void testCanExplicitlySortByDocumentId() {
     Map<String, Map<String, Object>> testDocs =

firebase-firestore/src/main/java/com/google/firebase/firestore/Query.java

@@ -639,7 +639,7 @@ private void validateNewFilter(com.google.firebase.firestore.core.Filter filter)
     com.google.firebase.firestore.core.Query testQuery = query;
     for (FieldFilter subfilter : filter.getFlattenedFilters()) {
       validateNewFieldFilter(testQuery, subfilter);
-      testQuery = query.filter(subfilter);
+      testQuery = testQuery.filter(subfilter);
     }
   }
 
@@ -651,10 +651,9 @@ private void validateNewFilter(com.google.firebase.firestore.core.Filter filter)
   private Operator findFilterWithOperator(
       List<com.google.firebase.firestore.core.Filter> filters, List<Operator> operators) {
     for (com.google.firebase.firestore.core.Filter filter : filters) {
-      if (filter instanceof FieldFilter) {
-        Operator filterOp = ((FieldFilter) filter).getOperator();
-        if (operators.contains(filterOp)) {
-          return filterOp;
+      for (FieldFilter fieldFilter : filter.getFlattenedFilters()) {
+        if (operators.contains(fieldFilter.getOperator())) {
+          return fieldFilter.getOperator();
         }
       }
     }

firebase-firestore/src/main/java/com/google/firebase/firestore/core/CompositeFilter.java

@@ -28,6 +28,10 @@ public class CompositeFilter extends Filter {
   private final List<Filter> filters;
   private final Operator operator;
 
+  // Memoized list of all field filters that can be found by traversing the tree of filters
+  // contained in this composite filter.
+  private List<FieldFilter> flattenedFilters;
+
   public CompositeFilter(List<Filter> filters, Operator operator) {
     this.filters = filters;
     this.operator = operator;
@@ -44,12 +48,14 @@ public Operator getOperator() {
 
   @Override
   public List<FieldFilter> getFlattenedFilters() {
-    // TODO(orquery): memoize this result if this method is used more than once.
-    List<FieldFilter> result = new ArrayList<>();
+    if (flattenedFilters != null) {
+      return flattenedFilters;
+    }
+    flattenedFilters = new ArrayList<>();
     for (Filter subfilter : filters) {
-      result.addAll(subfilter.getFlattenedFilters());
+      flattenedFilters.addAll(subfilter.getFlattenedFilters());
     }
-    return result;
+    return flattenedFilters;
   }
 
   /**