Merge pull request #1138 from jqno/fix-kotlin-generics-issue

Handles generics (and bounded generics) in Kotlin lazy delegates

Author: jqno

equalsverifier-core/src/main/java/nl/jqno/equalsverifier/internal/reflection/kotlin/KotlinProbe.java

@@ -67,8 +67,7 @@ public static Optional<TypeTag> determineLazyType(Class<?> container, Field fiel
     }
 
     private static TypeTag createTypeTag(KType kType) {
-        KClass<?> kclass = (KClass<?>) kType.getClassifier();
-        Class<?> rawClass = JvmClassMappingKt.getJavaClass(kclass);
+        Class<?> rawClass = determineClass(kType);
 
         if (kType.getArguments().isEmpty()) {
             return new TypeTag(rawClass);
@@ -85,6 +84,28 @@ private static TypeTag createTypeTag(KType kType) {
         return new TypeTag(rawClass, genericTypeTags);
     }
 
+    private static Class<?> determineClass(KType kType) {
+        // The logic in this method follows that of TypeTag's inner methods
+        var classifier = kType.getClassifier();
+
+        if (classifier instanceof KClass<?>) {
+            var kclass = (KClass<?>) classifier;
+            return JvmClassMappingKt.getJavaClass(kclass);
+        }
+
+        if (classifier instanceof KTypeParameter) {
+            var kTypeParameter = (KTypeParameter) classifier;
+            for (KType b : kTypeParameter.getUpperBounds()) {
+                var upper = determineClass(b);
+                if (!Object.class.equals(upper)) {
+                    return upper;
+                }
+            }
+        }
+
+        return Object.class;
+    }
+
     private static void assertHasKotlinReflect(Field f) {
         if (!KotlinScreen.canProbe()) {
             var msg = "Cannot read Kotlin field " + f.getName() + ". " + KotlinScreen.ERROR_MESSAGE;

equalsverifier-test-kotlin/src/test/kotlin/nl/jqno/equalsverifier/kotlin/KotlinDelegationTest.kt

@@ -96,13 +96,23 @@ class KotlinDelegationTest {
   }
 
   @Test
-  fun `succeed when class uses lazy generic delegate`() {
-    EqualsVerifier.forClass(LazyGenericDelegation::class.java).verify()
+  fun `succeed when class uses lazy delegate with generic value`() {
+    EqualsVerifier.forClass(LazyDelegationWithGenericValue::class.java).verify()
   }
 
   @Test
-  fun `succeed when class uses nested lazy generic delegate`() {
-    EqualsVerifier.forClass(NestedLazyGenericDelegation::class.java).verify()
+  fun `succeed when class uses lazy delegate with nested lazy value`() {
+    EqualsVerifier.forClass(LazyDelegationWithNestedGenericValue::class.java).verify()
+  }
+
+  @Test
+  fun `succeed when class is generic and uses that generic in its value`() {
+    EqualsVerifier.forClass(LazyDelegationWithGenericClass::class.java).verify()
+  }
+
+  @Test
+  fun `succeed when class is generic with bound and uses that generic in its value`() {
+    EqualsVerifier.forClass(LazyDelegationWithBoundedGenericClass::class.java).verify()
   }
 
   @Test

equalsverifier-test-kotlin/src/test/kotlin/nl/jqno/equalsverifier/kotlin/delegates/KotlinDelegates.kt

@@ -96,20 +96,38 @@ class LazyDelegation(fooValue: Int) {
   override fun hashCode(): Int = foo
 }
 
-class LazyGenericDelegation(fooValue: List<Int>) {
+class LazyDelegationWithGenericValue(fooValue: List<Int>) {
   val foo: List<Int> by lazy { fooValue }
 
   override fun equals(other: Any?): Boolean =
-    (other is LazyGenericDelegation) && foo == other.foo
+    (other is LazyDelegationWithGenericValue) && foo == other.foo
 
   override fun hashCode(): Int = foo.hashCode()
 }
 
-class NestedLazyGenericDelegation(fooValue: List<List<List<Int>>>) {
+class LazyDelegationWithNestedGenericValue(fooValue: List<List<List<Int>>>) {
   val foo: List<List<List<Int>>> by lazy { fooValue }
 
   override fun equals(other: Any?): Boolean =
-    (other is NestedLazyGenericDelegation) && foo == other.foo
+    (other is LazyDelegationWithNestedGenericValue) && foo == other.foo
+
+  override fun hashCode(): Int = foo.hashCode()
+}
+
+class LazyDelegationWithGenericClass<T>(fooValue: T) {
+  val foo: T by lazy { fooValue }
+
+  override fun equals(other: Any?): Boolean =
+    (other is LazyDelegationWithGenericClass<*>) && foo == other.foo
+
+  override fun hashCode(): Int = foo.hashCode()
+}
+
+class LazyDelegationWithBoundedGenericClass<T : Comparable<T>>(fooValue: T) {
+  val foo: T by lazy { fooValue }
+
+  override fun equals(other: Any?): Boolean =
+    (other is LazyDelegationWithBoundedGenericClass<*>) && foo == other.foo
 
   override fun hashCode(): Int = foo.hashCode()
 }