You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@lucene.apache.org by ro...@apache.org on 2022/03/03 11:26:22 UTC

[lucene] branch branch_9x updated: LUCENE-10431: Deprecate MultiTermQuery.setRewriteMethod() (#722)

This is an automated email from the ASF dual-hosted git repository.

romseygeek pushed a commit to branch branch_9x
in repository https://gitbox.apache.org/repos/asf/lucene.git


The following commit(s) were added to refs/heads/branch_9x by this push:
     new 63454b8  LUCENE-10431: Deprecate MultiTermQuery.setRewriteMethod() (#722)
63454b8 is described below

commit 63454b83ad3cea3bae7c70f4b6276fce60d81672
Author: Alan Woodward <ro...@apache.org>
AuthorDate: Thu Mar 3 11:08:39 2022 +0000

    LUCENE-10431: Deprecate MultiTermQuery.setRewriteMethod() (#722)
    
    Allowing users to mutate MultiTermQuery can give rise to odd bugs, for example
    in wrapper queries such as BooleanQuery which lazily calculate their hashcodes
    and then cache the result. This commit deprecates the setRewriteMethod()
    method on MultiTermQuery, in preparation for removing it entirely, and adds
    constructor parameters to the various MTQ implementations as a preferred
    way to set the rewrite method.
---
 lucene/CHANGES.txt                                 |  3 +
 .../benchmark/byTask/feeds/EnwikiQueryMaker.java   |  8 ++-
 .../org/apache/lucene/search/AutomatonQuery.java   | 21 ++++++-
 .../java/org/apache/lucene/search/FuzzyQuery.java  | 32 +++++++++-
 .../org/apache/lucene/search/MultiTermQuery.java   | 25 +++-----
 .../java/org/apache/lucene/search/PrefixQuery.java | 11 +++-
 .../java/org/apache/lucene/search/RegexpQuery.java | 32 +++++-----
 .../org/apache/lucene/search/ScoringRewrite.java   |  4 --
 .../org/apache/lucene/search/TermRangeQuery.java   | 42 ++++++++++++-
 .../org/apache/lucene/search/WildcardQuery.java    | 15 ++++-
 .../apache/lucene/search/TestAutomatonQuery.java   | 37 ++++++++---
 .../lucene/search/TestAutomatonQueryUnicode.java   | 38 +++++++++---
 .../org/apache/lucene/search/TestBooleanQuery.java |  8 ++-
 .../lucene/search/TestDocValuesRewriteMethod.java  | 58 ++++++++++++++----
 .../lucene/search/TestFieldCacheRewriteMethod.java | 71 +++++++++++++++++-----
 .../org/apache/lucene/search/TestFuzzyQuery.java   | 10 ++-
 .../lucene/search/TestMultiTermConstantScore.java  | 17 +++---
 .../lucene/search/TestMultiTermQueryRewrites.java  | 12 ++--
 .../org/apache/lucene/search/TestPrefixRandom.java |  2 +-
 .../apache/lucene/search/TestRegexpRandom2.java    |  2 +-
 .../apache/lucene/search/TestTermRangeQuery.java   |  6 +-
 .../org/apache/lucene/search/TestWildcard.java     | 32 +++++++---
 .../lucene/search/highlight/TestHighlighter.java   | 49 ++++++++++-----
 .../org/apache/lucene/search/join/TermsQuery.java  |  2 +-
 .../queryparser/classic/QueryParserBase.java       | 25 ++++----
 .../builders/PrefixWildcardQueryNodeBuilder.java   | 13 ++--
 .../standard/builders/RegexpQueryNodeBuilder.java  | 19 +++---
 .../builders/TermRangeQueryNodeBuilder.java        | 20 +++---
 .../builders/WildcardQueryNodeBuilder.java         | 14 ++---
 .../flexible/standard/TestQPHelper.java            | 25 +++++---
 .../queryparser/util/QueryParserTestBase.java      | 28 ++++++---
 31 files changed, 471 insertions(+), 210 deletions(-)

diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index eed62dc..1d49e49 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -54,6 +54,9 @@ API Changes
 * LUCENE-10440: TaxonomyFacets and FloatTaxonomyFacets have been deprecated and are no longer
   supported extension points for user-created faceting implementations. (Greg Miller)
 
+* LUCENE-10431: MultiTermQuery.setRewriteMethod() has been deprecated, and constructor
+  parameters for the various implementations added. (Alan Woodward)
+
 New Features
 ---------------------
 
diff --git a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
index 9af4145..e116fe9 100644
--- a/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
+++ b/lucene/benchmark/src/java/org/apache/lucene/benchmark/byTask/feeds/EnwikiQueryMaker.java
@@ -31,6 +31,7 @@ import org.apache.lucene.queryparser.classic.QueryParser;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.util.automaton.Operations;
 
 /**
  * A QueryMaker that uses common and uncommon actual Wikipedia queries for searching the English
@@ -130,8 +131,11 @@ public class EnwikiQueryMaker extends AbstractQueryMaker {
   };
 
   private static Query[] getPrebuiltQueries(String field) {
-    WildcardQuery wcq = new WildcardQuery(new Term(field, "fo*"));
-    wcq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+    WildcardQuery wcq =
+        new WildcardQuery(
+            new Term(field, "fo*"),
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.CONSTANT_SCORE_REWRITE);
     // be wary of unanalyzed text
     return new Query[] {
       new SpanFirstQuery(new SpanTermQuery(new Term(field, "ford")), 5),
diff --git a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
index ef30c0a..421ea88 100644
--- a/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/AutomatonQuery.java
@@ -96,7 +96,26 @@ public class AutomatonQuery extends MultiTermQuery implements Accountable {
    */
   public AutomatonQuery(
       final Term term, Automaton automaton, int determinizeWorkLimit, boolean isBinary) {
-    super(term.field());
+    this(term, automaton, determinizeWorkLimit, isBinary, CONSTANT_SCORE_REWRITE);
+  }
+
+  /**
+   * Create a new AutomatonQuery from an {@link Automaton}.
+   *
+   * @param term Term containing field and possibly some pattern structure. The term text is
+   *     ignored.
+   * @param automaton Automaton to run, terms that are accepted are considered a match.
+   * @param isBinary if true, this automaton is already binary and will not go through the
+   *     UTF32ToUTF8 conversion
+   * @param rewriteMethod the rewriteMethod to use to build the final query from the automaton
+   */
+  public AutomatonQuery(
+      final Term term,
+      Automaton automaton,
+      int determinizeWorkLimit,
+      boolean isBinary,
+      RewriteMethod rewriteMethod) {
+    super(term.field(), rewriteMethod);
     this.term = term;
     this.automaton = automaton;
     this.automatonIsBinary = isBinary;
diff --git a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
index 8e31ba4..4515c2d 100644
--- a/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/FuzzyQuery.java
@@ -56,6 +56,11 @@ public class FuzzyQuery extends MultiTermQuery {
   public static final int defaultMaxExpansions = 50;
   public static final boolean defaultTranspositions = true;
 
+  /** Creates a default top-terms blended frequency scoring rewrite with the given max expansions */
+  public static RewriteMethod defaultRewriteMethod(int maxExpansions) {
+    return new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(maxExpansions);
+  }
+
   private final int maxEdits;
   private final int maxExpansions;
   private final boolean transpositions;
@@ -76,10 +81,16 @@ public class FuzzyQuery extends MultiTermQuery {
    *     maxClauseCount will be used instead.
    * @param transpositions true if transpositions should be treated as a primitive edit operation.
    *     If this is false, comparisons will implement the classic Levenshtein algorithm.
+   * @param rewriteMethod the rewrite method to use to build the final query
    */
   public FuzzyQuery(
-      Term term, int maxEdits, int prefixLength, int maxExpansions, boolean transpositions) {
-    super(term.field());
+      Term term,
+      int maxEdits,
+      int prefixLength,
+      int maxExpansions,
+      boolean transpositions,
+      RewriteMethod rewriteMethod) {
+    super(term.field(), rewriteMethod);
 
     if (maxEdits < 0 || maxEdits > LevenshteinAutomata.MAXIMUM_SUPPORTED_DISTANCE) {
       throw new IllegalArgumentException(
@@ -97,7 +108,22 @@ public class FuzzyQuery extends MultiTermQuery {
     this.prefixLength = prefixLength;
     this.transpositions = transpositions;
     this.maxExpansions = maxExpansions;
-    setRewriteMethod(new MultiTermQuery.TopTermsBlendedFreqScoringRewrite(maxExpansions));
+  }
+
+  /**
+   * Calls {@link #FuzzyQuery(Term, int, int, int, boolean,
+   * org.apache.lucene.search.MultiTermQuery.RewriteMethod)} FuzzyQuery(term, maxEdits,
+   * prefixLength, maxExpansions, defaultRewriteMethod(maxExpansions))
+   */
+  public FuzzyQuery(
+      Term term, int maxEdits, int prefixLength, int maxExpansions, boolean transpositions) {
+    this(
+        term,
+        maxEdits,
+        prefixLength,
+        maxExpansions,
+        transpositions,
+        defaultRewriteMethod(maxExpansions));
   }
 
   /**
diff --git a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
index 7ddeeb4..e5bc87c 100644
--- a/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/MultiTermQuery.java
@@ -36,10 +36,10 @@ import org.apache.lucene.util.AttributeSource;
  * #getTermsEnum(Terms,AttributeSource)} to provide a {@link FilteredTermsEnum} that iterates
  * through the terms to be matched.
  *
- * <p><b>NOTE</b>: if {@link #setRewriteMethod} is either {@link #CONSTANT_SCORE_BOOLEAN_REWRITE} or
+ * <p><b>NOTE</b>: if {@link RewriteMethod} is either {@link #CONSTANT_SCORE_BOOLEAN_REWRITE} or
  * {@link #SCORING_BOOLEAN_REWRITE}, you may encounter a {@link IndexSearcher.TooManyClauses}
  * exception during searching, which happens when the number of terms to be searched exceeds {@link
- * IndexSearcher#getMaxClauseCount()}. Setting {@link #setRewriteMethod} to {@link
+ * IndexSearcher#getMaxClauseCount()}. Setting {@link RewriteMethod} to {@link
  * #CONSTANT_SCORE_REWRITE} prevents this.
  *
  * <p>The recommended rewrite method is {@link #CONSTANT_SCORE_REWRITE}: it doesn't spend CPU
@@ -52,7 +52,7 @@ import org.apache.lucene.util.AttributeSource;
  */
 public abstract class MultiTermQuery extends Query {
   protected final String field;
-  protected RewriteMethod rewriteMethod = CONSTANT_SCORE_REWRITE;
+  protected RewriteMethod rewriteMethod; // TODO make this final
 
   /** Abstract class that defines how the query is rewritten. */
   public abstract static class RewriteMethod {
@@ -77,8 +77,6 @@ public abstract class MultiTermQuery extends Query {
    * <p>This method is faster than the BooleanQuery rewrite methods when the number of matched terms
    * or matched documents is non-trivial. Also, it will never hit an errant {@link
    * IndexSearcher.TooManyClauses} exception.
-   *
-   * @see #setRewriteMethod
    */
   public static final RewriteMethod CONSTANT_SCORE_REWRITE =
       new RewriteMethod() {
@@ -96,8 +94,6 @@ public abstract class MultiTermQuery extends Query {
    *
    * <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
    * of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
-   *
-   * @see #setRewriteMethod
    */
   public static final RewriteMethod SCORING_BOOLEAN_REWRITE =
       ScoringRewrite.SCORING_BOOLEAN_REWRITE;
@@ -108,8 +104,6 @@ public abstract class MultiTermQuery extends Query {
    *
    * <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
    * of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
-   *
-   * @see #setRewriteMethod
    */
   public static final RewriteMethod CONSTANT_SCORE_BOOLEAN_REWRITE =
       ScoringRewrite.CONSTANT_SCORE_BOOLEAN_REWRITE;
@@ -120,8 +114,6 @@ public abstract class MultiTermQuery extends Query {
    *
    * <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
    * clause count.
-   *
-   * @see #setRewriteMethod
    */
   public static final class TopTermsScoringBooleanQueryRewrite
       extends TopTermsRewrite<BooleanQuery.Builder> {
@@ -167,8 +159,6 @@ public abstract class MultiTermQuery extends Query {
    *
    * <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
    * clause count.
-   *
-   * @see #setRewriteMethod
    */
   public static final class TopTermsBlendedFreqScoringRewrite
       extends TopTermsRewrite<BlendedTermQuery.Builder> {
@@ -217,8 +207,6 @@ public abstract class MultiTermQuery extends Query {
    *
    * <p>This rewrite method only uses the top scoring terms so it will not overflow the boolean max
    * clause count.
-   *
-   * @see #setRewriteMethod
    */
   public static final class TopTermsBoostOnlyBooleanQueryRewrite
       extends TopTermsRewrite<BooleanQuery.Builder> {
@@ -257,8 +245,9 @@ public abstract class MultiTermQuery extends Query {
   }
 
   /** Constructs a query matching terms that cannot be represented with a single Term. */
-  public MultiTermQuery(final String field) {
+  public MultiTermQuery(final String field, RewriteMethod rewriteMethod) {
     this.field = Objects.requireNonNull(field, "field must not be null");
+    this.rewriteMethod = Objects.requireNonNull(rewriteMethod, "rewriteMethod must not be null");
   }
 
   /** Returns the field name for this query */
@@ -294,7 +283,6 @@ public abstract class MultiTermQuery extends Query {
     return rewriteMethod.rewrite(reader, this);
   }
 
-  /** @see #setRewriteMethod */
   public RewriteMethod getRewriteMethod() {
     return rewriteMethod;
   }
@@ -302,7 +290,10 @@ public abstract class MultiTermQuery extends Query {
   /**
    * Sets the rewrite method to be used when executing the query. You can use one of the four core
    * methods, or implement your own subclass of {@link RewriteMethod}.
+   *
+   * @deprecated set this using a constructor instead
    */
+  @Deprecated
   public void setRewriteMethod(RewriteMethod method) {
     rewriteMethod = method;
   }
diff --git a/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java b/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
index 9b13d82..fb1d4f8 100644
--- a/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/PrefixQuery.java
@@ -30,9 +30,14 @@ public class PrefixQuery extends AutomatonQuery {
 
   /** Constructs a query for terms starting with <code>prefix</code>. */
   public PrefixQuery(Term prefix) {
-    // It's OK to pass unlimited determinizeWorkLimit: the automaton is born small and
-    // determinized:
-    super(prefix, toAutomaton(prefix.bytes()), Integer.MAX_VALUE, true);
+    this(prefix, CONSTANT_SCORE_REWRITE);
+  }
+
+  /**
+   * Constructs a query for terms starting with <code>prefix</code> using a defined RewriteMethod
+   */
+  public PrefixQuery(Term prefix, RewriteMethod rewriteMethod) {
+    super(prefix, toAutomaton(prefix.bytes()), Integer.MAX_VALUE, true, rewriteMethod);
   }
 
   /** Build an automaton accepting all terms with the specified prefix. */
diff --git a/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java b/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
index 7e31058..936b12f 100644
--- a/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/RegexpQuery.java
@@ -17,7 +17,6 @@
 package org.apache.lucene.search;
 
 import org.apache.lucene.index.Term;
-import org.apache.lucene.util.automaton.Automaton;
 import org.apache.lucene.util.automaton.AutomatonProvider;
 import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
@@ -42,14 +41,9 @@ import org.apache.lucene.util.automaton.RegExp;
  * @lucene.experimental
  */
 public class RegexpQuery extends AutomatonQuery {
+
   /** A provider that provides no named automata */
-  private static AutomatonProvider defaultProvider =
-      new AutomatonProvider() {
-        @Override
-        public Automaton getAutomaton(String name) {
-          return null;
-        }
-      };
+  public static final AutomatonProvider DEFAULT_PROVIDER = name -> null;
 
   /**
    * Constructs a query for terms matching <code>term</code>.
@@ -69,7 +63,7 @@ public class RegexpQuery extends AutomatonQuery {
    * @param flags optional RegExp features from {@link RegExp}
    */
   public RegexpQuery(Term term, int flags) {
-    this(term, flags, defaultProvider, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
+    this(term, flags, DEFAULT_PROVIDER, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT);
   }
 
   /**
@@ -83,7 +77,7 @@ public class RegexpQuery extends AutomatonQuery {
    *     otherwise know what to specify.
    */
   public RegexpQuery(Term term, int flags, int determinizeWorkLimit) {
-    this(term, flags, defaultProvider, determinizeWorkLimit);
+    this(term, flags, DEFAULT_PROVIDER, determinizeWorkLimit);
   }
 
   /**
@@ -100,7 +94,13 @@ public class RegexpQuery extends AutomatonQuery {
    *     otherwise know what to specify.
    */
   public RegexpQuery(Term term, int syntax_flags, int match_flags, int determinizeWorkLimit) {
-    this(term, syntax_flags, match_flags, defaultProvider, determinizeWorkLimit);
+    this(
+        term,
+        syntax_flags,
+        match_flags,
+        DEFAULT_PROVIDER,
+        determinizeWorkLimit,
+        CONSTANT_SCORE_REWRITE);
   }
 
   /**
@@ -116,7 +116,7 @@ public class RegexpQuery extends AutomatonQuery {
    */
   public RegexpQuery(
       Term term, int syntax_flags, AutomatonProvider provider, int determinizeWorkLimit) {
-    this(term, syntax_flags, 0, provider, determinizeWorkLimit);
+    this(term, syntax_flags, 0, provider, determinizeWorkLimit, CONSTANT_SCORE_REWRITE);
   }
 
   /**
@@ -130,18 +130,22 @@ public class RegexpQuery extends AutomatonQuery {
    *     regexp. Set higher to allow more complex queries and lower to prevent memory exhaustion.
    *     Use {@link Operations#DEFAULT_DETERMINIZE_WORK_LIMIT} as a decent default if you don't
    *     otherwise know what to specify.
+   * @param rewriteMethod the rewrite method to use to build the final query
    */
   public RegexpQuery(
       Term term,
       int syntax_flags,
       int match_flags,
       AutomatonProvider provider,
-      int determinizeWorkLimit) {
+      int determinizeWorkLimit,
+      RewriteMethod rewriteMethod) {
     super(
         term,
         new RegExp(term.text(), syntax_flags, match_flags)
             .toAutomaton(provider, determinizeWorkLimit),
-        determinizeWorkLimit);
+        determinizeWorkLimit,
+        false,
+        rewriteMethod);
   }
 
   /** Returns the regexp of this query wrapped in a Term. */
diff --git a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
index 5179f21..d2ee233 100644
--- a/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
+++ b/lucene/core/src/java/org/apache/lucene/search/ScoringRewrite.java
@@ -46,8 +46,6 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {
    *
    * <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
    * of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
-   *
-   * @see MultiTermQuery#setRewriteMethod
    */
   public static final ScoringRewrite<BooleanQuery.Builder> SCORING_BOOLEAN_REWRITE =
       new ScoringRewrite<BooleanQuery.Builder>() {
@@ -84,8 +82,6 @@ public abstract class ScoringRewrite<B> extends TermCollectingRewrite<B> {
    *
    * <p><b>NOTE</b>: This rewrite method will hit {@link IndexSearcher.TooManyClauses} if the number
    * of terms exceeds {@link IndexSearcher#getMaxClauseCount}.
-   *
-   * @see MultiTermQuery#setRewriteMethod
    */
   public static final RewriteMethod CONSTANT_SCORE_BOOLEAN_REWRITE =
       new RewriteMethod() {
diff --git a/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java b/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
index c446602..0020481 100644
--- a/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/TermRangeQuery.java
@@ -60,11 +60,37 @@ public class TermRangeQuery extends AutomatonQuery {
       BytesRef upperTerm,
       boolean includeLower,
       boolean includeUpper) {
+    this(field, lowerTerm, upperTerm, includeLower, includeUpper, CONSTANT_SCORE_REWRITE);
+  }
+
+  /**
+   * Constructs a query selecting all terms greater/equal than <code>lowerTerm</code> but less/equal
+   * than <code>upperTerm</code>.
+   *
+   * <p>If an endpoint is null, it is said to be "open". Either or both endpoints may be open. Open
+   * endpoints may not be exclusive (you can't select all but the first or last term without
+   * explicitly specifying the term to exclude.)
+   *
+   * @param field The field that holds both lower and upper terms.
+   * @param lowerTerm The term text at the lower end of the range
+   * @param upperTerm The term text at the upper end of the range
+   * @param includeLower If true, the <code>lowerTerm</code> is included in the range.
+   * @param includeUpper If true, the <code>upperTerm</code> is included in the range.
+   * @param rewriteMethod the rewrite method to use when building the final query
+   */
+  public TermRangeQuery(
+      String field,
+      BytesRef lowerTerm,
+      BytesRef upperTerm,
+      boolean includeLower,
+      boolean includeUpper,
+      RewriteMethod rewriteMethod) {
     super(
         new Term(field, lowerTerm),
         toAutomaton(lowerTerm, upperTerm, includeLower, includeUpper),
         Integer.MAX_VALUE,
-        true);
+        true,
+        rewriteMethod);
     this.lowerTerm = lowerTerm;
     this.upperTerm = upperTerm;
     this.includeLower = includeLower;
@@ -94,9 +120,21 @@ public class TermRangeQuery extends AutomatonQuery {
       String upperTerm,
       boolean includeLower,
       boolean includeUpper) {
+    return newStringRange(
+        field, lowerTerm, upperTerm, includeLower, includeUpper, CONSTANT_SCORE_REWRITE);
+  }
+
+  /** Factory that creates a new TermRangeQuery using Strings for term text. */
+  public static TermRangeQuery newStringRange(
+      String field,
+      String lowerTerm,
+      String upperTerm,
+      boolean includeLower,
+      boolean includeUpper,
+      RewriteMethod rewriteMethod) {
     BytesRef lower = lowerTerm == null ? null : new BytesRef(lowerTerm);
     BytesRef upper = upperTerm == null ? null : new BytesRef(upperTerm);
-    return new TermRangeQuery(field, lower, upper, includeLower, includeUpper);
+    return new TermRangeQuery(field, lower, upper, includeLower, includeUpper, rewriteMethod);
   }
 
   /** Returns the lower value of this range query */
diff --git a/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java b/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
index 19f312e..aeaecb1 100644
--- a/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
+++ b/lucene/core/src/java/org/apache/lucene/search/WildcardQuery.java
@@ -59,7 +59,20 @@ public class WildcardQuery extends AutomatonQuery {
    *     otherwise know what to specify.
    */
   public WildcardQuery(Term term, int determinizeWorkLimit) {
-    super(term, toAutomaton(term), determinizeWorkLimit);
+    this(term, determinizeWorkLimit, CONSTANT_SCORE_REWRITE);
+  }
+
+  /**
+   * Constructs a query for terms matching <code>term</code>.
+   *
+   * @param determinizeWorkLimit maximum effort to spend while compiling the automaton from this
+   *     wildcard. Set higher to allow more complex queries and lower to prevent memory exhaustion.
+   *     Use {@link Operations#DEFAULT_DETERMINIZE_WORK_LIMIT} as a decent default if you don't
+   *     otherwise know what to specify.
+   * @param rewriteMethod the rewrite method to use when building the final query
+   */
+  public WildcardQuery(Term term, int determinizeWorkLimit, RewriteMethod rewriteMethod) {
+    super(term, toAutomaton(term), determinizeWorkLimit, false, rewriteMethod);
   }
 
   /**
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
index 5d75eed..c8c5ffe 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQuery.java
@@ -91,16 +91,33 @@ public class TestAutomatonQuery extends LuceneTestCase {
   }
 
   private void assertAutomatonHits(int expected, Automaton automaton) throws IOException {
-    AutomatonQuery query = new AutomatonQuery(newTerm("bogus"), automaton);
-
-    query.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
-
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
-
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.SCORING_BOOLEAN_REWRITE)));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.CONSTANT_SCORE_REWRITE)));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE)));
   }
 
   /** Test some very simple automata. */
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
index 951dbd8..314b32a 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestAutomatonQueryUnicode.java
@@ -25,6 +25,7 @@ import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.util.automaton.Automaton;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 
 /**
@@ -97,16 +98,33 @@ public class TestAutomatonQueryUnicode extends LuceneTestCase {
   }
 
   private void assertAutomatonHits(int expected, Automaton automaton) throws IOException {
-    AutomatonQuery query = new AutomatonQuery(newTerm("bogus"), automaton);
-
-    query.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
-
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
-
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
-    assertEquals(expected, automatonQueryNrHits(query));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.SCORING_BOOLEAN_REWRITE)));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.CONSTANT_SCORE_REWRITE)));
+    assertEquals(
+        expected,
+        automatonQueryNrHits(
+            new AutomatonQuery(
+                newTerm("bogus"),
+                automaton,
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                false,
+                MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE)));
   }
 
   /**
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
index 5d8e828..75ede47 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestBooleanQuery.java
@@ -47,6 +47,7 @@ import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.tests.util.TestUtil;
 import org.apache.lucene.util.IOUtils;
 import org.apache.lucene.util.NamedThreadFactory;
+import org.apache.lucene.util.automaton.Operations;
 
 public class TestBooleanQuery extends LuceneTestCase {
 
@@ -254,8 +255,11 @@ public class TestBooleanQuery extends LuceneTestCase {
 
     BooleanQuery.Builder query = new BooleanQuery.Builder(); // Query: +foo -ba*
     query.add(new TermQuery(new Term("field", "foo")), BooleanClause.Occur.MUST);
-    WildcardQuery wildcardQuery = new WildcardQuery(new Term("field", "ba*"));
-    wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    WildcardQuery wildcardQuery =
+        new WildcardQuery(
+            new Term("field", "ba*"),
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.SCORING_BOOLEAN_REWRITE);
     query.add(wildcardQuery, BooleanClause.Occur.MUST_NOT);
 
     MultiReader multireader = new MultiReader(reader1, reader2);
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
index a694ed6..a87ca46 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestDocValuesRewriteMethod.java
@@ -36,6 +36,7 @@ import org.apache.lucene.tests.util.TestUtil;
 import org.apache.lucene.tests.util.automaton.AutomatonTestUtil;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.UnicodeUtil;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 
 /** Tests the DocValuesRewriteMethod */
@@ -114,8 +115,14 @@ public class TestDocValuesRewriteMethod extends LuceneTestCase {
 
   /** check that the # of hits is the same as if the query is run against the inverted index */
   protected void assertSame(String regexp) throws IOException {
-    RegexpQuery docValues = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
-    docValues.setRewriteMethod(new DocValuesRewriteMethod());
+    RegexpQuery docValues =
+        new RegexpQuery(
+            new Term(fieldName, regexp),
+            RegExp.NONE,
+            0,
+            name -> null,
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            new DocValuesRewriteMethod());
     RegexpQuery inverted = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
 
     TopDocs invertedDocs = searcher1.search(inverted, 25);
@@ -125,17 +132,42 @@ public class TestDocValuesRewriteMethod extends LuceneTestCase {
   }
 
   public void testEquals() throws Exception {
-    RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
-    RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
-    RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
-    assertEquals(a1, a2);
-    assertFalse(a1.equals(b));
+    {
+      RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+      RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+      RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
+      assertEquals(a1, a2);
+      assertFalse(a1.equals(b));
+    }
 
-    a1.setRewriteMethod(new DocValuesRewriteMethod());
-    a2.setRewriteMethod(new DocValuesRewriteMethod());
-    b.setRewriteMethod(new DocValuesRewriteMethod());
-    assertEquals(a1, a2);
-    assertFalse(a1.equals(b));
-    QueryUtils.check(a1);
+    {
+      RegexpQuery a1 =
+          new RegexpQuery(
+              new Term(fieldName, "[aA]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      RegexpQuery a2 =
+          new RegexpQuery(
+              new Term(fieldName, "[aA]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      RegexpQuery b =
+          new RegexpQuery(
+              new Term(fieldName, "[bB]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      assertEquals(a1, a2);
+      assertFalse(a1.equals(b));
+      QueryUtils.check(a1);
+    }
   }
 }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java b/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
index ca78ac3..d48f9a6 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestFieldCacheRewriteMethod.java
@@ -20,6 +20,7 @@ import java.io.IOException;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.tests.search.CheckHits;
 import org.apache.lucene.tests.search.QueryUtils;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 
 /** Tests the FieldcacheRewriteMethod with random regular expressions */
@@ -28,11 +29,23 @@ public class TestFieldCacheRewriteMethod extends TestRegexpRandom2 {
   /** Test fieldcache rewrite against filter rewrite */
   @Override
   protected void assertSame(String regexp) throws IOException {
-    RegexpQuery fieldCache = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
-    fieldCache.setRewriteMethod(new DocValuesRewriteMethod());
+    RegexpQuery fieldCache =
+        new RegexpQuery(
+            new Term(fieldName, regexp),
+            RegExp.NONE,
+            0,
+            name -> null,
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            new DocValuesRewriteMethod());
 
-    RegexpQuery filter = new RegexpQuery(new Term(fieldName, regexp), RegExp.NONE);
-    filter.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+    RegexpQuery filter =
+        new RegexpQuery(
+            new Term(fieldName, regexp),
+            RegExp.NONE,
+            0,
+            name -> null,
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.CONSTANT_SCORE_REWRITE);
 
     TopDocs fieldCacheDocs = searcher1.search(fieldCache, 25);
     TopDocs filterDocs = searcher2.search(filter, 25);
@@ -41,17 +54,43 @@ public class TestFieldCacheRewriteMethod extends TestRegexpRandom2 {
   }
 
   public void testEquals() throws Exception {
-    RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
-    RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
-    RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
-    assertEquals(a1, a2);
-    assertFalse(a1.equals(b));
-
-    a1.setRewriteMethod(new DocValuesRewriteMethod());
-    a2.setRewriteMethod(new DocValuesRewriteMethod());
-    b.setRewriteMethod(new DocValuesRewriteMethod());
-    assertEquals(a1, a2);
-    assertFalse(a1.equals(b));
-    QueryUtils.check(a1);
+    {
+      RegexpQuery a1 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+      RegexpQuery a2 = new RegexpQuery(new Term(fieldName, "[aA]"), RegExp.NONE);
+      RegexpQuery b = new RegexpQuery(new Term(fieldName, "[bB]"), RegExp.NONE);
+      assertEquals(a1, a2);
+      assertFalse(a1.equals(b));
+      QueryUtils.check(a1);
+    }
+
+    {
+      RegexpQuery a1 =
+          new RegexpQuery(
+              new Term(fieldName, "[aA]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      RegexpQuery a2 =
+          new RegexpQuery(
+              new Term(fieldName, "[aA]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      RegexpQuery b =
+          new RegexpQuery(
+              new Term(fieldName, "[bB]"),
+              RegExp.NONE,
+              0,
+              name -> null,
+              Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+              new DocValuesRewriteMethod());
+      assertEquals(a1, a2);
+      assertFalse(a1.equals(b));
+      QueryUtils.check(a1);
+    }
   }
 }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
index 2f9d2b7..ca72de8 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestFuzzyQuery.java
@@ -440,8 +440,14 @@ public class TestFuzzyQuery extends LuceneTestCase {
     IndexSearcher searcher = newSearcher(reader);
     writer.close();
 
-    FuzzyQuery query = new FuzzyQuery(new Term("field", "lucene"));
-    query.setRewriteMethod(new MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite(50));
+    FuzzyQuery query =
+        new FuzzyQuery(
+            new Term("field", "lucene"),
+            FuzzyQuery.defaultMaxEdits,
+            FuzzyQuery.defaultPrefixLength,
+            FuzzyQuery.defaultMaxExpansions,
+            FuzzyQuery.defaultTranspositions,
+            new MultiTermQuery.TopTermsBoostOnlyBooleanQueryRewrite(50));
     ScoreDoc[] hits = searcher.search(query, 1000).scoreDocs;
     assertEquals(3, hits.length);
     // normally, 'Lucenne' would be the first result as IDF will skew the score.
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
index fa61910..0fd1c15 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermConstantScore.java
@@ -28,6 +28,7 @@ import org.apache.lucene.tests.analysis.MockAnalyzer;
 import org.apache.lucene.tests.analysis.MockTokenizer;
 import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.tests.search.QueryUtils;
+import org.apache.lucene.util.automaton.Operations;
 import org.junit.AfterClass;
 import org.junit.Assert;
 import org.junit.BeforeClass;
@@ -94,8 +95,8 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
 
   /** macro for readability */
   public static Query csrq(String f, String l, String h, boolean il, boolean ih) {
-    TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih);
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+    TermRangeQuery query =
+        TermRangeQuery.newStringRange(f, l, h, il, ih, MultiTermQuery.CONSTANT_SCORE_REWRITE);
     if (VERBOSE) {
       System.out.println("TEST: query=" + query);
     }
@@ -104,8 +105,7 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
 
   public static Query csrq(
       String f, String l, String h, boolean il, boolean ih, MultiTermQuery.RewriteMethod method) {
-    TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih);
-    query.setRewriteMethod(method);
+    TermRangeQuery query = TermRangeQuery.newStringRange(f, l, h, il, ih, method);
     if (VERBOSE) {
       System.out.println("TEST: query=" + query + " method=" + method);
     }
@@ -114,16 +114,13 @@ public class TestMultiTermConstantScore extends TestBaseRangeFilter {
 
   /** macro for readability */
   public static Query cspq(Term prefix) {
-    PrefixQuery query = new PrefixQuery(prefix);
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
-    return query;
+    return new PrefixQuery(prefix, MultiTermQuery.CONSTANT_SCORE_REWRITE);
   }
 
   /** macro for readability */
   public static Query cswcq(Term wild) {
-    WildcardQuery query = new WildcardQuery(wild);
-    query.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
-    return query;
+    return new WildcardQuery(
+        wild, Operations.DEFAULT_DETERMINIZE_WORK_LIMIT, MultiTermQuery.CONSTANT_SCORE_REWRITE);
   }
 
   @Test
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
index fb36de7..216cc77 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestMultiTermQueryRewrites.java
@@ -120,8 +120,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
   }
 
   private void checkDuplicateTerms(MultiTermQuery.RewriteMethod method) throws Exception {
-    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
-    mtq.setRewriteMethod(method);
+    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
     final Query q1 = searcher.rewrite(mtq);
     final Query q2 = multiSearcher.rewrite(mtq);
     final Query q3 = multiSearcherDupls.rewrite(mtq);
@@ -163,7 +162,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
 
   private void checkBoosts(MultiTermQuery.RewriteMethod method) throws Exception {
     final MultiTermQuery mtq =
-        new MultiTermQuery("data") {
+        new MultiTermQuery("data", method) {
           @Override
           protected TermsEnum getTermsEnum(Terms terms, AttributeSource atts) throws IOException {
             return new FilteredTermsEnum(terms.iterator()) {
@@ -198,7 +197,6 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
           @Override
           public void visit(QueryVisitor visitor) {}
         };
-    mtq.setRewriteMethod(method);
     final Query q1 = searcher.rewrite(mtq);
     final Query q2 = multiSearcher.rewrite(mtq);
     final Query q3 = multiSearcherDupls.rewrite(mtq);
@@ -233,8 +231,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
     int savedMaxClauseCount = IndexSearcher.getMaxClauseCount();
     IndexSearcher.setMaxClauseCount(3);
 
-    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
-    mtq.setRewriteMethod(method);
+    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
     try {
       IndexSearcher.TooManyClauses expected =
           expectThrows(
@@ -256,8 +253,7 @@ public class TestMultiTermQueryRewrites extends LuceneTestCase {
     int savedMaxClauseCount = IndexSearcher.getMaxClauseCount();
     IndexSearcher.setMaxClauseCount(3);
 
-    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true);
-    mtq.setRewriteMethod(method);
+    final MultiTermQuery mtq = TermRangeQuery.newStringRange("data", "2", "7", true, true, method);
     try {
       multiSearcherDupls.rewrite(mtq);
     } finally {
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
index 2d0cdec..c6136be 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestPrefixRandom.java
@@ -81,7 +81,7 @@ public class TestPrefixRandom extends LuceneTestCase {
     private final BytesRef prefix;
 
     DumbPrefixQuery(Term term) {
-      super(term.field());
+      super(term.field(), CONSTANT_SCORE_REWRITE);
       prefix = term.bytes();
     }
 
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
index 13f76b7..8d97672 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestRegexpRandom2.java
@@ -109,7 +109,7 @@ public class TestRegexpRandom2 extends LuceneTestCase {
     private final Automaton automaton;
 
     DumbRegexpQuery(Term term, int flags) {
-      super(term.field());
+      super(term.field(), MultiTermQuery.CONSTANT_SCORE_REWRITE);
       RegExp re = new RegExp(term.text(), flags);
       automaton = re.toAutomaton();
     }
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
index 6cde85a..8dd192e 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestTermRangeQuery.java
@@ -128,7 +128,10 @@ public class TestTermRangeQuery extends LuceneTestCase {
 
     IndexReader reader = DirectoryReader.open(dir);
     IndexSearcher searcher = newSearcher(reader);
-    TermRangeQuery query = TermRangeQuery.newStringRange("content", "B", "J", true, true);
+    MultiTermQuery.RewriteMethod rewriteMethod =
+        new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(50);
+    TermRangeQuery query =
+        TermRangeQuery.newStringRange("content", "B", "J", true, true, rewriteMethod);
     checkBooleanTerms(searcher, query, "B", "C", "D", "E", "F", "G", "H", "I", "J");
 
     final int savedClauseCount = IndexSearcher.getMaxClauseCount();
@@ -143,7 +146,6 @@ public class TestTermRangeQuery extends LuceneTestCase {
 
   private void checkBooleanTerms(IndexSearcher searcher, TermRangeQuery query, String... terms)
       throws IOException {
-    query.setRewriteMethod(new MultiTermQuery.TopTermsScoringBooleanQueryRewrite(50));
     final BooleanQuery bq = (BooleanQuery) searcher.rewrite(query);
     final Set<String> allowedTerms = asSet(terms);
     assertEquals(allowedTerms.size(), bq.clauses().size());
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
index 83cf933..4522ab8 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestWildcard.java
@@ -28,6 +28,7 @@ import org.apache.lucene.store.Directory;
 import org.apache.lucene.tests.analysis.MockAnalyzer;
 import org.apache.lucene.tests.index.RandomIndexWriter;
 import org.apache.lucene.tests.util.LuceneTestCase;
+import org.apache.lucene.util.automaton.Operations;
 
 /** TestWildcard tests the '*' and '?' wildcard characters. */
 public class TestWildcard extends LuceneTestCase {
@@ -66,16 +67,28 @@ public class TestWildcard extends LuceneTestCase {
     MultiTermQuery wq = new WildcardQuery(new Term("field", "nowildcard"));
     assertMatches(searcher, wq, 1);
 
-    wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    Query q = searcher.rewrite(wq);
+    Query q =
+        searcher.rewrite(
+            new WildcardQuery(
+                new Term("field", "nowildcard"),
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                MultiTermQuery.SCORING_BOOLEAN_REWRITE));
     assertTrue(q instanceof TermQuery);
 
-    wq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
-    q = searcher.rewrite(wq);
+    q =
+        searcher.rewrite(
+            new WildcardQuery(
+                new Term("field", "nowildcard"),
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                MultiTermQuery.CONSTANT_SCORE_REWRITE));
     assertTrue(q instanceof MultiTermQueryConstantScoreWrapper);
 
-    wq.setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE);
-    q = searcher.rewrite(wq);
+    q =
+        searcher.rewrite(
+            new WildcardQuery(
+                new Term("field", "nowildcard"),
+                Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                MultiTermQuery.CONSTANT_SCORE_BOOLEAN_REWRITE));
     assertTrue(q instanceof ConstantScoreQuery);
     reader.close();
     indexStore.close();
@@ -87,8 +100,11 @@ public class TestWildcard extends LuceneTestCase {
     IndexReader reader = DirectoryReader.open(indexStore);
     IndexSearcher searcher = newSearcher(reader);
 
-    MultiTermQuery wq = new WildcardQuery(new Term("field", ""));
-    wq.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    MultiTermQuery wq =
+        new WildcardQuery(
+            new Term("field", ""),
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.SCORING_BOOLEAN_REWRITE);
     assertMatches(searcher, wq, 0);
     Query q = searcher.rewrite(wq);
     assertTrue(q instanceof MatchNoDocsQuery);
diff --git a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
index 895a704..185c217 100644
--- a/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
+++ b/lucene/highlighter/src/test/org/apache/lucene/search/highlight/TestHighlighter.java
@@ -92,6 +92,7 @@ import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.util.BytesRef;
 import org.apache.lucene.util.automaton.Automata;
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 import org.w3c.dom.Element;
 import org.w3c.dom.NodeList;
@@ -985,8 +986,14 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
           @Override
           public void run() throws Exception {
             numHighlights = 0;
-            FuzzyQuery fuzzyQuery = new FuzzyQuery(new Term(FIELD_NAME, "kinnedy"), 2);
-            fuzzyQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+            FuzzyQuery fuzzyQuery =
+                new FuzzyQuery(
+                    new Term(FIELD_NAME, "kinnedy"),
+                    2,
+                    FuzzyQuery.defaultPrefixLength,
+                    FuzzyQuery.defaultMaxExpansions,
+                    FuzzyQuery.defaultTranspositions,
+                    MultiTermQuery.SCORING_BOOLEAN_REWRITE);
             doSearching(fuzzyQuery);
             doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this, true);
             assertTrue(
@@ -1005,8 +1012,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
           @Override
           public void run() throws Exception {
             numHighlights = 0;
-            WildcardQuery wildcardQuery = new WildcardQuery(new Term(FIELD_NAME, "k?nnedy"));
-            wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+            WildcardQuery wildcardQuery =
+                new WildcardQuery(
+                    new Term(FIELD_NAME, "k?nnedy"),
+                    Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                    MultiTermQuery.SCORING_BOOLEAN_REWRITE);
             doSearching(wildcardQuery);
             doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
             assertTrue(
@@ -1025,8 +1035,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
           @Override
           public void run() throws Exception {
             numHighlights = 0;
-            WildcardQuery wildcardQuery = new WildcardQuery(new Term(FIELD_NAME, "k*dy"));
-            wildcardQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+            WildcardQuery wildcardQuery =
+                new WildcardQuery(
+                    new Term(FIELD_NAME, "k*dy"),
+                    Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+                    MultiTermQuery.SCORING_BOOLEAN_REWRITE);
             doSearching(wildcardQuery);
             doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
             assertTrue(
@@ -1050,12 +1063,14 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
             // rather
             // than RangeFilters
 
-            TermRangeQuery rangeQuery =
+            query =
                 new TermRangeQuery(
-                    FIELD_NAME, new BytesRef("kannedy"), new BytesRef("kznnedy"), true, true);
-            rangeQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-
-            query = rangeQuery;
+                    FIELD_NAME,
+                    new BytesRef("kannedy"),
+                    new BytesRef("kznnedy"),
+                    true,
+                    true,
+                    MultiTermQuery.SCORING_BOOLEAN_REWRITE);
             doSearching(query);
 
             doStandardHighlights(analyzer, searcher, hits, query, TestHighlighter.this);
@@ -1072,8 +1087,11 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
 
     numHighlights = 0;
 
-    query = new WildcardQuery(new Term(FIELD_NAME, "ken*"));
-    ((WildcardQuery) query).setRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
+    query =
+        new WildcardQuery(
+            new Term(FIELD_NAME, "ken*"),
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.CONSTANT_SCORE_REWRITE);
     searcher = newSearcher(reader);
     // can't rewrite ConstantScore if you want to highlight it -
     // it rewrites to ConstantScoreQuery which cannot be highlighted
@@ -1288,8 +1306,9 @@ public class TestHighlighter extends BaseTokenStreamTestCase implements Formatte
             numHighlights = 0;
             BooleanQuery.Builder booleanQuery = new BooleanQuery.Builder();
             booleanQuery.add(new TermQuery(new Term(FIELD_NAME, "john")), Occur.SHOULD);
-            PrefixQuery prefixQuery = new PrefixQuery(new Term(FIELD_NAME, "kenn"));
-            prefixQuery.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+            PrefixQuery prefixQuery =
+                new PrefixQuery(
+                    new Term(FIELD_NAME, "kenn"), MultiTermQuery.SCORING_BOOLEAN_REWRITE);
             booleanQuery.add(prefixQuery, Occur.SHOULD);
 
             doSearching(booleanQuery.build());
diff --git a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
index 67d6336..29f02e5 100644
--- a/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
+++ b/lucene/join/src/java/org/apache/lucene/search/join/TermsQuery.java
@@ -63,7 +63,7 @@ class TermsQuery extends MultiTermQuery implements Accountable {
       String fromField,
       Query fromQuery,
       Object indexReaderContextId) {
-    super(toField);
+    super(toField, CONSTANT_SCORE_REWRITE);
     this.terms = terms;
     ords = terms.sort();
     this.fromField = fromField;
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
index 0595b86..433e824 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/classic/QueryParserBase.java
@@ -541,9 +541,7 @@ public abstract class QueryParserBase extends QueryBuilder
    * @return new PrefixQuery instance
    */
   protected Query newPrefixQuery(Term prefix) {
-    PrefixQuery query = new PrefixQuery(prefix);
-    query.setRewriteMethod(multiTermRewriteMethod);
-    return query;
+    return new PrefixQuery(prefix, multiTermRewriteMethod);
   }
 
   /**
@@ -553,9 +551,13 @@ public abstract class QueryParserBase extends QueryBuilder
    * @return new RegexpQuery instance
    */
   protected Query newRegexpQuery(Term regexp) {
-    RegexpQuery query = new RegexpQuery(regexp, RegExp.ALL, determinizeWorkLimit);
-    query.setRewriteMethod(multiTermRewriteMethod);
-    return query;
+    return new RegexpQuery(
+        regexp,
+        RegExp.ALL,
+        0,
+        RegexpQuery.DEFAULT_PROVIDER,
+        determinizeWorkLimit,
+        multiTermRewriteMethod);
   }
 
   /**
@@ -601,11 +603,8 @@ public abstract class QueryParserBase extends QueryBuilder
       end = getAnalyzer().normalize(field, part2);
     }
 
-    final TermRangeQuery query =
-        new TermRangeQuery(field, start, end, startInclusive, endInclusive);
-
-    query.setRewriteMethod(multiTermRewriteMethod);
-    return query;
+    return new TermRangeQuery(
+        field, start, end, startInclusive, endInclusive, multiTermRewriteMethod);
   }
 
   /**
@@ -624,9 +623,7 @@ public abstract class QueryParserBase extends QueryBuilder
    * @return new WildcardQuery instance
    */
   protected Query newWildcardQuery(Term t) {
-    WildcardQuery query = new WildcardQuery(t, determinizeWorkLimit);
-    query.setRewriteMethod(multiTermRewriteMethod);
-    return query;
+    return new WildcardQuery(t, determinizeWorkLimit, multiTermRewriteMethod);
   }
 
   /**
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
index 3f09279..55f230b 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/PrefixWildcardQueryNodeBuilder.java
@@ -36,16 +36,15 @@ public class PrefixWildcardQueryNodeBuilder implements StandardQueryBuilder {
 
     PrefixWildcardQueryNode wildcardNode = (PrefixWildcardQueryNode) queryNode;
 
-    String text =
-        wildcardNode.getText().subSequence(0, wildcardNode.getText().length() - 1).toString();
-    PrefixQuery q = new PrefixQuery(new Term(wildcardNode.getFieldAsString(), text));
-
     MultiTermQuery.RewriteMethod method =
         (MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
-    if (method != null) {
-      q.setRewriteMethod(method);
+    if (method == null) {
+      method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
     }
 
-    return q;
+    String text =
+        wildcardNode.getText().subSequence(0, wildcardNode.getText().length() - 1).toString();
+
+    return new PrefixQuery(new Term(wildcardNode.getFieldAsString(), text), method);
   }
 }
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
index ac64f6b..a124caa 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/RegexpQueryNodeBuilder.java
@@ -23,6 +23,8 @@ import org.apache.lucene.queryparser.flexible.standard.nodes.RegexpQueryNode;
 import org.apache.lucene.queryparser.flexible.standard.processors.MultiTermRewriteMethodProcessor;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.RegexpQuery;
+import org.apache.lucene.util.automaton.Operations;
+import org.apache.lucene.util.automaton.RegExp;
 
 /** Builds a {@link RegexpQuery} object from a {@link RegexpQueryNode} object. */
 public class RegexpQueryNodeBuilder implements StandardQueryBuilder {
@@ -35,16 +37,19 @@ public class RegexpQueryNodeBuilder implements StandardQueryBuilder {
   public RegexpQuery build(QueryNode queryNode) throws QueryNodeException {
     RegexpQueryNode regexpNode = (RegexpQueryNode) queryNode;
 
-    // TODO: make the maxStates configurable w/ a reasonable default (QueryParserBase uses 10000)
-    RegexpQuery q =
-        new RegexpQuery(new Term(regexpNode.getFieldAsString(), regexpNode.textToBytesRef()));
-
     MultiTermQuery.RewriteMethod method =
         (MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
-    if (method != null) {
-      q.setRewriteMethod(method);
+    if (method == null) {
+      method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
     }
 
-    return q;
+    // TODO: make the maxStates configurable w/ a reasonable default (QueryParserBase uses 10000)
+    return new RegexpQuery(
+        new Term(regexpNode.getFieldAsString(), regexpNode.textToBytesRef()),
+        RegExp.ALL,
+        0,
+        name -> null,
+        Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+        method);
   }
 }
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
index 929a952..05766f5 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/TermRangeQueryNodeBuilder.java
@@ -50,20 +50,18 @@ public class TermRangeQueryNodeBuilder implements StandardQueryBuilder {
       upperText = null;
     }
 
-    TermRangeQuery rangeQuery =
-        TermRangeQuery.newStringRange(
-            field,
-            lowerText,
-            upperText,
-            rangeNode.isLowerInclusive(),
-            rangeNode.isUpperInclusive());
-
     MultiTermQuery.RewriteMethod method =
         (MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
-    if (method != null) {
-      rangeQuery.setRewriteMethod(method);
+    if (method == null) {
+      method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
     }
 
-    return rangeQuery;
+    return TermRangeQuery.newStringRange(
+        field,
+        lowerText,
+        upperText,
+        rangeNode.isLowerInclusive(),
+        rangeNode.isUpperInclusive(),
+        method);
   }
 }
diff --git a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
index d2b1a73..93bee36 100644
--- a/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
+++ b/lucene/queryparser/src/java/org/apache/lucene/queryparser/flexible/standard/builders/WildcardQueryNodeBuilder.java
@@ -23,6 +23,7 @@ import org.apache.lucene.queryparser.flexible.standard.nodes.WildcardQueryNode;
 import org.apache.lucene.queryparser.flexible.standard.processors.MultiTermRewriteMethodProcessor;
 import org.apache.lucene.search.MultiTermQuery;
 import org.apache.lucene.search.WildcardQuery;
+import org.apache.lucene.util.automaton.Operations;
 
 /** Builds a {@link WildcardQuery} object from a {@link WildcardQueryNode} object. */
 public class WildcardQueryNodeBuilder implements StandardQueryBuilder {
@@ -35,16 +36,15 @@ public class WildcardQueryNodeBuilder implements StandardQueryBuilder {
   public WildcardQuery build(QueryNode queryNode) throws QueryNodeException {
     WildcardQueryNode wildcardNode = (WildcardQueryNode) queryNode;
 
-    WildcardQuery q =
-        new WildcardQuery(
-            new Term(wildcardNode.getFieldAsString(), wildcardNode.getTextAsString()));
-
     MultiTermQuery.RewriteMethod method =
         (MultiTermQuery.RewriteMethod) queryNode.getTag(MultiTermRewriteMethodProcessor.TAG_ID);
-    if (method != null) {
-      q.setRewriteMethod(method);
+    if (method == null) {
+      method = MultiTermQuery.CONSTANT_SCORE_REWRITE;
     }
 
-    return q;
+    return new WildcardQuery(
+        new Term(wildcardNode.getFieldAsString(), wildcardNode.getTextAsString()),
+        Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+        method);
   }
 }
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
index 66a8ccd..a927aaf 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/flexible/standard/TestQPHelper.java
@@ -77,6 +77,7 @@ import org.apache.lucene.tests.analysis.MockTokenizer;
 import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.util.automaton.Automata;
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -1151,14 +1152,6 @@ public class TestQPHelper extends LuceneTestCase {
     assertEquals(q, qp.parse("/[a-z][123]/", df));
     assertEquals(q, qp.parse("/[A-Z][123]/", df));
     assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
-    qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    q.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
-    assertEquals(
-        MultiTermQuery.SCORING_BOOLEAN_REWRITE,
-        ((RegexpQuery) (((BoostQuery) qp.parse("/[A-Z][123]/^0.5", df)).getQuery()))
-            .getRewriteMethod());
-    qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
 
     Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
     assertEquals(escaped, qp.parse("/[a-z]\\/[123]/", df));
@@ -1197,6 +1190,22 @@ public class TestQPHelper extends LuceneTestCase {
     two.add(new RegexpQuery(new Term("field", "bar")), Occur.SHOULD);
     assertEquals(two.build(), qp.parse("field:/foo/ field:/bar/", df));
     assertEquals(two.build(), qp.parse("/foo/ /bar/", df));
+
+    qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    q =
+        new RegexpQuery(
+            new Term("field", "[a-z][123]"),
+            RegExp.ALL,
+            0,
+            name -> null,
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    assertEquals(new BoostQuery(q, 0.5f), qp.parse("/[A-Z][123]/^0.5", df));
+    assertEquals(
+        MultiTermQuery.SCORING_BOOLEAN_REWRITE,
+        ((RegexpQuery) (((BoostQuery) qp.parse("/[A-Z][123]/^0.5", df)).getQuery()))
+            .getRewriteMethod());
+    qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
   }
 
   public void testStopwords() throws Exception {
diff --git a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
index f7f59d6..6a5b385 100644
--- a/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
+++ b/lucene/queryparser/src/test/org/apache/lucene/queryparser/util/QueryParserTestBase.java
@@ -66,6 +66,7 @@ import org.apache.lucene.tests.analysis.MockTokenizer;
 import org.apache.lucene.tests.util.LuceneTestCase;
 import org.apache.lucene.util.automaton.Automata;
 import org.apache.lucene.util.automaton.CharacterRunAutomaton;
+import org.apache.lucene.util.automaton.Operations;
 import org.apache.lucene.util.automaton.RegExp;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
@@ -1035,16 +1036,6 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
     assertEquals(q, getQuery("/[a-z][123]/", qp));
     assertEquals(q, getQuery("/[A-Z][123]/", qp));
     assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
-    qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    q.setRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
-    assertTrue(getQuery("/[A-Z][123]/^0.5", qp) instanceof BoostQuery);
-    assertTrue(((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery() instanceof RegexpQuery);
-    assertEquals(
-        MultiTermQuery.SCORING_BOOLEAN_REWRITE,
-        ((RegexpQuery) ((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery())
-            .getRewriteMethod());
-    assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
-    qp.setMultiTermRewriteMethod(MultiTermQuery.CONSTANT_SCORE_REWRITE);
 
     Query escaped = new RegexpQuery(new Term("field", "[a-z]\\/[123]"));
     assertEquals(escaped, getQuery("/[a-z]\\/[123]/", qp));
@@ -1080,6 +1071,23 @@ public abstract class QueryParserTestBase extends LuceneTestCase {
     two.add(new RegexpQuery(new Term("field", "bar")), Occur.SHOULD);
     assertEquals(two.build(), getQuery("field:/foo/ field:/bar/", qp));
     assertEquals(two.build(), getQuery("/foo/ /bar/", qp));
+
+    qp.setMultiTermRewriteMethod(MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    q =
+        new RegexpQuery(
+            new Term("field", "[a-z][123]"),
+            RegExp.ALL,
+            0,
+            name -> null,
+            Operations.DEFAULT_DETERMINIZE_WORK_LIMIT,
+            MultiTermQuery.SCORING_BOOLEAN_REWRITE);
+    assertTrue(getQuery("/[A-Z][123]/^0.5", qp) instanceof BoostQuery);
+    assertTrue(((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery() instanceof RegexpQuery);
+    assertEquals(
+        MultiTermQuery.SCORING_BOOLEAN_REWRITE,
+        ((RegexpQuery) ((BoostQuery) getQuery("/[A-Z][123]/^0.5", qp)).getQuery())
+            .getRewriteMethod());
+    assertEquals(new BoostQuery(q, 0.5f), getQuery("/[A-Z][123]/^0.5", qp));
   }
 
   public void testStopwords() throws Exception {