Index: src/java/org/apache/lucene/search/BooleanQuery.java
===================================================================
--- src/java/org/apache/lucene/search/BooleanQuery.java	(revision 541399)
+++ src/java/org/apache/lucene/search/BooleanQuery.java	(working copy)
@@ -347,7 +347,8 @@
      */
     public Scorer scorer(IndexReader reader) throws IOException {
       BooleanScorer2 result = new BooleanScorer2(similarity,
-                                                 minNrShouldMatch);
+                                                 minNrShouldMatch,
+                                                 useScorer14);
 
       for (int i = 0 ; i < weights.size(); i++) {
         BooleanClause c = (BooleanClause)clauses.get(i);
@@ -375,14 +376,7 @@
   }
 
   protected Weight createWeight(Searcher searcher) throws IOException {
-
-    if (0 < minNrShouldMatch) {
-      // :TODO: should we throw an exception if getUseScorer14 ?
-      return new BooleanWeight2(searcher);
-    }
-
-    return getUseScorer14() ? (Weight) new BooleanWeight(searcher)
-                            : (Weight) new BooleanWeight2(searcher);
+    return new BooleanWeight2(searcher);
   }
 
   public Query rewrite(IndexReader reader) throws IOException {
Index: src/java/org/apache/lucene/search/BooleanScorer2.java
===================================================================
--- src/java/org/apache/lucene/search/BooleanScorer2.java	(revision 541399)
+++ src/java/org/apache/lucene/search/BooleanScorer2.java	(working copy)
@@ -32,7 +32,6 @@
   private ArrayList optionalScorers = new ArrayList();
   private ArrayList prohibitedScorers = new ArrayList();
 
-
   private class Coordinator {
     int maxCoord = 0; // to be increased for each non prohibited scorer
     
@@ -66,7 +65,13 @@
 
   /** The number of optionalScorers that need to match (if there are any) */
   private final int minNrShouldMatch;
+  
+  /** Whether it is allowed to return documents out of order.
+   *  This can accelerate the scoring of disjunction queries.  
+   */  
+  private boolean allowDocsOutOfOrder;
 
+
   /** Create a BooleanScorer2.
    * @param similarity The similarity to be used.
    * @param minNrShouldMatch The minimum number of optional added scorers
@@ -74,23 +79,40 @@
    *                         In case no required scorers are added,
    *                         at least one of the optional scorers will have to
    *                         match during the search.
+   * @param allowDocsOutOfOrder Whether it is allowed to return documents out of order.
+   *                            This can accelerate the scoring of disjunction queries.                         
    */
-  public BooleanScorer2(Similarity similarity, int minNrShouldMatch) {
+  public BooleanScorer2(Similarity similarity, int minNrShouldMatch, boolean allowDocsOutOfOrder) {
     super(similarity);
     if (minNrShouldMatch < 0) {
       throw new IllegalArgumentException("Minimum number of optional scorers should not be negative");
     }
     coordinator = new Coordinator();
     this.minNrShouldMatch = minNrShouldMatch;
+    this.allowDocsOutOfOrder = allowDocsOutOfOrder;
   }
 
   /** Create a BooleanScorer2.
    *  In no required scorers are added,
    *  at least one of the optional scorers will have to match during the search.
    * @param similarity The similarity to be used.
+   * @param minNrShouldMatch The minimum number of optional added scorers
+   *                         that should match during the search.
+   *                         In case no required scorers are added,
+   *                         at least one of the optional scorers will have to
+   *                         match during the search.
    */
+  public BooleanScorer2(Similarity similarity, int minNrShouldMatch) {
+    this(similarity, minNrShouldMatch, false);
+  }
+  
+  /** Create a BooleanScorer2.
+   *  In no required scorers are added,
+   *  at least one of the optional scorers will have to match during the search.
+   * @param similarity The similarity to be used.
+   */
   public BooleanScorer2(Similarity similarity) {
-    this(similarity, 0);
+    this(similarity, 0, false);
   }
 
   public void add(final Scorer scorer, boolean required, boolean prohibited) {
@@ -285,8 +307,8 @@
    * <br>When this method is used the {@link #explain(int)} method should not be used.
    */
   public void score(HitCollector hc) throws IOException {
-    if ((requiredScorers.size() == 0) &&
-        prohibitedScorers.size() < 32) {
+    if (allowDocsOutOfOrder && requiredScorers.size() == 0
+            && prohibitedScorers.size() < 32) {
       // fall back to BooleanScorer, scores documents somewhat out of order
       BooleanScorer bs = new BooleanScorer(getSimilarity(), minNrShouldMatch);
       Iterator si = optionalScorers.iterator();
Index: src/test/org/apache/lucene/search/QueryUtils.java
===================================================================
--- src/test/org/apache/lucene/search/QueryUtils.java	(revision 541399)
+++ src/test/org/apache/lucene/search/QueryUtils.java	(working copy)
@@ -106,10 +106,6 @@
       final Weight w = q.weight(s);
       final Scorer scorer = w.scorer(s.getIndexReader());
       
-      if (scorer instanceof BooleanScorer || scorer instanceof BooleanScorer2) {
-        return; // TODO change this if BooleanScorers would once again guarantee docs in order. 
-      }
-
       // FUTURE: ensure scorer.doc()==-1
 
       final int[] sdoc = new int[] {-1};