// (limited by the size of fd_set).
//
// 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,

	case goos == "freebsd":
		// Keep pre-FreeBSD 10 / non-POSIX 2008 names for timespec fields
		re := regexp.MustCompile("(A|M|C|Birth)tim\\s+Timespec")
		s = re.ReplaceAllString(s, "${1}timespec Timespec")
	}

	// gofmt
	b, err = format.Source([]byte(s))
	if err != nil {
		log.Fatal(err)
	}

	// Append this command to the header to show where the new file
	// came from.

	}

	tmplOut := new(bytes.Buffer)
	tmpl := template.Must(template.New("zosarch").Parse(zosarchTmpl))
	err = tmpl.Execute(tmplOut, entries)
	if err != nil {
		t.Fatal(err)
	}

	cmd = testenv.Command(t, "gofmt")
	cmd.Stdin = bytes.NewReader(tmplOut.Bytes())
	want, err := cmd.Output()
	if err != nil {
		t.Logf("stdin:\n%s", tmplOut.Bytes())
		if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {

  - type: input
    id: go-toolchain
    attributes:
      label: Changes to Go ToolChain
      description: "How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected? "
    validations:
      required: false

  - type: input
    id: perf-costs
    attributes:
      label: Performance Costs

	for _, s := range sizes {
		fmt.Fprintf(w, "  testCopy%d(t)\n", s)
	}
	for _, s := range usizes {
		fmt.Fprintf(w, "  testUnalignedCopy%d(t)\n", s)
	}
	fmt.Fprintf(w, "}\n")

	// gofmt result
	b := w.Bytes()
	src, err := format.Source(b)
	if err != nil {
		fmt.Printf("%s\n", b)
		panic(err)
	}

	// write to file
	err = os.WriteFile("../copy_test.go", src, 0666)
	if err != nil {

func f7(func(int) MyBool)             {}
func f8(func(MyInt, MyString) MyBool) {}

func test() {
	// TODO: Would be nice to 'for range T.M' and 'for range (*T).PM' directly,
	// but there is no gofmt-friendly way to write the error pattern in the right place.
	m1 := T.M
	for range m1 /* ERROR "cannot range over m1 (variable of type func(T)): func must be func(yield func(...) bool): argument is not func" */ {
	}
	m2 := (*T).PM

	p.output = append(p.output, block...)
	p.output = append(p.output, after...)
}

// appendLines is like append(x, y...)
// but it avoids creating doubled blank lines,
// which would not be gofmt-standard output.
// It assumes that only whole blocks of lines are being appended,
// not line fragments.
func appendLines(x, y []byte) []byte {
	if len(y) > 0 && isNL(y[0]) && // y starts in blank line

			case "api", "dist", "distpack", "metadata":
				return false
			}
		}
		return true
	})

	// Add go and gofmt to bin, using cross-compiled binaries
	// if this is a cross-compiled distribution.
	binExes := []string{
		"go",
		"gofmt",
	}
	crossBin := "bin"
	if goos != gohostos || goarch != gohostarch {
		crossBin = "bin/" + goosUnderGoarch
	}
	for _, b := range binExes {

					want = want[:len(want)-1]
				}
				var out []byte
				switch f.Name {
				default:
					t.Fatalf("unknown output file %q", f.Name)
				case "dump":
					out = dump(d)
				case "gofmt":
					out = pr.Comment(d)
				case "html":
					out = pr.HTML(d)
				case "markdown":
					out = pr.Markdown(d)
				case "text":
					out = pr.Text(d)
				}
				if string(out) != string(want) {

	for _, s := range sizes {
		fmt.Fprintf(w, "  testZero%d(t)\n", s)
	}
	for _, s := range usizes {
		fmt.Fprintf(w, "  testZero%du(t)\n", s)
	}
	fmt.Fprintf(w, "}\n")

	// gofmt result
	b := w.Bytes()
	src, err := format.Source(b)
	if err != nil {
		fmt.Printf("%s\n", b)
		panic(err)
	}

	// write to file
	err = os.WriteFile("../zero_test.go", src, 0666)
	if err != nil {