Index: lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java	(revision 0)
+++ lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java	(working copy)
@@ -0,0 +1,73 @@
+package org.apache.lucene.search;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.LuceneTestCase;
+
+public class TestQueryRescorer extends LuceneTestCase {
+
+  public void testBasic() throws Exception {
+    Directory dir = newDirectory();
+    RandomIndexWriter w = new RandomIndexWriter(random(), dir);
+
+    Document doc = new Document();
+    doc.add(newStringField("id", "0", Field.Store.YES));
+    doc.add(newTextField("field", "wizard the the the the the oz", Field.Store.NO));
+    w.addDocument(doc);
+    doc = new Document();
+    doc.add(newStringField("id", "1", Field.Store.YES));
+    // 1 extra token, but wizard and oz are close;
+    doc.add(newTextField("field", "wizard oz the the the the the the", Field.Store.NO));
+    w.addDocument(doc);
+    IndexReader r = w.getReader();
+    w.close();
+
+    // Do ordinary BooleanQuery:
+    BooleanQuery bq = new BooleanQuery();
+    bq.add(new TermQuery(new Term("field", "wizard")), Occur.SHOULD);
+    bq.add(new TermQuery(new Term("field", "oz")), Occur.SHOULD);
+    IndexSearcher searcher = newSearcher(r);
+
+    TopDocs hits = searcher.search(bq, 10);
+    assertEquals(2, hits.totalHits);
+    assertEquals("0", searcher.doc(hits.scoreDocs[0].doc).get("id"));
+    assertEquals("1", searcher.doc(hits.scoreDocs[1].doc).get("id"));
+
+    // Now, resort using ProxBooleanTermQuery:
+    ProxBooleanTermQuery pq = new ProxBooleanTermQuery("field", Occur.SHOULD);
+    pq.add(new BytesRef("wizard"));
+    pq.add(new BytesRef("oz"));
+
+    TopDocs hits2 = QueryRescorer.rescore(searcher, hits, pq, 2.0, 10);
+
+    assertEquals(2, hits2.totalHits);
+    assertEquals("1", searcher.doc(hits2.scoreDocs[0].doc).get("id"));
+    assertEquals("0", searcher.doc(hits2.scoreDocs[1].doc).get("id"));
+
+    r.close();
+    dir.close();
+  }
+}

Property changes on: lucene/core/src/test/org/apache/lucene/search/TestQueryRescorer.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: lucene/core/src/test/org/apache/lucene/search/TestProxBooleanTermQuery.java
===================================================================
--- lucene/core/src/test/org/apache/lucene/search/TestProxBooleanTermQuery.java	(revision 0)
+++ lucene/core/src/test/org/apache/lucene/search/TestProxBooleanTermQuery.java	(working copy)
@@ -0,0 +1,52 @@
+package org.apache.lucene.search;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import org.apache.lucene.document.Document;
+import org.apache.lucene.document.Field;
+import org.apache.lucene.document.TextField;
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.index.RandomIndexWriter;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.store.Directory;
+import org.apache.lucene.util.BytesRef;
+import org.apache.lucene.util.LuceneTestCase;
+
+public class TestProxBooleanTermQuery extends LuceneTestCase {
+
+  public void test() throws Exception {
+    Directory dir = newDirectory();
+    RandomIndexWriter w = new RandomIndexWriter(random(), dir);
+    Document doc = new Document();
+    doc.add(new TextField("field", "here is some text", Field.Store.NO));
+    w.addDocument(doc);
+    IndexReader r = w.getReader();
+    w.close();
+
+    IndexSearcher s = newSearcher(r);
+    ProxBooleanTermQuery q = new ProxBooleanTermQuery("field", Occur.SHOULD);
+    q.add(new BytesRef("here"));
+    q.add(new BytesRef("some"));
+    TopDocs hits = s.search(q, 10);
+    assertEquals(1, hits.totalHits);
+
+    r.close();
+
+    dir.close();
+  }
+}

