remove one last dodgy typing workaround after Date stuff

JavaTypeRegistry and TypeConfiguration are now much cleaner

+ related minor cleanups in these classes

Author: gavinking

hibernate-core/src/main/java/org/hibernate/type/descriptor/java/spi/JavaTypeRegistry.java

@@ -122,19 +122,14 @@ public <J> JavaType<J> resolveDescriptor(Class<? extends J> javaType, Supplier<J
 	}
 
 	private static <J> JavaType<J> checkCached(Class<? extends J> javaClass, JavaType<?> cached) {
-		final var cachedClass = cached.getJavaTypeClass();
-		if ( !isCompatible( javaClass, cachedClass ) ) {
+		if ( cached.getJavaTypeClass() != canonicalize( javaClass ) ) {
 			throw new IllegalStateException( "Type registration was corrupted for: " + javaClass.getName() );
 		}
 		@SuppressWarnings("unchecked") // safe, we just checked
 		final var resolvedType = (JavaType<J>) cached;
 		return resolvedType;
 	}
 
-	private static boolean isCompatible(Class<?> givenClass, Class<?> cachedClass) {
-		return cachedClass == canonicalize( givenClass );
-	}
-
 	@Deprecated(since = "7.2", forRemoval = true) // Can be private
 	private JavaType<?> resolveDescriptor(String javaTypeName, Supplier<? extends JavaType<?>> creator) {
 		final var cached = descriptorsByTypeName.get( javaTypeName );
@@ -180,10 +175,15 @@ public <T> JavaType<T[]> resolveArrayDescriptor(Class<T> elementJavaType) {
 //				() -> createArrayTypeDescriptor( elementJavaType, JavaTypeRegistry::createMutabilityPlan) );
 //	}
 
+	@Internal @FunctionalInterface
+	public interface MutabilityPlanCreator {
+		MutabilityPlan<?> create(Type elementJavaType, TypeConfiguration typeConfiguration);
+	}
+
 	@Internal // Can be demoted to private
 	public <J> JavaType<J> resolveDescriptor(
 			Class<J> javaType,
-			BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
+			MutabilityPlanCreator mutabilityPlanCreator) {
 		//noinspection unchecked
 		return resolveDescriptor(
 				javaType,
@@ -196,7 +196,7 @@ public <J> JavaType<J> resolveDescriptor(
 	@Internal // Can be demoted to private
 	public JavaType<?> resolveDescriptor(
 			Type javaType,
-			BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
+			MutabilityPlanCreator mutabilityPlanCreator) {
 		return resolveDescriptor(
 				javaType.getTypeName(),
 				() -> {
@@ -214,20 +214,24 @@ else if ( javaType instanceof Class<?> javaClass && javaClass.isArray() ) {
 		);
 	}
 
-	private <J> JavaType<J[]> createArrayTypeDescriptor(Class<J> elementJavaType, BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
+	private <J> JavaType<J[]> createArrayTypeDescriptor(
+			Class<J> elementJavaType,
+			MutabilityPlanCreator mutabilityPlanCreator) {
 		var elementTypeDescriptor = findDescriptor( elementJavaType );
 		if ( elementTypeDescriptor == null ) {
 			elementTypeDescriptor = createTypeDescriptor( elementJavaType, mutabilityPlanCreator );
 		}
 		return new ArrayJavaType<>( elementTypeDescriptor );
 	}
 
-	private <J> JavaType<J> createTypeDescriptor(Type javaType, BiFunction<Type, TypeConfiguration, MutabilityPlan<?>> mutabilityPlanCreator) {
+	private <J> JavaType<J> createTypeDescriptor(
+			Type javaType,
+			MutabilityPlanCreator mutabilityPlanCreator) {
 		//noinspection unchecked
 		return RegistryHelper.INSTANCE.createTypeDescriptor(
 				javaType,
 				() -> (MutabilityPlan<J>)
-						mutabilityPlanCreator.apply( javaType, typeConfiguration ),
+						mutabilityPlanCreator.create( javaType, typeConfiguration ),
 				typeConfiguration
 		);
 	}
@@ -289,11 +293,12 @@ private <J> JavaType<?> resolveManagedTypeDescriptor(
 
 					final var determinedPlan =
 							RegistryHelper.INSTANCE.determineMutabilityPlan( javaTypeClass, typeConfiguration );
-					final MutabilityPlan<J> mutabilityPlan =
+					return instantiate.apply(
+							javaTypeClass,
 							determinedPlan != null
 									? determinedPlan
-									: MutableMutabilityPlan.instance();
-					return instantiate.apply( javaTypeClass, mutabilityPlan );
+									: MutableMutabilityPlan.instance()
+					);
 				}
 		);
 	}

hibernate-core/src/main/java/org/hibernate/type/spi/TypeConfiguration.java

@@ -266,7 +266,7 @@ public JpaCompliance getJpaCompliance() {
 	 */
 	@Internal
 	public Class<?> entityClassForEntityName(String entityName) {
-		return scope.entityClassForEntityName(entityName);
+		return scope.entityClassForEntityName( entityName );
 	}
 
 	@Override
@@ -632,7 +632,6 @@ private Object readResolve() throws InvalidObjectException {
 					}
 				}
 			}
-
 			return this;
 		}
 
@@ -649,18 +648,20 @@ private Class<?> entityClassForEntityName(String entityName) {
 	private final ConcurrentMap<ArrayCacheKey, ArrayTupleType> arrayTuples = new ConcurrentHashMap<>();
 
 	public SqmBindableType<?> resolveTupleType(List<? extends SqmTypedNode<?>> typedNodes) {
-		final var components = new SqmBindableType<?>[typedNodes.size()];
-		for ( int i = 0; i < typedNodes.size(); i++ ) {
+		final int size = typedNodes.size();
+		final var components = new SqmBindableType<?>[size];
+		for ( int i = 0; i < size; i++ ) {
 			final var tupleElement = typedNodes.get(i);
 			final var sqmExpressible = tupleElement.getNodeType();
 			// keep null value for Named Parameters
 			if ( tupleElement instanceof SqmParameter<?> && sqmExpressible == null ) {
 				components[i] = QueryParameterJavaObjectType.INSTANCE;
 			}
 			else {
-				components[i] = sqmExpressible != null
-						? sqmExpressible
-						: castNonNull( getBasicTypeForJavaType( Object.class ) );
+				components[i] =
+						sqmExpressible == null
+								? castNonNull( getBasicTypeForJavaType( Object.class ) )
+								: sqmExpressible;
 			}
 		}
 		return arrayTuples.computeIfAbsent( new ArrayCacheKey( components ),
@@ -755,25 +756,22 @@ else if ( firstType==null && getSqlTemporalType( secondType ) != null ) {
 
 	private static boolean matchesJavaType(SqmExpressible<?> type, Class<?> javaType) {
 		assert javaType != null;
-		return type != null && javaType.isAssignableFrom( type.getRelationalJavaType().getJavaTypeClass() );
+		return type != null
+			&& javaType.isAssignableFrom( type.getRelationalJavaType().getJavaTypeClass() );
 	}
 
 
 	private final ConcurrentHashMap<Type, BasicType<?>> basicTypeByJavaType = new ConcurrentHashMap<>();
 
 	private static <J> BasicType<J> checkExisting(Class<J> javaClass, BasicType<?> existing) {
-		if ( !isCompatible( javaClass, existing.getJavaType() ) ) {
+		if ( existing.getJavaType() != canonicalize( javaClass ) ) {
 			throw new IllegalStateException( "Type registration was corrupted for: " + javaClass.getName() );
 		}
 		@SuppressWarnings("unchecked") // safe, we just checked
 		final var basicType = (BasicType<J>) existing;
 		return basicType;
 	}
 
-	private static <J> boolean isCompatible(Class<J> javaClass, Class<?> existing) {
-		return existing.isAssignableFrom( canonicalize( javaClass ) );
-	}
-
 	@Deprecated(since = "7.2", forRemoval = true) // no longer used
 	public <J> @Nullable BasicType<J> getBasicTypeForGenericJavaType(Class<? super J> javaType, Type... typeArguments) {
 		//noinspection unchecked