Consider nested generics in TypeDiscoverer equality comparison.

We now compare nested generics wrapped into TypeInformation to consider type equality for deeply parametrized types.

Previously, we resolved type parameters to Class so Foo<List<String>> was considered equal to Foo<List<Map>> as the type parameter of the first nesting level was erased.

Closes #3051

Author: mp911de

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

@@ -60,7 +60,7 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
 	private final Map<Constructor<?>, List<TypeInformation<?>>> constructorParameters = new ConcurrentHashMap<>();
 	private final Lazy<List<TypeInformation<?>>> typeArguments;
 
-	private final Lazy<List<Class>> resolvedGenerics;
+	private final Lazy<List<TypeInformation<?>>> resolvedGenerics;
 
 	protected TypeDiscoverer(ResolvableType type) {
 
@@ -71,7 +71,9 @@ protected TypeDiscoverer(ResolvableType type) {
 		this.valueType = Lazy.of(this::doGetMapValueType);
 		this.typeArguments = Lazy.of(this::doGetTypeArguments);
 		this.resolvedGenerics = Lazy.of(() -> Arrays.stream(resolvableType.getGenerics()) //
-				.map(ResolvableType::toClass).collect(Collectors.toList()));
+				.map(TypeInformation::of) // use TypeInformation comparison to remove any attachments to variableResolver
+																	// holding the type source
+				.collect(Collectors.toList()));
 	}
 
 	static TypeDiscoverer<?> ofCached(ResolvableType type) {

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

@@ -29,6 +29,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.mockito.junit.jupiter.MockitoExtension;
+
 import org.springframework.beans.factory.annotation.Autowire;
 import org.springframework.core.ResolvableType;
 import org.springframework.data.geo.GeoResults;
@@ -348,6 +349,15 @@ void differentEqualsAndHashCodeForTypeDiscovererAndClassTypeInformation() {
 		assertThat(discoverer.hashCode()).isNotEqualTo(classTypeInformation.hashCode());
 	}
 
+	@Test // GH-3051
+	void considersNestedGenericsInEquality() throws ReflectiveOperationException {
+
+		ResolvableType containerList = ResolvableType.forField(WithContainer.class.getDeclaredField("containerList"));
+		ResolvableType containerMap = ResolvableType.forField(WithContainer.class.getDeclaredField("containerMap"));
+
+		assertThat(TypeInformation.of(containerList)).isNotEqualTo(TypeInformation.of(containerMap));
+	}
+
 	class Person {
 
 		Addresses addresses;
@@ -441,4 +451,15 @@ class EnumMapWrapper {
 	class GeoResultsWrapper {
 		GeoResults<Leaf> results;
 	}
+
+	static class WithContainer {
+		MyContainer<List<String>> containerList;
+
+		MyContainer<List<Map<Long, Double>>> containerMap;
+	}
+
+	static class MyContainer<T> {
+		T data;
+	}
+
 }