Property changes on: lucene/core/src/test/org/apache/lucene/search/TestProxBooleanTermQuery.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: lucene/core/src/java/org/apache/lucene/search/ProxBooleanTermQuery.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/ProxBooleanTermQuery.java	(revision 0)
+++ lucene/core/src/java/org/apache/lucene/search/ProxBooleanTermQuery.java	(working copy)
@@ -0,0 +1,518 @@
+package org.apache.lucene.search;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+  TODO
+    - take TermStates so a custom rewrite method can avoid
+      double-term lookup
+    - coord
+    - what about multi-fields?
+ */
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.index.DocsAndPositionsEnum;
+import org.apache.lucene.index.Term;
+import org.apache.lucene.index.TermsEnum;
+import org.apache.lucene.search.BooleanClause.Occur;
+import org.apache.lucene.search.TermQuery.TermWeight;
+import org.apache.lucene.search.similarities.Similarity;
+import org.apache.lucene.util.AttributeSource;
+import org.apache.lucene.util.Bits;
+import org.apache.lucene.util.BytesRef;
+
+/** Scores like {@link BooleanQuery} but also boosts matches
+ *  where terms occur close to one another.  The field must
+ *  be indexed with positions.  Typically, this query is
+ *  too costly to run as the primary query; instead, run a
+ *  simpler first-pass query and then use {@link
+ *  QueryRescorer} to rescore the top results using this
+ *  query. */
+public class ProxBooleanTermQuery extends Query {
+
+  private final BooleanClause.Occur occur;
+  private final String field;
+  private final List<BytesRef> terms;
+  private final boolean disableCoord;
+
+  public ProxBooleanTermQuery(String field, Occur occur) {
+    this(field, occur, false);
+  }
+
+  @Override
+  public String toString(String field) {
+    StringBuilder b = new StringBuilder();
+    b.append("ProxBooleanTermQuery(field=");
+    b.append(this.field);
+    b.append(", occur=");
+    b.append(occur);
+    b.append(", terms=");
+    for(int i=0;i<terms.size();i++) {
+      if (i > 0) {
+        b.append(' ');
+      }
+      b.append(terms.get(i).utf8ToString());
+    }
+    b.append(")");
+
+    return b.toString();
+  }
+
+  // nocommit rewrite, e.g. only 1 clause?
+
+  public ProxBooleanTermQuery(String field, Occur occur, boolean disableCoord) {
+    this.field = field;
+    this.occur = occur;
+    terms = new ArrayList<BytesRef>();
+    this.disableCoord = disableCoord;
+  }
+
+  public void add(BytesRef term) {
+    terms.add(term);
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if ((o instanceof ProxBooleanTermQuery) == false) {
+      return false;
+    }
+    ProxBooleanTermQuery other = (ProxBooleanTermQuery) o;
+    return getBoost() == other.getBoost() &&
+      field.equals(other.field) &&
+      disableCoord == other.disableCoord &&
+      terms.equals(other.terms) &&
+      occur.equals(other.occur);
+  }
+
+  @Override
+  public int hashCode() {
+    int PRIME = 101;
+    int hashCode = Float.floatToIntBits(getBoost());
+    hashCode = hashCode * PRIME + field.hashCode();
+    hashCode = hashCode * PRIME + occur.hashCode();
+    hashCode = hashCode * PRIME + terms.hashCode();
+    hashCode = hashCode * PRIME + (disableCoord ? 17:0);
+
+    return hashCode;
+  }
+
+  @Override
+  public Weight createWeight(IndexSearcher searcher) throws IOException {
+    return new ProxBooleanTermWeight(searcher);
+  }
+
+  private class ProxBooleanTermWeight extends Weight {
+
+    protected Similarity similarity;
+    private List<TermWeight> weights;
+
+    public ProxBooleanTermWeight(IndexSearcher searcher) throws IOException {
+      this.similarity = searcher.getSimilarity();
+      weights = new ArrayList<TermWeight>();
+      for (BytesRef term : terms) {
+        TermQuery tq = new TermQuery(new Term(field, term));
+        weights.add((TermWeight) tq.createWeight(searcher));
+      }
+    }
+
+    @Override
+    public float getValueForNormalization() {
+      float sum = 0.0f;
+      for (TermWeight tw : weights) {
+        // call sumOfSquaredWeights for all clauses in case of side effects
+        sum += tw.getValueForNormalization();         // sum sub weights
+      }
+
+      sum *= getBoost() * getBoost();             // boost each sub-weight
+
+      return sum;
+    }
+
+    @Override
+    public void normalize(float norm, float topLevelBoost) {
+      topLevelBoost *= getBoost();
+      for(TermWeight tw : weights) {
+        tw.normalize(norm, topLevelBoost);
+      }
+    }
+
+    @Override
+    public Explanation explain(AtomicReaderContext context, int doc) throws IOException {
+      // nocommit todo
+      return null;
+    }
+
+    @Override
+    public Query getQuery() {
+      return ProxBooleanTermQuery.this;
+    }
+
+    @Override
+    public Scorer scorer(AtomicReaderContext context, boolean scoreDocsInOrder,
+                         boolean topScorer, Bits acceptDocs) throws IOException {
+
+      List<ProxTermScorer> scorers = new ArrayList<ProxTermScorer>();
+
+      int ord = 0;
+      for(TermWeight tw : weights) {
+
+        TermsEnum termsEnum = tw.getTermsEnum(context);
+        if (termsEnum == null) {
+          if (occur == Occur.MUST) {
+            return null;
+          }
+          continue;
+        }
+        DocsAndPositionsEnum posEnum = termsEnum.docsAndPositions(acceptDocs, null, 0);
+        if (posEnum == null) {
+          throw new IllegalStateException("field \"" + field + "\" was indexed without position data; cannot run ProxBooleanTermQuery (term=" + tw.getQuery() + ")");
+        }
+        TermScorer ts = new TermScorer(tw, posEnum, similarity.simScorer(tw.stats, context));
+        scorers.add(new ProxTermScorer(this, ord++, posEnum, ts));
+      }
+
+      float[] coords = new float[scorers.size()+1];
+
+      for(int i=0;i<coords.length;i++) {
+        float coord;
+        if (disableCoord) {
+          coord = 1.0f;
+        } else if (coords.length == 1) {
+          // LUCENE-4300: in most cases of maxOverlap=1, BQ rewrites itself away,
+          // so coord() is not applied. But when BQ cannot optimize itself away
+          // for a single clause (minNrShouldMatch, prohibited clauses, etc), its
+          // important not to apply coord(1,1) for consistency, it might not be 1.0F
+          coord = 1.0f;
+        } else {
+          coord = similarity.coord(i, coords.length);
+        }
+
+        coords[i] = coord;
+      }
+
+      if (occur != Occur.SHOULD) {
+        // nocommit MUST too?
+        throw new IllegalArgumentException("can only handle SHOULD for now");
+      }
+
+      // nocommmit should we re-order the clauses by cost?
+      // i think only ConjunctionScorer needs to?
+      return new ProxBooleanDisjunctionTermScorer(this, scorers.toArray(new ProxTermScorer[scorers.size()]), coords);
+    }
+  }
+
+  @Override
+  public void extractTerms(Set<Term> queryTerms) {
+    for(BytesRef term : terms) {
+      queryTerms.add(new Term(field, term));
+    }
+  }
+
+  /** Wrapper/delegator around TermScorer, that just holds the D&PEnum
+   *  and ord. */
+  private static class ProxTermScorer extends Scorer {
+    final DocsAndPositionsEnum posEnum;
+    final TermScorer termScorer;
+    final int ord;
+
+    public ProxTermScorer(Weight weight, int ord, DocsAndPositionsEnum posEnum, TermScorer termScorer) {
+      super(weight);
+      this.ord = ord;
+      this.posEnum = posEnum;
+      this.termScorer = termScorer;
+    }
+
+    @Override
+    public int docID() {
+      return termScorer.docID();
+    }
+
+    @Override
+    public int nextDoc() throws IOException {
+      return termScorer.nextDoc();
+    }
+
+    @Override
+    public int advance(int target) throws IOException {
+      return termScorer.advance(target);
+    }
+    
+    @Override
+    public long cost() {
+      return termScorer.cost();
+    }
+
+    @Override
+    public int freq() throws IOException {
+      return termScorer.freq();
+    }
+
+    @Override
+    public AttributeSource attributes() {
+      return termScorer.attributes();
+    }
+
+    @Override
+    public float score() throws IOException {
+      return termScorer.score();
+    }
+
+    @Override
+    public Weight getWeight() {
+      return termScorer.getWeight();
+    }
+  }
+
+  /** Utility class to merge-sort multiple
+   *  DocsAndPositionsEnum currently "on" a single doc, and
+   *  compute resulting score "boost". */
+  private static class ProxScorer {
+
+    private static class PosEnumAndPos {
+      int pos;
+      int posUpto;
+      int posLimit;
+      final DocsAndPositionsEnum posEnum;
+      final Similarity.SimScorer docScorer;
+
+      public PosEnumAndPos(ProxTermScorer termScorer) {
+        this.docScorer = termScorer.termScorer.docScorer;
+        this.posEnum = termScorer.posEnum;
+      }
+    }
+
+    final PosEnumAndPos[] enums;
+    final PosEnumAndPos[] heap;
+    private int heapSize;
+
+    public ProxScorer(ProxTermScorer[] scorers) {
+      enums = new PosEnumAndPos[scorers.length];
+      for(int i=0;i<enums.length;i++) {
+        enums[i] = new PosEnumAndPos(scorers[i]);
+      }
+      // +1 because queue[0] is unused
+      heap = new PosEnumAndPos[enums.length+1];
+    }
+
+    public void add(int idx) throws IOException {
+      PosEnumAndPos posEnum = enums[idx];
+      System.out.println("add idx=" + idx + " heapSize=" + heapSize + " docID=" + posEnum.posEnum.docID());
+
+      heapSize++;
+      heap[heapSize] = posEnum;
+
+      // All enums should be on the same doc:
+      assert heapSize == 1 || posEnum.posEnum.docID() == heap[heapSize-1].posEnum.docID();
+
+      posEnum.posLimit = posEnum.posEnum.freq();
+      posEnum.pos = posEnum.posEnum.nextPosition();
+      posEnum.posUpto = 1;
+
+      // nocommit need test w/ syns @ same position as other tokens
+
+      // upHeap:
+      int i = heapSize;
+      PosEnumAndPos node = heap[i];          // save bottom node
+      int j = i >>> 1;
+      while (j > 0 && node.pos < heap[j].pos) {
+        heap[i] = heap[j];       // shift parents down
+        i = j;
+        j = j >>> 1;
+      }
+      heap[i] = node;            // install saved node
+    }
+
+    /** Computes the overall prox boost visiting all terms
+     *  in position order. */
+    public float boost() throws IOException {
+      int lastPos = -1;
+
+      float boost = 0.0f;
+      System.out.println("boost: " + heapSize);
+      while (heapSize != 0) {
+        PosEnumAndPos min = heap[1];
+        System.out.println("  cycle pos=" + min.pos);
+        if (lastPos != -1 && lastPos != min.pos) {
+          // nocomit hack hack:
+          int distance = min.pos - lastPos;
+          assert distance > 0;
+          boost += 1.0f/(distance*distance);
+        }
+        lastPos = min.pos;
+
+        if (min.posUpto < min.posLimit) {
+          min.pos = min.posEnum.nextPosition();
+          min.posUpto++;
+        } else {
+          // This enum is exhausted:
+          heap[1] = heap[heapSize];
+          heapSize--;
+        }
+
+        // downHeap:
+        int i = 1;
+        PosEnumAndPos node = heap[i];          // save top node
+        int j = i << 1;            // find smaller child
+        int k = j + 1;
+        if (k <= heapSize && heap[k].pos < heap[j].pos) {
+          j = k;
+        }
+        while (j <= heapSize && heap[j].pos < node.pos) {
+          heap[i] = heap[j];       // shift up child
+          i = j;
+          j = i << 1;
+          k = j + 1;
+          if (k <= heapSize && heap[k].pos < heap[j].pos) {
+            j = k;
+          }
+        }
+        heap[i] = node;            // install saved node
+      }
+      System.out.println("prox boost: " + boost);
+      return boost;
+    }
+  }
+
+  /** The Scorer impl used for this query */
+  private static class ProxBooleanDisjunctionTermScorer extends DisjunctionScorer {
+    final ProxTermScorer[] scorers;
+    final float[] coord;
+    final ProxScorer proxScorer;
+    private double score;
+    private float proxBoost;
+    private int doc = -1;
+    private int nrMatchers;
+
+    public ProxBooleanDisjunctionTermScorer(Weight weight, ProxTermScorer[] scorers, float[] coord) {
+      super(weight, scorers, scorers.length);
+      if (scorers.length <= 1) {
+        throw new IllegalArgumentException("There must be at least 2 subScorers");
+      }
+      this.scorers = scorers;
+      this.coord = coord;
+      this.proxScorer = new ProxScorer(scorers);
+    }
+
+    // nocommit shouldn't this be in base class?  (rob's
+    // patch)
+
+    @Override
+    public int nextDoc() throws IOException {
+      assert doc != NO_MORE_DOCS;
+      while(true) {
+        if (subScorers[0].nextDoc() != NO_MORE_DOCS) {
+          heapAdjust(0);
+        } else {
+          heapRemoveRoot();
+          if (numScorers == 0) {
+            return doc = NO_MORE_DOCS;
+          }
+        }
+        if (subScorers[0].docID() != doc) {
+          afterNext();
+          return doc;
+        }
+      }
+    }
+  
+    private void afterNext() throws IOException {
+      final Scorer sub = subScorers[0];
+      doc = sub.docID();
+      if (doc != NO_MORE_DOCS) {
+        // nocommit if we generified our base class we
+        // wouldn't have to cast every time here:
+        proxScorer.add(((ProxTermScorer) sub).ord);
+        score = sub.score();
+        nrMatchers = 1;
+        countMatches(1);
+        countMatches(2);
+
+        proxBoost = proxScorer.boost();
+      }
+    }
+  
+    // TODO: this currently scores, but so did the previous impl
+    // TODO: remove recursion.
+    // TODO: if we separate scoring, out of here, 
+    // then change freq() to just always compute it from scratch
+    private void countMatches(int root) throws IOException {
+      if (root < numScorers && subScorers[root].docID() == doc) {
+        nrMatchers++;
+        Scorer sub = subScorers[root];
+        proxScorer.add(((ProxTermScorer) sub).ord);
+        score += sub.score();
+        countMatches((root<<1)+1);
+        countMatches((root<<1)+2);
+      }
+    }
+  
+    /** Returns the score of the current document matching the query.
+     * Initially invalid, until {@link #nextDoc()} is called the first time.
+     */
+    @Override
+    public float score() throws IOException { 
+      // nocomit hack hack:
+      System.out.println("score: proxBoost=" + proxBoost);
+      return (float)score * coord[nrMatchers] + proxBoost; 
+    }
+   
+    @Override
+    public int docID() {
+      return doc;
+    }
+
+    @Override
+    public int freq() throws IOException {
+      return nrMatchers;
+    }
+
+    /**
+     * Advances to the first match beyond the current whose document number is
+     * greater than or equal to a given target. <br>
+     * The implementation uses the advance() method on the subscorers.
+     * 
+     * @param target
+     *          The target document number.
+     * @return the document whose number is greater than or equal to the given
+     *         target, or -1 if none exist.
+     */
+    @Override
+    public int advance(int target) throws IOException {
+      assert doc != NO_MORE_DOCS;
+      while(true) {
+        if (subScorers[0].advance(target) != NO_MORE_DOCS) {
+          heapAdjust(0);
+        } else {
+          heapRemoveRoot();
+          if (numScorers == 0) {
+            return doc = NO_MORE_DOCS;
+          }
+        }
+        if (subScorers[0].docID() >= target) {
+          afterNext();
+          return doc;
+        }
+      }
+    }
+  }
+}

