receivesChanges(change3, change2, change1)
        }
        0 * _

        and:
        reported == [change3, change2, change1]
    }

    def "does not cache if visitor aborts visiting"() {
        when:
        cachingChanges.accept(new LimitingChangeVisitor(2, new CollectingChangeVisitor()))

        then:
        interaction {
            receivesChanges(change1, change2)
        }

     * <p>
     * The collection is live, so that the contents are queried as required on query of the collection.
     *
     * @param contents The file set contents for the constructed file collection

import org.gradle.internal.operations.RunnableBuildOperation;
import org.gradle.internal.work.WorkerLeaseService;

import javax.inject.Inject;

/**
 * Resolves a {@link ResolvedArtifactSet} in a build operation, visiting the results.
 */
public class ResolvedArtifactSetResolver {

    private final WorkerLeaseService workerLeaseService;
    private final BuildOperationRunner buildOperationRunner;

            return;
        }

        // Collect the finalizers and their dependencies so that each node is ordered before all of its dependencies
        LinkedList<Node> nodes = new LinkedList<>();
        Set<Node> visiting = new HashSet<>();
        Set<Node> visited = new HashSet<>();
        Deque<Node> queue = new ArrayDeque<>(finalizers);
        while (!queue.isEmpty()) {
            Node node = queue.peek();

         */
        void visit(ArtifactVisitor visitor);
    }

    /**
     * A listener that is notified as artifacts are made available while visiting the contents of a set. Implementations must be thread safe as they are notified from multiple threads concurrently.
     */
    interface Visitor {
        /**

    /**
     * @return the list of versions which were considered for this module but rejected.
     */
    Collection<RejectedVersion> getRejectedVersions();

    /**
     * Tags this resolve result, for visiting. This is a performance optimization. It will return
     * true if the last tagged object is different, false otherwise. This is meant to replace the
     * use of a hash set to collect the visited items.
     */

import org.gradle.internal.operations.RunnableBuildOperation;

import java.util.ArrayList;
import java.util.List;

/**
 * A wrapper that prepares artifacts in parallel when visiting the delegate.
 * This is done by collecting all artifacts to prepare and/or visit in a first step.
 * The collected artifacts are prepared in parallel and subsequently visited in sequence.
 */

  } ]
}, {
  "scenario" : "org.gradle.performance.regression.corefeature.ArchiveTreePerformanceTest.visiting gzip tar trees",
  "durations" : [ {
    "testProject" : "archivePerformanceProject",
    "linux" : 322
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.corefeature.ArchiveTreePerformanceTest.visiting tar trees",
  "durations" : [ {
    "testProject" : "archivePerformanceProject",
    "linux" : 320

}

type worklist struct {
	f            *Func               // the target function to be optimized out
	edges        []Edge              // propagate constant facts through edges
	uses         []*Value            // re-visiting set
	visited      map[Edge]bool       // visited edges
	latticeCells map[*Value]lattice  // constant lattices
	defUse       map[*Value][]*Value // def-use chains for some values

 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *
     * When visiting a nested property, child properties are discovered using the type of the
     * return property value. This can be a more specific type than the return type of the property's