if (methodNode.access.isSynthetic) return false

        if (!hasSuperType) return true

        fun ArrayDeque<String>.addSuperTypesOf(classNode: ClassNode) {
            classNode.interfaces.forEach { push(it) }
            if (classNode.superName != null) push(classNode.superName)
        }

        val superTypeStack = ArrayDeque<String>().apply {
            addSuperTypesOf(delegate)
        }

        List<ClassMetaData> interfaces = new ArrayList<ClassMetaData>();
        for (String interfaceName : interfaceNames) {
            ClassMetaData interfaceMetaData = metaDataRepository.find(interfaceName);
            if (interfaceMetaData != null) {
                interfaces.add(interfaceMetaData);
            }
        }
        return interfaces;
    }

        when:
        ClassDoc doc = withCategories {
            def doc = new ClassDoc('org.gradle.Class', content, document, classMetaData, null)
            doc.superClass = superDoc
            doc.interfaces << superType1
            doc.interfaces << superType2
            builder.build(doc)
            return doc
        }

        then:
        doc.classProperties.size() == 5
        doc.classProperties[0].name == 'a'

        then:
        m == overriddenMethod
        _ * owner.superClass >> superClassMetaData
        _ * owner.interfaces >> []
        1 * superClassMetaData.findDeclaredMethod('method()') >> null
        _ * superClassMetaData.superClass >> ancestorClassMetaData
        _ * superClassMetaData.interfaces >> []
        1 * ancestorClassMetaData.findDeclaredMethod('method()') >> overriddenMethod
    }

    void addClassExtension(ClassExtensionDoc extensionDoc) {
        classExtensions.add(extensionDoc)
    }

    List<ClassDoc> getSuperTypes() {
        return superClass == null ? interfaces : [superClass] + interfaces
    }

    Element getClassSection() { return classSection }

    Element getPropertiesTable() { return propertiesTable }

    def getPropertiesSection() { return propertiesSection }

            parse(f, repository)
            counter++
        }

        //updating/modifying the metadata and making sure every type reference across the metadata is fully qualified
        //so, the superClassName, interfaces and types needed by declared properties and declared methods will have fully qualified name
        TypeNameResolver resolver = new TypeNameResolver(repository)
        repository.each { name, metaData ->

                public interface $TEST_INTERFACE_SIMPLE_NAME {
                    String field = "value";
                    void method();
                }
            """
            : """
                public class $TEST_INTERFACE_SIMPLE_NAME {
                    public String field = "value";
                    public void method() { }
                    public $TEST_INTERFACE_SIMPLE_NAME() { }

Another more targeted interface is `CompilationFailedIndicator`.
This interface is used to indicate that the exception is caused by a compilation failure. 

package org.gradle.test.sub;

public interface SubJavaInterface {

package org.gradle.test;

public @interface JavaAnnotation {