HHH-19326 Properly handling generics parameter types

Author: cigaly

tooling/metamodel-generator/src/main/java/org/hibernate/processor/annotation/AbstractAnnotatedMethod.java

@@ -24,7 +24,7 @@
 public abstract class AbstractAnnotatedMethod implements MetaAttribute {
 
 	final AnnotationMetaEntity annotationMetaEntity;
-	private final ExecutableElement method;
+	final ExecutableElement method;
 	final String sessionType;
 	final String sessionName;
 

tooling/metamodel-generator/src/main/java/org/hibernate/processor/annotation/AnnotationMetaEntity.java

@@ -1830,7 +1830,8 @@ else if ( returnArgument
 								context.addNonnullAnnotation(),
 								lifecycleParameterKind(parameterType),
 								returnArgument,
-								hasGeneratedId(declaredType)
+								hasGeneratedId(declaredType),
+								element
 						)
 				);
 			}

tooling/metamodel-generator/src/main/java/org/hibernate/processor/annotation/LifecycleMethod.java

@@ -4,19 +4,31 @@
  */
 package org.hibernate.processor.annotation;
 
-
 import javax.lang.model.element.ExecutableElement;
-
+import javax.lang.model.element.TypeElement;
+import javax.lang.model.element.TypeParameterElement;
+import javax.lang.model.element.VariableElement;
+import javax.lang.model.type.ArrayType;
+import javax.lang.model.type.DeclaredType;
+import javax.lang.model.type.TypeKind;
+import javax.lang.model.type.TypeMirror;
+import javax.lang.model.type.TypeVariable;
+import javax.lang.model.type.WildcardType;
+import java.util.Collection;
 import java.util.Set;
 
 import static java.lang.Character.toUpperCase;
+import static java.util.stream.Collectors.joining;
+import static java.util.stream.Collectors.toSet;
+import static javax.lang.model.type.TypeKind.VOID;
 import static org.hibernate.processor.util.Constants.EVENT;
 import static org.hibernate.processor.util.Constants.INJECT;
 import static org.hibernate.processor.util.Constants.JD_LIFECYCLE_EVENT;
 import static org.hibernate.processor.util.Constants.LIST;
 import static org.hibernate.processor.util.Constants.NONNULL;
 import static org.hibernate.processor.util.Constants.TYPE_LITERAL;
 import static org.hibernate.processor.util.Constants.UNI;
