Introduce MethodParameterFactory to Parameters.

We now provide a factory function to create MethodParameter objects associated with the enclosing class so parameters can resolve generics properly.

Author: mp911de

src/main/java/org/springframework/data/repository/query/DefaultParameters.java

@@ -17,7 +17,9 @@
 
 import java.lang.reflect.Method;
 import java.util.List;
+import java.util.function.IntFunction;
 
+import org.springframework.core.MethodParameter;
 import org.springframework.data.util.TypeInformation;
 
 /**
@@ -40,13 +42,30 @@ public DefaultParameters(Method method) {
 
 	/**
 	 * Creates a new {@link DefaultParameters} instance from the given {@link Method} and aggregate
-	 * {@link TypeInformation}.
+	 * {@link TypeInformation}. Note that this constructor uses a {@link IntFunction MethodParameterFactory} that doesn't
+	 * resolve generic method parameter types that are declared on the containing class. Use
+	 * {@link DefaultParameters#DefaultParameters(Method, IntFunction, TypeInformation)} with a
+	 * {@link MethodParameter#withContainingClass(Class) contextual factory} to ensure proper gerneric resolution.
 	 *
 	 * @param method must not be {@literal null}.
 	 * @param aggregateType must not be {@literal null}.
 	 */
 	public DefaultParameters(Method method, TypeInformation<?> aggregateType) {
-		super(method, param -> new Parameter(param, aggregateType));
+		this(method, index -> new MethodParameter(method, index), aggregateType);
+	}
+
+	/**
+	 * Creates a new {@link DefaultParameters} instance from the given {@link Method} and aggregate
+	 * {@link TypeInformation}.
+	 *
+	 * @param method           must not be {@literal null}.
+	 * @param parameterFactory must not be {@literal null}.
+	 * @param aggregateType    must not be {@literal null}.
+	 * @since 3.2.1
+	 */
+	public DefaultParameters(Method method, IntFunction<MethodParameter> parameterFactory,
+			TypeInformation<?> aggregateType) {
+		super(method, parameterFactory, param -> new Parameter(param, aggregateType));
 	}
 
 	private DefaultParameters(List<Parameter> parameters) {

src/main/java/org/springframework/data/repository/query/Parameters.java

@@ -23,6 +23,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.function.Function;
+import java.util.function.IntFunction;
 
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.MethodParameter;
@@ -44,7 +45,8 @@
  */
 public abstract class Parameters<S extends Parameters<S, T>, T extends Parameter> implements Streamable<T> {
 
-	public static final List<Class<?>> TYPES = Arrays.asList(ScrollPosition.class, Pageable.class, Sort.class, Limit.class);
+	public static final List<Class<?>> TYPES = Arrays.asList(ScrollPosition.class, Pageable.class, Sort.class,
+			Limit.class);
 
 	private static final String PARAM_ON_SPECIAL = format("You must not use @%s on a parameter typed %s or %s",
 			Param.class.getSimpleName(), Pageable.class.getSimpleName(), Sort.class.getSimpleName());
@@ -84,6 +86,20 @@ public Parameters(Method method) {
 	 * @since 3.0.2
 	 */
 	protected Parameters(Method method, Function<MethodParameter, T> parameterFactory) {
+		this(method, index -> new MethodParameter(method, index), parameterFactory);
+	}
+
+	/**
+	 * Creates a new {@link Parameters} instance for the given {@link Method} and {@link Function} to create a
+	 * {@link Parameter} instance from a {@link MethodParameter}.
+	 *
+	 * @param method must not be {@literal null}.
+	 * @param methodParameterFactory must not be {@literal null}.
+	 * @param parameterFactory must not be {@literal null}.
+	 * @since 3.2.1
+	 */
+	protected Parameters(Method method, IntFunction<MethodParameter> methodParameterFactory,
+			Function<MethodParameter, T> parameterFactory) {
 
 		Assert.notNull(method, "Method must not be null");
 
@@ -102,7 +118,8 @@ protected Parameters(Method method, Function<MethodParameter, T> parameterFactor
 
 		for (int i = 0; i < parameterCount; i++) {
 
-			MethodParameter methodParameter = new MethodParameter(method, i);
+			MethodParameter methodParameter = methodParameterFactory.apply(i);
+
 			methodParameter.initParameterNameDiscovery(PARAMETER_NAME_DISCOVERER);
 
 			T parameter = parameterFactory == null //
@@ -421,7 +438,9 @@ public static boolean isBindable(Class<?> type) {
 		return !TYPES.contains(type);
 	}
 
+	@Override
 	public Iterator<T> iterator() {
 		return parameters.iterator();
 	}
+
 }

src/main/java/org/springframework/data/repository/query/QueryMethod.java

@@ -20,9 +20,11 @@
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.Set;
+import java.util.function.IntFunction;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
+import org.springframework.core.MethodParameter;
 import org.springframework.data.domain.Limit;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
@@ -61,6 +63,7 @@ public class QueryMethod {
 	private final ResultProcessor resultProcessor;
 	private final Lazy<Class<?>> domainClass;
 	private final Lazy<Boolean> isCollectionQuery;
+	private final IntFunction<MethodParameter> methodParameterFactory;
 
 	/**
 	 * Creates a new {@link QueryMethod} from the given parameters. Looks up the correct query to use for following
@@ -85,6 +88,8 @@ public QueryMethod(Method method, RepositoryMetadata metadata, ProjectionFactory
 		this.method = method;
 		this.unwrappedReturnType = potentiallyUnwrapReturnTypeFor(metadata, method);
 		this.metadata = metadata;
+		this.methodParameterFactory = index -> new MethodParameter(method, index)
+				.withContainingClass(metadata.getRepositoryInterface());
 		this.parameters = createParameters(method);
 
 		this.domainClass = Lazy.of(() -> {
@@ -186,13 +191,23 @@ private boolean calculateIsCollectionQuery() {
 	 * @since 3.0.2
 	 */
 	protected Parameters<?, ?> createParameters(Method method, TypeInformation<?> domainType) {
-		return new DefaultParameters(method, domainType);
+		return new DefaultParameters(method, getMethodParameterFactory(), domainType);
+	}
+
+	/**
+	 * The {@link IntFunction MethodParameterFactory} to create method parameters.
+	 *
+	 * @return factory to create method parameters.
+	 * @since 3.2.1
+	 */
+	protected IntFunction<MethodParameter> getMethodParameterFactory() {
+		return methodParameterFactory;
 	}
 
 	/**
 	 * Returns the method's name.
 	 *
-	 * @return
+	 * @return the method's name.
 	 */
 	public String getName() {
 		return method.getName();
@@ -314,7 +329,7 @@ public ResultProcessor getResultProcessor() {
 		return resultProcessor;
 	}
 
-	RepositoryMetadata getMetadata() {
+	protected RepositoryMetadata getMetadata() {
 		return metadata;
 	}
 

src/test/java/org/springframework/data/repository/query/ParametersUnitTests.java

@@ -26,12 +26,16 @@
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.reactivestreams.Publisher;
+
+import org.springframework.core.MethodParameter;
 import org.springframework.data.domain.Limit;
 import org.springframework.data.domain.OffsetScrollPosition;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort;
 import org.springframework.data.domain.Window;
+import org.springframework.data.repository.Repository;
+import org.springframework.data.util.TypeInformation;
 import org.springframework.test.util.ReflectionTestUtils;
 
 /**
@@ -202,6 +206,18 @@ void acceptsLimitParameter() throws Exception {
 		assertThat(parameters.getLimitIndex()).isOne();
 	}
 
+	@Test // GH-2995
+	void considersGenericType() throws Exception {
+
+		var method = TypedInterface.class.getMethod("foo", Object.class);
+
+		var parameters = new DefaultParameters(method,
+				index -> new MethodParameter(method, index).withContainingClass(TypedInterface.class),
+				TypeInformation.of(User.class));
+
+		assertThat(parameters.getParameter(0).getType()).isEqualTo(Long.class);
+	}
+
 	private Parameters<?, Parameter> getParametersFor(String methodName, Class<?>... parameterTypes)
 			throws SecurityException, NoSuchMethodException {
 
@@ -214,7 +230,7 @@ static class User {
 
 	}
 
-	static interface SampleDao {
+	interface SampleDao {
 
 		User valid(@Param("username") String username);
 
@@ -248,4 +264,11 @@ static interface SampleDao {
 	}
 
 	interface SomePageable extends Pageable {}
+
+	interface Intermediate<T, ID> extends Repository<T, ID> {
+		void foo(ID id);
+	}
+
+	interface TypedInterface extends Intermediate<User, Long> {}
+
 }