return n.doChildren(do)
}

// Visit visits each non-nil node x in the IR tree rooted at n
// in a depth-first preorder traversal, calling visit on each node visited.
func Visit(n Node, visit func(Node)) {
	if n == nil {
		return
	}
	var do func(Node) bool
	do = func(x Node) bool {
		visit(x)
		return DoChildren(x, do)
	}
	do(n)
}

// VisitList calls Visit(x, visit) for each node x in the list.

    stat.getCollectionExpression().visit(this);
    stat.setLoopBlock(replace(stat.getLoopBlock()));
  }

  @Override
  public void visitWhileLoop(WhileStatement stat) {
    stat.getBooleanExpression().visit(this);
    stat.setLoopBlock(replace(stat.getLoopBlock()));
  }

  @Override
  public void visitDoWhileLoop(DoWhileStatement stat) {
    stat.getBooleanExpression().visit(this);

    def artifact1 = Mock(TestArtifact)
    def artifact2 = Mock(TestArtifact)

    def "visits empty variant"() {
        def visitor = Mock(ResolvedArtifactSet.Visitor)
        def set1 = of([])

        when:
        set1.artifacts.visit(visitor)

        then:
        0 * _
    }

    def "visits local artifacts of empty variant"() {
        def visitor = Mock(ResolvedArtifactSet.TransformSourceVisitor)

                    node.content.forEach(::visit)
                }

                is DeclarativeDocument.DocumentNode.PropertyNode -> {
                    visit(node.value)
                }

                is DeclarativeDocument.ValueNode.ValueFactoryNode -> {
                    node.values.forEach(::visit)
                }

                is DeclarativeDocument.DocumentNode.ErrorNode,

        then:
        output.count("visit ") == 3
        outputContains("visit one.txt")
        outputContains("visit a")
        outputContains("visit a/two.txt")

        when:
        file("src/a/three.txt").createFile()
        run "source"

        then:
        output.count("visit ") == 4
        outputContains("visit one.txt")
        outputContains("visit a")
        outputContains("visit a/two.txt")

      void visitParameterizedType(ParameterizedType t) {
        visit(t.getActualTypeArguments());
      }

      @Override
      void visitTypeVariable(TypeVariable<?> t) {
        visit(t.getBounds());
      }
    }.visit(type);
  }

  private static void assertVisited(Type type) {
    TypeVisitor visitor = new BaseTypeVisitor();
    try {
      visitor.visit(type);
      fail("Type not visited");

	case *ast.CommClause:
		f.walk(n.Comm, ctxStmt, visit)
		f.walk(n.Body, ctxStmt, visit)
	case *ast.SelectStmt:
		f.walk(n.Body, ctxStmt, visit)
	case *ast.ForStmt:
		f.walk(n.Init, ctxStmt, visit)
		f.walk(&n.Cond, ctxExpr, visit)
		f.walk(n.Post, ctxStmt, visit)
		f.walk(n.Body, ctxStmt, visit)
	case *ast.RangeStmt:
		f.walk(&n.Key, ctxExpr, visit)
		f.walk(&n.Value, ctxExpr, visit)

        when:
        fileTree.visit(visitor)

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

    def "include inner dir"() {
        fileTree = new SingleIncludePatternFileTree(tempDir.testDirectory, "dir2")

        when:
        fileTree.visit(visitor)

        then:

	return i.Mapping
}

// VisitorList implements Visit for the sub visitors it contains. The first error
// returned from a child Visitor will terminate iteration.
type VisitorList []Visitor

// Visit implements Visitor
func (l VisitorList) Visit(fn VisitorFunc) error {
	for i := range l {
		if err := l[i].Visit(fn); err != nil {
			return err
		}
	}
	return nil
}

        dir.file("a/b/empty").createDir()

        when:
        walker.visit(dir, visitor)

        then:
        1 * visitor.visit({ it.name == "a.class" }) >> { ClasspathEntryVisitor.Entry entry ->
            assert entry.path.toString() == "a.class"
            assert Arrays.equals(entry.content, "a".bytes)
        }
        1 * visitor.visit({ it.name == "a/b/c.class" }) >> { ClasspathEntryVisitor.Entry entry ->