This closes #331.

Author: abhi_rao

src/main/kotlin/com/coxautodev/graphql/tools/ResolverInfo.kt

@@ -19,13 +19,8 @@ internal class NormalResolverInfo(val resolver: GraphQLResolver<*>, private val
     override val dataClassType = findDataClass()
 
     private fun findDataClass(): Class<out Any> {
-        // Grab the parent interface with type GraphQLResolver from our resolver and get its first type argument.
-        val interfaceType = GenericType(resolverType, options).getGenericInterface(GraphQLResolver::class.java)
-        if (interfaceType == null || interfaceType !is ParameterizedType) {
-            error("${GraphQLResolver::class.java.simpleName} interface was not parameterized for: ${resolverType.name}")
-        }
 
-        val type = TypeUtils.determineTypeArguments(resolverType, interfaceType)[GraphQLResolver::class.java.typeParameters[0]]
+        val type = TypeUtils.getTypeArguments(resolverType, GraphQLResolver::class.java)[GraphQLResolver::class.java.typeParameters[0]]
 
         if (type == null || type !is Class<*>) {
             throw ResolverError("Unable to determine data class for resolver '${resolverType.name}' from generic interface! This is most likely a bug with graphql-java-tools.")

src/test/groovy/com/coxautodev/graphql/tools/GenericResolverSpec.groovy

@@ -16,15 +16,15 @@ class GenericResolverSpec extends Specification {
                             value: String
                         }
                         ''')
-                    .resolvers(new QueryResolver(), new BarResolver())
+                    .resolvers(new QueryResolver1(), new BarResolver())
                     .build()
                     .makeExecutableSchema()
 
         then:
             noExceptionThrown()
     }
 
-    class QueryResolver implements GraphQLQueryResolver {
+    class QueryResolver1 implements GraphQLQueryResolver {
         Bar getBar() {
             return new Bar()
         }
@@ -33,7 +33,7 @@ class GenericResolverSpec extends Specification {
     class Bar {
     }
 
-    abstract class FooResolver<T> {
+    abstract class FooResolver<T> implements GraphQLResolver<T> {
         String getValue(T foo) {
             return "value"
         }
@@ -42,4 +42,43 @@ class GenericResolverSpec extends Specification {
     class BarResolver extends FooResolver<Bar> implements GraphQLResolver<Bar> {
 
     }
+
+
+    def "methods from generic inherited resolvers are resolved"() {
+        when:
+        SchemaParser.newParser().schemaString('''\
+                        type Query {
+                            car: Car!
+                        }
+                        type Car {
+                            value: String
+                        }
+                        ''')
+                .resolvers(new QueryResolver2(), new CarResolver())
+                .build()
+                .makeExecutableSchema()
+
+        then:
+        noExceptionThrown()
+    }
+
+
+    class QueryResolver2 implements GraphQLQueryResolver {
+        Car getCar() {
+            return new Car()
+        }
+    }
+
+    abstract class FooGraphQLResolver<T> implements GraphQLResolver<T> {
+        String getValue(T foo) {
+            return "value"
+        }
+    }
+
+    class Car {
+    }
+
+    class CarResolver extends FooGraphQLResolver<Car> {
+
+    }
 }