From cbfcec9d0e1119382c1c8f788461095a763c302f Mon Sep 17 00:00:00 2001
From: marko-bekhta <marko.prykladna@gmail.com>
Date: Thu, 12 Dec 2024 22:26:08 +0100
Subject: [PATCH] HSEARCH-3319 Address scope changes in the Lucene - next
 backend

---
 .../backend/lucene/LuceneExtension.java       | 41 ++++++++++---------
 .../impl/LuceneSearchIndexScopeImpl.java      | 14 +++----
 .../dsl/LuceneSearchAggregationFactory.java   |  4 +-
 .../LuceneSearchAggregationFactoryImpl.java   | 17 ++++----
 .../dsl/LuceneSearchPredicateFactory.java     |  2 +-
 .../LuceneSearchPredicateFactoryImpl.java     | 11 ++---
 .../predicate/impl/LuceneNamedPredicate.java  |  9 ++--
 .../dsl/LuceneSearchProjectionFactory.java    |  5 ++-
 .../LuceneSearchProjectionFactoryImpl.java    |  9 ++--
 .../dsl/LuceneSearchQueryOptionsStep.java     |  9 ++--
 .../dsl/LuceneSearchQuerySelectStep.java      | 25 +++++------
 .../query/dsl/LuceneSearchQueryWhereStep.java |  4 +-
 .../LuceneSearchQueryOptionsStepImpl.java     | 21 +++++-----
 .../impl/LuceneSearchQuerySelectStepImpl.java | 39 +++++++++---------
 .../impl/LuceneSearchQueryIndexScope.java     |  8 ++--
 .../sort/dsl/LuceneSearchSortFactory.java     |  8 ++--
 .../dsl/impl/LuceneSearchSortFactoryImpl.java | 19 +++++----
 17 files changed, 129 insertions(+), 116 deletions(-)

diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/LuceneExtension.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/LuceneExtension.java
index 179f112a40f..43a4eb1fecb 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/LuceneExtension.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/LuceneExtension.java
@@ -63,22 +63,23 @@
  *
  * @see #get()
  */
-public final class LuceneExtension<H, R, E, LOS>
-		implements SearchQueryDslExtension<LuceneSearchQuerySelectStep<R, E, LOS>, R, E, LOS>,
+public final class LuceneExtension<SR, H, R, E, LOS>
+		implements SearchQueryDslExtension<SR, LuceneSearchQuerySelectStep<SR, R, E, LOS>, R, E, LOS>,
 		SearchQueryExtension<LuceneSearchQuery<H>, H>,
