Fix TypeInformation.OBJECT initialization.

We now create a decoupled instance of ClassTypeInformation to avoid initialization visibility cycle issues when TypeInformation.OBJECT (and other fields) are initialized with null because ClassTypeInformation.OBJECT hasn't been initialized yet.

Closes #3340

Author: mp911de

src/main/java/org/springframework/data/util/ClassTypeInformation.java

@@ -15,7 +15,6 @@
  */
 package org.springframework.data.util;
 
-import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -40,23 +39,12 @@ class ClassTypeInformation<S> extends TypeDiscoverer<S> {
 	private static final ConcurrentLruCache<Class<?>, ResolvableType> resolvableTypeCache = new ConcurrentLruCache<>(128,
 			ResolvableType::forClass);
 
-	public static final ClassTypeInformation<Collection> COLLECTION;
-	public static final ClassTypeInformation<List> LIST;
-	public static final ClassTypeInformation<Set> SET;
-	public static final ClassTypeInformation<Map> MAP;
-	public static final ClassTypeInformation<Object> OBJECT;
-
-	static {
+	private final Class<S> type;
 
-		OBJECT = from(Object.class);
-		COLLECTION = from(Collection.class);
-		LIST = from(List.class);
-		SET = from(Set.class);
-		MAP = from(Map.class);
+	ClassTypeInformation(Class<?> type) {
+		this(ResolvableType.forType(type));
 	}
 
-	private final Class<S> type;
-
 	ClassTypeInformation(ResolvableType type) {
 		super(type);
 		this.type = (Class<S>) type.resolve(Object.class);
@@ -68,13 +56,34 @@ class ClassTypeInformation<S> extends TypeDiscoverer<S> {
 	 * @return
 	 */
 	public static <S> ClassTypeInformation<S> from(Class<S> type) {
+
+		if (type == Object.class) {
+			return (ClassTypeInformation<S>) TypeInformation.OBJECT;
+		} else if (type == List.class) {
+			return (ClassTypeInformation<S>) TypeInformation.LIST;
+		} else if (type == Set.class) {
+			return (ClassTypeInformation<S>) TypeInformation.SET;
+		} else if (type == Map.class) {
+			return (ClassTypeInformation<S>) TypeInformation.MAP;
+		}
+
 		return from(resolvableTypeCache.get(type));
 	}
 
 	static <S> ClassTypeInformation<S> from(ResolvableType type) {
 
 		Assert.notNull(type, "Type must not be null");
 
+		if (type.getType() == Object.class) {
+			return (ClassTypeInformation<S>) TypeInformation.OBJECT;
+		} else if (type.getType() == List.class) {
+			return (ClassTypeInformation<S>) TypeInformation.LIST;
+		} else if (type.getType() == Set.class) {
+			return (ClassTypeInformation<S>) TypeInformation.SET;
+		} else if (type.getType() == Map.class) {
+			return (ClassTypeInformation<S>) TypeInformation.MAP;
+		}
+
 		return (ClassTypeInformation<S>) cache.get(type);
 	}
 

src/main/java/org/springframework/data/util/TypeInformation.java

@@ -42,11 +42,11 @@
  */
 public interface TypeInformation<S> {
 
-	TypeInformation<Collection> COLLECTION = ClassTypeInformation.COLLECTION;
-	TypeInformation<List> LIST = ClassTypeInformation.LIST;
-	TypeInformation<Set> SET = ClassTypeInformation.SET;
-	TypeInformation<Map> MAP = ClassTypeInformation.MAP;
-	TypeInformation<Object> OBJECT = ClassTypeInformation.OBJECT;
+	@SuppressWarnings("rawtypes") TypeInformation<Collection> COLLECTION = new ClassTypeInformation<>(Collection.class);
+	@SuppressWarnings("rawtypes") TypeInformation<List> LIST = new ClassTypeInformation<>(List.class);
+	@SuppressWarnings("rawtypes") TypeInformation<Set> SET = new ClassTypeInformation<>(Set.class);
+	@SuppressWarnings("rawtypes") TypeInformation<Map> MAP = new ClassTypeInformation<>(Map.class);
+	TypeInformation<Object> OBJECT = new ClassTypeInformation<>(Object.class);
 
 	/**
 	 * Creates a new {@link TypeInformation} from the given {@link ResolvableType}.
@@ -55,7 +55,7 @@ public interface TypeInformation<S> {
 	 * @return will never be {@literal null}.
 	 * @since 3.0
 	 */
-	public static TypeInformation<?> of(ResolvableType type) {
+	static TypeInformation<?> of(ResolvableType type) {
 
 		Assert.notNull(type, "Type must not be null");
 
@@ -70,7 +70,7 @@ public static TypeInformation<?> of(ResolvableType type) {
 	 * @return will never be {@literal null}.
 	 * @since 3.0
 	 */
-	public static <S> TypeInformation<S> of(Class<S> type) {
+	static <S> TypeInformation<S> of(Class<S> type) {
 
 		Assert.notNull(type, "Type must not be null");
 
@@ -84,7 +84,7 @@ public static <S> TypeInformation<S> of(Class<S> type) {
 	 * @return will never be {@literal null}.
 	 * @since 3.0
 	 */
-	public static TypeInformation<?> fromReturnTypeOf(Method method) {
+	static TypeInformation<?> fromReturnTypeOf(Method method) {
 
 		Assert.notNull(method, "Method must not be null");
 
@@ -99,7 +99,7 @@ public static TypeInformation<?> fromReturnTypeOf(Method method) {
 	 * @return will never be {@literal null}.
 	 * @since 3.0
 	 */
-	public static TypeInformation<?> fromReturnTypeOf(Method method, @Nullable Class<?> type) {
+	static TypeInformation<?> fromReturnTypeOf(Method method, @Nullable Class<?> type) {
 
 		ResolvableType intermediate = type == null ? ResolvableType.forMethodReturnType(method)
 				: ResolvableType.forMethodReturnType(method, type);
@@ -114,7 +114,7 @@ public static TypeInformation<?> fromReturnTypeOf(Method method, @Nullable Class
 	 * @return will never be {@literal null}.
 	 * @since 3.0
 	 */
-	public static TypeInformation<?> fromMethodParameter(MethodParameter parameter) {
+	static TypeInformation<?> fromMethodParameter(MethodParameter parameter) {
 		return TypeInformation.of(ResolvableType.forMethodParameter(parameter));
 	}
 

src/test/java/org/springframework/data/util/ClassTypeInformationUnitTests.java

@@ -45,6 +45,24 @@
  */
 public class ClassTypeInformationUnitTests {
 
+	@Test // GH-3340
+	void typeInformationConstantsShouldNotBeNull() {
+
+		assertThat(ClassTypeInformation.COLLECTION).isNotNull();
+		assertThat(TypeInformation.COLLECTION).isNotNull();
+		assertThat(TypeInformation.LIST).isNotNull();
+		assertThat(TypeInformation.SET).isNotNull();
+		assertThat(TypeInformation.MAP).isNotNull();
+		assertThat(TypeInformation.OBJECT).isNotNull();
+		assertThat(ClassTypeInformation.OBJECT).isNotNull();
+
+		assertThat(TypeInformation.COLLECTION).isEqualTo(ClassTypeInformation.COLLECTION);
+		assertThat(TypeInformation.LIST).isEqualTo(ClassTypeInformation.LIST);
+		assertThat(TypeInformation.SET).isEqualTo(ClassTypeInformation.SET);
+		assertThat(TypeInformation.MAP).isEqualTo(ClassTypeInformation.MAP);
+		assertThat(TypeInformation.OBJECT).isEqualTo(ClassTypeInformation.OBJECT);
+	}
+
 	@Test
 	public void discoversTypeForSimpleGenericField() {