for i := range l.visitors {
		i := i
		g.Go(func() error {
			return l.visitors[i].Visit(fn)
		})
	}

	return g.Wait()
}

// EagerVisitorList implements Visit for the sub visitors it contains. All errors
// will be captured and returned at the end of iteration.
type EagerVisitorList []Visitor

// Visit implements Visitor, and gathers errors that occur during processing until
// all sub visitors have been visited.

	"istio.io/istio/pkg/util/istiomultierror"
)

// Visitor is performs a partial check operation on a single message.
type Visitor func(echoClient.Response) error

// Visit is a utility method that just invokes this Visitor function on the given response.
func (v Visitor) Visit(r echoClient.Response) error {
	return v(r)
}

// And returns a Visitor that performs a logical AND of this Visitor and the one provided.

	// has been changed.
	// +optional
	NestedValueValidation func(vv *NestedValueValidation) bool
}

// Visit recursively walks through the structural schema and calls the given callbacks
// at each node of those types.
func (m *Visitor) Visit(s *Structural) {
	m.visitStructural(s)
}

func (m *Visitor) visitStructural(s *Structural) bool {
	ret := false
	if m.Structural != nil {
		ret = m.Structural(s)
	}

#include "mlir/IR/Visitors.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

namespace mlir {
namespace TF {

WalkResult WalkReachableFunctions(
    func::FuncOp func,
    llvm::function_ref<WalkResult(func::FuncOp)> callback,
    SymbolTableCollection* symbol_table) {
  llvm::SmallDenseSet<Operation*> visited;

  llvm::SmallVector<func::FuncOp> stack;

#include "mlir/IR/SymbolTable.h"  // from @llvm-project
#include "mlir/IR/Visitors.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project

namespace mlir {
namespace TF {

// Walks the function by following function call chains and calling the callback
// for each reachable function (including `func`). Each function is visited only
// once even if it's called from multiple places and/or recursively.
//

            protected void visitChildren(Consumer<FileCollectionInternal> visitor) {
                visitor.accept(child1)
                visitor.accept(child2)
            }
        }
        def visitor = Mock(FileCollectionStructureVisitor)

        when:
        collection.visitStructure(visitor)

        then:
        1 * visitor.startVisit(FileCollectionInternal.OTHER, collection) >> true

        fileTree.visit(visitor)

        then:
        1 * visitor.visitDir({ it.file == tempDir.file("dir1") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir3") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir1") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir2") })

        when:
        visitor.stopOn = rootFile2
        fileTree.visit(visitor)

        then:
        visitor.visited == [rootFile1, rootFile2]

        when:
        visitor = new TestVisitor(true)
        visitor.stopOn = dirFile1
        fileTree.visit(visitor)

        then:
        visitor.visited == [rootFile1, rootFile2, dir1, dirFile1]

        where:

                visitFile(file, prefix + file.getName(), visitor);
            } else if (fileMetadata.getType() == FileType.Directory) {
                visitDir(file, prefix + file.getName() + "/", visitor);
            }
        }
    }

    private void visitFile(File file, String name, ClasspathEntryVisitor visitor) throws IOException {
        visitor.visit(new FileEntry(name, file));
    }

        visitAnnotatedProperties(propertyWalker, task, validationContext, visitor);
        visitRegisteredProperties(task, visitor);
    }

    private static void visitRegisteredProperties(TaskInternal task, PropertyVisitor visitor) {
        task.getInputs().visitRegisteredProperties(visitor);
        task.getOutputs().visitRegisteredProperties(visitor);