Native types don't include all implemented interfaces

[pupnewfster]

I was doing a bit of code cleanup and removing "duplicate" implement calls and noticed that ZC stopped recognizing that one of my native classes implements a different native interface due to not doing any flattening of implemented interfaces. A basic setup class structure wise that fails to find that A implements C is as follows:

public class A implements B {
}

public interface B extends C {
}

public interface C {
}

I am fairly certain this is due to how implemented interfaces are collected here, as Class#getAnnotatedInterfaces only gets directly declared interfaces. I did some basic testing (outside of ZC/CrT so I haven't yet validated this actually fixes the issue I ran into but I am fairly certain it does) and I believe adjusting fillImplementedInterfaces to behave like:

private void fillImplementedInterfaces(Class<?> cls, HighLevelDefinition definition, JavaClass javaClass) {
 Set<AnnotatedType> interfaces = new LinkedHashSet<>();
 addAllAnnotatedInterfaces(interfaces, cls);
 for (AnnotatedType iface : interfaces) {
 if (shouldLoadType(iface.getType())) {
 TypeID type = typeConverter.loadType(typeConversionContext.context, iface);
 ImplementationMember member = new ImplementationMember(CodePosition.NATIVE, definition, Modifiers.PUBLIC, type);
 definition.members.add(member);
 typeConversionContext.compiled.setImplementationInfo(member, new JavaImplementation(true, javaClass));
 }
 }
}

private void addAllAnnotatedInterfaces(Set<AnnotatedType> interfaces, Class<?> cls) {
 for (AnnotatedType iface : cls.getAnnotatedInterfaces()) {
 interfaces.add(iface);
 Type type = iface.getType();
 while (type instanceof ParameterizedType) {
 type = ((ParameterizedType) type).getRawType();
 }
 if (type instanceof Class) {
 addAllAnnotatedInterfaces(interfaces, (Class<?>) type);
 }
 }
}

Will properly get all parent interfaces, except I am unsure how shouldLoadType behaves and whether this will cause issues in cases where B is registered to ZC so it knows about A, B, and C and not just A and C, as I feel like this may cause it to have C effectively be registered as both B and C, though that might happen already if the implementations are manually declared?