Rename GenericType to GenericTypeResolver

- Rename GenericType to GenericTypeResolver and unwrapGenericType to resolve
- Rename the fields holding it to typeResolver

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: oryan-block

…n/graphql/kickstart/tools/GenericType.kt …l/kickstart/tools/GenericTypeResolver.ktsrc/main/kotlin/graphql/kickstart/tools/GenericType.kt renamed to src/main/kotlin/graphql/kickstart/tools/GenericTypeResolver.kt src/main/kotlin/graphql/kickstart/tools/GenericType.kt renamed to src/main/kotlin/graphql/kickstart/tools/GenericTypeResolver.kt

@@ -12,7 +12,7 @@ import java.lang.reflect.WildcardType
 /**
  * @author Andrew Potter
  */
-internal class GenericType(private val containingType: JavaType, private val options: SchemaParserOptions) {
+internal class GenericTypeResolver(private val containingType: JavaType, private val options: SchemaParserOptions) {
 
     fun getRawClass() = getRawClass(containingType)
 
@@ -29,7 +29,7 @@ internal class GenericType(private val containingType: JavaType, private val opt
      * - 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 {
+    fun resolve(javaType: JavaType): JavaType {
         return when (val type = resolveTypeVariables(javaType)) {
             is ParameterizedType -> {
                 val rawType = type.rawType
@@ -42,7 +42,7 @@ internal class GenericType(private val containingType: JavaType, private val opt
                 }
 
                 val unwrapsTo = wrapper.schemaWrapper.invoke(typeArguments[wrapper.index])
-                unwrapGenericType(unwrapsTo)
+                resolve(unwrapsTo)
             }
             is TypeVariable<*> -> error("Could not resolve type variable '${TypeUtils.toLongString(type)}' relative to ${TypeUtils.toString(containingType)}")
             is WildcardType -> type.upperBounds.firstOrNull()

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

@@ -396,7 +396,7 @@ internal class SchemaClassScanner(
                                 handleFoundType(typeClassMatcher.match(TypeClassMatcher.PotentialMatch.parameterType(
                                     inputValueDefinition.type,
                                     inputValueJavaType,
-                                    GenericType(javaType, options),
+                                    GenericTypeResolver(javaType, options),
                                     InputObjectReference(inputValueDefinition)
                                 )))
                             } else {

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

@@ -22,14 +22,14 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
 
     private fun match(potentialMatch: PotentialMatch, graphQLType: GraphQLLangType, javaType: JavaType, root: Boolean = false): Match {
 
-        var realType = potentialMatch.generic.unwrapGenericType(javaType)
+        var realType = potentialMatch.typeResolver.resolve(javaType)
 
         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())
+            realType = potentialMatch.typeResolver.resolve(realType.actualTypeArguments.first())
 
             if (realType is ParameterizedType && realType.isSubtypeOf(DataFetcherResult::class.java)) {
                 throw error(potentialMatch, "${DataFetcherResult::class.java.name} cannot be nested within itself")
@@ -46,7 +46,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
                 throw error(potentialMatch, "${Optional::class.java.name} can only be used at the top level of a return type")
             }
 
-            realType = potentialMatch.generic.unwrapGenericType(realType.actualTypeArguments.first())
+            realType = potentialMatch.typeResolver.resolve(realType.actualTypeArguments.first())
 
             if (realType is ParameterizedType && realType.isSubtypeOf(Optional::class.java)) {
                 throw error(potentialMatch, "${Optional::class.java.name} cannot be nested within itself")
@@ -104,16 +104,16 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
     internal data class PotentialMatch(
         val graphQLType: GraphQLLangType,
         val javaType: JavaType,
-        val generic: GenericType,
+        val typeResolver: GenericTypeResolver,
         val reference: SchemaClassScanner.Reference,
         val location: Location
     ) {
         companion object {
-            fun returnValue(graphQLType: GraphQLLangType, javaType: JavaType, generic: GenericType, reference: SchemaClassScanner.Reference) =
-                PotentialMatch(graphQLType, javaType, generic, reference, Location.RETURN_TYPE)
+            fun returnValue(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: SchemaClassScanner.Reference) =
+                PotentialMatch(graphQLType, javaType, typeResolver, reference, Location.RETURN_TYPE)
 
-            fun parameterType(graphQLType: GraphQLLangType, javaType: JavaType, generic: GenericType, reference: SchemaClassScanner.Reference) =
-                PotentialMatch(graphQLType, javaType, generic, reference, Location.PARAMETER_TYPE)
+            fun parameterType(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: SchemaClassScanner.Reference) =
+                PotentialMatch(graphQLType, javaType, typeResolver, reference, Location.PARAMETER_TYPE)
         }
     }
 }

src/main/kotlin/graphql/kickstart/tools/resolver/FieldResolver.kt

@@ -14,7 +14,7 @@ internal abstract class FieldResolver(
     val options: SchemaParserOptions
 ) {
     val resolverInfo: ResolverInfo = search.resolverInfo
-    val genericType = GenericType(search.type, options)
+    val typeResolver = GenericTypeResolver(search.type, options)
 
     abstract fun scanForMatches(): List<TypeClassMatcher.PotentialMatch>
 
@@ -33,8 +33,8 @@ internal abstract class FieldResolver(
                     ?: environment?.getSource<Any>()
                     ?: throw ResolverError("Expected DataFetchingEnvironment and source object to not be null!")
 
-                if (!this.genericType.isAssignableFrom(source.javaClass)) {
-                    throw ResolverError("Expected source object to be an instance of '${this.genericType.getRawClass().name}' but instead got '${source.javaClass.name}'")
+                if (!this.typeResolver.isAssignableFrom(source.javaClass)) {
+                    throw ResolverError("Expected source object to be an instance of '${this.typeResolver.getRawClass().name}' but instead got '${source.javaClass.name}'")
                 }
 
                 source

src/main/kotlin/graphql/kickstart/tools/resolver/MapFieldResolver.kt

@@ -44,7 +44,7 @@ internal class MapFieldResolver(
     }
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
-        return listOf(TypeClassMatcher.PotentialMatch.returnValue(field.type, mapGenericValue, genericType, SchemaClassScanner.FieldTypeReference(field.name)))
+        return listOf(TypeClassMatcher.PotentialMatch.returnValue(field.type, mapGenericValue, typeResolver, SchemaClassScanner.FieldTypeReference(field.name)))
     }
 
     override fun toString() = "MapFieldResolver{key=${field.name}}"

src/main/kotlin/graphql/kickstart/tools/resolver/MethodFieldResolver.kt

@@ -72,11 +72,11 @@ internal class MethodFieldResolver(
         this.field.inputValueDefinitions.forEachIndexed { index, definition ->
 
             val parameterType = this.getMethodParameterType(index)
-                ?.apply { genericType.getRawClass(this) }
+                ?.apply { typeResolver.getRawClass(this) }
                 ?: throw ResolverError("Missing method type at position ${this.getJavaMethodParameterIndex(index)}, this is most likely a bug with graphql-java-tools")
 
             val isNonNull = definition.type is NonNullType
-            val isOptional = this.genericType.getRawClass(parameterType) == Optional::class.java
+            val isOptional = this.typeResolver.getRawClass(parameterType) == Optional::class.java
 
             args.add { environment ->
                 val argumentPresent = environment.arguments.containsKey(definition.name)
@@ -130,7 +130,7 @@ internal class MethodFieldResolver(
 
         // the class the return type unwraps to, so a value that happens to implement Future isn't mistaken for a wrapper.
         // Object (e.g. for a union) can't tell them apart, so then every future of a method declared to return Future is checked
-        val valueClass = (TypeUtils.getRawType(getUnwrappedReturnType(), null) ?: Any::class.java)
+        val valueClass = (TypeUtils.getRawType(getResolvedReturnType(), null) ?: Any::class.java)
             .takeUnless { it == Any::class.java && TypeUtils.getRawType(getReturnType(), null) == Future::class.java }
 
         return if (numberOfParameters > 0 || isSuspendFunction) {
@@ -153,8 +153,8 @@ internal class MethodFieldResolver(
      */
     private fun isConcreteScalarType(environment: DataFetchingEnvironment, type: Type<*>, genericParameterType: JavaType): Boolean {
         return when (type) {
-            is ListType -> List::class.java.isAssignableFrom(this.genericType.getRawClass(genericParameterType))
-                && isConcreteScalarType(environment, type.type, this.genericType.unwrapGenericType(genericParameterType))
+            is ListType -> List::class.java.isAssignableFrom(this.typeResolver.getRawClass(genericParameterType))
+                && isConcreteScalarType(environment, type.type, this.typeResolver.resolve(genericParameterType))
 
             is TypeName -> environment.graphQLSchema?.getType(type.name!!)?.let { isScalar(it) && type.name != "ID" }
                 ?: false
@@ -165,10 +165,10 @@ internal class MethodFieldResolver(
     }
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
-        val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, getUnwrappedReturnType(), genericType, SchemaClassScanner.ReturnValueReference(method))
+        val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, getResolvedReturnType(), typeResolver, SchemaClassScanner.ReturnValueReference(method))
 
         return field.inputValueDefinitions.mapIndexed { i, inputDefinition ->
-            TypeClassMatcher.PotentialMatch.parameterType(inputDefinition.type, getMethodParameterType(i)!!, genericType, SchemaClassScanner.MethodParameterReference(method, i))
+            TypeClassMatcher.PotentialMatch.parameterType(inputDefinition.type, getMethodParameterType(i)!!, typeResolver, SchemaClassScanner.MethodParameterReference(method, i))
         } + listOf(returnValueMatch)
     }
 
@@ -186,8 +186,8 @@ internal class MethodFieldResolver(
             method.genericReturnType
         }
 
-    private fun getUnwrappedReturnType(): JavaType =
-        getReturnType().let { genericType.unwrapGenericType(if (search.isSubscription) it.asPublisher() else it) }
+    private fun getResolvedReturnType(): JavaType =
+        getReturnType().let { typeResolver.resolve(if (search.isSubscription) it.asPublisher() else it) }
 
     private fun getIndexOffset(): Int {
         return if (resolverInfo is DataClassTypeResolverInfo && !method.declaringClass.isAssignableFrom(resolverInfo.dataClassType)) {

src/main/kotlin/graphql/kickstart/tools/resolver/PropertyFieldResolver.kt

@@ -30,7 +30,7 @@ internal class PropertyFieldResolver(
             TypeClassMatcher.PotentialMatch.returnValue(
                 field.type,
                 property.genericType,
-                genericType,
+                typeResolver,
                 SchemaClassScanner.FieldTypeReference(property.toString())
             )
         )