Simplify resolveTypeVariable and tweaks for parameterized types

Author: mbellade

src/main/java/org/hibernate/models/spi/ClassDetails.java

@@ -12,8 +12,6 @@
 import org.hibernate.models.internal.SimpleClassDetails;
 import org.hibernate.models.internal.util.IndexedConsumer;
 
-import static org.hibernate.models.spi.TypeDetailsHelper.resolveTypeVariableFromParameterizedType;
-
 /**
  * Abstraction for what Hibernate understands about a "class", generally before it has access to
  * the actual {@link Class} reference, if there is a {@code Class} at all (dynamic models).
@@ -149,23 +147,12 @@ default TypeDetails resolveTypeVariable(TypeVariableDetails typeVariable) {
 
 		if ( isSuperclass( typeVariable.getDeclaringType() ) ) {
 			final TypeDetails genericSuperType = getGenericSuperType();
-			if ( genericSuperType != null && genericSuperType.getTypeKind() == TypeDetails.Kind.PARAMETERIZED_TYPE ) {
-				final TypeDetails resolvedType = resolveTypeVariableFromParameterizedType(
-						genericSuperType.asParameterizedType(),
-						typeVariable
-				);
-				if ( resolvedType != null ) {
-					return resolvedType;
-				}
-			}
-
-			final ClassDetails superClass = getSuperClass();
-			if ( superClass != null ) {
-				return superClass.resolveTypeVariable( typeVariable );
+			if ( genericSuperType != null ) {
+				return genericSuperType.resolveTypeVariable( typeVariable );
 			}
 		}
 
-		return ClassBasedTypeDetails.OBJECT_TYPE_DETAILS;
+		return null;
 	}
 
 	@Override

src/main/java/org/hibernate/models/spi/TypeDetailsHelper.java

@@ -194,31 +194,42 @@ public static TypeDetails resolveTypeVariableFromParameterizedType(
 			ParameterizedTypeDetails parameterizedType,
 			TypeVariableDetails typeVariable) {
 		final ClassDetails classDetails = parameterizedType.getRawClassDetails();
-		final List<TypeVariableDetails> typeParameters = classDetails.getTypeParameters();
-		final List<TypeDetails> typeArguments = parameterizedType.getArguments();
-		assert typeParameters.size() == typeArguments.size();
+		final TypeDetails typeArgument = findMatchingTypeArgument(
+				classDetails.getTypeParameters(),
+				parameterizedType.getArguments(),
+				typeVariable.getIdentifier()
+		);
+
+		// If no type argument is found, or the type variable is defined by another
+		// class, try resolving it in the generic super type if present
+		if ( typeArgument == null || classDetails != typeVariable.getDeclaringType() ) {
+			final TypeDetails genericSuper = classDetails.getGenericSuperType();
+			final TypeDetails resolvedType = genericSuper != null ?
+					genericSuper.resolveTypeVariable( typeVariable ) :
+					null;
+			if ( typeArgument == null || resolvedType != null
+					&& resolvedType.getTypeKind() != TypeDetails.Kind.TYPE_VARIABLE ) {
+				return resolvedType;
+			}
+		}
+
+		// Either we found the exact type variable's argument, or the parameterized class redefines
+		// a type variable with the same identifier as a supertype, and it should be ignored.
+		// Return the matching generic type argument
+		return typeArgument;
+	}
 
+	private static TypeDetails findMatchingTypeArgument(
+			List<TypeVariableDetails> typeParameters,
+			List<TypeDetails> typeArguments,
+			String identifier) {
+		assert typeParameters.size() == typeArguments.size();
 		for ( int i = 0; i < typeParameters.size(); i++ ) {
 			final TypeVariableDetails typeParameter = typeParameters.get( i );
-			if ( typeParameter.getIdentifier().equals( typeVariable.getIdentifier() ) ) {
-				if ( classDetails != typeVariable.getDeclaringType() ) {
-					final TypeDetails genericSuper = classDetails.getGenericSuperType();
-					if ( genericSuper != null && genericSuper.getTypeKind() == TypeDetails.Kind.PARAMETERIZED_TYPE ) {
-						// Recursively check if the type variable is resolved in supertypes
-						final TypeDetails superResolvedType = classDetails.resolveTypeVariable( typeVariable );
-						if ( superResolvedType.getTypeKind() != TypeDetails.Kind.TYPE_VARIABLE
-								&& superResolvedType != OBJECT_TYPE_DETAILS ) {
-							return superResolvedType;
-						}
-					}
-				}
-				// Either we found the exact parameter definition, or the local generic supertype
-				// redefines a type variable with the same identifier, and we should ignore it.
-				// Return the matching generic type argument
+			if ( typeParameter.getIdentifier().equals( identifier ) ) {
 				return typeArguments.get( i );
 			}
 		}
-
 		return null;
 	}
 

src/main/java/org/hibernate/models/spi/TypeVariableScope.java

@@ -35,7 +35,7 @@ public interface TypeVariableScope {
 	 *
 	 * @param typeVariable The type variable to resolve
 	 *
-	 * @return The type variable's resolved type, or {@code null} none could be found
+	 * @return The type variable's resolved type, or {@code null} if none could be found
 	 */
 	TypeDetails resolveTypeVariable(TypeVariableDetails typeVariable);