var stack []int
	seen := make([]bool, len(check.mono.vertices))

	// We have a path that contains a cycle and ends at v, but v may
	// only be reachable from the cycle, not on the cycle itself. We
	// start by walking backwards along the path until we find a vertex
	// that appears twice.
	for !seen[v] {
		stack = append(stack, v)
		seen[v] = true
		v = check.mono.edges[check.mono.vertices[v].pre].src
	}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// IR visitors for walking the IR tree.
//
// The lowest level helpers are DoChildren and EditChildren, which
// nodes help implement and provide control over whether and when
// recursion happens during the walk of the IR.
//
// Although these are both useful directly, two simpler patterns
// are fairly common and also provided: Visit and Any.

        }));

        SyncCopyActionDecoratorFileVisitor fileVisitor = new SyncCopyActionDecoratorFileVisitor(visited, preserveSpec, deleter);

        MinimalFileTree walker = directoryFileTreeFactory.create(baseDestDir).postfix();
        walker.visit(fileVisitor);
        visited.clear();

        return WorkResults.didWork(didWork.getDidWork() || fileVisitor.didWork);
    }

func f2(done chan bool) {
	defer func() {
		recover()
		done <- true
		runtime.Goexit()
	}()
	time.Sleep(10 * time.Millisecond) // overwrote Panic struct with Timer struct
	runtime.GC()                      // walked gp->panic list, found mangled Panic struct, crashed
	panic("p")

stderr '404 Not Found'

# get should walk down the proxy list past 404 and 410 responses.
env GOPROXY=$proxy/404,$proxy/410,$proxy
go get rsc.io/quote@v1.1.0

# get should not walk past other 4xx errors if proxies are separated with ','.
env GOPROXY=$proxy/403,$proxy
! go get rsc.io/quote@v1.2.0
stderr 'reading.*/403/rsc.io/.*: 403 Forbidden'

# get should not walk past non-4xx errors if proxies are separated with ','.

package ast_test

import (
	"go/ast"
	"go/parser"
	"go/token"
	"testing"
)

func TestPreorderBreak(t *testing.T) {
	// This test checks that Preorder correctly handles a break statement while
	// in the middle of walking a node. Previously, incorrect handling of the
	// boolean returned by the yield function resulted in the iterator calling
	// yield for sibling nodes even after yield had returned false. With that

    /**
     * Whether the {@link FileVisitor} should receive the files in a reproducible order independent of the underlying file system.
     *
     * @return <code>true</code> if files should be walked in a reproducible order.
     */
    boolean isReproducibleFileOrder();

//
// Go does not use select, so it should not be subject to these limits.
// On some systems the limit is 256, which is very easy to run into,
// even in simple programs like gofmt when they parallelize walking
// a file tree.
//
// After a long discussion on go.dev/issue/46279, we decided the
// best approach was for Go to raise the limit unconditionally for itself,
// and then leave old software to set the limit back as needed.

	script, err := os.ReadFile("testdata/script/chdir.txt")
	if err != nil {
		t.Fatal(err)
	}

	var walk func(string, *base.Command)
	walk = func(name string, cmd *base.Command) {
		if len(cmd.Commands) > 0 {
			for _, sub := range cmd.Commands {
				walk(name+" "+sub.Name(), sub)
			}
			return
		}
		if !cmd.Runnable() {
			return
		}
		if cmd.CustomFlags {

stdout '^\[h.go i.go\]$'

# Overlay that removes a file from a directory
! go list ./dir3 # contains a file without a package statement
go list -overlay overlay.json -f '{{.GoFiles}}' ./dir3 # overlay removes that file

# Walking through an overlay
go list -overlay overlay.json ./...
cmp stdout want-list.txt

# TODO(#39958): assembly files, C files, files that require cgo preprocessing

-- want-list.txt --
m
m/dir
m/dir2
m/dir3