Interface type can have non-empty interface lists

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

@@ -234,6 +234,11 @@ class SchemaParser internal constructor(
             builder.field { field -> createField(field, fieldDefinition, inputObjects) }
         }
 
+        interfaceDefinition.implements.forEach { implementsDefinition ->
+            val interfaceName = (implementsDefinition as TypeName).name
+            builder.withInterface(GraphQLTypeReference(interfaceName))
+        }
+
         return schemaGeneratorDirectiveHelper.onInterface(builder.build(), schemaDirectiveParameters)
     }
 

src/test/groovy/graphql/kickstart/tools/SchemaParserSpec.groovy

@@ -2,6 +2,8 @@ package graphql.kickstart.tools
 
 import graphql.kickstart.tools.resolver.FieldResolverError
 import graphql.language.SourceLocation
+import graphql.schema.GraphQLInterfaceType
+import graphql.schema.GraphQLObjectType
 import graphql.schema.GraphQLSchema
 import org.springframework.aop.framework.ProxyFactory
 import spock.lang.Specification
@@ -418,6 +420,80 @@ class SchemaParserSpec extends Specification {
         noExceptionThrown()
     }
 
+    def "interface implementing an interface should have non-empty interface list"() {
+        when:
+        GraphQLSchema schema = SchemaParser.newParser().schemaString('''\
+            interface Trait {
+                id: ID!
+            }
+            interface MammalTrait implements Trait {
+                id: ID!
+            }
+            type PoodleTrait implements Trait & MammalTrait {
+                id: ID!
+            }
+
+            interface Animal {
+                id: ID!
+                traits: [Trait]
+            }
+            interface Dog implements Animal {
+                id: ID!
+                traits: [MammalTrait]
+            }
+            type Poodle implements Animal & Dog {
+                id: ID!
+                traits: [PoodleTrait]
+            }
+
+            type Query { test: [Poodle] }
+            '''.stripIndent())
+                .resolvers(new GraphQLQueryResolver() {
+                    static abstract class Trait {
+                        String id;
+                    }
+
+                    static abstract class MammalTrait extends Trait {
+                        String id;
+                    }
+
+                    static class PoodleTrait extends MammalTrait {
+                        String id;
+                    }
+
+                    static abstract class Animal {
+                        String id;
+                        abstract List<Trait> traits;
+                    }
+
+                    static abstract class Dog extends Animal {
+                        abstract List<MammalTrait> traits;
+                    }
+
+                    static class Poodle extends Dog {
+                        List<PoodleTrait> traits;
+                    }
+
+                    List<Poodle> test() { return new ArrayList<Poodle>(); }
+                })
+                .build()
+                .makeExecutableSchema()
+        GraphQLInterfaceType traitInterface = schema.getType("Trait") as GraphQLInterfaceType
+        GraphQLInterfaceType animalInterface = schema.getType("Animal") as GraphQLInterfaceType
+        GraphQLInterfaceType mammalTraitInterface = schema.getType("MammalTrait") as GraphQLInterfaceType
+        GraphQLInterfaceType dogInterface = schema.getType("Dog") as GraphQLInterfaceType
+        GraphQLObjectType poodleObject = schema.getType("Poodle") as GraphQLObjectType
+        GraphQLObjectType poodleTraitObject = schema.getType("PoodleTrait") as GraphQLObjectType
+
+        then:
+        poodleObject.interfaces.containsAll([dogInterface, animalInterface])
+        poodleTraitObject.interfaces.containsAll([mammalTraitInterface, traitInterface])
+        dogInterface.interfaces.contains(animalInterface)
+        mammalTraitInterface.interfaces.contains(traitInterface)
+        traitInterface.interfaces.empty
+        animalInterface.interfaces.empty
+    }
+
     enum EnumType {
         TEST
     }