//      concrete function(s).
//   5) For each function with captures, bind the appropriate objects as
//      captured inputs.
//   6) Take the fully-prepared objects, and build them into a hierarchy.
//   7) Return the prepared model.

// Converts a SavedUserObject into its corresponding data structure.
// TODO(b/185579152): This method returns empty data structures currently.

    public DefaultSerializerRegistry() {
        this(true);
    }

    public DefaultSerializerRegistry(boolean supportClassHierarchy) {
        this.classMatcher = supportClassHierarchy ? SerializerClassMatcherStrategy.HIERARCHY : SerializerClassMatcherStrategy.STRICT;
    }

    @Override
    public <T> void register(Class<T> implementationType, final Serializer<T> serializer) {

import org.gradle.api.plugins.PluginCollection;
import org.gradle.api.specs.Spec;
import org.gradle.api.specs.Specs;

import java.util.Collection;

@SuppressWarnings("deprecation") // Something is weird with the hierarchy of 'add(T)', the implementation inherited from DefaultDomainObjectSet is used internally in DefaultPluginContainer.pluginAdded() but at the same time PluginCollection.add(T) is deprecated

import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

/**
 * A collection of files in Xcode's virtual filesystem hierarchy.
 */
public class PBXGroup extends PBXReference {
    private final List<PBXReference> children;
    private final LoadingCache<String, PBXGroup> childGroupsByName;

        taskA.project == project

        project.tasks.find { it.name == 'b' && it.path == ':b' }
        project.tasks.find { it.name == 'c' && it.path == ':c' }
    }

    def "provides hierarchy"() {
        file('settings.gradle') << "include 'a', 'a:b', 'a:c', 'a:c:d'"
        file('build.gradle') << '''
task rootTask
project (':a') { description = 'A rocks!' }
'''

        when:

    /**
     * Adds or replaces a classloader. This should be called to register specialized classloaders that belong to the hierarchy, so they can be cleaned up as required.
     *
     * @param id the ID of the classloader.
     * @return the classloader.
     */

        withValidityAssertion { analysisSession.symbolDeclarationOverridesProvider.getDirectlyOverriddenSymbols(this) }

    /**
     * Checks if [this] class has [superClass] as its superclass somewhere in the inheritance hierarchy.
     *
     * N.B. The class is not considered to be a subclass of itself, so `myClass.isSubClassOf(myClass)` is always `false`.
     */

import javax.annotation.Nullable;
import java.util.HashSet;
import java.util.Map;

/**
 * Fingerprint file system snapshots normalizing the path to the relative path in a hierarchy.
 *
 * File names for root directories are ignored. For root files, the file name is used as normalized path.
 */
public class RelativePathFingerprintingStrategy extends AbstractDirectorySensitiveFingerprintingStrategy {

    def "can build javadoc from modularized java with -module-source-path specified"() {

        testBuildFile << """
            // Module source path needs a folder structure where the module name appears in the hierarchy
            tasks.withType(Javadoc) {
                options.addStringOption('-module-source-path', "\$projectDir/../*/src/main/java")
            }
"""

        when:
        succeeds("javadoc")

        Set<Class<?>> seen = new HashSet<Class<?>>();
        Deque<Class<?>> queue = new ArrayDeque<Class<?>>();

        // fully visit the class hierarchy before any interfaces in order to meet the contract
        // of PropertyDetails.getGetters() etc.
        queue.add(type);
        superClasses(type, queue);
        while (!queue.isEmpty()) {