Erase MethodParameter generic type signature when unresolvable.

Make sure to use the raw type or java.lang.Object for unresolvable generic method parameters while retaining the type variable in the method signature.

See: #3374

Author: christophstrobl

src/main/java/org/springframework/data/repository/aot/generate/AotRepositoryCreator.java

@@ -16,32 +16,23 @@
 package org.springframework.data.repository.aot.generate;
 
 import java.lang.reflect.Method;
-import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
-import java.lang.reflect.WildcardType;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
-import java.util.HashSet;
 import java.util.List;
-import java.util.Set;
 import java.util.function.Consumer;
-import java.util.function.Predicate;
 
 import javax.lang.model.element.Modifier;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.jspecify.annotations.Nullable;
-
-import org.springframework.core.ResolvableType;
 import org.springframework.data.projection.ProjectionFactory;
 import org.springframework.data.repository.core.RepositoryInformation;
 import org.springframework.data.repository.core.support.RepositoryComposition;
 import org.springframework.data.repository.core.support.RepositoryFragment;
 import org.springframework.data.repository.query.QueryMethod;
 import org.springframework.data.util.Lazy;
-import org.springframework.data.util.TypeInformation;
 import org.springframework.javapoet.ClassName;
 import org.springframework.javapoet.FieldSpec;
 import org.springframework.javapoet.MethodSpec;
@@ -340,210 +331,6 @@ private void contributeMethod(Method method, @Nullable MethodContributorFactory
 		generationMetadata.addRepositoryMethod(method, contributor);
 	}
 
