HHH-18693 [6.6 backport] Hibernate Processor does not handle inner types

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

@@ -77,16 +77,40 @@ public interface JpaMetamodel extends Metamodel {
 	<X> EntityDomainType<X> resolveHqlEntityReference(String entityName);
 
 	/**
-	 * Same as {@link #managedType} except {@code null} is returned rather
+	 * Same as {@link #managedType(Class)} except {@code null} is returned rather
 	 * than throwing an exception
 	 */
-	<X> ManagedDomainType<X> findManagedType(Class<X> cls);
+	@Nullable <X> ManagedDomainType<X> findManagedType(Class<X> cls);
 
 	/**
-	 * Same as {@link #entity} except {@code null} is returned rather
+	 * Same as {@link #entity(Class)} except {@code null} is returned rather
 	 * than throwing an exception
 	 */
-	<X> EntityDomainType<X> findEntityType(Class<X> cls);
+	@Nullable <X> EntityDomainType<X> findEntityType(Class<X> cls);
+
+	/**
+	 * Same as {@link #embeddable(Class)} except {@code null} is returned rather
+	 * than throwing an exception
+	 */
+	@Nullable <X> EmbeddableDomainType<X> findEmbeddableType(Class<X> cls);
+
+	/**
+	 * Same as {@link #managedType(String)} except {@code null} is returned rather
+	 * than throwing an exception
+	 */
+	@Nullable <X> ManagedDomainType<X> findManagedType(@Nullable String typeName);
+
+	/**
+	 * Same as {@link #entity(String)} except {@code null} is returned rather
+	 * than throwing an exception
+	 */
+	@Nullable EntityDomainType<?> findEntityType(@Nullable String entityName);
+
+	/**
+	 * Same as {@link #embeddable(String)} except {@code null} is returned rather
+	 * than throwing an exception
+	 */
+	@Nullable EmbeddableDomainType<?> findEmbeddableType(@Nullable String embeddableName);
 
 	String qualifyImportableName(String queryName);
 

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

@@ -132,35 +132,62 @@ public JpaCompliance getJpaCompliance() {
 	}
 
 	@Override
-	public <X> ManagedDomainType<X> managedType(String typeName) {
+	public @Nullable <X> ManagedDomainType<X> findManagedType(@Nullable String typeName) {
 		//noinspection unchecked
 		return typeName == null ? null : (ManagedDomainType<X>) managedTypeByName.get( typeName );
 	}
 
 	@Override
-	public <X> EntityDomainType<X> entity(String entityName) {
+	public <X> ManagedDomainType<X> managedType(String typeName) {
+		final ManagedDomainType<X> managedType = findManagedType( typeName );
+		if ( managedType == null ) {
+			throw new IllegalArgumentException("Not a managed type: " + typeName);
+		}
+		return managedType;
+	}
+
+	@Override
+	@Nullable public EntityDomainType<?> findEntityType(@Nullable String entityName) {
 		if ( entityName == null ) {
 			return null;
 		}
 		final ManagedDomainType<?> managedType = managedTypeByName.get( entityName );
-		if ( !( managedType instanceof EntityDomainType<?> ) ) {
+		if ( !(managedType instanceof EntityDomainType<?>) ) {
 			return null;
 		}
 		//noinspection unchecked
-		return (EntityDomainType<X>) managedType;
+		return (EntityDomainType<?>) managedType;
 	}
 
 	@Override
-	public <X> EmbeddableDomainType<X> embeddable(String embeddableName) {
+	public <X> EntityDomainType<X> entity(String entityName) {
+		final EntityDomainType<?> entityType = findEntityType( entityName );
+		if ( entityType == null ) {
+			// per JPA
+			throw new IllegalArgumentException("Not an entity: " + entityName);
+		}
+		return (EntityDomainType<X>) entityType;
+	}
+
+	@Override
+	@Nullable public EmbeddableDomainType<?> findEmbeddableType(@Nullable String embeddableName) {
 		if ( embeddableName == null ) {
 			return null;
 		}
 		final ManagedDomainType<?> managedType = managedTypeByName.get( embeddableName );
-		if ( !( managedType instanceof EmbeddableDomainType<?> ) ) {
+		if ( !(managedType instanceof EmbeddableDomainType<?>) ) {
 			return null;
 		}
-		//noinspection unchecked
-		return (EmbeddableDomainType<X>) managedType;
+		return (EmbeddableDomainType<?>) managedType;
+	}
+
+	@Override
+	public <X> EmbeddableDomainType<X> embeddable(String embeddableName) {
+		final EmbeddableDomainType<?> embeddableType = findEmbeddableType( embeddableName );
+		if ( embeddableType == null ) {
+			throw new IllegalArgumentException("Not an embeddable: " + embeddableName);
+		}
+		return (EmbeddableDomainType<X>) embeddableType;
 	}
 
 	@Override
@@ -172,9 +199,9 @@ public <X> EntityDomainType<X> getHqlEntityReference(String entityName) {
 			entityName = importInfo.importedName;
 		}
 
-		final EntityDomainType<X> entityDescriptor = entity( entityName );
+		final EntityDomainType<?> entityDescriptor = findEntityType( entityName );
 		if ( entityDescriptor != null ) {
-			return entityDescriptor;
+			return (EntityDomainType<X>) entityDescriptor;
 		}
 
 		if ( loadedClass == null ) {
@@ -200,13 +227,23 @@ public <X> EntityDomainType<X> resolveHqlEntityReference(String entityName) {
 	}
 
 	@Override
-	public <X> ManagedDomainType<X> findManagedType(Class<X> cls) {
+	@Nullable public <X> ManagedDomainType<X> findManagedType(Class<X> cls) {
 		//noinspection unchecked
 		return (ManagedDomainType<X>) managedTypeByClass.get( cls );
 	}
 
 	@Override
-	public <X> EntityDomainType<X> findEntityType(Class<X> cls) {
+	public <X> ManagedDomainType<X> managedType(Class<X> cls) {
+		final ManagedDomainType<X> type = findManagedType( cls );
+		if ( type == null ) {
+			// per JPA
+			throw new IllegalArgumentException( "Not a managed type: " + cls );
+		}
+		return type;
+	}
+
+	@Override
+	@Nullable public <X> EntityDomainType<X> findEntityType(Class<X> cls) {
 		final ManagedType<?> type = managedTypeByClass.get( cls );
 		if ( !( type instanceof EntityDomainType<?> ) ) {
 			return null;
@@ -216,35 +253,31 @@ public <X> EntityDomainType<X> findEntityType(Class<X> cls) {
 	}
 
 	@Override
-	public <X> ManagedDomainType<X> managedType(Class<X> cls) {
-		final ManagedType<?> type = managedTypeByClass.get( cls );
-		if ( type == null ) {
-			// per JPA
-			throw new IllegalArgumentException( "Not a managed type: " + cls );
+	public <X> EntityDomainType<X> entity(Class<X> cls) {
+		final EntityDomainType<X> entityType = findEntityType( cls );
+		if ( entityType == null ) {
+			throw new IllegalArgumentException( "Not an entity: " + cls.getName() );
 		}
-
-		//noinspection unchecked
-		return (ManagedDomainType<X>) type;
+		return entityType;
 	}
 
 	@Override
-	public <X> EntityDomainType<X> entity(Class<X> cls) {
+	public @Nullable <X> EmbeddableDomainType<X> findEmbeddableType(Class<X> cls) {
 		final ManagedType<?> type = managedTypeByClass.get( cls );
-		if ( !( type instanceof EntityDomainType<?> ) ) {
-			throw new IllegalArgumentException( "Not an entity: " + cls.getName() );
+		if ( !( type instanceof EmbeddableDomainType<?> ) ) {
+			return null;
 		}
 		//noinspection unchecked
-		return (EntityDomainType<X>) type;
+		return (EmbeddableDomainType<X>) type;
 	}
 
 	@Override
 	public <X> EmbeddableDomainType<X> embeddable(Class<X> cls) {
-		final ManagedType<?> type = managedTypeByClass.get( cls );
-		if ( !( type instanceof EmbeddableDomainType<?> ) ) {
+		final EmbeddableDomainType<X> embeddableType = findEmbeddableType( cls );
+		if ( embeddableType == null ) {
 			throw new IllegalArgumentException( "Not an embeddable: " + cls.getName() );
 		}
-		//noinspection unchecked
-		return (EmbeddableDomainType<X>) type;
+		return embeddableType;
 	}
 
 	private Collection<ManagedDomainType<?>> getAllManagedTypes() {
@@ -428,7 +461,7 @@ private void applyNamedEntityGraphs(Collection<NamedEntityGraphDefinition> named
 					definition.getEntityName(),
 					definition.getJpaEntityName()
 			);
-			final EntityDomainType<Object> entityType = entity( definition.getEntityName() );
+			final EntityDomainType<Object> entityType = (EntityDomainType<Object>) findEntityType( definition.getEntityName() );
 			if ( entityType == null ) {
 				throw new IllegalArgumentException(
 						"Attempted to register named entity graph [" + definition.getRegisteredName()
@@ -442,7 +475,7 @@ private void applyNamedEntityGraphs(Collection<NamedEntityGraphDefinition> named
 			final NamedEntityGraph namedEntityGraph = definition.getAnnotation();
 
 			if ( namedEntityGraph.includeAllAttributes() ) {
-				for ( Attribute<? super Object, ?> attribute : entityType.getAttributes() ) {
+				for ( Attribute<Object, ?> attribute : entityType.getAttributes() ) {
 					entityGraph.addAttributeNodes( attribute );
 				}
 			}

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

@@ -19,6 +19,7 @@
 import java.util.function.Function;
 import java.util.stream.Stream;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hibernate.EntityNameResolver;
 import org.hibernate.HibernateException;
 import org.hibernate.MappingException;
@@ -490,16 +491,31 @@ public Set<EmbeddableType<?>> getEmbeddables() {
 		return jpaMetamodel.getEmbeddables();
 	}
 
+	@Override
+	public @Nullable <X> ManagedDomainType<X> findManagedType(@Nullable String typeName) {
+		return jpaMetamodel.findManagedType( typeName );
+	}
+
 	@Override
 	public <X> ManagedDomainType<X> managedType(String typeName) {
 		return jpaMetamodel.managedType( typeName );
 	}
 
+	@Override
+	public @Nullable EntityDomainType<?> findEntityType(@Nullable String entityName) {
+		return jpaMetamodel.findEntityType( entityName );
+	}
+
 	@Override
 	public <X> EntityDomainType<X> entity(String entityName) {
 		return jpaMetamodel.entity( entityName );
 	}
 
+	@Override
+	public @Nullable EmbeddableDomainType<?> findEmbeddableType(@Nullable String embeddableName) {
+		return jpaMetamodel.findEmbeddableType( embeddableName );
+	}
+
 	@Override
 	public <X> EmbeddableDomainType<X> embeddable(String embeddableName) {
 		return jpaMetamodel.embeddable( embeddableName );
@@ -525,6 +541,11 @@ public <X> EntityDomainType<X> findEntityType(Class<X> cls) {
 		return jpaMetamodel.findEntityType( cls );
 	}
 
+	@Override
+	public @Nullable <X> EmbeddableDomainType<X> findEmbeddableType(Class<X> cls) {
+		return jpaMetamodel.findEmbeddableType( cls );
+	}
+
 	@Override
 	public String qualifyImportableName(String queryName) {
 		return jpaMetamodel.qualifyImportableName( queryName );

hibernate-core/src/main/java/org/hibernate/query/hql/internal/FullyQualifiedReflectivePathTerminal.java

@@ -75,7 +75,7 @@ public FullyQualifiedReflectivePathTerminal copy(SqmCopyContext context) {
 			// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 			// See if it is an entity-type literal
 
-			final EntityDomainType<?> entityDescriptor = creationContext.getJpaMetamodel().entity( fullPath );
+			final EntityDomainType<?> entityDescriptor = creationContext.getJpaMetamodel().findEntityType( fullPath );
 			if ( entityDescriptor != null ) {
 				return new SqmLiteralEntityType<>( entityDescriptor, creationContext.getNodeBuilder() );
 			}

hibernate-core/src/main/java/org/hibernate/query/hql/internal/SemanticQueryBuilder.java

@@ -1298,12 +1298,13 @@ private SqmFromClause buildInferredFromClause(HqlParser.SelectClauseContext sele
 	private EntityDomainType<R> getResultEntity() {
 		final JpaMetamodelImplementor jpaMetamodel = creationContext.getJpaMetamodel();
 		if ( expectedResultEntity != null ) {
-			final EntityDomainType<R> entityDescriptor = jpaMetamodel.entity( expectedResultEntity );
+			final EntityDomainType<?> entityDescriptor = jpaMetamodel.findEntityType( expectedResultEntity );
 			if ( entityDescriptor == null ) {
 				throw new SemanticException( "Query has no 'from' clause, and the result type '"
 						+ expectedResultEntity + "' is not an entity type", query );
 			}
-			return entityDescriptor;
+			//noinspection unchecked
+			return (EntityDomainType<R>) entityDescriptor;
 		}
 		else if ( expectedResultType != null ) {
 			final EntityDomainType<R> entityDescriptor = jpaMetamodel.findEntityType( expectedResultType );

hibernate-core/src/main/java/org/hibernate/query/sqm/sql/BaseSqmToSqlAstConverter.java

@@ -3084,9 +3084,8 @@ private void registerEntityNameUsage(
 		if ( tableGroup.getModelPart() instanceof EmbeddableValuedModelPart ) {
 			persister = null;
 			final EmbeddableDomainType<?> embeddableDomainType = creationContext.getSessionFactory()
-					.getRuntimeMetamodels()
 					.getJpaMetamodel()
-					.embeddable( treatTargetTypeName );
+					.findEmbeddableType( treatTargetTypeName );
 			if ( embeddableDomainType == null || !embeddableDomainType.isPolymorphic() ) {
 				return;
 			}

hibernate-core/src/test/java/org/hibernate/orm/test/collection/bag/PersistentBagContainsTest.java

@@ -16,6 +16,7 @@
 import jakarta.persistence.ManyToOne;
 import jakarta.persistence.OneToMany;
 
+import org.hibernate.annotations.processing.Exclude;
 import org.hibernate.testing.TestForIssue;
 import org.hibernate.testing.orm.junit.DomainModel;
 import org.hibernate.testing.orm.junit.SessionFactory;
@@ -36,6 +37,7 @@
 		}
 )
 @SessionFactory
+@Exclude
 public class PersistentBagContainsTest {
 
 	/**

hibernate-core/src/test/java/org/hibernate/orm/test/event/entity/MergeListPreAndPostPersistTest.java

@@ -15,6 +15,7 @@
 import jakarta.persistence.OneToMany;
 
 import org.hibernate.Session;
+import org.hibernate.annotations.processing.Exclude;
 import org.hibernate.event.service.spi.EventListenerRegistry;
 import org.hibernate.event.spi.EventType;
 import org.hibernate.event.spi.PostInsertEvent;
@@ -33,6 +34,7 @@
  * @author Gail Badner
  */
 @TestForIssue( jiraKey = "HHH-9979")
+@Exclude
 public class MergeListPreAndPostPersistTest extends BaseCoreFunctionalTestCase {
 
 	protected Class[] getAnnotatedClasses() {

hibernate-core/src/test/java/org/hibernate/orm/test/hql/QuotedIdentifierTest.java

@@ -8,6 +8,7 @@
 
 import java.util.List;
 
+import org.hibernate.annotations.processing.Exclude;
 import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
 import org.junit.After;
 import org.junit.Before;
@@ -26,6 +27,7 @@
 /**
  * @author Christian Beikov
  */
+@Exclude
 public class QuotedIdentifierTest extends BaseCoreFunctionalTestCase {
 
 	private Person person;