HHH-19076 Fix SessionFactory error with a specific @IdClass setup

This commit fixes HHH-19076. This bug is not trivial to reproduce
since it requires a very specific entity setup:

- There must be at least 2 entities
- Both entities must extend the same @MappedSuperclass
- The @MappedSuperclass must have an @id
- One (and only one) of the entities must additionally use @IdClass
- The entities must be named / loaded / etc. so that the entity WITHOUT the @IdClass is processed first

Specifically the last step is impossible to reproduce reliably, since it depends
on the [order hibernate processes the entities][1], which in turn depends on the
order of the values of [a map `entityBindingMap`][2].

Depending on the order the entites are processed, the
[`MetadataContext.mappedSuperClassTypeToPersistentClass`][3] map
stores for the shared @MappedSuperclass a different entity. However,
to correctly process the attributes of the @MappedSuperclass, the
entity with the @IdClass must be used in [`resolveVirtualIdentifierMember`][4].

To fix this, this commit changes the simple
[`mappedSuperClassTypeToPersistentClass`][3] map to store a set
of entities instead of only the first encountered entity. Next,
the [`resolveVirtualIdentifierMember`][4] function uses the first
matching entity of this set.

[1]: https://github.com/hibernate/hibernate-orm/blob/3cfeb8fa29769258a0c0615b7e14b469798f0f3a/hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/JpaMetamodelImpl.java#L627-L629
[2]: https://github.com/hibernate/hibernate-orm/blob/3cfeb8fa29769258a0c0615b7e14b469798f0f3a/hibernate-core/src/main/java/org/hibernate/boot/internal/MetadataImpl.java#L86
[3]: https://github.com/hibernate/hibernate-orm/blob/3cfeb8fa29769258a0c0615b7e14b469798f0f3a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/MetadataContext.java#L96
[4]: https://github.com/hibernate/hibernate-orm/blob/3cfeb8fa29769258a0c0615b7e14b469798f0f3a/hibernate-core/src/main/java/org/hibernate/metamodel/internal/AttributeFactory.java#L687

Author: mensinda

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

@@ -9,6 +9,7 @@
 import java.lang.reflect.Method;
 import java.lang.reflect.ParameterizedType;
 import java.util.HashMap;
+import java.util.Set;
 
 import org.hibernate.AssertionFailure;
 import org.hibernate.PropertyNotFoundException;