Property changes on: lucene/core/src/java/org/apache/lucene/search/ProxBooleanTermQuery.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java	(revision 0)
+++ lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java	(working copy)
@@ -0,0 +1,169 @@
+package org.apache.lucene.search;
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.lucene.index.AtomicReaderContext;
+import org.apache.lucene.util.Bits;
+
+/** Re-scores the topN results from an original
+ *  query using a second query.  Typically, the first query
+ *  will be less costly and run on the entire index, and
+ *  return the top few  hundred results, then the second
+ *  more-costly query, such as {@link ProxBooleanTermQuery},
+ *  is used only to re-score those results. */
+
+public class QueryRescorer {
+
+  /** Filter accepting only the specified docIDs */
+  private static class OnlyDocIDsFilter extends Filter {
+
+    private final int[] docIDs;
+
+    /** NOTE: resorts the incoming docIDs */
+    public OnlyDocIDsFilter(int[] docIDs) {
+      this.docIDs = docIDs;
+      Arrays.sort(docIDs);
+    }
+
+    @Override
+    public DocIdSet getDocIdSet(final AtomicReaderContext context, final Bits acceptDocs) throws IOException {
+      int loc = Arrays.binarySearch(docIDs, context.docBase);
+      if (loc < 0) {
+        loc = -loc-1;
+      }
+
+      final int startLoc = loc;
+      final int endDoc = context.docBase + context.reader().maxDoc();
+
+      return new DocIdSet() {
+
+        int pos = startLoc;
+
+        @Override
+        public DocIdSetIterator iterator() throws IOException {
+          return new DocIdSetIterator() {
+
+            int docID;
+
+            @Override
+            public int docID() {
+              return docID;
+            }
+
+            @Override
+            public int nextDoc() {
+              if (pos == docIDs.length) {
+                return NO_MORE_DOCS;
+              }
+              int docID = docIDs[pos];
+              if (docID >= endDoc) {
+                return NO_MORE_DOCS;
+              }
+              pos++;
+              assert acceptDocs == null || acceptDocs.get(docID-context.docBase);
+              return docID-context.docBase;
+            }
+
+            @Override
+            public long cost() {
+              // nocommit?
+              return 0;
+            }
+
+            @Override
+            public int advance(int target) {
+              int loc = Arrays.binarySearch(docIDs, target + context.docBase);
+              if (loc < 0) {
+                loc = -loc-1;
+              }
+              pos = loc;
+              return nextDoc();
+            }
+          };
+        }
+      };
+    }
+  }
+
+  /** @parmas
+   * searcher {@link IndexSearcher} used to produce the
+   *   first pass topDocs
+   * topDocs Hits from the first pass search
+   * query Query to use for rescoring
+   * scoreWeight The score of the returned hits is
+   *   firstPassScore + weight * queryScore
+   * topN How many re-scored hits to return
+   */ 
+  public static TopDocs rescore(IndexSearcher searcher, TopDocs topDocs, Query query, double weight, int topN) throws IOException {
+    int[] docIDs = new int[topDocs.scoreDocs.length];
+    for(int i=0;i<docIDs.length;i++) {
+      docIDs[i] = topDocs.scoreDocs[i].doc;
+    }
+
+    TopDocs topDocs2 = searcher.search(query, new OnlyDocIDsFilter(docIDs), topDocs.scoreDocs.length);
+    
+    Map<Integer,Float> newScores = new HashMap<Integer,Float>();
+    for(ScoreDoc sd : topDocs2.scoreDocs) {
+      newScores.put(sd.doc, sd.score);
+    }
+
+    ScoreDoc[] newHits = new ScoreDoc[topDocs.scoreDocs.length];
+    for(int i=0;i<topDocs.scoreDocs.length;i++) {
+      int docID = topDocs.scoreDocs[i].doc;
+      float oldScore = topDocs.scoreDocs[i].score;
+      Float newScore = newScores.get(docID);
+      assert newScore != null;
+
+      newHits[i] = new ScoreDoc(docID, (float) (oldScore + weight * newScore));
+    }
+
+    // TODO: we should do a partial sort (of only topN)
+    // instead, but typically the number of hits is
+    // smallish:
+    Arrays.sort(newHits,
+                new Comparator<ScoreDoc>() {
+                  @Override
+                  public int compare(ScoreDoc a, ScoreDoc b) {
+                    // Sort by score descending, then docID ascending:
+                    if (a.score > b.score) {
+                      return -1;
+                    } else if (a.score < b.score) {
+                      return 1;
+                    } else {
+                      // This subtraction can't overflow int
+                      // because docIDs are >= 0:
+                      return a.doc - b.doc;
+                    }
+                  }
+                });
+
+    if (topN < newHits.length) {
+      ScoreDoc[] subset = new ScoreDoc[topN];
+      System.arraycopy(newHits, 0, subset, 0, topN);
+      newHits = subset;
+    }
+
+    return new TopDocs(topDocs.totalHits, newHits, newHits[0].score);
+  }
+}

