GeezerVison

Summary

Fixes #3384.

The core issue is that a built GraphQLSchema can contain two views of the same relationship:

• the original child list used for rebuild traversal, which may still contain GraphQLTypeReference("Node")
• the resolved accessor view used by runtime/schema APIs, where Person.getInterfaces() returns the actual GraphQLInterfaceType Node instance

In the #3384 repro, Person was originally created with .withInterface(typeRef("Node")). During schema build, that reference is resolved and Person.getInterfaces() starts returning the real Node interface. Later, when the mutation root is removed, Node is no longer reachable through the deleted mutation field. The rebuilt schema still reaches Person from Query, and Person still implements Node, so Node must remain in the rebuilt type map.

The catch is that schema build collection intentionally traverses getChildrenWithTypeReferences(). For Person, that traversal sees the original GraphQLTypeReference("Node"), not the already-resolved Node object returned by Person.getInterfaces(). So the collector can visit Person without collecting the resolved Node interface. Later, GraphQLTypeResolvingVisitor uses Person.getInterfaces(), looks up Node in the rebuilt type map, and fails because Node was missed during collection.

This is what the code calls an indirect strong reference:

• indirect: the traverser did not visit it as a normal child node, because the child list exposes the original type reference
• strong: the schema element already holds the actual GraphQLNamedType object through an accessor such as getInterfaces() or getTypes()

GraphQLTypeCollectingVisitor already handled this pattern for field, argument, input field, and applied directive argument types. This PR extends the same collection logic to:

• object implemented interfaces
• interface implemented interfaces
• union member types

The same original-reference versus resolved-accessor split exists for unions and interface inheritance:

• GraphQLUnionType.getChildrenWithTypeReferences() exposes original possible types, while getTypes() can return resolved object types
• GraphQLInterfaceType.getChildrenWithTypeReferences() exposes original implemented interfaces, while getInterfaces() can return resolved interfaces

This does not keep every deleted-path extra type alive. It only preserves resolved named types that are still referenced by a schema element that remains reachable in the rebuilt schema.

Repro Coverage

Adds #3384 Spock coverage for these schema rebuild cases:

• object implementing an interface through a type reference
• union containing a member through a type reference
• interface implementing another interface through a type reference

The object/interface case is covered through both paths:

• direct rebuild with GraphQLSchema.newSchema(schema).mutation((GraphQLObjectType) null).build()
• traversal-based deletion with SchemaTransformer.transformSchemaWithDeletes(...)

The union and interface-inheritance cases specifically prove why GraphQLTypeCollectingVisitor needs to follow getTypes() and getInterfaces(), not just field/argument/input references.

Before the collector change, these cases fail during rebuild with an NPE in GraphQLTypeResolvingVisitor; they now pass.

Local Test Stability

This PR also keeps the local build cleanup from the previous version of #4390: markGeneratedEqualsHashCode now cleans classes-jacoco before rewriting and does not append duplicate graphql.coverage.Generated annotations. That prevents local-only ArchUnit failures in JMHForkArchRuleTest after interrupted or repeated incremental runs.

Verification

./gradlew test --tests "graphql.schema.impl.SchemaUtilTest.can rebuild schema after removing root type that made an implemented interface reachable" --tests "graphql.schema.impl.SchemaUtilTest.can transform schema after deleting root type that made an implemented interface reachable" --tests "graphql.schema.impl.SchemaUtilTest.can rebuild schema after removing root type that made a union member reachable" --tests "graphql.schema.impl.SchemaUtilTest.can rebuild schema after removing root type that made an interface implemented by another interface reachable"

./gradlew test --tests graphql.schema.impl.SchemaUtilTest

Also ran:

git diff --check