}
    }

    @Override
    public void visitArtifacts(DependencyGraphNode from, LocalFileDependencyMetadata fileDependency, int artifactSetId, ArtifactSet artifactSet) {
        for (DependencyArtifactsVisitor visitor : visitors) {
            visitor.visitArtifacts(from, fileDependency, artifactSetId, artifactSet);
        }
    }

    @Override

     */
    void visitArtifacts(ArtifactVisitor visitor, boolean continueOnSelectionFailure);

    /**
     * Visits the files of this set. Does not include any files that could not be selected. Failures to select or resolve artifacts are supplied to the visitor.
     */
    default void visitFiles(ResolvedFileVisitor visitor, boolean continueOnSelectionFailure) {

    public Set<File> getFiles() throws ResolveException {
        ResolvedFilesCollectingVisitor visitor = new ResolvedFilesCollectingVisitor();
        visitedArtifacts.select(configuration.getImplicitSelectionSpec()).visitArtifacts(visitor, false);
        resolutionHost.rethrowFailure("files", visitor.getFailures());
        return visitor.getFiles();
    }

    @Override
    @Deprecated

        ensureResolved();
        return result.get().failures;
    }

    @Override
    public void visitArtifacts(ArtifactVisitor visitor) {
        // TODO - if already resolved, use the results
        fileCollection.getSelectedArtifacts().visitArtifacts(visitor, lenient);
    }

    private void ensureResolved() {
        result.finalizeIfNotAlready();
    }

        this.buildProjectDependencies = buildProjectDependencies;
    }

    @Override
    public void visitArtifacts(DependencyGraphNode from, LocalFileDependencyMetadata fileDependency, int artifactSetId, ArtifactSet artifacts) {
        collectArtifacts(artifactSetId, artifacts);
    }

    @Override
    public void visitArtifacts(DependencyGraphNode from, DependencyGraphNode to, int artifactSetId, ArtifactSet artifacts) {

                }
            }
        }
    }

    @Override
    public void visitArtifacts(DependencyGraphNode from, LocalFileDependencyMetadata fileDependency, int artifactSetId, ArtifactSet artifactSet) {
        builder.addNodeArtifacts(from, artifactSetId);
    }

    @Override
    public void visitArtifacts(DependencyGraphNode from, DependencyGraphNode to, int artifactSetId, ArtifactSet artifacts) {

            visitor.visitArtifacts(new EndCollection(this));
            return;
        }

        // Calculate the artifacts now
        result.finalizeIfNotAlready();
        for (Artifacts artifacts : result.get()) {
            artifacts.prepareForVisitingIfNotAlready();
            visitor.visitArtifacts(artifacts);
        }

        // to instead to memoize the results on the first visit so that this is not required.
        workerLeaseService.runAsUnmanagedWorkerThread(() -> visitArtifacts(artifacts, visitor, resolutionHost));
    }

    public void visitArtifacts(ResolvedArtifactSet artifacts, ArtifactVisitor visitor, ResolutionHost resolutionHost) {
        buildOperationRunner.run(new RunnableBuildOperation() {
            @Override

public class FileDependencyCollectingGraphVisitor implements DependencyArtifactsVisitor {
    private final Map<FileCollectionDependency, Integer> rootFiles = new LinkedHashMap<>();

    @Override
    public void visitArtifacts(DependencyGraphNode node, LocalFileDependencyMetadata fileDependency, int artifactSetId, ArtifactSet artifactSet) {
        if (node.isRoot()) {
            rootFiles.put(fileDependency.getSource(), artifactSetId);
        }

                DependencyGraphNode parent = dependency.getFrom();
                ArtifactsForNode artifacts = resolveVariantArtifacts(dependency, node);
                artifactResults.visitArtifacts(parent, node, artifacts.artifactSetId, artifacts.artifactSet);
            }
        }

        if (node.isRoot() || hasTransitiveIncomingEdge) {