yieldAll(classes)

    // Then all supported interfaces sorted by subtyping (subtypes before supertypes)
    val interfaces = mutableListOf<Class<*>>()
    classes.forEach { `class` ->
        `class`.interfaces.forEach { `interface` ->
            when (val indexOfSupertype = interfaces.indexOfFirst { it.isAssignableFrom(`interface`) }) {
                -1 -> interfaces.add(`interface`)

        Type publicType = getType(publicClass);
        Type superClass;
        String[] interfaces;
        if (publicClass.isInterface()) {
            superClass = OBJECT;
            interfaces = new String[]{publicType.getInternalName(), MANAGED.getInternalName()};
        } else {
            superClass = publicType;
            interfaces = INTERFACES_FOR_ABSTRACT_CLASS;
        }

 *  Deserialization, on the other hand, is performed by a {@link org.gradle.internal.serialize.graph.DecodingProvider}.
 *  </p>
 *  <p>Both protocols are highly specialized and, as such, they are specified as Single Abstract Method interfaces.</p>
 *
 *  <h3>Codecs</h3>
 *  <p>A {@link org.gradle.internal.serialize.graph.Codec Codec} is an object that is both an <code>EncodingProvider</code> and a <code>DecodingProvider</code>.</p>
 *  <p>Codecs may be implemented:

    }

    private
    fun serviceType(type: Class<*>): Class<*>? {
        if (type.getAnnotation(ServiceScope::class.java) != null) {
            return type
        }
        for (superInterface in type.interfaces) {
            val serviceType = serviceType(superInterface)
            if (serviceType != null) {
                return serviceType
            }
        }
        if (type.superclass != null) {

            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 ->

            <p>
            We check the binary compatibility by comparing the current code’s binary interfaces
            against THE LATEST VERSION WHICH IS RELEASED FROM RELEASE BRANCH (from `released-version.json` on this branch)
            AND LOWER THAN CURRENT BASE VERSION (from `version.txt` on this branch).

     */
    private
    fun typeHierarchyViaJavaReflection(kClass: KClass<*>): Iterable<KClass<*>> =
        Traverser.forGraph<Class<*>> { listOfNotNull(it.superclass) + it.interfaces }
            .breadthFirst(kClass.java).map { it.kotlin }

        ]
    }

    @SuppressWarnings("unused")
    interface FirstInterfaceWithInheritedProperty {
        @Color(declaredBy = "first-interface")
        String getOverriddenProperty()
    }

    @SuppressWarnings("unused")
    interface SecondInterfaceWithInheritedProperty {
        @Color(declaredBy = "second-interface")
        String getOverriddenProperty()

              files=".*[/\\]platforms[/\\]ide[/\\]ide-plugins[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\]plugins[/\\]ide[/\\]eclipse[/\\][^/\\]+"/>

    <!-- Protocol types may only define constants in interfaces -->
    <suppress checks="InterfaceIsTypeCheck"
              files=".*[/\\]tooling-api[/\\]src[/\\]main[/\\]java[/\\]org[/\\]gradle[/\\]tooling[/\\]internal[/\\]protocol.+"/>
    <suppress checks="InterfaceIsTypeCheck"

      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

      "Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions