Polishing.

Fix Like with starts/ends, use proper parameter origins instead of assuming binding name matches parameter names. Simplify binding block.

See #3830

Author: mp911de

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/AotQueryCreator.java

@@ -226,31 +226,49 @@ private CodeBlock createQuery(String queryVariableName, String queryStringNameVa
 			for (ParameterBinding binding : query.getParameterBindings()) {
 
 				Object prepare = binding.prepare("s");
+				Object parameterIdentifier = getParameterName(binding.getIdentifier());
+				String valueFormat = parameterIdentifier instanceof CharSequence ? "$S" : "$L";
 
 				if (prepare instanceof String prepared && !prepared.equals("s")) {
+
 					String format = prepared.replaceAll("%", "%%").replace("s", "%s");
-					if (binding.getIdentifier().hasPosition()) {
-						builder.addStatement("$L.setParameter($L, $S.formatted($L))", queryVariableName,
-								binding.getIdentifier().getPosition(), format,
-								context.getParameterNameOfPosition(binding.getIdentifier().getPosition() - 1));
-					} else {
-						builder.addStatement("$L.setParameter($S, $S.formatted($L))", queryVariableName,
-								binding.getIdentifier().getName(), format, binding.getIdentifier().getName());
-					}
+					builder.addStatement("$L.setParameter(%s, $S.formatted($L))".formatted(valueFormat), queryVariableName,
+							parameterIdentifier, format, getParameter(binding.getOrigin()));
 				} else {
-					if (binding.getIdentifier().hasPosition()) {
-						builder.addStatement("$L.setParameter($L, $L)", queryVariableName, binding.getIdentifier().getPosition(),
-								context.getParameterNameOfPosition(binding.getIdentifier().getPosition() - 1));
-					} else {
-						builder.addStatement("$L.setParameter($S, $L)", queryVariableName, binding.getIdentifier().getName(),
-								binding.getIdentifier().getName());
-					}
+					builder.addStatement("$L.setParameter(%s, $L)".formatted(valueFormat), queryVariableName, parameterIdentifier,
+							getParameter(binding.getOrigin()));
 				}
 			}
 
 			return builder.build();
 		}
 
