HV-1927 Use Executable#getAnnotatedParameterTypes() instead of Executable#getGenericParameterTypes()

getGenericParameterTypes() is problematic with synthetic and implicit
parameters and we used to have ugly workarounds and warnings. Using
getAnnotatedParameterTypes() solves the issue.

I was extremely conservative in the changes as I want to be able to
backport it.

Author: gsmet

engine/src/main/java/org/hibernate/validator/internal/properties/javabean/JavaBeanExecutable.java

@@ -7,14 +7,12 @@
 package org.hibernate.validator.internal.properties.javabean;
 
 import java.lang.annotation.Annotation;
-import java.lang.invoke.MethodHandles;
 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
 import java.lang.reflect.Type;
-import java.lang.reflect.TypeVariable;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -25,18 +23,13 @@
 import org.hibernate.validator.internal.util.ExecutableHelper;
 import org.hibernate.validator.internal.util.ExecutableParameterNameProvider;
 import org.hibernate.validator.internal.util.ReflectionHelper;
-import org.hibernate.validator.internal.util.TypeHelper;
-import org.hibernate.validator.internal.util.logging.Log;
-import org.hibernate.validator.internal.util.logging.LoggerFactory;
 
 /**
  * @author Marko Bekhta
  * @author Guillaume Smet
  */
 public abstract class JavaBeanExecutable<T extends Executable> implements Callable, JavaBeanAnnotatedConstrainable {
 
-	private static final Log LOG = LoggerFactory.make( MethodHandles.lookup() );
-
 	protected final T executable;
 	private final Type typeForValidatorResolution;
 	private final boolean hasReturnValue;
@@ -194,72 +187,12 @@ private static List<JavaBeanParameter> getParameters(Executable executable) {
 
 		Parameter[] parameterArray = executable.getParameters();
 		Class<?>[] parameterTypes = executable.getParameterTypes();
-		// getGenericParameterTypes() does not include either the synthetic or the implicit parameters so we need to be
-		// extra careful
-		Type[] genericParameterTypes = executable.getGenericParameterTypes();
-
-		if ( parameterTypes.length == genericParameterTypes.length ) {
-			// this is the simple case where both arrays are consistent
-			// we could do without it but at some point, the behavior of getGenericParameterTypes() might be changed in
-			// Java and we'd better be ready.
-			for ( int i = 0; i < parameterArray.length; i++ ) {
-				parameters.add( new JavaBeanParameter( i, parameterArray[i], parameterTypes[i], getErasedTypeIfTypeVariable( genericParameterTypes[i] ) ) );
-			}
-		}
-		else {
-			// in this case, we have synthetic or implicit parameters
-
-			// do we have the information about which parameter is synthetic/implicit?
-			// (this metadata is only included when classes are compiled with the '-parameters' flag)
-			boolean hasParameterModifierInfo = isAnyParameterCarryingMetadata( parameterArray );
-
-			if ( ! hasParameterModifierInfo ) {
-				LOG.missingParameterMetadataWithSyntheticOrImplicitParameters( executable );
-			}
-
-			int explicitlyDeclaredParameterIndex = 0;
-
-			for ( int i = 0; i < parameterArray.length; i++ ) {
-				if ( explicitlyDeclaredParameterIndex < genericParameterTypes.length // we might already be out of the bounds of generic params array
-						&& isExplicit( parameterArray[i] )
-						&& parameterTypesMatch( parameterTypes[i], genericParameterTypes[explicitlyDeclaredParameterIndex] ) ) {
-					// in this case we have a parameter that is present and matches ("most likely") to the one in the generic parameter types list
-					parameters.add( new JavaBeanParameter( i, parameterArray[i], parameterTypes[i],
-							getErasedTypeIfTypeVariable( genericParameterTypes[explicitlyDeclaredParameterIndex] ) ) );
-					explicitlyDeclaredParameterIndex++;
-				}
-				else {
-					// in this case, the parameter is not present in genericParameterTypes, or the types doesn't match
-					parameters.add( new JavaBeanParameter( i, parameterArray[i], parameterTypes[i], parameterTypes[i] ) );
-				}
-			}
-		}
-
-		return CollectionHelper.toImmutableList( parameters );
-	}
-
-	private static boolean isAnyParameterCarryingMetadata(Parameter[] parameterArray) {
-		for ( Parameter parameter : parameterArray ) {
-			if ( parameter.isSynthetic() || parameter.isImplicit() ) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	private static boolean parameterTypesMatch(Class<?> paramType, Type genericParamType) {
-		return TypeHelper.getErasedType( genericParamType ).equals( paramType );
-	}
+		AnnotatedType[] annotatedTypes = executable.getAnnotatedParameterTypes();
 
-	private static boolean isExplicit(Parameter parameter) {
-		return !parameter.isSynthetic() && !parameter.isImplicit();
-	}
-
-	private static Type getErasedTypeIfTypeVariable(Type genericType) {
-		if ( genericType instanceof TypeVariable ) {
-			return TypeHelper.getErasedType( genericType );
+		for ( int i = 0; i < parameterArray.length; i++ ) {
+			parameters.add( new JavaBeanParameter( i, parameterArray[i], parameterTypes[i], annotatedTypes[i] ) );
 		}
 
-		return genericType;
+		return CollectionHelper.toImmutableList( parameters );
 	}
 }

engine/src/main/java/org/hibernate/validator/internal/properties/javabean/JavaBeanParameter.java

@@ -15,6 +15,7 @@
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 
+import org.hibernate.validator.internal.util.TypeHelper;
 import org.hibernate.validator.internal.util.logging.Log;
 import org.hibernate.validator.internal.util.logging.LoggerFactory;
 
@@ -35,11 +36,14 @@ public class JavaBeanParameter implements JavaBeanAnnotatedElement {
 
 	private final Type genericType;
 
-	JavaBeanParameter(int index, Parameter parameter, Class<?> type, Type genericType) {
+	private final AnnotatedType annotatedType;
+
+	JavaBeanParameter(int index, Parameter parameter, Class<?> type, AnnotatedType annotatedType) {
 		this.index = index;
 		this.parameter = parameter;
 		this.type = type;
-		this.genericType = genericType;
+		this.genericType = getErasedTypeIfTypeVariable( annotatedType.getType() );
+		this.annotatedType = annotatedType;
 	}
 
 	public int getIndex() {
@@ -53,7 +57,7 @@ public Class<?> getType() {
 
 	@Override
 	public AnnotatedType getAnnotatedType() {
-		return parameter.getAnnotatedType();
+		return annotatedType;
 	}
 
 	@Override
@@ -75,11 +79,19 @@ public Type getGenericType() {
 
 	@Override
 	public TypeVariable<?>[] getTypeParameters() {
-		return parameter.getType().getTypeParameters();
+		return type.getTypeParameters();
 	}
 
 	@Override
 	public <A extends Annotation> A getAnnotation(Class<A> annotationClass) {
 		return parameter.getAnnotation( annotationClass );
 	}
+
+	private static Type getErasedTypeIfTypeVariable(Type genericType) {
+		if ( genericType instanceof TypeVariable ) {
+			return TypeHelper.getErasedType( genericType );
+		}
+
+		return genericType;
+	}
 }

engine/src/main/java/org/hibernate/validator/internal/util/logging/Log.java

@@ -895,14 +895,6 @@ ConstraintDefinitionException getConstraintValidatorDefinitionConstraintMismatch
 	@Message(id = 253, value = "Unable to instantiate property node name provider class %s.")
 	ValidationException getUnableToInstantiatePropertyNodeNameProviderClassException(String propertyNodeNameProviderClassName, @Cause Exception e);
 
-	@LogMessage(level = WARN)
-	@Message(id = 254, value = "Missing parameter metadata for %s, which declares implicit or synthetic parameters."
-			+ " Automatic resolution of generic type information for method parameters"
-			+ " may yield incorrect results if multiple parameters have the same erasure."
-			+ " To solve this, compile your code with the '-parameters' flag."
-	)
-	void missingParameterMetadataWithSyntheticOrImplicitParameters(@FormatWith(ExecutableFormatter.class) Executable executable);
-
 	@LogMessage(level = DEBUG)
 	@Message(id = 255, value = "Using %s as locale resolver.")
 	void usingLocaleResolver(@FormatWith(ClassObjectFormatter.class) Class<? extends LocaleResolver> localeResolverClass);