Use isSubtypeOf for generic wrapper type checks

- Add ParameterizedType.isSubtypeOf and use it in TypeClassMatcher in place of GenericType.isTypeAssignableFromRawClass
- Remove the isListType helpers in favor of the same check
- Rename mostSpecificType to containingType and document unwrapGenericType

Author: oryan-block

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

@@ -12,58 +12,61 @@ import java.lang.reflect.WildcardType
 /**
  * @author Andrew Potter
  */
-internal class GenericType(private val mostSpecificType: JavaType, private val options: SchemaParserOptions) {
+internal class GenericType(private val containingType: JavaType, private val options: SchemaParserOptions) {
 
-    fun isTypeAssignableFromRawClass(type: ParameterizedType, clazz: Class<*>) =
-        clazz.isAssignableFrom(getRawClass(type.rawType))
+    fun getRawClass() = getRawClass(containingType)
 
-    fun getRawClass() = getRawClass(mostSpecificType)
+    fun getRawClass(type: JavaType): Class<*> = TypeUtils.getRawType(type, containingType)
 
-    fun getRawClass(type: JavaType): Class<*> = TypeUtils.getRawType(type, mostSpecificType)
-
-    fun isAssignableFrom(type: JavaType) = TypeUtils.isAssignable(type, mostSpecificType)
+    fun isAssignableFrom(type: JavaType) = TypeUtils.isAssignable(type, containingType)
 
     /**
-     * Unwrap certain Java types to find the "real" class.
+     * Turns a type as declared in the source (a method's return or parameter type, or a field's type) into the type
+     * the GraphQL type is matched against:
+     * - type variables are resolved relative to the containing type,
+     *   e.g. `T` of `AbstractItem<T>.getId()` becomes `Long` for `class Item : AbstractItem<Long>()`
+     * - generic wrappers are replaced by their wrapped type, e.g. `CompletableFuture<Foo>` becomes `Foo`
+     * - wildcards are replaced by their upper bound, e.g. `? extends Foo` becomes `Foo`
+     * - primitives are replaced by their boxed class, e.g. `int` becomes `Integer`
      */
     fun unwrapGenericType(javaType: JavaType): JavaType {
-        return when (val type = replaceTypeVariable(javaType)) {
+        return when (val type = resolveTypeVariables(javaType)) {
             is ParameterizedType -> {
                 val rawType = type.rawType
-                val genericType = options.genericWrappers.find { it.type == rawType }
+                val wrapper = options.genericWrappers.find { it.type == rawType }
                     ?: return type
 
                 val typeArguments = type.actualTypeArguments
-                if (typeArguments.size <= genericType.index) {
-                    throw IndexOutOfBoundsException("Generic type '${TypeUtils.toString(type)}' does not have a type argument at index ${genericType.index}!")
+                if (typeArguments.size <= wrapper.index) {
+                    throw IndexOutOfBoundsException("Generic type '${TypeUtils.toString(type)}' does not have a type argument at index ${wrapper.index}!")
                 }
 
-                val unwrapsTo = genericType.schemaWrapper.invoke(typeArguments[genericType.index])
+                val unwrapsTo = wrapper.schemaWrapper.invoke(typeArguments[wrapper.index])
                 unwrapGenericType(unwrapsTo)
             }
-            is TypeVariable<*> -> error("Could not resolve type variable '${TypeUtils.toLongString(type)}' relative to ${TypeUtils.toString(mostSpecificType)}")
+            is TypeVariable<*> -> error("Could not resolve type variable '${TypeUtils.toLongString(type)}' relative to ${TypeUtils.toString(containingType)}")
             is WildcardType -> type.upperBounds.firstOrNull()
                 ?: error("Unable to unwrap type, wildcard has no upper bound: $type")
             is Class<*> -> if (type.isPrimitive) Primitives.wrap(type) else type
             else -> error("Unable to unwrap type: $type")
         }
     }
 
-    private fun replaceTypeVariable(type: JavaType, resolving: Set<TypeVariable<*>> = emptySet()): JavaType {
+    private fun resolveTypeVariables(type: JavaType, resolving: Set<TypeVariable<*>> = emptySet()): JavaType {
         return when (type) {
             is ParameterizedType -> {
-                val actualTypeArguments = type.actualTypeArguments.map { replaceTypeVariable(it, resolving) }.toTypedArray()
-                ParameterizedTypeImpl(type.rawType as Class<*>, actualTypeArguments, type.ownerType?.let { replaceTypeVariable(it, resolving) })
+                val actualTypeArguments = type.actualTypeArguments.map { resolveTypeVariables(it, resolving) }.toTypedArray()
+                ParameterizedTypeImpl(type.rawType as Class<*>, actualTypeArguments, type.ownerType?.let { resolveTypeVariables(it, resolving) })
             }
             is WildcardType -> TypeUtils.wildcardType()
-                .withUpperBounds(*type.upperBounds.map { replaceTypeVariable(it, resolving) }.toTypedArray())
-                .withLowerBounds(*type.lowerBounds.map { replaceTypeVariable(it, resolving) }.toTypedArray())
+                .withUpperBounds(*type.upperBounds.map { resolveTypeVariables(it, resolving) }.toTypedArray())
+                .withLowerBounds(*type.lowerBounds.map { resolveTypeVariables(it, resolving) }.toTypedArray())
                 .build()
             is ResolvedType -> {
                 if (type.typeParameters.isEmpty()) {
                     type.erasedType
                 } else {
-                    val actualTypeArguments = type.typeParameters.map { replaceTypeVariable(it) }.toTypedArray()
+                    val actualTypeArguments = type.typeParameters.map { resolveTypeVariables(it) }.toTypedArray()
                     ParameterizedTypeImpl(type.erasedType, actualTypeArguments, null)
                 }
             }
@@ -73,19 +76,17 @@ internal class GenericType(private val mostSpecificType: JavaType, private val o
                     // only a variable leaked from a raw type can be bound to a type containing itself (e.g. T -> List<T>),
                     // erase it like the raw type does instead of expanding it forever
                     type in resolving -> TypeUtils.getRawType(type.bounds.first(), null) ?: Any::class.java
-                    // the most specific type binds the variables of all its supertypes
-                    genericDeclaration is Class<*> -> generateSequence(mostSpecificType) { (it as? ParameterizedType)?.ownerType }
+                    // the containing type binds the variables of all its supertypes
+                    genericDeclaration is Class<*> -> generateSequence(containingType) { (it as? ParameterizedType)?.ownerType }
                         // an inner class can also use the variables of its outer class, those are bound by its owner type (e.g. Connection<Owner>.Entry)
                         .firstNotNullOfOrNull { TypeUtils.getTypeArguments(it, genericDeclaration)?.get(type) }
                         // keep the full type argument (e.g. List<Foo>) rather than its raw class so nested generics aren't lost
-                        ?.let { replaceTypeVariable(it, resolving + type) }
+                        ?.let { resolveTypeVariables(it, resolving + type) }
                         ?: type
                     else -> type
                 }
             }
-            else -> {
-                type
-            }
+            else -> type
         }
     }
 }

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

@@ -3,6 +3,7 @@ package graphql.kickstart.tools
 import graphql.execution.DataFetcherResult
 import graphql.kickstart.tools.util.GraphQLLangType
 import graphql.kickstart.tools.util.JavaType
+import graphql.kickstart.tools.util.isSubtypeOf
 import graphql.language.*
 import graphql.schema.idl.ScalarInfo
 import java.lang.reflect.ParameterizedType
@@ -13,10 +14,6 @@ import java.util.*
  */
 internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeDefinition<*>>) {
 
-    companion object {
-        fun isListType(realType: ParameterizedType, generic: GenericType) = generic.isTypeAssignableFromRawClass(realType, Iterable::class.java)
-    }
-
     private fun error(potentialMatch: PotentialMatch, msg: String) = SchemaClassScannerError("Unable to match type definition (${potentialMatch.graphQLType}) for reference ${potentialMatch.reference} with java type (${potentialMatch.javaType}): $msg")
 
     fun match(potentialMatch: PotentialMatch): Match {
@@ -27,22 +24,22 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
 
         var realType = potentialMatch.generic.unwrapGenericType(javaType)
 
-        if (realType is ParameterizedType && potentialMatch.generic.isTypeAssignableFromRawClass(realType, DataFetcherResult::class.java)) {
+        if (realType is ParameterizedType && realType.isSubtypeOf(DataFetcherResult::class.java)) {
             if (potentialMatch.location != Location.RETURN_TYPE) {
                 throw error(potentialMatch, "${DataFetcherResult::class.java.name} can only be used as a return type")
             }
 
             realType = potentialMatch.generic.unwrapGenericType(realType.actualTypeArguments.first())
 
-            if (realType is ParameterizedType && potentialMatch.generic.isTypeAssignableFromRawClass(realType, DataFetcherResult::class.java)) {
+            if (realType is ParameterizedType && realType.isSubtypeOf(DataFetcherResult::class.java)) {
                 throw error(potentialMatch, "${DataFetcherResult::class.java.name} cannot be nested within itself")
             }
         }
 
         var optional = false
 
         // Handle jdk8 Optionals
-        if (realType is ParameterizedType && potentialMatch.generic.isTypeAssignableFromRawClass(realType, Optional::class.java)) {
+        if (realType is ParameterizedType && realType.isSubtypeOf(Optional::class.java)) {
             optional = true
 
             if (potentialMatch.location == Location.RETURN_TYPE && !root) {
@@ -51,7 +48,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
 
             realType = potentialMatch.generic.unwrapGenericType(realType.actualTypeArguments.first())
 
-            if (realType is ParameterizedType && potentialMatch.generic.isTypeAssignableFromRawClass(realType, Optional::class.java)) {
+            if (realType is ParameterizedType && realType.isSubtypeOf(Optional::class.java)) {
                 throw error(potentialMatch, "${Optional::class.java.name} cannot be nested within itself")
             }
         }
@@ -66,7 +63,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
             }
 
             is ListType -> when {
-                realType is ParameterizedType && isListType(realType, potentialMatch) ->
+                realType is ParameterizedType && realType.isSubtypeOf(Iterable::class.java) ->
                     match(potentialMatch, graphQLType.type, realType.actualTypeArguments.first())
                 realType is Class<*> && realType.isArray ->
                     match(potentialMatch, graphQLType.type, realType.componentType)
@@ -93,8 +90,6 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
         }
     }
 
-    private fun isListType(realType: ParameterizedType, potentialMatch: PotentialMatch) = isListType(realType, potentialMatch.generic)
-
     internal sealed interface Match
 
     internal data class ScalarMatch(val type: ScalarTypeDefinition) : Match

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

@@ -41,6 +41,8 @@ internal fun JavaType.unwrap(): Class<out Any> =
         this as Class<*>
     }
 
+internal fun ParameterizedType.isSubtypeOf(type: Class<*>): Boolean = type.isAssignableFrom(unwrap())
+
 /**
  * Replaces a parameterized type whose type arguments are all unbounded wildcards, e.g. Kotlin's Page<*>, by its raw type.
  */