We get the TypeDefinition, just to keep the existing semantics of that method that verified the type actually exists in the schema.

For performance reason we avoid streams. Normal iterations are faster in our experience,

Great, I avoid them too but I had seen others so tried to match general style 😸 will remove.

We have evolved the code base BTW - older code still uses.stream() but mostly we try to unwind them now to get those extra 0.1% boosts

What TypeInfo gave us, but without allocation of a TypeInfo object and without the tracking of decorations.

This needs a unit test and some JavaDoc

I am confused here

The code above is about the same as getAllImplementationsOf()

Its the saving here because it avoids

Optional<InterfaceTypeDefinition> interfaceTypeDef = getType(iFace, InterfaceTypeDefinition.class);

and the iinner

        String typeName = TypeInfo.typeInfo(type).getName();

??

So, it's basically the two things I have in the PR description:

1. No call to getTypes, which allocates a huge list of implementing types (Edit: note that getTypes(Class<T> targetClass) is very different from the reference to types used in this PR)
2. No allocation of a TypeInfo object (TypeInfo.typeInfo)

On top of this we don't need to allocate the return list of getAllImplementationsOf, simply check if any matches.

Doesn't look like much but for our schema this is about 25-30% of the allocations for a makeExecutableSchema call.

Doesn't look like much but for our schema this is about 25-30% of the allocations for a makeExecutableSchema call.

To add to this:

• Imagine you have 1000s of types in a schema, including many abstract types.
• For every field of all interfaces types
  • Get and allocate a list for all the object and interface types in the schema
  • For all the implementations of the above, allocate a TypeInfo object
  • Filter and allocate a list of all implementing types

Probably worth investing in a cached reverse lookup at some point instead of looking through all the types everytime. Maybe on that new read only type registry.

How do you see this reverse lookup working - simply a map of name -> type say or somethings else?

ps the read only type registry PR is now merged

I think i know now - I suspect you want something like

    private final Map<InterfaceTypeDefinition, List<ImplementingTypeDefinition>> allImplementationsOf;
    private final Map<InterfaceTypeDefinition, List<ObjectTypeDefinition>> implementationsOf;


    @Override
    public List<ImplementingTypeDefinition> getAllImplementationsOf(InterfaceTypeDefinition targetInterface) {
        return allImplementationsOf.getOrDefault(targetInterface, ImmutableList.of());
    }

    @Override
    public List<ObjectTypeDefinition> getImplementationsOf(InterfaceTypeDefinition targetInterface) {
        return implementationsOf.getOrDefault(targetInterface, ImmutableList.of());
    }

👍