lucene 4: fixed facets and filtering aliases

I am not completely sure about this one, but it reduces the number of failing tests from 98 to 31 so I am going to check it in. Please, review and fix it, if there is a better solution.

Because of change in Lucene 4.0, ContextIndexSearcher was bypassed and elasticsearch filters and collectors were ignored.

In lucene 3.6 the stack of Searcher search calls looked like this:
search(Query query, int n)
search(Query query, Filter filter, int n)
search(Weight weight, Filter filter, int nDocs)
search(Weight weight, Filter filter, ScoreDoc after, int nDocs)
search(Weight weight, Filter filter, Collector collector) <-- this is ContextIndexSearcher was injecting combined filter and collector
search(Weight weight, Filter filter, Collector collector)

In Lucene 4.0 the stack looks like this:
search(Query query, int n)
search(Query query, Filter filter, int n) <-- here lucene wraps Query and Filter into Weight
search(Weight weight, ScoreDoc after, int nDocs)
search(List<AtomicReaderContext> leaves, Weight weight, ScoreDoc after, int nDocs)
search(List<AtomicReaderContext> leaves, Weight weight, Collector collector)
...

In other words, when we have Filter, we don't have a Collector yet, but when we have Collector, Filter is already wrapped inside Weight.  The only way to fix for the problem that I could think of is by introducing two injection points: one for Filters and another one for Collectors:

search(Query query, int n)
search(Query query, Filter filter, int n) <-- here combined Filters are injected
search(Weight weight, ScoreDoc after, int nDocs)
search(List<AtomicReaderContext> leaves, Weight weight, ScoreDoc after, int nDocs)
search(List<AtomicReaderContext> leaves, Weight weight, Collector collector) <-- here Collectors are injected

Similar problem existed for count(), so I had to override search(Query query, Collector results) as well.

src/main/java/org/elasticsearch/search/internal/ContextIndexSearcher.java

@@ -133,8 +133,37 @@ public class ContextIndexSearcher extends IndexSearcher {
         return super.createNormalizedWeight(query);
     }
 
+    private Filter combinedFilter(Filter filter) {
+        Filter combinedFilter;
+        if (filter == null) {
+            combinedFilter = searchContext.aliasFilter();
+        } else {
+            if (searchContext.aliasFilter() != null) {
+                combinedFilter = new AndFilter(ImmutableList.of(filter, searchContext.aliasFilter()));
+            } else {
+                combinedFilter = filter;
+            }
+        }
+        return combinedFilter;
+    }
+
     @Override
-    public void search(Query query, Filter filter, Collector collector) throws IOException {
+    public void search(Query query, Collector results) throws IOException {
+        Filter filter = combinedFilter(null);
+        if (filter != null) {
+            super.search(wrapFilter(query, filter), results);
+        } else {
+            super.search(query, results);
+        }
+    }
+
+    @Override
+    public TopDocs search(Query query, Filter filter, int n) throws IOException {
+        return super.search(query, combinedFilter(filter), n);
+    }
+
+    @Override
+    public void search(List<AtomicReaderContext> leaves, Weight weight, Collector collector) throws IOException {
         if (searchContext.parsedFilter() != null && Scopes.MAIN.equals(processingScope)) {
             // this will only get applied to the actual search collector and not
             // to any scoped collectors, also, it will only be applied to the main collector
@@ -156,26 +185,16 @@ public class ContextIndexSearcher extends IndexSearcher {
             collector = new MinimumScoreCollector(collector, searchContext.minimumScore());
         }
 
-        Filter combinedFilter;
-        if (filter == null) {
-            combinedFilter = searchContext.aliasFilter();
-        } else {
-            if (searchContext.aliasFilter() != null) {
-                combinedFilter = new AndFilter(ImmutableList.of(filter, searchContext.aliasFilter()));
-            } else {
-                combinedFilter = filter;
-            }
-        }
 
         // we only compute the doc id set once since within a context, we execute the same query always...
         if (searchContext.timeoutInMillis() != -1) {
             try {
-                super.search(query, combinedFilter, collector);
+                super.search(leaves, weight, collector);
             } catch (TimeLimitingCollector.TimeExceededException e) {
                 searchContext.queryResult().searchTimedOut(true);
             }
         } else {
-            super.search(query, combinedFilter, collector);
+            super.search(leaves, weight, collector);
         }
     }