HHH-19449 simplify the whole design

Remove BindableType.getBindableJavaType() which created all
sorts of confusion with JPAs Bindable.getBindableJavaType().
Now can just use Type.getJavaType() for this.

Author: gavinking

hibernate-core/src/main/java/org/hibernate/boot/model/internal/NamedGraphCreatorJpa.java

@@ -142,7 +142,7 @@ private static <T, E, K> SubGraphImplementor<?> makeAttributeNodeValueSubgraph(
 	private static <T, E, K> SubGraphImplementor<?> makeAttributeNodeKeySubgraph(
 			AttributeNodeImplementor<T, E, K> attributeNode, Class<?> subgraphType) {
 		final Class<?> attributeKeyType =
-				attributeNode.getAttributeDescriptor().getKeyGraphType().getBindableJavaType();
+				attributeNode.getAttributeDescriptor().getKeyGraphType().getJavaType();
 		if ( !attributeKeyType.isAssignableFrom( subgraphType ) ) {
 			throw new AnnotationException( "Named subgraph type '" + subgraphType.getName()
 										+ "' is not a subtype of the key type '" + attributeKeyType.getName() + "'" );

hibernate-core/src/main/java/org/hibernate/engine/query/spi/AbstractParameterDescriptor.java

@@ -38,7 +38,7 @@ public Integer getPosition() {
 
 	@Override
 	public Class<T> getParameterType() {
-		return expectedType == null ? null : expectedType.getBindableJavaType();
+		return expectedType == null ? null : expectedType.getJavaType();
 	}
 
 	@Override

hibernate-core/src/main/java/org/hibernate/graph/internal/AttributeNodeImpl.java

@@ -16,7 +16,6 @@
 import org.hibernate.metamodel.model.domain.PluralPersistentAttribute;
 import org.hibernate.metamodel.model.domain.SimpleDomainType;
 import org.hibernate.metamodel.model.domain.SingularPersistentAttribute;
-import org.hibernate.type.BindableType;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -260,7 +259,7 @@ public SubGraphImplementor<E> makeSubGraph() {
 	@Override @Deprecated
 	public <S> SubGraphImplementor<S> makeSubGraph(Class<S> subtype) {
 		final ManagedDomainType<E> managedType = asManagedType( valueGraphType );
-		if ( !((BindableType<K>) managedType).getBindableJavaType().isAssignableFrom( subtype ) ) {
+		if ( !managedType.getJavaType().isAssignableFrom( subtype ) ) {
 			throw new IllegalArgumentException( "Not a subtype: " + subtype.getName() );
 		}
 		@SuppressWarnings("unchecked")
@@ -284,7 +283,7 @@ public SubGraphImplementor<K> makeKeySubGraph() {
 	public <S> SubGraphImplementor<S> makeKeySubGraph(Class<S> subtype) {
 		checkMap();
 		final ManagedDomainType<K> type = asManagedType( keyGraphType );
-		if ( ! ((BindableType<K>) type).getBindableJavaType().isAssignableFrom( subtype ) ) {
+		if ( !type.getJavaType().isAssignableFrom( subtype ) ) {
 			throw new IllegalArgumentException( "Not a key subtype: " + subtype.getName() );
 		}
 		@SuppressWarnings("unchecked")

hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java

@@ -173,8 +173,9 @@ public Map<Class<?>, MappedSuperclassDomainType<?>> getMappedSuperclassTypeMap()
 	}
 
 	public  void registerEntityType(PersistentClass persistentClass, EntityTypeImpl<?> entityType) {
-		if ( entityType.getBindableJavaType() != null && entityType.getBindableJavaType() != Map.class ) {
-			entityTypes.put( entityType.getBindableJavaType(), entityType );
+		final Class<?> javaType = entityType.getJavaType();
+		if ( javaType != null && javaType != Map.class ) {
+			entityTypes.put( javaType, entityType );
 		}
 
 		identifiableTypesByName.put( persistentClass.getEntityName(), entityType );

hibernate-core/src/main/java/org/hibernate/metamodel/mapping/CollectionPart.java

@@ -18,41 +18,36 @@
  * @author Steve Ebersole
  */
 public interface CollectionPart extends ValuedModelPart, Fetchable, JavaTypedExpressible {
+
 	enum Nature {
 		/**
-		 * The Collection element or Map element
+		 * The Collection element or Map element.
 		 */
-		ELEMENT( "{element}" ),
+		ELEMENT,
 		/**
-		 * The List index or Map key
+		 * The List index or Map key.
 		 */
-		INDEX( "{index}" ),
+		INDEX,
 		/**
-		 * The identifier for
+		 * The identifier for and idbag.
 		 */
-		ID( "{collection-id}" );
-
-		private final String name;
-
-		Nature(String name) {
-			this.name = name;
-		}
+		ID;
 
 		public String getName() {
-			return name;
+			return switch (this) {
+				case ELEMENT -> "{element}";
+				case INDEX -> "{index}";
+				case ID -> "{collection-id}";
+			};
 		}
 
 		public static Nature fromNameExact(String name) {
-			switch ( name ) {
-				case "{element}":
-					return ELEMENT;
-				case "{index}":
-					return INDEX;
-				case "{collection-id}":
-					return ID;
-			}
-
-			return null;
+			return switch ( name ) {
+				case "{element}" -> ELEMENT;
+				case "{index}" -> INDEX;
+				case "{collection-id}" -> ID;
+				default -> null;
+			};
 		}
 
 		public static Nature fromName(String name) {
@@ -75,7 +70,7 @@ public static Nature fromName(String name) {
 				return ELEMENT;
 			}
 
-			if ( ID.name.equals( name ) ) {
+			if ( ID.getName().equals( name ) ) {
 				return ID;
 			}
 

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/BasicDomainType.java

@@ -20,11 +20,6 @@ default PersistenceType getPersistenceType() {
 		return PersistenceType.BASIC;
 	}
 
-	@Override
-	default Class<J> getBindableJavaType() {
-		return ReturnableType.super.getBindableJavaType();
-	}
-
 	@Override
 	default Class<J> getJavaType() {
 		return ReturnableType.super.getJavaType();

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/DomainType.java

@@ -39,11 +39,12 @@ public interface DomainType<J> {
 	Class<J> getJavaType();
 
 	/**
-	 * The name of the type.
+	 * The name of the type. Usually, but not always, the name of a Java class.
 	 *
-	 * @apiNote This is the Hibernate notion of the type name. For most
-	 *          types this is just the Java type ({@link Class}) name.
-	 *          However, using the string allows for dynamic models.
+	 * @see ManagedDomainType#getTypeName()
+	 * @see org.hibernate.query.sqm.SqmExpressible#getTypeName()
 	 */
-	String getTypeName();
+	default String getTypeName() {
+		return getExpressibleJavaType().getTypeName();
+	}
 }

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/ManagedDomainType.java

@@ -7,6 +7,7 @@
 import java.util.Collection;
 import java.util.function.Consumer;
 
+import org.hibernate.Internal;
 import org.hibernate.metamodel.RepresentationMode;
 
 import jakarta.persistence.metamodel.ManagedType;
@@ -18,22 +19,33 @@
  */
 public interface ManagedDomainType<J> extends DomainType<J>, ManagedType<J> {
 	/**
-	 * Get the type name.
+	 * The name of the managed type.
 	 *
 	 * @apiNote This usually returns the name of the Java class. However, for
 	 *          {@linkplain RepresentationMode#MAP dynamic models}, this returns
 	 *          the symbolic name since the Java type is {@link java.util.Map}.
 	 *
-	 * @return The type name.
-	 *
 	 * @see #getRepresentationMode()
 	 */
+	@Override
 	String getTypeName();
 
+	/**
+	 * The parent {@linkplain JpaMetamodel metamodel}.
+	 */
 	JpaMetamodel getMetamodel();
 
+	/**
+	 * The representation mode.
+	 *
+	 * @return {@link RepresentationMode#POJO POJO} for Java class entities,
+	 *         or {@link RepresentationMode#MAP MAP} for dynamic entities.
+	 */
 	RepresentationMode getRepresentationMode();
 
+	/**
+	 * The Java class of the entity type.
+	 */
 	@Override
 	default Class<J> getJavaType() {
 		return getExpressibleJavaType().getJavaTypeClass();
@@ -44,8 +56,12 @@ default Class<J> getJavaType() {
 	 */
 	ManagedDomainType<? super J> getSuperType();
 
+	/**
+	 * The descriptors of all known managed subtypes of this type.
+	 */
 	Collection<? extends ManagedDomainType<? extends J>> getSubTypes();
 
+	@Internal
 	void addSubType(ManagedDomainType<? extends J> subType);
 
 	void visitAttributes(Consumer<? super PersistentAttribute<? super J, ?>> action);

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/SimpleDomainType.java

@@ -7,16 +7,11 @@
 import jakarta.persistence.metamodel.Type;
 
 /**
- * Describes any non-collection type
+ * Describes any non-collection type.
  *
  * @author Steve Ebersole
  */
 public interface SimpleDomainType<J> extends DomainType<J>, Type<J> {
-
-	default Class<J> getBindableJavaType() {
-		return getJavaType();
-	}
-
 	@Override
 	default Class<J> getJavaType() {
 		return getExpressibleJavaType().getJavaTypeClass();

hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/AbstractManagedType.java

@@ -102,11 +102,6 @@ public Class<J> getJavaType() {
 		return super.getJavaType();
 	}
 
-	@Override
-	public Class<J> getBindableJavaType() {
-		return super.getBindableJavaType();
-	}
-
 	@Override
 	public SqmManagedDomainType<? super J> getSuperType() {
 		return supertype;
@@ -336,13 +331,13 @@ private <K,Y> SqmSingularPersistentAttribute<K,Y> checkTypeForSingleAttribute(
 
 	private <T, Y> boolean hasMatchingReturnType(SingularAttribute<T, ?> attribute, Class<Y> javaType) {
 		return javaType == null
-			|| attribute.getBindableJavaType().equals( javaType )
+			|| attribute.getJavaType().equals( javaType )
 			|| isPrimitiveVariant( attribute, javaType );
 	}
 
 	protected <Y> boolean isPrimitiveVariant(SingularAttribute<?,?> attribute, Class<Y> javaType) {
 		if ( attribute != null ) {
-			final Class<?> declaredType = attribute.getBindableJavaType();
+			final Class<?> declaredType = attribute.getJavaType();
 			if ( declaredType.isPrimitive() ) {
 				return ( Boolean.class.equals( javaType ) && Boolean.TYPE.equals( declaredType ) )
 					|| ( Character.class.equals( javaType ) && Character.TYPE.equals( declaredType ) )
@@ -418,7 +413,7 @@ private <E> void checkTypeForPluralAttributes(
 			Class<E> elementType,
 			PluralAttribute.CollectionType collectionType) {
 		if ( attribute == null
-				|| ( elementType != null && !attribute.getBindableJavaType().equals( elementType ) )
+				|| elementType != null && !attribute.getBindableJavaType().equals( elementType )
 				|| attribute.getCollectionType() != collectionType ) {
 			throw new IllegalArgumentException(
 					attributeType + " named " + name