Move the scan references into ScanDictionary

Moves Reference and its subclasses next to DictionaryEntry, which stores them
and prints them in the "Two different classes" error. TypeClassMatcher and the
field resolvers no longer name SchemaClassScanner.

Edits to compile:
- InterfaceReference and InputObjectReference are private again.
- private dropped on DictionaryReference, UnusedTypeReference,
  UnionMemberReference and SealedSubclassReference, which the scanner creates.
- SchemaClassScanner.XReference becomes ScanDictionary.XReference in
  TypeClassMatcher, MethodFieldResolver, PropertyFieldResolver,
  MapFieldResolver and NestedGenericWrapperTest.
- Imports.

Author: oryan-block

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

@@ -1,17 +1,14 @@
 package graphql.kickstart.tools
 
 import com.fasterxml.jackson.databind.JsonNode
-import graphql.kickstart.tools.SchemaClassScanner.InputObjectReference
-import graphql.kickstart.tools.SchemaClassScanner.InterfaceReference
-import graphql.kickstart.tools.SchemaClassScanner.Reference
-import graphql.kickstart.tools.SchemaClassScanner.ReturnValueReference
 import graphql.kickstart.tools.util.JavaType
 import graphql.kickstart.tools.util.unwrap
 import graphql.kickstart.tools.util.withExtensions
 import graphql.language.*
 import graphql.schema.idl.ScalarInfo
 import org.slf4j.Logger
 import java.lang.reflect.Member
+import java.lang.reflect.Method
 
 internal class ScanDictionary(
     private val options: SchemaParserOptions,
@@ -227,4 +224,46 @@ internal class ScanDictionary(
             return clazz
         }
     }
+
+    abstract class Reference {
+        abstract fun getDescription(): String
+        override fun toString() = getDescription()
+    }
+
+    class DictionaryReference : Reference() {
+        override fun getDescription() = "provided dictionary"
+    }
+
+    class UnusedTypeReference : Reference() {
+        override fun getDescription() = "unused type"
+    }
+
+    private class InterfaceReference(private val type: ObjectTypeDefinition) : Reference() {
+        override fun getDescription() = "interface declarations of ${type.name}"
+    }
+
+    class UnionMemberReference(private val union: UnionTypeDefinition) : Reference() {
+        override fun getDescription() = "member of union ${union.name}"
+    }
+
+    class SealedSubclassReference(private val sealedType: JavaType) : Reference() {
+        override fun getDescription() = "subclass of sealed type ${sealedType.typeName}"
+    }
+
+    private class InputObjectReference(private val type: InputValueDefinition) : Reference() {
+        override fun getDescription() = "input object $type"
+    }
+
+    internal class ReturnValueReference(private val method: Method) : Reference() {
+        fun getMethod() = method
+        override fun getDescription() = "return type of method $method"
+    }
+
+    internal class MethodParameterReference(private val method: Method, private val index: Int) : Reference() {
+        override fun getDescription() = "parameter $index of method $method"
+    }
+
+    internal class FieldTypeReference(private val field: String) : Reference() {
+        override fun getDescription() = "type of field $field"
+    }
 }

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

@@ -1,6 +1,11 @@
 package graphql.kickstart.tools
 
+import graphql.kickstart.tools.ScanDictionary.DictionaryReference
+import graphql.kickstart.tools.ScanDictionary.FieldTypeReference
 import graphql.kickstart.tools.ScanDictionary.InitialDictionaryEntry
+import graphql.kickstart.tools.ScanDictionary.SealedSubclassReference
+import graphql.kickstart.tools.ScanDictionary.UnionMemberReference
+import graphql.kickstart.tools.ScanDictionary.UnusedTypeReference
 import graphql.kickstart.tools.resolver.FieldResolver
 import graphql.kickstart.tools.resolver.FieldResolverScanner
 import graphql.kickstart.tools.resolver.MethodFieldResolver
@@ -14,7 +19,6 @@ import org.apache.commons.lang3.reflect.TypeUtils
 import org.slf4j.LoggerFactory
 import java.lang.reflect.Field
 import java.lang.reflect.Member
-import java.lang.reflect.Method
 import java.lang.reflect.Modifier
 import java.lang.reflect.ParameterizedType
 