Property changes on: lucene/core/src/java/org/apache/lucene/search/QueryRescorer.java
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Index: lucene/core/src/java/org/apache/lucene/search/TermQuery.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/TermQuery.java	(revision 1532782)
+++ lucene/core/src/java/org/apache/lucene/search/TermQuery.java	(working copy)
@@ -44,7 +44,7 @@
 
   final class TermWeight extends Weight {
     private final Similarity similarity;
-    private final Similarity.SimWeight stats;
+    final Similarity.SimWeight stats;
     private final TermContext termStates;
 
     public TermWeight(IndexSearcher searcher, TermContext termStates)
@@ -91,7 +91,7 @@
      * Returns a {@link TermsEnum} positioned at this weights Term or null if
      * the term does not exist in the given context
      */
-    private TermsEnum getTermsEnum(AtomicReaderContext context) throws IOException {
+    TermsEnum getTermsEnum(AtomicReaderContext context) throws IOException {
       final TermState state = termStates.get(context.ord);
       if (state == null) { // term is not present in that reader
         assert termNotInReader(context.reader(), term) : "no termstate found but term exists in reader term=" + term;
Index: lucene/core/src/java/org/apache/lucene/search/TermScorer.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/TermScorer.java	(revision 1532782)
+++ lucene/core/src/java/org/apache/lucene/search/TermScorer.java	(working copy)
@@ -26,7 +26,7 @@
  */
 final class TermScorer extends Scorer {
   private final DocsEnum docsEnum;
-  private final Similarity.SimScorer docScorer;
+  final Similarity.SimScorer docScorer;
   
   /**
    * Construct a <code>TermScorer</code>.
Index: lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java
===================================================================
--- lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java	(revision 1532782)
+++ lucene/core/src/java/org/apache/lucene/search/BooleanQuery.java	(working copy)
@@ -68,7 +68,7 @@
   }
 
   private ArrayList<BooleanClause> clauses = new ArrayList<BooleanClause>();
-  private final boolean disableCoord;
+  protected final boolean disableCoord;
 
   /** Constructs an empty boolean query. */
   public BooleanQuery() {
@@ -163,8 +163,7 @@
    * Expert: the Weight for BooleanQuery, used to
    * normalize, score and explain these queries.
    *
-   * <p>NOTE: this API and implementation is subject to
-   * change suddenly in the next release.</p>
+   * @lucene.experimental
    */
   protected class BooleanWeight extends Weight {
     /** The Similarity implementation. */
@@ -322,6 +321,11 @@
         }
       }
 
+      return scorer(required, prohibited, optional, scoreDocsInOrder, topScorer, acceptDocs);
+    }
+
+    protected Scorer scorer(List<Scorer> required, List<Scorer> prohibited, List<Scorer> optional, boolean scoreDocsInOrder,
+                            boolean topScorer, Bits acceptDocs) throws IOException {
       // NOTE: we could also use BooleanScorer, if we knew
       // this BooleanQuery was embedded in another
       // BooleanQuery that was also using BooleanScorer (ie,