return patternSet;
        });
    }

    @Override
    public FileTree visit(FileVisitor visitor) {
        visitContentsAsFileTrees(child -> child.visit(visitor));
        return this;
    }

    @Override
    public void visitContentsAsFileTrees(Consumer<FileTreeInternal> visitor) {
        visitContents(new FileCollectionStructureVisitor() {
            @Override

    @Override
    public void describe(DiagnosticsVisitor visitor) {
        visitor.candidate("String or CharSequence instances").example("\"some/path\"");
        visitor.candidate("Boolean values").example("true").example("Boolean.TRUE");
        visitor.candidate("Number values").example("42").example("3.14");
        visitor.candidate("A File instance");
        visitor.candidate("A Closure that returns any supported value.");

    def "collects union of potential values"() {
        def visitor = new ValueCollectingDiagnosticsVisitor()

        given:
        visitor.candidate("thing 1").values(["a", "b"])
        visitor.candidate("thing 2").values(["a", 1.2, false])
        visitor.candidate("thing 3")

        expect:
        visitor.values == ["a", "b", "false", "1.2"] as Set
    }

        }

        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.candidate("Instances of Provider<RegularFile>.");
            visitor.candidate("Instances of Provider<Directory>.");
            visitor.candidate("Instances of Provider<File>.");
        }

        @Override

        def listener2 = Mock(TestListener)
        def visitor = Mock(Action)

        given:
        broadcast.add(listener1)
        broadcast.add(listener2)

        when:
        broadcast.visitListeners(visitor)

        then:
        1 * visitor.execute(listener1)

        then:
        1 * visitor.execute(listener2)
        0 * visitor._
    }

     *
     * @param clazz the type of whose type hierarchy to visit.
     * @param visitor the visitor to call for each type in the hierarchy.
     */
    public static <T> void walkTypeHierarchy(Class<T> clazz, TypeVisitor<? extends T> visitor) {
        walkTypeHierarchy(clazz, OBJECT_TYPE, visitor);
    }

    /**

        then:
        result.toList() == [file1, file2, file3]

        1 * source1.visitStructure(_) >> { FileCollectionStructureVisitor visitor -> visitor.visitCollection(null, [file1, file2]) }
        1 * source2.visitStructure(_) >> { FileCollectionStructureVisitor visitor -> visitor.visitCollection(null, [file2, file3]) }
        0 * _

        when:
        def result2 = collection.files

        then:

    private final FileCollectionStructureVisitor visitor;
    private final Set<File> files = new LinkedHashSet<>();
    private final Set<Throwable> failures = new LinkedHashSet<>();

    public ResolvedFileCollectionVisitor(FileCollectionStructureVisitor visitor) {
        this.visitor = visitor;
    }

    public Set<Throwable> getFailures() {
        return failures;
    }

        AnnotationMember annotation = new AnnotationMember(desc, true);
        SortingAnnotationVisitor visitor =
            new SortingAnnotationVisitor(annotation, super.visitAnnotation(name, desc));
        visitor.parentVisitor = this;
        visitor.annotationValueName = nameOrValue(name);
        return visitor;
    }

    @Override
    public void visit(String name, Object value) {

        ComponentGraphResolveState component;
        if (decoder.readBoolean()) {
            readComponentData(decoder, visitor);
        } else {
            readComponentReference(decoder, visitor);
        }
    }

    private void readComponentReference(Decoder decoder, ResolvedComponentVisitor visitor) throws IOException {