} else {
            // Climb up the hierarchy looking for the highest parent
            ClassLoader parent = createWorkerClassLoaderWithStructure(workerInfrastructureClassloader, classLoaderStructure.getParent(), legacyTypesSupport);
            return createClassLoaderFromSpec(parent, classLoaderStructure.getSpec(), legacyTypesSupport);
        }
    }

        this.spec = spec;
    }

    public ConfigurableRule<ComponentMetadataContext> getConfigurableRule() {
        return configurableRule;
    }

    public Spec<ModuleVersionIdentifier> getSpec() {
        return spec;
    }

    private List<Map.Entry<FileNormalizationSpec, FileCollectionFingerprinter>> entriesFrom(Collection<FingerprinterRegistration> registrations) {
        return registrations.stream().map(registration -> Maps.immutableEntry(registration.getSpec(), registration.getFingerprinter())).collect(ImmutableList.toImmutableList());
    }

    @Override
    public FileCollectionFingerprinter getFingerprinter(FileNormalizationSpec spec) {

        this.action = action;
        this.spec = spec;
    }

    public RuleAction<? super T> getAction() {
        return action;
    }

    public Spec<? super T> getSpec() {
        return spec;
    }

    private static final DescribingAndSpec<?> EMPTY = new DescribingAndSpec<>();
    private final AndSpec<T> specHolder;

    private DescribingAndSpec(AndSpec<T> specHolder) {
        super(specHolder.getSpecs().toArray(Cast.uncheckedCast(new Spec[0])));
        this.specHolder = specHolder;
    }

    public DescribingAndSpec() {
        this(AndSpec.empty());
    }

    private final VisitableURLClassLoader.Spec spec;

    public FlatClassLoaderStructure(VisitableURLClassLoader.Spec spec) {
        this.spec = spec;
    }

    @Override
    public VisitableURLClassLoader.Spec getSpec() {
        return spec;
    }

    @Override
    public ClassLoaderStructure getParent() {
        return null;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {

    private FingerprinterRegistration(FileNormalizationSpec spec, FileCollectionFingerprinter fingerprinter) {
        this.spec = spec;
        this.fingerprinter = fingerprinter;
    }

    public FileNormalizationSpec getSpec() {
        return spec;
    }

    public FileCollectionFingerprinter getFingerprinter() {
        return fingerprinter;
    }

        HierarchicalClassLoaderStructure childNode = new HierarchicalClassLoaderStructure(spec, this);
        return childNode;
    }

    @Override
    public ClassLoaderSpec getSpec() {
        return self;
    }

    @Override
    public HierarchicalClassLoaderStructure getParent() {
        return parent;
    }

    @Override
    public boolean equals(Object o) {

    }

    /**
     * The address of a spec relative to its parent.
     */
    interface CopySpecAddress {
        @Nullable
        CopySpecAddress getParent();

        CopySpecInternal getSpec();

        int getAdditionIndex();

        CopySpecAddress append(CopySpecInternal spec, int additionIndex);

        CopySpecAddress append(CopySpecAddress relativeAddress);

    // Not public. Evaluation of these specs is a major hot spot for large builds, so use an array for iteration
    Spec<? super T>[] getSpecsArray() {
        return specs;
    }

    public List<Spec<? super T>> getSpecs() {
        return Collections.unmodifiableList(Arrays.asList(specs));
    }

    public boolean isEmpty() {
        return specs.length == 0;
    }

    @Override
    public final boolean equals(Object o) {