enhance type-checked result effect during the call to createQuery()

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

@@ -32,6 +32,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
 import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
@@ -214,6 +215,7 @@
 import org.hibernate.sql.ast.SqlAstNodeRenderingMode;
 import org.hibernate.sql.ast.tree.cte.CteMaterialization;
 import org.hibernate.sql.ast.tree.cte.CteSearchClauseKind;
+import org.hibernate.sql.results.graph.instantiation.internal.InstantiationHelper;
 import org.hibernate.type.BasicPluralType;
 import org.hibernate.type.BasicType;
 import org.hibernate.type.descriptor.java.JavaType;
@@ -1498,12 +1500,24 @@ public SqmDynamicInstantiation<?> visitInstantiation(HqlParser.InstantiationCont
 		}
 
 		if ( !dynamicInstantiation.checkInstantiation( creationContext.getTypeConfiguration() ) ) {
-			final String typeName = dynamicInstantiation.getJavaType().getSimpleName();
+			final Class<?> type = dynamicInstantiation.getJavaType();
 			if ( dynamicInstantiation.isFullyAliased() ) {
-				throw new SemanticException( "Missing constructor or attributes for injection into type '" + typeName + "'", query );
+				throw new SemanticException("Missing constructor or attributes for injection into type [" + type + "]." +
+						"Expected arguments are: " + dynamicInstantiation.argumentTypes(), query);
 			}
 			else {
-				throw new SemanticException( "Missing constructor for type '" + typeName  + "'", query );
+				List<InstantiationHelper.MismatchConstructorFieldPositionInfo> list = dynamicInstantiation.findMismatchConstructorFieldPositions(creationContext.getTypeConfiguration());
+
+				String conjecture = "";
+				if (list != null && list.isEmpty() == false) {
+					conjecture = " The presumed mismatch field position is: " +
+							list.stream()
+									.map(InstantiationHelper.MismatchConstructorFieldPositionInfo::toString)
+									.collect(Collectors.joining(","));
+				}
+
+				throw new SemanticException("Unable to locate appropriate constructor on class [" + type + "]. " +
+						"Expected arguments are: " + dynamicInstantiation.argumentTypes() + conjecture, query);
 			}
 		}
 

hibernate-core/src/main/java/org/hibernate/query/sqm/tree/select/SqmDynamicInstantiation.java

@@ -29,8 +29,7 @@
 import static org.hibernate.query.sqm.DynamicInstantiationNature.CLASS;
 import static org.hibernate.query.sqm.DynamicInstantiationNature.LIST;
 import static org.hibernate.query.sqm.DynamicInstantiationNature.MAP;
-import static org.hibernate.sql.results.graph.instantiation.internal.InstantiationHelper.isConstructorCompatible;
-import static org.hibernate.sql.results.graph.instantiation.internal.InstantiationHelper.isInjectionCompatible;
+import static org.hibernate.sql.results.graph.instantiation.internal.InstantiationHelper.*;
 
 /**
  * Represents a dynamic instantiation ({@code select new XYZ(...) ...}) as part of the SQM.
@@ -141,7 +140,23 @@ public boolean checkInstantiation(TypeConfiguration typeConfiguration) {
 		}
 	}
 
-	private List<Class<?>> argumentTypes() {
+	public List<MismatchConstructorFieldPositionInfo> findMismatchConstructorFieldPositions(TypeConfiguration typeConfiguration) {
+		if (getInstantiationTarget().getNature() == CLASS) {
+			if (getJavaType().isArray()) {
+				// hack to accommodate the needs of jpamodelgen
+				// where Class objects not available during build
+				return null;
+			}
+			final List<Class<?>> argTypes = argumentTypes();
+
+			return findMismatchConstructorFieldPosition(getJavaType(), argTypes, typeConfiguration);
+		} else {
+			// TODO: is there anything we need to check for list/map instantiation?
+			return null;
+		}
+	}
+
+	public List<Class<?>> argumentTypes() {
 		return getArguments().stream()
 				.map(arg -> arg.getNodeJavaType() == null ? Void.class : arg.getNodeJavaType().getJavaTypeClass())
 				.collect(toList());

hibernate-core/src/main/java/org/hibernate/sql/results/graph/instantiation/internal/InstantiationHelper.java

@@ -15,6 +15,7 @@
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Field;
 import java.lang.reflect.Type;
+import java.util.ArrayList;
 import java.util.List;
 
 import static org.hibernate.query.sqm.tree.expression.Compatibility.areAssignmentCompatible;
@@ -97,6 +98,59 @@ public static boolean isConstructorCompatible(
 		}
 	}
 
+	public static List<MismatchConstructorFieldPositionInfo> findMismatchConstructorFieldPosition(Class<?> javaClass, List<Class<?>> argTypes, TypeConfiguration typeConfiguration) {
+		List<MismatchConstructorFieldPositionInfo> list = new ArrayList<>();
+
+		for (Constructor<?> constructor : javaClass.getDeclaredConstructors()) {
+			MismatchConstructorFieldPositionInfo positionInfo = findMismatchConstructorFieldPosition(constructor, argTypes, typeConfiguration);
+			if (positionInfo != null) {
+				list.add(positionInfo);
+			}
+		}
+		return list;
+	}
+
+	public static MismatchConstructorFieldPositionInfo findMismatchConstructorFieldPosition(
+			Constructor<?> constructor,
+			List<Class<?>> argumentTypes,
+			TypeConfiguration typeConfiguration) {
+		final Type[] genericParameterTypes = constructor.getGenericParameterTypes();
+		if (genericParameterTypes.length == argumentTypes.size()) {
+			for (int i = 0; i < argumentTypes.size(); i++) {
+				final Type parameterType = genericParameterTypes[i];
+				final Class<?> argumentType = argumentTypes.get(i);
+				final Class<?> type = parameterType instanceof Class<?>
+						? (Class<?>) parameterType
+						: typeConfiguration.getJavaTypeRegistry().resolveDescriptor(parameterType).getJavaTypeClass();
+
+				if (!areAssignmentCompatible(type, argumentType)) {
+					return new MismatchConstructorFieldPositionInfo(i, argumentType.getTypeName(),
+							parameterType.getTypeName());
+				}
+			}
+			return null;
+		} else {
+			return null;
+		}
+	}
+
+	public static class MismatchConstructorFieldPositionInfo {
+		private final int position;
+		private final String expectTypeName;
+		private final String actualTypeName;
+
+		public MismatchConstructorFieldPositionInfo(int index, String expectTypeName, String actualTypeName) {
+			this.position = index + 1;
+			this.expectTypeName = expectTypeName;
+			this.actualTypeName = actualTypeName;
+		}
+
+		@Override
+		public String toString() {
+			return String.format("[%s](%s -> %s)", position, expectTypeName, actualTypeName);
+		}
+	}
+
 	static Field findField(Class<?> declaringClass, String name, Class<?> javaType) {
 		try {
 			final Field field = declaringClass.getDeclaredField( name );