+import static org.hibernate.processor.util.TypeUtils.resolveTypeName;
 
 public class LifecycleMethod extends AbstractAnnotatedMethod {
 	private final String entity;
@@ -28,6 +40,8 @@ public class LifecycleMethod extends AbstractAnnotatedMethod {
 	private final ParameterKind parameterKind;
 	private final boolean returnArgument;
 	private final boolean hasGeneratedId;
+	private final Collection<String> methodTypeParameters;
+	private final TypeElement element;
 
 	public enum ParameterKind {
 		NORMAL,
@@ -48,7 +62,8 @@ public LifecycleMethod(
 			boolean addNonnullAnnotation,
 			ParameterKind parameterKind,
 			boolean returnArgument,
-			boolean hasGeneratedId) {
+			boolean hasGeneratedId,
+			TypeElement element) {
 		super(annotationMetaEntity, method, sessionName, sessionType);
 		this.entity = entity;
 		this.actualEntity = actualEntity;
@@ -59,6 +74,11 @@ public LifecycleMethod(
 		this.parameterKind = parameterKind;
 		this.returnArgument = returnArgument;
 		this.hasGeneratedId = hasGeneratedId;
+		this.methodTypeParameters = method.getTypeParameters().stream()
+				.map( TypeParameterElement::asType )
+				.map( TypeMirror::toString )
+				.collect( toSet() );
+		this.element = element;
 	}
 
 	@Override
@@ -334,27 +354,84 @@ private boolean isGeneratedIdUpsert() {
 	private void preamble(StringBuilder declaration) {
 		declaration
 				.append("\n@Override\npublic ")
+				.append(parameterTypeBopunds())
 				.append(returnType())
 				.append(' ')
 				.append(methodName)
 				.append('(');
 		notNull(declaration);
+		final var parameters = method.getParameters();
+		assert parameters.size() == 1;
+		final VariableElement element = parameters.get(0);
 		declaration
-				.append(annotationMetaEntity.importType(entity))
+				.append(resolveAsString(element.asType()))
 				.append(' ')
-				.append(parameterName)
+				.append(element.getSimpleName())
 				.append(')')
 				.append(" {\n");
 	}
 
+	private String parameterTypeBopunds() {
+		if ( method.getTypeParameters().isEmpty() ) {
+			return "";
+		}
+		return method.getTypeParameters().stream()
+				.map( this::resolveTypeParameter )
+				.collect( joining( ", ", " <", "> " ) );
+	}
+
+	private String resolveAsString(TypeMirror type) {
+		if ( type.getKind().isPrimitive() || type.getKind() == VOID ) {
+			return type.toString();
+		}
+		else if ( type instanceof DeclaredType declaredType ) {
+			final var element = annotationMetaEntity.importType(
+					((TypeElement) declaredType.asElement()).getQualifiedName().toString()
+			);
+			if ( declaredType.getTypeArguments().isEmpty() ) {
+				return element;
+			}
+			return element + declaredType.getTypeArguments().stream().map( this::resolveAsString )
+					.collect( joining( ",", "<", ">" ) );
+		}
+		else if ( type instanceof TypeVariable typeVariable ) {
+			final var value = typeVariable.toString();
+			if ( methodTypeParameters.contains( value ) ) {
+				return value;
+			}
+			return annotationMetaEntity.importType( resolveTypeName( element, method.getEnclosingElement(), value ) );
+		}
+		else if ( type instanceof WildcardType wildcardType ) {
+			return "?"
+				+ (wildcardType.getExtendsBound() == null ? ""
+					: " extends " + resolveAsString( wildcardType.getExtendsBound() ))
+				+ (wildcardType.getSuperBound() == null ? ""
+					: " super " + resolveAsString( wildcardType.getExtendsBound() ));
+		}
+		else if ( type instanceof ArrayType arrayType ) {
+			return resolveAsString( arrayType.getComponentType() ) + "[]";
+		}
+		else {
+			System.err.printf( "Type kind %s - %s%n", type.getKind(), type );
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	private String resolveTypeParameter(TypeParameterElement p) {
+		final var type = (TypeVariable) p.asType();
+		return type.toString()
+			+ (type.getUpperBound().getKind() == TypeKind.NULL ? ""
+				: " extends " + resolveAsString( type.getUpperBound() ))
+			+ (type.getLowerBound().getKind() == TypeKind.NULL ? ""
+				: " super " + resolveAsString( type.getLowerBound() ));
+	}
+
 	private String returnType() {
-		final String entityType = annotationMetaEntity.importType(entity);
-		if ( isReactive() ) {
-			return annotationMetaEntity.importType(UNI)
-					+ '<' + (returnArgument ? entityType : "Void") + '>';
+		if ( returnArgument ) {
+			return resolveAsString(method.getReturnType());
 		}
 		else {
-			return returnArgument ? entityType : "void";
+			return isReactive() ? annotationMetaEntity.importType(UNI) + "<Void>" : "void";
 		}
 	}
 

tooling/metamodel-generator/src/main/java/org/hibernate/processor/util/TypeUtils.java

@@ -784,6 +784,11 @@ public static boolean isPrimitive(String paramType) {
 	public static final Set<String> PRIMITIVE_TYPES =
 			Set.of("boolean", "char", "long", "int", "short", "byte", "double", "float");
 
+	public static String resolveTypeName(TypeElement typeElement, Element element, String name) {
+		final var mirror = resolveTypeMirror( typeElement, element, name );
+		return mirror == null ? name : mirror.toString();
+	}
+
 	public static @Nullable TypeMirror resolveTypeMirror(TypeElement typeElement, Element element, String name) {
 		final var mirrorMap = resolveTypeParameters( typeElement.asType(), element, Map.of(), new HashSet<>() );
 		return mirrorMap == null ? null : mirrorMap.get( name );
@@ -808,7 +813,7 @@ public static boolean isPrimitive(String paramType) {
 					? generic.get( 0 ).getBounds().get( 0 )
 					: typeArguments.get( n );
 			final var value = mirror.toString();
-			map.put( generic.get( n ).toString(), parametersMap.getOrDefault( value, mirror ) );
+			map.put( generic.get( n ).asType().toString(), parametersMap.getOrDefault( value, mirror ) );
 		}
 		if ( typeElement.equals( element ) ) {
 			return map;