+		private Object getParameterName(ParameterBinding.BindingIdentifier identifier) {
+
+			if (identifier.hasPosition()) {
+				return identifier.getPosition();
+			}
+
+			return identifier.getName();
+
+		}
+
+		private Object getParameter(ParameterBinding.ParameterOrigin origin) {
+
+			if (origin.isMethodArgument() && origin instanceof ParameterBinding.MethodInvocationArgument mia) {
+
+				if (mia.identifier().hasPosition()) {
+					return context.getParameterNameOfPosition(mia.identifier().getPosition() - 1);
+				}
+
+				if (mia.identifier().hasName()) {
+					return mia.identifier().getName();
+				}
+			}
+
+			throw new UnsupportedOperationException("Not supported yet");
+		}
+
 		private CodeBlock applyHints(String queryVariableName, MergedAnnotation<QueryHints> queryHints) {
 
 			Builder hintsBuilder = CodeBlock.builder();

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/JpaCodeBlocks.java

@@ -23,6 +23,8 @@
 import org.springframework.core.annotation.AnnotatedElementUtils;
 import org.springframework.core.annotation.MergedAnnotation;
 import org.springframework.core.annotation.MergedAnnotations;
+import org.springframework.data.domain.KeysetScrollPosition;
+import org.springframework.data.domain.ScrollPosition;
 import org.springframework.data.jpa.projection.CollectionAwareProjectionFactory;
 import org.springframework.data.jpa.repository.NativeQuery;
 import org.springframework.data.jpa.repository.Query;
@@ -59,14 +61,12 @@
 public class JpaRepositoryContributor extends RepositoryContributor {
 
 	private final CollectionAwareProjectionFactory projectionFactory = new CollectionAwareProjectionFactory();
-	private final AotQueryCreator queryCreator;
 	private final AotMetaModel metaModel;
 
 	public JpaRepositoryContributor(AotRepositoryContext repositoryContext) {
 		super(repositoryContext);
 
 		this.metaModel = new AotMetaModel(repositoryContext.getResolvedTypes());
-		this.queryCreator = new AotQueryCreator(metaModel);
 	}
 
 	@Override
@@ -106,6 +106,12 @@ protected AotRepositoryMethodBuilder contributeRepositoryMethod(
 			}
 		}
 
+		// no KeysetScrolling for now.
+		if (generationContext.getParameterNameOf(ScrollPosition.class) != null
+				|| generationContext.getParameterNameOf(KeysetScrollPosition.class) != null) {
+			return null;
+		}
+
 		// TODO: Named query via EntityManager, NamedQuery via properties, also for count queries.
 
 		return new AotRepositoryMethodBuilder(generationContext).customize((context, body) -> {

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/JpaRepositoryContributor.java

@@ -34,6 +34,9 @@ private StringAotQuery(List<ParameterBinding> parameterBindings) {
 		super(parameterBindings);
 	}
 
+	/**
+	 * Creates a new {@code StringAotQuery} from a {@link DeclaredQuery}. Parses the query into {@link PreprocessedQuery}.
+	 */
 	static StringAotQuery of(DeclaredQuery query) {
 
 		if (query instanceof PreprocessedQuery pq) {
@@ -43,21 +46,37 @@ static StringAotQuery of(DeclaredQuery query) {
 		return new DeclaredAotQuery(PreprocessedQuery.parse(query));
 	}
 
+	/**
+	 * Creates a new {@code StringAotQuery} from a JPQL {@code queryString}. Parses the query into
+	 * {@link PreprocessedQuery}.
+	 */
 	static StringAotQuery jpqlQuery(String queryString) {
 		return of(DeclaredQuery.jpqlQuery(queryString));
 	}
 
+	/**
+	 * Creates a JPQL {@code StringAotQuery} using the given bindings and limit.
+	 */
 	public static StringAotQuery jpqlQuery(String queryString, List<ParameterBinding> bindings, Limit resultLimit) {
 		return new LimitedAotQuery(queryString, bindings, resultLimit);
 	}
 
+	/**
+	 * Creates a new {@code StringAotQuery} from a native (SQL) {@code queryString}. Parses the query into
+	 * {@link PreprocessedQuery}.
+	 */
 	static StringAotQuery nativeQuery(String queryString) {
 		return of(DeclaredQuery.nativeQuery(queryString));
 	}
 
+	/**
+	 * @return the underlying declared query.
+	 */
 	public abstract DeclaredQuery getQuery();
 
-	public abstract String getQueryString();
+	public String getQueryString() {
+		return getQuery().getQueryString();
+	}
 
 	@Override
 	public String toString() {
@@ -94,6 +113,8 @@ public PreprocessedQuery getQuery() {
 	}
 
 	/**
+	 * Query with a limit associated.
+	 *
 	 * @author Mark Paluch
 	 */
 	static class LimitedAotQuery extends StringAotQuery {

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/aot/generated/StringAotQuery.java

@@ -25,9 +25,9 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
-import org.springframework.data.expression.ValueExpression;
-
 import org.jspecify.annotations.Nullable;
+
+import org.springframework.data.expression.ValueExpression;
 import org.springframework.data.jpa.provider.PersistenceProvider;
 import org.springframework.data.jpa.repository.support.JpqlQueryTemplates;
 import org.springframework.data.repository.query.Parameter;
@@ -608,7 +608,7 @@ public String toString() {
 	 * @author Mark Paluch
 	 * @since 3.1.2
 	 */
-	sealed interface ParameterOrigin permits Expression, MethodInvocationArgument, Synthetic {
+	public sealed interface ParameterOrigin permits Expression, MethodInvocationArgument, Synthetic {
 
 		/**
 		 * Creates a {@link Expression} for the given {@code expression}.

spring-data-jpa/src/main/java/org/springframework/data/jpa/repository/query/ParameterBinding.java

@@ -218,6 +218,20 @@ void testAnnotatedFinderUsingNamedParameterPlaceholderReturningListWithQuery() {
 				"kylo@new-empire.com", "luke@jedi.org", "vader@empire.com");
 	}
 
+	@Test
+	void shouldApplyAnnotatedLikeStartsEnds() {
+
+		// start with case
+		List<User> users = fragment.findAnnotatedLikeStartsEnds("S");
+		assertThat(users).extracting(User::getEmailAddress).containsExactlyInAnyOrder("han@smuggler.net",
+				"kylo@new-empire.com", "luke@jedi.org", "vader@empire.com");
+
+		// ends case
+		users = fragment.findAnnotatedLikeStartsEnds("a");
+		assertThat(users).extracting(User::getEmailAddress).containsExactlyInAnyOrder("leia@resistance.gov",
+				"chewie@smuggler.net", "yoda@jedi.org");
+	}
+
 	@Test
 	void testAnnotatedMultilineFinderWithQuery() {
 
@@ -306,14 +320,16 @@ void shouldApplyQueryHints() {
 	@Test
 	void testDerivedFinderReturningPageOfProjections() {
 
-		// TODO: query.setParameter(1, "%s%%".formatted(lastname));
 		Page<UserDtoProjection> page = fragment.findUserProjectionByLastnameStartingWith("S",
 				PageRequest.of(0, 2, Sort.by("emailAddress")));
 
 		assertThat(page.getTotalElements()).isEqualTo(4);
 		assertThat(page.getSize()).isEqualTo(2);
 		assertThat(page.getContent()).extracting(UserDtoProjection::getEmailAddress).containsExactly("han@smuggler.net",
 				"kylo@new-empire.com");
+
+		Page<UserDtoProjection> noResults = fragment.findUserProjectionByLastnameStartingWith("a",
+				PageRequest.of(0, 2, Sort.by("emailAddress")));
 	}
 
 	// modifying
@@ -345,9 +361,10 @@ void nativeQuery() {
 
 	// old stuff below
 
-	// TODO:
 	void todo() {
 
+		// expressions, templated query with #{#entityName}
+		// synthetic parameters (keyset scrolling! yuck!)
 		// interface projections
 		// named queries
 		// dynamic projections

spring-data-jpa/src/test/java/org/springframework/data/jpa/repository/aot/generated/JpaRepositoryContributorIntegrationTests.java

@@ -75,6 +75,9 @@ public interface UserRepository extends CrudRepository<User, Integer> {
 	@Query("select u from User u where u.lastname like :lastname%")
 	List<User> findAnnotatedQueryByLastnameParameter(String lastname);
 
+	@Query("select u from User u where u.lastname like :lastname% or u.lastname like %:lastname")
+	List<User> findAnnotatedLikeStartsEnds(String lastname);
+
 	@Query("""
 			select u
 			from User u