@@ -395,20 +396,29 @@ private static JavaType<?> determineRelationalJavaType(
 	private static EntityPersister getDeclaringEntity(
 			AbstractIdentifiableType<?> ownerType,
 			MetadataContext metadataContext) {
+		final java.util.List<EntityPersister> resultList = getDeclarerEntityPersister( ownerType, metadataContext );
+		return resultList.isEmpty() ? null : resultList.getFirst();
+	}
+
+	private static java.util.List<EntityPersister> getAllDeclaringEntities(AbstractIdentifiableType<?> ownerType,
+																		MetadataContext metadataContext) {
 		return getDeclarerEntityPersister( ownerType, metadataContext );
 	}
 
-	private static EntityPersister getDeclarerEntityPersister(
+	private static java.util.List<EntityPersister> getDeclarerEntityPersister(
 			AbstractIdentifiableType<?> ownerType,
 			MetadataContext metadataContext) {
 		final Type.PersistenceType persistenceType = ownerType.getPersistenceType();
 		if ( persistenceType == Type.PersistenceType.ENTITY ) {
-			return metadataContext.getMetamodel().getEntityDescriptor( ownerType.getTypeName() );
+			return java.util.List.of(metadataContext.getMetamodel().getEntityDescriptor( ownerType.getTypeName() ));
 		}
 		else if ( persistenceType == Type.PersistenceType.MAPPED_SUPERCLASS ) {
-			final PersistentClass persistentClass =
+			final Set<PersistentClass> persistentClassSet =
 					metadataContext.getPersistentClassHostingProperties( (MappedSuperclassTypeImpl<?>) ownerType );
-			return persistentClass != null ? metadataContext.getMetamodel().findEntityDescriptor( persistentClass.getClassName() ) : null;
+			if (persistentClassSet == null) {
+				return java.util.List.of();
+			}
+			return persistentClassSet.stream().map( persistentClass -> metadataContext.getMetamodel().findEntityDescriptor( persistentClass.getClassName() ) ).toList();
 		}
 		else {
 			throw new AssertionFailure( "Cannot get the metamodel for PersistenceType: " + persistenceType );
@@ -680,18 +690,27 @@ private static EmbeddableRepresentationStrategy ownerRepresentationStrategy(
 
 	private static final MemberResolver virtualIdentifierMemberResolver = (attributeContext, metadataContext) -> {
 		final AbstractIdentifiableType<?> identifiableType = (AbstractIdentifiableType<?>) attributeContext.getOwnerType();
-		final EntityPersister declaringEntity = getDeclaringEntity( identifiableType, metadataContext );
-		return resolveVirtualIdentifierMember( attributeContext.getPropertyMapping(), declaringEntity );
+		final java.util.List<EntityPersister> declaringEntities = getAllDeclaringEntities( identifiableType, metadataContext );
+		return resolveVirtualIdentifierMember( attributeContext.getPropertyMapping(), declaringEntities );
 	};
 
-	private static Member resolveVirtualIdentifierMember( Property property, EntityPersister entityPersister) {
-		final EntityIdentifierMapping identifierMapping = entityPersister.getIdentifierMapping();
+	private static Member resolveVirtualIdentifierMember( Property property, java.util.List<EntityPersister> entityPersisters) {
+		CompositeIdentifierMapping cid = null;
+
+		// HHH-19076: Find the first EntityPersister for the property with a VIRTUAL identifierMapping
+		for (EntityPersister entityPersister : entityPersisters) {
+			EntityIdentifierMapping identifierMapping = entityPersister.getIdentifierMapping();
+
+			if ( identifierMapping.getNature() == EntityIdentifierMapping.Nature.VIRTUAL ) {
+				cid = (CompositeIdentifierMapping) identifierMapping;
+				break;
+			}
+		}
 
-		if ( identifierMapping.getNature() != EntityIdentifierMapping.Nature.VIRTUAL ) {
+		if ( cid == null ) {
 			throw new IllegalArgumentException( "expecting IdClass mapping" );
 		}
 
-		final CompositeIdentifierMapping cid = (CompositeIdentifierMapping) identifierMapping;
 		final EmbeddableMappingType embeddable = cid.getPartMappingType();
 		final String attributeName = property.getName();
 		final AttributeMapping attributeMapping = embeddable.findAttributeMapping( attributeName );
@@ -718,7 +737,7 @@ private static Member resolveVirtualIdentifierMember( Property property, EntityP
 		return switch ( persistenceType ) {
 			case ENTITY ->
 					resolveEntityMember( property,
-							getDeclaringEntity( (AbstractIdentifiableType<?>) ownerType, metadataContext ) );
+							getAllDeclaringEntities( (AbstractIdentifiableType<?>) ownerType, metadataContext ) );
 			case MAPPED_SUPERCLASS ->
 					resolveMappedSuperclassMember( property, (MappedSuperclassDomainType<?>) ownerType, metadataContext );
 			case EMBEDDABLE ->
@@ -727,31 +746,32 @@ private static Member resolveVirtualIdentifierMember( Property property, EntityP
 		};
 	};
 
-	private static Member resolveEntityMember(Property property, EntityPersister declaringEntity) {
+	private static Member resolveEntityMember(Property property, java.util.List<EntityPersister> declaringEntities) {
 		final String propertyName = property.getName();
-		final AttributeMapping attributeMapping = declaringEntity.findAttributeMapping( propertyName );
+		final EntityPersister firstDeclaringEntity = declaringEntities.getFirst();
+		final AttributeMapping attributeMapping = firstDeclaringEntity.findAttributeMapping( propertyName );
 		return attributeMapping == null
 				// just like in #determineIdentifierJavaMember , this *should* indicate we have an IdClass mapping
-				? resolveVirtualIdentifierMember( property, declaringEntity )
-				: getter( declaringEntity, property, propertyName, property.getType().getReturnedClass() );
+				? resolveVirtualIdentifierMember( property, declaringEntities )
+				: getter( firstDeclaringEntity, property, propertyName, property.getType().getReturnedClass() );
 	}
 
 	private static Member resolveMappedSuperclassMember(
 			Property property,
 			MappedSuperclassDomainType<?> ownerType,
 			MetadataContext context) {
-		final EntityPersister declaringEntity =
-				getDeclaringEntity( (AbstractIdentifiableType<?>) ownerType, context );
-		if ( declaringEntity != null ) {
-			return resolveEntityMember( property, declaringEntity );
+		final java.util.List<EntityPersister> declaringEntities =
+				getAllDeclaringEntities( (AbstractIdentifiableType<?>) ownerType, context );
+		if ( !declaringEntities.isEmpty() ) {
+			return resolveEntityMember( property, declaringEntities );
 		}
 		else {
 			final ManagedDomainType<?> subType = ownerType.getSubTypes().iterator().next();
 			final Type.PersistenceType persistenceType = subType.getPersistenceType();
 			return switch ( persistenceType ) {
 				case ENTITY ->
 						resolveEntityMember( property,
-								getDeclaringEntity( (AbstractIdentifiableType<?>) subType, context ) );
+								getAllDeclaringEntities( (AbstractIdentifiableType<?>) subType, context ) );
 				case MAPPED_SUPERCLASS ->
 						resolveMappedSuperclassMember( property, (MappedSuperclassDomainType<?>) subType, context );
 				case EMBEDDABLE ->

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

@@ -93,7 +93,7 @@ public class MetadataContext {
 	private final Map<EmbeddableDomainType<?>, Component> componentByEmbeddable = new HashMap<>();
 
 	private final Map<MappedSuperclass, MappedSuperclassDomainType<?>> mappedSuperclassByMappedSuperclassMapping = new HashMap<>();
-	private final Map<MappedSuperclassDomainType<?>, PersistentClass> mappedSuperClassTypeToPersistentClass = new HashMap<>();
+	private final Map<MappedSuperclassDomainType<?>, Set<PersistentClass>> mappedSuperClassTypeToPersistentClass = new HashMap<>();
 
 	//this list contains MappedSuperclass and EntityTypes ordered by superclass first
 	private final List<Object> orderedMappings = new ArrayList<>();
@@ -211,13 +211,19 @@ public void registerMappedSuperclassType(
 		identifiableTypesByName.put( mappedSuperclassType.getTypeName(), mappedSuperclassType );
 		mappedSuperclassByMappedSuperclassMapping.put( mappedSuperclass, mappedSuperclassType );
 		orderedMappings.add( mappedSuperclass );
-		if ( !stackOfPersistentClassesBeingProcessed.isEmpty() ) {
-			mappedSuperClassTypeToPersistentClass.put( mappedSuperclassType, getEntityWorkedOn() );
-		}
 
 		knownMappedSuperclasses.remove( mappedSuperclass );
 	}
 
+	public void registerMappedSuperclassForPersistenceClass(MappedSuperclassDomainType<?> mappedSuperclassType) {
+		if ( stackOfPersistentClassesBeingProcessed.isEmpty() ) {
+			return;
+		}
+
+		final Set<PersistentClass> persistentClassSet = mappedSuperClassTypeToPersistentClass.computeIfAbsent( mappedSuperclassType, x -> new HashSet<>() );
+		persistentClassSet.add( getEntityWorkedOn() );
+	}
+
 	/**
 	 * Given a Hibernate {@link PersistentClass}, locate the corresponding JPA {@link org.hibernate.type.EntityType}
 	 * implementation.  May return null if the given {@link PersistentClass} has not yet been processed.
@@ -855,7 +861,7 @@ private PersistentClass getEntityWorkedOn() {
 		);
 	}
 
-	public PersistentClass getPersistentClassHostingProperties(MappedSuperclassTypeImpl<?> mappedSuperclassType) {
+	public Set<PersistentClass> getPersistentClassHostingProperties(MappedSuperclassTypeImpl<?> mappedSuperclassType) {
 		return mappedSuperClassTypeToPersistentClass.get( mappedSuperclassType );
 	}
 

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

@@ -780,11 +780,14 @@ private <T> MappedSuperclassDomainType<T> locateOrBuildMappedSuperclassType(
 			MetadataContext context,
 			TypeConfiguration typeConfiguration) {
 		@SuppressWarnings("unchecked")
-		final MappedSuperclassDomainType<T> mappedSuperclassType =
+		MappedSuperclassDomainType<T> mappedSuperclassType =
 				(MappedSuperclassDomainType<T>) context.locateMappedSuperclassType( mappedSuperclass );
-		return mappedSuperclassType == null
-				? buildMappedSuperclassType( mappedSuperclass, context, typeConfiguration )
-				: mappedSuperclassType;
+		if (mappedSuperclassType == null) {
+			mappedSuperclassType = buildMappedSuperclassType( mappedSuperclass, context, typeConfiguration );
+		}
+		// HHH-19076: Ensure that each mapped superclass knows ALL its implementations
+		context.registerMappedSuperclassForPersistenceClass( mappedSuperclassType );
+		return mappedSuperclassType;
 	}
 
 	private <T> MappedSuperclassTypeImpl<T> buildMappedSuperclassType(