@@ -582,48 +586,6 @@ internal class SchemaClassScanner(
 
     private data class QueueItem(val type: ObjectTypeDefinition, val clazz: JavaType)
 
-    abstract class Reference {
-        abstract fun getDescription(): String
-        override fun toString() = getDescription()
-    }
-
-    private class DictionaryReference : Reference() {
-        override fun getDescription() = "provided dictionary"
-    }
-
-    private class UnusedTypeReference : Reference() {
-        override fun getDescription() = "unused type"
-    }
-
-    class InterfaceReference(private val type: ObjectTypeDefinition) : Reference() {
-        override fun getDescription() = "interface declarations of ${type.name}"
-    }
-
-    private class UnionMemberReference(private val union: UnionTypeDefinition) : Reference() {
-        override fun getDescription() = "member of union ${union.name}"
-    }
-
-    private class SealedSubclassReference(private val sealedType: JavaType) : Reference() {
-        override fun getDescription() = "subclass of sealed type ${sealedType.typeName}"
-    }
-
-    class InputObjectReference(private val type: InputValueDefinition) : Reference() {
-        override fun getDescription() = "input object $type"
-    }
-
-    internal class ReturnValueReference(private val method: Method) : Reference() {
-        fun getMethod() = method
-        override fun getDescription() = "return type of method $method"
-    }
-
-    internal class MethodParameterReference(private val method: Method, private val index: Int) : Reference() {
-        override fun getDescription() = "parameter $index of method $method"
-    }
-
-    internal class FieldTypeReference(private val field: String) : Reference() {
-        override fun getDescription() = "type of field $field"
-    }
-
     private class RootTypesHolder(
         options: SchemaParserOptions,
         rootInfo: RootTypeInfo,

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

@@ -95,7 +95,7 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
 
     internal data class ScalarMatch(val type: ScalarTypeDefinition) : Match
 
-    internal data class ValidMatch(val type: TypeDefinition<*>, val javaType: JavaType, val reference: SchemaClassScanner.Reference) : Match
+    internal data class ValidMatch(val type: TypeDefinition<*>, val javaType: JavaType, val reference: ScanDictionary.Reference) : Match
 
     internal enum class Location(val prettyName: String) {
         RETURN_TYPE("return type"),
@@ -106,14 +106,14 @@ internal class TypeClassMatcher(private val definitionsByName: Map<String, TypeD
         val graphQLType: GraphQLLangType,
         val javaType: JavaType,
         val typeResolver: GenericTypeResolver,
-        val reference: SchemaClassScanner.Reference,
+        val reference: ScanDictionary.Reference,
         val location: Location
     ) {
         companion object {
-            fun returnValue(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: SchemaClassScanner.Reference) =
+            fun returnValue(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: ScanDictionary.Reference) =
                 PotentialMatch(graphQLType, javaType, typeResolver, reference, Location.RETURN_TYPE)
 
-            fun parameterType(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: SchemaClassScanner.Reference) =
+            fun parameterType(graphQLType: GraphQLLangType, javaType: JavaType, typeResolver: GenericTypeResolver, reference: ScanDictionary.Reference) =
                 PotentialMatch(graphQLType, javaType, typeResolver, reference, Location.PARAMETER_TYPE)
         }
     }

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

@@ -1,7 +1,7 @@
 package graphql.kickstart.tools.resolver
 
 import com.fasterxml.classmate.TypeResolver
-import graphql.kickstart.tools.SchemaClassScanner
+import graphql.kickstart.tools.ScanDictionary
 import graphql.kickstart.tools.SchemaParserOptions
 import graphql.kickstart.tools.TypeClassMatcher
 import graphql.kickstart.tools.util.JavaType
@@ -44,7 +44,7 @@ internal class MapFieldResolver(
     }
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
-        return listOf(TypeClassMatcher.PotentialMatch.returnValue(field.type, mapGenericValue, typeResolver, SchemaClassScanner.FieldTypeReference(field.name)))
+        return listOf(TypeClassMatcher.PotentialMatch.returnValue(field.type, mapGenericValue, typeResolver, ScanDictionary.FieldTypeReference(field.name)))
     }
 
     override fun toString() = "MapFieldResolver{key=${field.name}}"

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

@@ -160,10 +160,10 @@ internal class MethodFieldResolver(
     }
 
     override fun scanForMatches(): List<TypeClassMatcher.PotentialMatch> {
-        val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, getResolvedReturnType(), typeResolver, SchemaClassScanner.ReturnValueReference(method))
+        val returnValueMatch = TypeClassMatcher.PotentialMatch.returnValue(field.type, getResolvedReturnType(), typeResolver, ScanDictionary.ReturnValueReference(method))
 
         return field.inputValueDefinitions.mapIndexed { i, inputDefinition ->
-            TypeClassMatcher.PotentialMatch.parameterType(inputDefinition.type, getMethodParameterType(i)!!, typeResolver, SchemaClassScanner.MethodParameterReference(method, i))
+            TypeClassMatcher.PotentialMatch.parameterType(inputDefinition.type, getMethodParameterType(i)!!, typeResolver, ScanDictionary.MethodParameterReference(method, i))
         } + listOf(returnValueMatch)
     }
 

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

@@ -1,6 +1,6 @@
 package graphql.kickstart.tools.resolver
 
-import graphql.kickstart.tools.SchemaClassScanner
+import graphql.kickstart.tools.ScanDictionary
 import graphql.kickstart.tools.SchemaParserOptions
 import graphql.kickstart.tools.TypeClassMatcher
 import graphql.language.FieldDefinition
@@ -31,7 +31,7 @@ internal class PropertyFieldResolver(
                 field.type,
                 property.genericType,
                 typeResolver,
-                SchemaClassScanner.FieldTypeReference(property.toString())
+                ScanDictionary.FieldTypeReference(property.toString())
             )
         )
     }

src/test/kotlin/graphql/kickstart/tools/NestedGenericWrapperTest.kt

@@ -181,7 +181,7 @@ class NestedGenericWrapperTest {
 
         val accepted = javaTypes.flatMap { (shape, javaType) -> graphQLTypes.map { Triple(shape, javaType, it) } }.filter { (_, javaType, graphQLType) ->
             val match = try {
-                matcher.match(TypeClassMatcher.PotentialMatch.returnValue(graphQLType, typeResolver.resolve(javaType), typeResolver, SchemaClassScanner.ReturnValueReference(method)))
+                matcher.match(TypeClassMatcher.PotentialMatch.returnValue(graphQLType, typeResolver.resolve(javaType), typeResolver, ScanDictionary.ReturnValueReference(method)))
             } catch (e: SchemaClassScannerError) {
                 null
             }