Reimplement ParameterizedType

src/main/kotlin/graphql/kickstart/tools/GenericType.kt

@@ -141,14 +141,14 @@ internal open class GenericType(protected val mostSpecificType: JavaType, protec
             return when (type) {
                 is ParameterizedType -> {
                     val actualTypeArguments = type.actualTypeArguments.map { replaceTypeVariable(it) }.toTypedArray()
-                    ParameterizedTypeImpl.make(type.rawType as Class<*>?, actualTypeArguments, type.ownerType)
+                    ParameterizedTypeImpl(type.rawType as Class<*>, actualTypeArguments, type.ownerType)
                 }
                 is ResolvedType -> {
                     if (type.typeParameters.isEmpty()) {
                         type.erasedType
                     } else {
                         val actualTypeArguments = type.typeParameters.map { replaceTypeVariable(it) }.toTypedArray()
-                        ParameterizedTypeImpl.make(type.erasedType, actualTypeArguments, null)
+                        ParameterizedTypeImpl(type.erasedType, actualTypeArguments, null)
                     }
                 }
                 is TypeVariable<*> -> {

src/main/kotlin/graphql/kickstart/tools/SchemaParserOptions.kt

@@ -250,12 +250,9 @@ data class SchemaParserOptions internal constructor(
                 index: Int,
                 transformer: (T) -> Any?
             ): GenericWrapper where T : Any {
-                return withTransformer(
-                    type,
-                    index,
-                    transformer,
-                    { innerType -> ParameterizedTypeImpl.make(List::class.java, arrayOf(innerType), null) }
-                )
+                return withTransformer(type, index, transformer) { innerType ->
+                    ParameterizedTypeImpl(List::class.java, arrayOf(innerType), null)
+                }
             }
 
             fun <T> listCollectionWithTransformer(

src/main/kotlin/graphql/kickstart/tools/util/ParameterizedTypeImpl.kt

@@ -0,0 +1,49 @@
+package graphql.kickstart.tools.util
+
+import java.lang.reflect.ParameterizedType
+import java.lang.reflect.Type
+
+class ParameterizedTypeImpl(
+    private val rawType: Class<*>,
+    private val actualTypeArguments: Array<Type>,
+    private val ownerType: Type?
+) : ParameterizedType {
+    override fun getActualTypeArguments(): Array<Type> = actualTypeArguments.clone()
+
+    override fun getRawType(): Type = rawType
+
+    override fun getOwnerType(): Type? = ownerType
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as ParameterizedTypeImpl
+
+        if (rawType != other.rawType) return false
+        if (ownerType != other.ownerType) return false
+        if (!actualTypeArguments.contentEquals(other.actualTypeArguments)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = rawType.hashCode()
+        result = 31 * result + (ownerType?.hashCode() ?: 0)
+        result = 31 * result + actualTypeArguments.contentHashCode()
+        return result
+    }
+
+    override fun toString(): String = buildString {
+        if (ownerType != null) {
+            append(ownerType.typeName)
+            append("$")
+            append(rawType.simpleName)
+        } else {
+            append(rawType.name)
+        }
+        if (actualTypeArguments.isNotEmpty()) {
+            actualTypeArguments.joinTo(this, ",", "<", ">", transform = Type::getTypeName)
+        }
+    }
+}