return BUILDER;
    }

    static class MapConverter extends MapNotationConverter<ComponentSelector> {
        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.example("Maps, e.g. [group: 'org.gradle', name:'gradle-core', version: '1.0'].");
        }

        def owner = Stub(FileTreeInternal)
        def visitor = Mock(MinimalFileTree.MinimalFileTreeStructureVisitor)
        def backingFile = tmpDir.createFile("thing.bin")

        def fileTree = new TestArchiveFileTree(TestDecompressionCoordinators.decompressionCoordinator(tmpDir.createDir("cache-dir")), backingFile)

        when:
        fileTree.visitStructure(visitor, owner)

        then:

        }

        @Override
        public boolean accept(String propertyName, ChangeVisitor visitor) {
            return inputFileChangesDelegate.accept(propertyName, visitor);
        }

        @Override
        public boolean accept(ChangeVisitor visitor) {
            return changeContainerDelegate.accept(visitor);
        }
    }

    @Override
    public boolean accept(NodeVisitor visitor) {
        if (visitor.enter(this)) {
            for (Node child : getChildren()) {
                if (!child.accept(visitor)) {
                    break;
                }
            }
        }
        return visitor.leave(this);
    }

    @Override
    public Node filter(Predicate<Node> filter) {

	"fmt"
	"iter"
)

// A Visitor's Visit method is invoked for each node encountered by [Walk].
// If the result visitor w is not nil, [Walk] visits each of the children
// of node with the visitor w, followed by a call of w.Visit(nil).
type Visitor interface {
	Visit(node Node) (w Visitor)
}

func walkList[N Node](v Visitor, list []N) {
	for _, node := range list {
		Walk(v, node)
	}
}

            ExecutionTimeValue<? extends V> value = providerOfValue.calculateExecutionTimeValue();
            if (value.isMissing()) {
                visitor.execute(ExecutionTimeValue.missing());
            } else if (value.hasFixedValue()) {
                // transform preserving side effects

        workerLeaseService.runAsUnmanagedWorkerThread(() -> visitArtifacts(artifacts, visitor, resolutionHost));
    }

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

    /**
     * Traverses this node and potentially its children using the specified visitor.
     *
     * @param visitor the visitor to call back, must not be {@code null}
     * @return {@code true} to visit siblings nodes of this node as well, {@code false} to skip siblings
     */
    boolean accept(@Nonnull NodeVisitor visitor);

    /**
     * Returns a new tree starting at this node, filtering the children.

            identityFileInputs.get(DEPENDENCIES_PROPERTY_NAME).getHash()
        );
    }

    @Override
    public void visitIdentityInputs(InputVisitor visitor) {
        super.visitIdentityInputs(visitor);
        visitInputArtifact(visitor);
    }

    }

    @Override
    public void visitProducerTasks(Action<? super Task> visitor) {
        try (EvaluationContext.ScopeContext ignored = EvaluationContext.current().open(owner)) {
            if (mayHaveValue(left)) {
                if (leftProducer.isKnown()) {
                    leftProducer.visitProducerTasks(visitor);
                }
                return;
            }