-		SearchPredicateFactoryExtension<LuceneSearchPredicateFactory>,
-		SearchSortFactoryExtension<LuceneSearchSortFactory>,
-		SearchProjectionFactoryExtension<LuceneSearchProjectionFactory<R, E>, R, E>,
-		SearchAggregationFactoryExtension<LuceneSearchAggregationFactory>,
+		SearchPredicateFactoryExtension<SR, LuceneSearchPredicateFactory<SR>>,
+		SearchSortFactoryExtension<SR, LuceneSearchSortFactory<SR>>,
+		SearchProjectionFactoryExtension<SR, LuceneSearchProjectionFactory<SR, R, E>, R, E>,
+		SearchAggregationFactoryExtension<SR, LuceneSearchAggregationFactory<SR>>,
 		IndexFieldTypeFactoryExtension<LuceneIndexFieldTypeFactory>,
 		IndexScopeExtension<LuceneIndexScope>,
 		SchemaExportExtension<LuceneIndexSchemaExport> {
 
-	private static final LuceneExtension<Object, Object, Object, Object> INSTANCE = new LuceneExtension<>();
+	private static final LuceneExtension<Object, Object, Object, Object, Object> INSTANCE = new LuceneExtension<>();
 
 	/**
 	 * Get the extension with generic parameters automatically set as appropriate for the context in which it's used.
 	 *
+	 * @param <SR> Scope root type.
 	 * @param <H> The type of query hits.
 	 * Users should not have to care about this, as the parameter will automatically take the appropriate value when calling
 	 * {@code .extension( LuceneExtension.get() }.
@@ -94,8 +95,8 @@ public final class LuceneExtension<H, R, E, LOS>
 	 * @return The extension.
 	 */
 	@SuppressWarnings("unchecked") // The instance works for any H, R and E
-	public static <H, R, E, LOS> LuceneExtension<H, R, E, LOS> get() {
-		return (LuceneExtension<H, R, E, LOS>) INSTANCE;
+	public static <SR, H, R, E, LOS> LuceneExtension<SR, H, R, E, LOS> get() {
+		return (LuceneExtension<SR, H, R, E, LOS>) INSTANCE;
 	}
 
 	private LuceneExtension() {
@@ -106,8 +107,8 @@ private LuceneExtension() {
 	 * {@inheritDoc}
 	 */
 	@Override
-	public Optional<LuceneSearchQuerySelectStep<R, E, LOS>> extendOptional(
-			SearchQuerySelectStep<?, R, E, LOS, ?, ?> original,
+	public Optional<LuceneSearchQuerySelectStep<SR, R, E, LOS>> extendOptional(
+			SearchQuerySelectStep<SR, ?, R, E, LOS, ?, ?> original,
 			SearchQueryIndexScope<?> scope,
 			BackendSessionContext sessionContext,
 			SearchLoadingContextBuilder<E, LOS> loadingContextBuilder) {
@@ -139,9 +140,9 @@ public Optional<LuceneSearchQuery<H>> extendOptional(SearchQuery<H> original,
 	 * {@inheritDoc}
 	 */
 	@Override
-	public Optional<LuceneSearchPredicateFactory> extendOptional(SearchPredicateFactory original) {
+	public Optional<LuceneSearchPredicateFactory<SR>> extendOptional(SearchPredicateFactory<SR> original) {
 		if ( original instanceof LuceneSearchPredicateFactory ) {
-			return Optional.of( (LuceneSearchPredicateFactory) original );
+			return Optional.of( (LuceneSearchPredicateFactory<SR>) original );
 		}
 		else {
 			return Optional.empty();
@@ -152,10 +153,10 @@ public Optional<LuceneSearchPredicateFactory> extendOptional(SearchPredicateFact
 	 * {@inheritDoc}
 	 */
 	@Override
-	public Optional<LuceneSearchSortFactory> extendOptional(
-			SearchSortFactory original) {
+	public Optional<LuceneSearchSortFactory<SR>> extendOptional(
+			SearchSortFactory<SR> original) {
 		if ( original instanceof LuceneSearchSortFactory ) {
-			return Optional.of( (LuceneSearchSortFactory) original );
+			return Optional.of( (LuceneSearchSortFactory<SR>) original );
 		}
 		else {
 			return Optional.empty();
@@ -166,9 +167,9 @@ public Optional<LuceneSearchSortFactory> extendOptional(
 	 * {@inheritDoc}
 	 */
 	@Override
-	public Optional<LuceneSearchProjectionFactory<R, E>> extendOptional(SearchProjectionFactory<R, E> original) {
+	public Optional<LuceneSearchProjectionFactory<SR, R, E>> extendOptional(SearchProjectionFactory<SR, R, E> original) {
 		if ( original instanceof LuceneSearchProjectionFactory ) {
-			return Optional.of( (LuceneSearchProjectionFactory<R, E>) original );
+			return Optional.of( (LuceneSearchProjectionFactory<SR, R, E>) original );
 		}
 		else {
 			return Optional.empty();
@@ -179,9 +180,9 @@ public Optional<LuceneSearchProjectionFactory<R, E>> extendOptional(SearchProjec
 	 * {@inheritDoc}
 	 */
 	@Override
-	public Optional<LuceneSearchAggregationFactory> extendOptional(SearchAggregationFactory original) {
+	public Optional<LuceneSearchAggregationFactory<SR>> extendOptional(SearchAggregationFactory<SR> original) {
 		if ( original instanceof LuceneSearchAggregationFactory ) {
-			return Optional.of( (LuceneSearchAggregationFactory) original );
+			return Optional.of( (LuceneSearchAggregationFactory<SR>) original );
 		}
 		else {
 			return Optional.empty();
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/scope/model/impl/LuceneSearchIndexScopeImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/scope/model/impl/LuceneSearchIndexScopeImpl.java
index 08770115084..e0e1b54c943 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/scope/model/impl/LuceneSearchIndexScopeImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/scope/model/impl/LuceneSearchIndexScopeImpl.java
@@ -162,24 +162,24 @@ public <P> LuceneSearchQueryBuilder<P> select(BackendSessionContext sessionConte
 	}
 
 	@Override
-	public LuceneSearchPredicateFactory predicateFactory() {
-		return new LuceneSearchPredicateFactoryImpl( SearchPredicateDslContext.root( this ) );
+	public <SR> LuceneSearchPredicateFactory<SR> predicateFactory() {
+		return new LuceneSearchPredicateFactoryImpl<>( SearchPredicateDslContext.root( this ) );
 	}
 
 	@Override
-	public LuceneSearchSortFactory sortFactory() {
-		return new LuceneSearchSortFactoryImpl( SearchSortDslContext
+	public <SR> LuceneSearchSortFactory<SR> sortFactory() {
+		return new LuceneSearchSortFactoryImpl<SR>( SearchSortDslContext
 				.root( this, LuceneSearchSortFactoryImpl::new, predicateFactory() ) );
 	}
 
 	@Override
-	public <R, E> LuceneSearchProjectionFactory<R, E> projectionFactory() {
+	public <SR, R, E> LuceneSearchProjectionFactory<SR, R, E> projectionFactory() {
 		return new LuceneSearchProjectionFactoryImpl<>( SearchProjectionDslContext.root( this ) );
 	}
 
 	@Override
-	public LuceneSearchAggregationFactory aggregationFactory() {
-		return new LuceneSearchAggregationFactoryImpl( SearchAggregationDslContext.root( this, predicateFactory() ) );
+	public <SR> LuceneSearchAggregationFactory<SR> aggregationFactory() {
+		return new LuceneSearchAggregationFactoryImpl<SR>( SearchAggregationDslContext.root( this, predicateFactory() ) );
 	}
 
 	@Override
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/LuceneSearchAggregationFactory.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/LuceneSearchAggregationFactory.java
index 672d8055ef7..3d7ab6f90bb 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/LuceneSearchAggregationFactory.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/LuceneSearchAggregationFactory.java
@@ -7,7 +7,7 @@
 import org.hibernate.search.backend.lucene.search.predicate.dsl.LuceneSearchPredicateFactory;
 import org.hibernate.search.engine.search.aggregation.dsl.ExtendedSearchAggregationFactory;
 
-public interface LuceneSearchAggregationFactory
-		extends ExtendedSearchAggregationFactory<LuceneSearchAggregationFactory, LuceneSearchPredicateFactory> {
+public interface LuceneSearchAggregationFactory<SR>
+		extends ExtendedSearchAggregationFactory<SR, LuceneSearchAggregationFactory<SR>, LuceneSearchPredicateFactory<SR>> {
 
 }
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/impl/LuceneSearchAggregationFactoryImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/impl/LuceneSearchAggregationFactoryImpl.java
index 88f7d780848..b22685c68a8 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/impl/LuceneSearchAggregationFactoryImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/aggregation/dsl/impl/LuceneSearchAggregationFactoryImpl.java
@@ -10,21 +10,24 @@
 import org.hibernate.search.engine.search.aggregation.dsl.spi.AbstractSearchAggregationFactory;
 import org.hibernate.search.engine.search.aggregation.dsl.spi.SearchAggregationDslContext;
 
-public class LuceneSearchAggregationFactoryImpl
+public class LuceneSearchAggregationFactoryImpl<SR>
 		extends AbstractSearchAggregationFactory<
-				LuceneSearchAggregationFactory,
+				SR,
+				LuceneSearchAggregationFactory<SR>,
 				LuceneSearchAggregationIndexScope<?>,
-				LuceneSearchPredicateFactory>
-		implements LuceneSearchAggregationFactory {
+				LuceneSearchPredicateFactory<SR>>
+		implements LuceneSearchAggregationFactory<SR> {
 
 	public LuceneSearchAggregationFactoryImpl(
-			SearchAggregationDslContext<LuceneSearchAggregationIndexScope<?>, LuceneSearchPredicateFactory> dslContext) {
+			SearchAggregationDslContext<SR,
+					LuceneSearchAggregationIndexScope<?>,
+					LuceneSearchPredicateFactory<SR>> dslContext) {
 		super( dslContext );
 	}
 
 	@Override
-	public LuceneSearchAggregationFactory withRoot(String objectFieldPath) {
-		return new LuceneSearchAggregationFactoryImpl( dslContext.rescope(
+	public LuceneSearchAggregationFactory<SR> withRoot(String objectFieldPath) {
+		return new LuceneSearchAggregationFactoryImpl<SR>( dslContext.rescope(
 				dslContext.scope().withRoot( objectFieldPath ),
 				dslContext.predicateFactory().withRoot( objectFieldPath ) ) );
 	}
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/LuceneSearchPredicateFactory.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/LuceneSearchPredicateFactory.java
index 5bfdfc80fad..9fc4d5f8c77 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/LuceneSearchPredicateFactory.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/LuceneSearchPredicateFactory.java
@@ -12,7 +12,7 @@
 /**
  * A factory for search predicates with some Lucene-specific methods.
  */
-public interface LuceneSearchPredicateFactory extends ExtendedSearchPredicateFactory<LuceneSearchPredicateFactory> {
+public interface LuceneSearchPredicateFactory<SR> extends ExtendedSearchPredicateFactory<SR, LuceneSearchPredicateFactory<SR>> {
 
 	/**
 	 * Create a predicate from a Lucene {@link Query}.
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/impl/LuceneSearchPredicateFactoryImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/impl/LuceneSearchPredicateFactoryImpl.java
index 121daec55d3..bb73666ba1b 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/impl/LuceneSearchPredicateFactoryImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/dsl/impl/LuceneSearchPredicateFactoryImpl.java
@@ -13,19 +13,20 @@
 
 import org.apache.lucene.search.Query;
 
-public class LuceneSearchPredicateFactoryImpl
+public class LuceneSearchPredicateFactoryImpl<SR>
 		extends AbstractSearchPredicateFactory<
-				LuceneSearchPredicateFactory,
+				SR,
+				LuceneSearchPredicateFactory<SR>,
 				LuceneSearchPredicateIndexScope<?>>
-		implements LuceneSearchPredicateFactory {
+		implements LuceneSearchPredicateFactory<SR> {
 
 	public LuceneSearchPredicateFactoryImpl(SearchPredicateDslContext<LuceneSearchPredicateIndexScope<?>> dslContext) {
 		super( dslContext );
 	}
 
 	@Override
-	public LuceneSearchPredicateFactory withRoot(String objectFieldPath) {
-		return new LuceneSearchPredicateFactoryImpl( dslContext.rescope(
+	public LuceneSearchPredicateFactory<SR> withRoot(String objectFieldPath) {
+		return new LuceneSearchPredicateFactoryImpl<SR>( dslContext.rescope(
 				dslContext.scope().withRoot( objectFieldPath ) ) );
 	}
 
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/impl/LuceneNamedPredicate.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/impl/LuceneNamedPredicate.java
index 789c1fb1b3e..8da0453254e 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/impl/LuceneNamedPredicate.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/predicate/impl/LuceneNamedPredicate.java
@@ -70,7 +70,7 @@ private static class Builder extends AbstractBuilder implements NamedPredicateBu
 		private final PredicateDefinition definition;
 		private final String predicateName;
 		private final LuceneSearchIndexCompositeNodeContext field;
-		private SearchPredicateFactory factory;
+		private SearchPredicateFactory<?> factory;
 		private final Map<String, Object> params = new LinkedHashMap<>();
 
 		Builder(PredicateDefinition definition, String predicateName, LuceneSearchIndexScope<?> scope,
@@ -82,7 +82,7 @@ private static class Builder extends AbstractBuilder implements NamedPredicateBu
 		}
 
 		@Override
-		public void factory(SearchPredicateFactory factory) {
+		public void factory(SearchPredicateFactory<?> factory) {
 			this.factory = factory;
 		}
 
@@ -93,8 +93,9 @@ public void param(String name, Object value) {
 
 		@Override
 		public SearchPredicate build() {
-			NamedValuesBasedPredicateDefinitionContext ctx = new NamedValuesBasedPredicateDefinitionContext( factory, params,
-					name -> QueryLog.INSTANCE.paramNotDefined( name, predicateName, field.eventContext() ) );
+			NamedValuesBasedPredicateDefinitionContext<?> ctx =
+					new NamedValuesBasedPredicateDefinitionContext<>( factory, params,
+							name -> QueryLog.INSTANCE.paramNotDefined( name, predicateName, field.eventContext() ) );
 
 			LuceneSearchPredicate providedPredicate = LuceneSearchPredicate.from( scope, definition.create( ctx ) );
 
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/LuceneSearchProjectionFactory.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/LuceneSearchProjectionFactory.java
index abf30741110..94d8717e4c0 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/LuceneSearchProjectionFactory.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/LuceneSearchProjectionFactory.java
@@ -15,12 +15,13 @@
 /**
  * A factory for search projections with some Lucene-specific methods.
  *
+ * @param <SR> Scope root type.
  * @param <R> The type of entity references.
  * @param <E> The type of entities.
  * @see SearchProjectionFactory
  */
-public interface LuceneSearchProjectionFactory<R, E>
-		extends ExtendedSearchProjectionFactory<LuceneSearchProjectionFactory<R, E>, R, E> {
+public interface LuceneSearchProjectionFactory<SR, R, E>
+		extends ExtendedSearchProjectionFactory<SR, LuceneSearchProjectionFactory<SR, R, E>, R, E> {
 
 	/**
 	 * Project to a Lucene {@link Document} containing all the stored fields.
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/impl/LuceneSearchProjectionFactoryImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/impl/LuceneSearchProjectionFactoryImpl.java
index daf4eb4bfdd..8b1d8c2d554 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/impl/LuceneSearchProjectionFactoryImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/projection/dsl/impl/LuceneSearchProjectionFactoryImpl.java
@@ -15,20 +15,21 @@
 import org.apache.lucene.document.Document;
 import org.apache.lucene.search.Explanation;
 
-public class LuceneSearchProjectionFactoryImpl<R, E>
+public class LuceneSearchProjectionFactoryImpl<SR, R, E>
 		extends AbstractSearchProjectionFactory<
-				LuceneSearchProjectionFactory<R, E>,
+				SR,
+				LuceneSearchProjectionFactory<SR, R, E>,
 				LuceneSearchProjectionIndexScope<?>,
 				R,
 				E>
-		implements LuceneSearchProjectionFactory<R, E> {
+		implements LuceneSearchProjectionFactory<SR, R, E> {
 
 	public LuceneSearchProjectionFactoryImpl(SearchProjectionDslContext<LuceneSearchProjectionIndexScope<?>> dslContext) {
 		super( dslContext );
 	}
 
 	@Override
-	public LuceneSearchProjectionFactory<R, E> withRoot(String objectFieldPath) {
+	public LuceneSearchProjectionFactory<SR, R, E> withRoot(String objectFieldPath) {
 		return new LuceneSearchProjectionFactoryImpl<>( dslContext.rescope(
 				dslContext.scope().withRoot( objectFieldPath ) ) );
 	}
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryOptionsStep.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryOptionsStep.java
index fca7d25b2f6..df0f94d6d2d 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryOptionsStep.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryOptionsStep.java
@@ -10,13 +10,14 @@
 import org.hibernate.search.backend.lucene.search.sort.dsl.LuceneSearchSortFactory;
 import org.hibernate.search.engine.search.query.dsl.SearchQueryOptionsStep;
 
-public interface LuceneSearchQueryOptionsStep<H, LOS>
+public interface LuceneSearchQueryOptionsStep<SR, H, LOS>
 		extends SearchQueryOptionsStep<
-				LuceneSearchQueryOptionsStep<H, LOS>,
+				SR,
+				LuceneSearchQueryOptionsStep<SR, H, LOS>,
 				H,
 				LOS,
-				LuceneSearchSortFactory,
-				LuceneSearchAggregationFactory>,
+				LuceneSearchSortFactory<SR>,
+				LuceneSearchAggregationFactory<SR>>,
 		LuceneSearchFetchable<H> {
 
 	@Override
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQuerySelectStep.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQuerySelectStep.java
index 0c64a658dd4..44d180ae731 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQuerySelectStep.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQuerySelectStep.java
@@ -13,33 +13,34 @@
 import org.hibernate.search.engine.search.projection.dsl.ProjectionFinalStep;
 import org.hibernate.search.engine.search.query.dsl.SearchQuerySelectStep;
 
-public interface LuceneSearchQuerySelectStep<R, E, LOS>
+public interface LuceneSearchQuerySelectStep<SR, R, E, LOS>
 		extends SearchQuerySelectStep<
-				LuceneSearchQueryOptionsStep<E, LOS>,
+				SR,
+				LuceneSearchQueryOptionsStep<SR, E, LOS>,
 				R,
 				E,
 				LOS,
-				LuceneSearchProjectionFactory<R, E>,
-				LuceneSearchPredicateFactory>,
-		LuceneSearchQueryWhereStep<E, LOS> {
+				LuceneSearchProjectionFactory<SR, R, E>,
+				LuceneSearchPredicateFactory<SR>>,
+		LuceneSearchQueryWhereStep<SR, E, LOS> {
 
 	@Override
-	LuceneSearchQueryWhereStep<E, LOS> selectEntity();
+	LuceneSearchQueryWhereStep<SR, E, LOS> selectEntity();
 
 	@Override
-	LuceneSearchQueryWhereStep<R, LOS> selectEntityReference();
+	LuceneSearchQueryWhereStep<SR, R, LOS> selectEntityReference();
 
 	@Override
-	<P> LuceneSearchQueryWhereStep<P, LOS> select(Class<P> objectClass);
+	<P> LuceneSearchQueryWhereStep<SR, P, LOS> select(Class<P> objectClass);
 
 	@Override
-	<P> LuceneSearchQueryWhereStep<P, LOS> select(
-			Function<? super LuceneSearchProjectionFactory<R, E>, ? extends ProjectionFinalStep<P>> projectionContributor);
+	<P> LuceneSearchQueryWhereStep<SR, P, LOS> select(
+			Function<? super LuceneSearchProjectionFactory<SR, R, E>, ? extends ProjectionFinalStep<P>> projectionContributor);
 
 	@Override
-	<P> LuceneSearchQueryWhereStep<P, LOS> select(SearchProjection<P> projection);
+	<P> LuceneSearchQueryWhereStep<SR, P, LOS> select(SearchProjection<P> projection);
 
 	@Override
-	LuceneSearchQueryWhereStep<List<?>, LOS> select(SearchProjection<?>... projections);
+	LuceneSearchQueryWhereStep<SR, List<?>, LOS> select(SearchProjection<?>... projections);
 
 }
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryWhereStep.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryWhereStep.java
index 04aa09d4e43..cfe93fdeb8c 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryWhereStep.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/LuceneSearchQueryWhereStep.java
@@ -7,7 +7,7 @@
 import org.hibernate.search.backend.lucene.search.predicate.dsl.LuceneSearchPredicateFactory;
 import org.hibernate.search.engine.search.query.dsl.SearchQueryWhereStep;
 
-public interface LuceneSearchQueryWhereStep<H, LOS>
-		extends SearchQueryWhereStep<LuceneSearchQueryOptionsStep<H, LOS>, H, LOS, LuceneSearchPredicateFactory> {
+public interface LuceneSearchQueryWhereStep<SR, H, LOS>
+		extends SearchQueryWhereStep<SR, LuceneSearchQueryOptionsStep<SR, H, LOS>, H, LOS, LuceneSearchPredicateFactory<SR>> {
 
 }
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQueryOptionsStepImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQueryOptionsStepImpl.java
index b7eec76fa5e..3515b979882 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQueryOptionsStepImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQueryOptionsStepImpl.java
@@ -18,18 +18,19 @@
 import org.hibernate.search.engine.search.loading.spi.SearchLoadingContextBuilder;
 import org.hibernate.search.engine.search.query.dsl.spi.AbstractExtendedSearchQueryOptionsStep;
 
-class LuceneSearchQueryOptionsStepImpl<H, LOS>
+class LuceneSearchQueryOptionsStepImpl<SR, H, LOS>
 		extends AbstractExtendedSearchQueryOptionsStep<
-				LuceneSearchQueryOptionsStep<H, LOS>,
+				SR,
+				LuceneSearchQueryOptionsStep<SR, H, LOS>,
 				H,
 				LuceneSearchResult<H>,
 				LuceneSearchScroll<H>,
 				LOS,
-				LuceneSearchPredicateFactory,
-				LuceneSearchSortFactory,
-				LuceneSearchAggregationFactory,
+				LuceneSearchPredicateFactory<SR>,
+				LuceneSearchSortFactory<SR>,
+				LuceneSearchAggregationFactory<SR>,
 				LuceneSearchQueryIndexScope<?>>
-		implements LuceneSearchQueryWhereStep<H, LOS>, LuceneSearchQueryOptionsStep<H, LOS> {
+		implements LuceneSearchQueryWhereStep<SR, H, LOS>, LuceneSearchQueryOptionsStep<SR, H, LOS> {
 
 	private final LuceneSearchQueryBuilder<H> searchQueryBuilder;
 
@@ -46,22 +47,22 @@ public LuceneSearchQuery<H> toQuery() {
 	}
 
 	@Override
-	protected LuceneSearchQueryOptionsStepImpl<H, LOS> thisAsS() {
+	protected LuceneSearchQueryOptionsStepImpl<SR, H, LOS> thisAsS() {
 		return this;
 	}
 
 	@Override
-	protected LuceneSearchPredicateFactory predicateFactory() {
+	protected LuceneSearchPredicateFactory<SR> predicateFactory() {
 		return scope.predicateFactory();
 	}
 
 	@Override
-	protected LuceneSearchSortFactory sortFactory() {
+	protected LuceneSearchSortFactory<SR> sortFactory() {
 		return scope.sortFactory();
 	}
 
 	@Override
-	protected LuceneSearchAggregationFactory aggregationFactory() {
+	protected LuceneSearchAggregationFactory<SR> aggregationFactory() {
 		return scope.aggregationFactory();
 	}
 
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQuerySelectStepImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQuerySelectStepImpl.java
index 4ed9a537a84..2a1283cb6e3 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQuerySelectStepImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/dsl/impl/LuceneSearchQuerySelectStepImpl.java
@@ -26,15 +26,16 @@
 import org.hibernate.search.engine.search.projection.spi.ProjectionCompositor;
 import org.hibernate.search.engine.search.query.dsl.spi.AbstractSearchQuerySelectStep;
 
-public class LuceneSearchQuerySelectStepImpl<R, E, LOS>
+public class LuceneSearchQuerySelectStepImpl<SR, R, E, LOS>
 		extends AbstractSearchQuerySelectStep<
-				LuceneSearchQueryOptionsStep<E, LOS>,
+				SR,
+				LuceneSearchQueryOptionsStep<SR, E, LOS>,
 				R,
 				E,
 				LOS,
-				LuceneSearchProjectionFactory<R, E>,
-				LuceneSearchPredicateFactory>
-		implements LuceneSearchQuerySelectStep<R, E, LOS> {
+				LuceneSearchProjectionFactory<SR, R, E>,
+				LuceneSearchPredicateFactory<SR>>
+		implements LuceneSearchQuerySelectStep<SR, R, E, LOS> {
 
 	private final LuceneSearchQueryIndexScope<?> scope;
 	private final BackendSessionContext sessionContext;
@@ -49,56 +50,56 @@ public LuceneSearchQuerySelectStepImpl(LuceneSearchQueryIndexScope<?> scope,
 	}
 
 	@Override
-	public LuceneSearchQueryWhereStep<E, LOS> selectEntity() {
-		return select( scope.<R, E>projectionFactory().entity().toProjection() );
+	public LuceneSearchQueryWhereStep<SR, E, LOS> selectEntity() {
+		return select( scope.<SR, R, E>projectionFactory().entity().toProjection() );
 	}
 
 	@Override
-	public LuceneSearchQueryWhereStep<R, LOS> selectEntityReference() {
+	public LuceneSearchQueryWhereStep<SR, R, LOS> selectEntityReference() {
 		return select( scope.projectionBuilders().entityReference() );
 	}
 
 	@Override
-	public <P> LuceneSearchQueryWhereStep<P, LOS> select(Class<P> objectClass) {
+	public <P> LuceneSearchQueryWhereStep<SR, P, LOS> select(Class<P> objectClass) {
 		return select( scope.projectionFactory().composite().as( objectClass ).toProjection() );
 	}
 
 	@Override
-	public <P> LuceneSearchQueryWhereStep<P, LOS> select(
-			Function<? super LuceneSearchProjectionFactory<R, E>, ? extends ProjectionFinalStep<P>> projectionContributor) {
+	public <P> LuceneSearchQueryWhereStep<SR, P, LOS> select(
+			Function<? super LuceneSearchProjectionFactory<SR, R, E>, ? extends ProjectionFinalStep<P>> projectionContributor) {
 		SearchProjection<P> projection = projectionContributor.apply( scope.projectionFactory() ).toProjection();
 		return select( projection );
 	}
 
 	@Override
-	public <P> LuceneSearchQueryWhereStep<P, LOS> select(SearchProjection<P> projection) {
+	public <P> LuceneSearchQueryWhereStep<SR, P, LOS> select(SearchProjection<P> projection) {
 		LuceneSearchQueryBuilder<P> builder =
 				scope.select( sessionContext, loadingContextBuilder, projection );
 		return new LuceneSearchQueryOptionsStepImpl<>( scope, builder, loadingContextBuilder );
 	}
 
 	@Override
-	public LuceneSearchQueryWhereStep<List<?>, LOS> select(SearchProjection<?>... projections) {
+	public LuceneSearchQueryWhereStep<SR, List<?>, LOS> select(SearchProjection<?>... projections) {
 		return select( scope.projectionBuilders().composite()
 				.build( projections, ProjectionCompositor.fromList( projections.length ),
 						ProjectionCollector.nullable() ) );
 	}
 
 	@Override
-	public LuceneSearchQueryOptionsStep<E, LOS> where(SearchPredicate predicate) {
+	public LuceneSearchQueryOptionsStep<SR, E, LOS> where(SearchPredicate predicate) {
 		return selectEntity().where( predicate );
 	}
 
 	@Override
-	public LuceneSearchQueryOptionsStep<E, LOS> where(
-			Function<? super LuceneSearchPredicateFactory, ? extends PredicateFinalStep> predicateContributor) {
+	public LuceneSearchQueryOptionsStep<SR, E, LOS> where(
+			Function<? super LuceneSearchPredicateFactory<SR>, ? extends PredicateFinalStep> predicateContributor) {
 		return selectEntity().where( predicateContributor );
 	}
 
 	@Override
-	public LuceneSearchQueryOptionsStep<E, LOS> where(
-			BiConsumer<? super LuceneSearchPredicateFactory,
-					? super SimpleBooleanPredicateClausesCollector<?>> predicateContributor) {
+	public LuceneSearchQueryOptionsStep<SR, E, LOS> where(
+			BiConsumer<? super LuceneSearchPredicateFactory<SR>,
+					? super SimpleBooleanPredicateClausesCollector<SR, ?>> predicateContributor) {
 		return selectEntity().where( predicateContributor );
 	}
 
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/impl/LuceneSearchQueryIndexScope.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/impl/LuceneSearchQueryIndexScope.java
index e9568937880..026703216b8 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/impl/LuceneSearchQueryIndexScope.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/query/impl/LuceneSearchQueryIndexScope.java
@@ -36,16 +36,16 @@ <P> LuceneSearchQueryBuilder<P> select(BackendSessionContext sessionContext,
 			SearchLoadingContextBuilder<?, ?> loadingContextBuilder, SearchProjection<P> projection);
 
 	@Override
-	LuceneSearchPredicateFactory predicateFactory();
+	<SR> LuceneSearchPredicateFactory<SR> predicateFactory();
 
 	@Override
-	LuceneSearchSortFactory sortFactory();
+	<SR> LuceneSearchSortFactory<SR> sortFactory();
 
 	@Override
-	<R, E> LuceneSearchProjectionFactory<R, E> projectionFactory();
+	<SR, R, E> LuceneSearchProjectionFactory<SR, R, E> projectionFactory();
 
 	@Override
-	LuceneSearchAggregationFactory aggregationFactory();
+	<SR> LuceneSearchAggregationFactory<SR> aggregationFactory();
 
 	Query filterOrNull(String tenantId);
 
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/LuceneSearchSortFactory.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/LuceneSearchSortFactory.java
index 089b619e4c9..452199ba1dd 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/LuceneSearchSortFactory.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/LuceneSearchSortFactory.java
@@ -14,8 +14,8 @@
 /**
  * A factory for search sorts with some Lucene-specific methods.
  */
-public interface LuceneSearchSortFactory
-		extends ExtendedSearchSortFactory<LuceneSearchSortFactory, LuceneSearchPredicateFactory> {
+public interface LuceneSearchSortFactory<SR>
+		extends ExtendedSearchSortFactory<SR, LuceneSearchSortFactory<SR>, LuceneSearchPredicateFactory<SR>> {
 
 	/**
 	 * Order elements by a given Lucene {@link SortField}.
@@ -24,7 +24,7 @@ public interface LuceneSearchSortFactory
 	 * @return A {@link SortThenStep} allowing the retrieval of the sort
 	 * or the chaining of other sorts.
 	 */
-	SortThenStep fromLuceneSortField(SortField luceneSortField);
+	SortThenStep<SR> fromLuceneSortField(SortField luceneSortField);
 
 	/**
 	 * Order elements by a given Lucene {@link Sort}.
@@ -33,6 +33,6 @@ public interface LuceneSearchSortFactory
 	 * @return A {@link SortThenStep} allowing the retrieval of the sort
 	 * or the chaining of other sorts.
 	 */
-	SortThenStep fromLuceneSort(Sort luceneSort);
+	SortThenStep<SR> fromLuceneSort(Sort luceneSort);
 
 }
diff --git a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/impl/LuceneSearchSortFactoryImpl.java b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/impl/LuceneSearchSortFactoryImpl.java
index 4281a1156d6..925879d6e3a 100644
--- a/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/impl/LuceneSearchSortFactoryImpl.java
+++ b/lucene-next/backend/lucene/src/main/java/org/hibernate/search/backend/lucene/search/sort/dsl/impl/LuceneSearchSortFactoryImpl.java
@@ -14,32 +14,33 @@
 import org.apache.lucene.search.Sort;
 import org.apache.lucene.search.SortField;
 
-public class LuceneSearchSortFactoryImpl
+public class LuceneSearchSortFactoryImpl<SR>
 		extends AbstractSearchSortFactory<
-				LuceneSearchSortFactory,
+				SR,
+				LuceneSearchSortFactory<SR>,
 				LuceneSearchSortIndexScope<?>,
-				LuceneSearchPredicateFactory>
-		implements LuceneSearchSortFactory {
+				LuceneSearchPredicateFactory<SR>>
+		implements LuceneSearchSortFactory<SR> {
 
 	public LuceneSearchSortFactoryImpl(
-			SearchSortDslContext<LuceneSearchSortIndexScope<?>, LuceneSearchPredicateFactory> dslContext) {
+			SearchSortDslContext<SR, LuceneSearchSortIndexScope<?>, LuceneSearchPredicateFactory<SR>> dslContext) {
 		super( dslContext );
 	}
 
 	@Override
-	public LuceneSearchSortFactory withRoot(String objectFieldPath) {
-		return new LuceneSearchSortFactoryImpl( dslContext.rescope(
+	public LuceneSearchSortFactory<SR> withRoot(String objectFieldPath) {
+		return new LuceneSearchSortFactoryImpl<SR>( dslContext.rescope(
 				dslContext.scope().withRoot( objectFieldPath ),
 				dslContext.predicateFactory().withRoot( objectFieldPath ) ) );
 	}
 
 	@Override
-	public SortThenStep fromLuceneSortField(SortField luceneSortField) {
+	public SortThenStep<SR> fromLuceneSortField(SortField luceneSortField) {
 		return staticThenStep( dslContext.scope().sortBuilders().fromLuceneSortField( luceneSortField ) );
 	}
 
 	@Override
-	public SortThenStep fromLuceneSort(Sort luceneSort) {
+	public SortThenStep<SR> fromLuceneSort(Sort luceneSort) {
 		return staticThenStep( dslContext.scope().sortBuilders().fromLuceneSort( luceneSort ) );
 	}