-	/**
-	 * Value object to determine whether generics in a given {@link Method} can be resolved. Resolvable generics are e.g.
-	 * declared on the method level (unbounded type variables, type variables using class boundaries). Considers
-	 * collections and map types.
-	 * <p>
-	 * Considers resolvable:
-	 * <ul>
-	 * <li>Unbounded method-level type parameters {@code <T> T foo(Class<T>)}</li>
-	 * <li>Bounded method-level type parameters that resolve to a class
-	 * {@code <T extends Serializable> T foo(Class<T>)}</li>
-	 * <li>Simple references to interface variables {@code T foo(), List<T> foo(…)}</li>
-	 * <li>Unbounded wildcards {@code User foo(GeoJson<?>)}</li>
-	 * </ul>
-	 * Considers non-resolvable:
-	 * <ul>
-	 * <li>Parametrized bounds referring to known variables on method-level type parameters
-	 * {@code <P extends T> T foo(Class<T>), List<? super T> foo()}</li>
-	 * <li>Generally unresolvable generics</li>
-	 * </ul>
-	 * </p>
-	 *
-	 * @author Mark Paluch
-	 */
-	record ResolvableGenerics(Method method, Class<?> implClass, Set<Type> resolvableTypeVariables,
-			Set<Type> unwantedMethodVariables) {
-
-		/**
-		 * Create a new {@code ResolvableGenerics} object for the given {@link Method}.
-		 *
-		 * @param method
-		 * @return
-		 */
-		public static ResolvableGenerics of(Method method, Class<?> implClass) {
-			return new ResolvableGenerics(method, implClass, getResolvableTypeVariables(method),
-					getUnwantedMethodVariables(method));
-		}
-
-		private static Set<Type> getResolvableTypeVariables(Method method) {
-
-			Set<Type> simpleTypeVariables = new HashSet<>();
-
-			for (TypeVariable<Method> typeParameter : method.getTypeParameters()) {
-				if (isClassBounded(typeParameter.getBounds())) {
-					simpleTypeVariables.add(typeParameter);
-				}
-			}
-
-			return simpleTypeVariables;
-		}
-
-		private static Set<Type> getUnwantedMethodVariables(Method method) {
-
-			Set<Type> unwanted = new HashSet<>();
-
-			for (TypeVariable<Method> typeParameter : method.getTypeParameters()) {
-				if (!isClassBounded(typeParameter.getBounds())) {
-					unwanted.add(typeParameter);
-				}
-			}
-			return unwanted;
-		}
-
-		/**
-		 * Check whether the {@link Method} has unresolvable generics when being considered in the context of the
-		 * implementation class.
-		 *
-		 * @return
-		 */
-		public boolean hasUnresolvableGenerics() {
-
-			ResolvableType resolvableType = ResolvableType.forMethodReturnType(method, implClass);
-
-			if (isUnresolvable(resolvableType)) {
-				return true;
-			}
-
-			for (int i = 0; i < method.getParameterCount(); i++) {
-				if (isUnresolvable(ResolvableType.forMethodParameter(method, i, implClass))) {
-					return true;
-				}
-			}
-
-			return false;
-		}
-
-		private boolean isUnresolvable(TypeInformation<?> typeInformation) {
-			return isUnresolvable(typeInformation.toResolvableType());
-		}
-
-		private boolean isUnresolvable(ResolvableType resolvableType) {
-
-			if (isResolvable(resolvableType)) {
-				return false;
-			}
-
-			if (isUnwanted(resolvableType)) {
-				return true;
-			}
-
-			if (resolvableType.isAssignableFrom(Class.class)) {
-				return isUnresolvable(resolvableType.getGeneric(0));
-			}
-
-			TypeInformation<?> typeInformation = TypeInformation.of(resolvableType);
-			if (typeInformation.isMap() || typeInformation.isCollectionLike()) {
-
-				for (ResolvableType type : resolvableType.getGenerics()) {
-					if (isUnresolvable(type)) {
-						return true;
-					}
-				}
-
-				return false;
-			}
-
-			if (typeInformation.getActualType() != null && typeInformation.getActualType() != typeInformation) {
-				return isUnresolvable(typeInformation.getRequiredActualType());
-			}
-
-			return resolvableType.hasUnresolvableGenerics();
-		}
-
-		private boolean isResolvable(Type[] types) {
-
-			for (Type type : types) {
-
-				if (resolvableTypeVariables.contains(type)) {
-					continue;
-				}
-
-				if (isClass(type)) {
-					continue;
-				}
-
-				return false;
-			}
-
-			return true;
-		}
-
-		private boolean isResolvable(ResolvableType resolvableType) {
-
-			return testGenericType(resolvableType, it -> {
-
-				if (resolvableTypeVariables.contains(it)) {
-					return true;
-				}
-
-				if (it instanceof WildcardType wt) {
-					return isClassBounded(wt.getLowerBounds()) && isClassBounded(wt.getUpperBounds());
-				}
-
-				return false;
-			});
-		}
-
-		private boolean isUnwanted(ResolvableType resolvableType) {
-
-			return testGenericType(resolvableType, o -> {
-
-				if (o instanceof WildcardType wt) {
-					return !isResolvable(wt.getLowerBounds()) || !isResolvable(wt.getUpperBounds());
-				}
-
-				return unwantedMethodVariables.contains(o);
-			});
-		}
-
-		private static boolean testGenericType(ResolvableType resolvableType, Predicate<Type> predicate) {
-
-			if (predicate.test(resolvableType.getType())) {
-				return true;
-			}
-
-			ResolvableType[] generics = resolvableType.getGenerics();
-			for (ResolvableType generic : generics) {
-				if (testGenericType(generic, predicate)) {
-					return true;
-				}
-			}
-
-			return false;
-		}
-
-		private static boolean isClassBounded(Type[] bounds) {
-
-			for (Type bound : bounds) {
-
-				if (isClass(bound)) {
-					continue;
-				}
-
-				return false;
-			}
-
-			return true;
-		}
-
-		private static boolean isClass(Type type) {
-			return type instanceof Class;
-		}
-
-	}
-
 	/**
 	 * Factory interface to conditionally create {@link MethodContributor} instances. An implementation may decide whether
 	 * to return a {@link MethodContributor} or {@literal null}, if no method (code or metadata) should be contributed.

src/main/java/org/springframework/data/repository/aot/generate/MethodMetadata.java

@@ -26,7 +26,6 @@
 import java.util.function.Function;
 
 import org.jspecify.annotations.Nullable;
-
 import org.springframework.core.DefaultParameterNameDiscoverer;
 import org.springframework.core.MethodParameter;
 import org.springframework.core.ParameterNameDiscoverer;
@@ -36,6 +35,7 @@
 import org.springframework.data.util.TypeInformation;
 import org.springframework.javapoet.ParameterSpec;
 import org.springframework.javapoet.TypeName;
+import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 
 /**
@@ -79,14 +79,17 @@ private static void initializeMethodArguments(Method method, ParameterNameDiscov
 			ResolvableType repositoryInterface, Map<String, ParameterSpec> methodArguments,
 			Map<String, MethodParameter> methodParameters) {
 
+		Class<?> repositoryInterfaceType = repositoryInterface.toClass();
+
 		for (Parameter parameter : method.getParameters()) {
 
-			MethodParameter methodParameter = MethodParameter.forParameter(parameter).withContainingClass(repositoryInterface.resolve());
+			MethodParameter methodParameter = MethodParameter.forParameter(parameter)
+					.withContainingClass(repositoryInterfaceType);
 			methodParameter.initParameterNameDiscovery(nameDiscoverer);
-			ResolvableType resolvableParameterType = ResolvableType.forMethodParameter(methodParameter);
 
-			TypeName parameterType = TypeNames.resolvedTypeName(resolvableParameterType);
+			TypeName parameterType = parameterTypeName(methodParameter, repositoryInterfaceType);
 
+			Assert.notNull(methodParameter.getParameterName(), "MethodParameter.getParameterName() must not be null");
 			ParameterSpec parameterSpec = ParameterSpec.builder(parameterType, methodParameter.getParameterName()).build();
 
 			if (methodArguments.containsKey(parameterSpec.name())) {
@@ -98,6 +101,20 @@ private static void initializeMethodArguments(Method method, ParameterNameDiscov
 		}
 	}
 
+    @SuppressWarnings("NullAway")
+	static TypeName parameterTypeName(MethodParameter methodParameter, Class<?> repositoryInterface) {
+
+		ResolvableType resolvableParameterType = ResolvableType.forMethodParameter(methodParameter);
+		if (ClassUtils.isPrimitiveOrWrapper(resolvableParameterType.toClass())) {
+			return TypeNames.className(resolvableParameterType);
+		}
+
+		ResolvableGenerics resolvableGenerics = ResolvableGenerics.of(methodParameter.getMethod(), repositoryInterface);
+		return resolvableGenerics.isFullyResolvableParameter(methodParameter.getParameter())
+				? TypeNames.resolvedTypeName(resolvableParameterType)
+				: TypeNames.className(resolvableParameterType);
+	}
+
 	ResolvableType getReturnType() {
 		return returnType;
 	}