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

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

@@ -60,6 +60,8 @@ 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<TypeInformation<?>>> resolvedGenerics;
+
 	protected TypeDiscoverer(ResolvableType type) {
 
 		Assert.notNull(type, "Type must not be null");
@@ -68,6 +70,10 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
 		this.componentType = Lazy.of(this::doGetComponentType);
 		this.valueType = Lazy.of(this::doGetMapValueType);
 		this.typeArguments = Lazy.of(this::doGetTypeArguments);
+		this.resolvedGenerics = Lazy.of(() -> Arrays.stream(resolvableType.getGenerics()) //
+				.map(TypeInformation::of) // use TypeInformation comparison to remove any attachments to variableResolver
+																	// holding the type source
+				.collect(Collectors.toList()));
 	}
 
 	static TypeDiscoverer<?> td(ResolvableType type) {
@@ -325,15 +331,7 @@ class TypeDiscoverer<S> implements TypeInformation<S> {
 			return false;
 		}
 
-		var collect1 = Arrays.stream(resolvableType.getGenerics()) //
-				.map(ResolvableType::toClass) //
-				.collect(Collectors.toList());
-
-		var collect2 = Arrays.stream(that.resolvableType.getGenerics()) //
-				.map(ResolvableType::toClass) //
-				.collect(Collectors.toList());
-
-		return ObjectUtils.nullSafeEquals(collect1, collect2);
+		return ObjectUtils.nullSafeEquals(resolvedGenerics.get(), that.resolvedGenerics.get());
 	}
 
 	@Override

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

@@ -29,6 +29,7 @@ import java.util.Set;
 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 @@ public class TypeDiscovererUnitTests {
 		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 @@ public class TypeDiscovererUnitTests {
 	class GeoResultsWrapper {
 		GeoResults<Leaf> results;
 	}
+
+	static class WithContainer {
+		MyContainer<List<String>> containerList;
+
+		MyContainer<List<Map<Long, Double>>> containerMap;
+	}
+
+	static class MyContainer<T> {
+		T data;
+	}
+
 }