isMapIndex(pass.TypesInfo, lhs) {
				continue // expressions may not be equal
			}
			if reflect.TypeOf(lhs) != reflect.TypeOf(rhs) {
				continue // short-circuit the heavy-weight gofmt check
			}
			le := analysisutil.Format(pass.Fset, lhs)
			re := analysisutil.Format(pass.Fset, rhs)
			if le == re {
				pass.Report(analysis.Diagnostic{

// (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,

  - 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

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) {

func (s *ServerRunOptions) Flags() (fss cliflag.NamedFlagSets) {
	s.Options.AddFlags(&fss)
	s.CloudProvider.AddFlags(fss.FlagSet("cloud provider"))

	// Note: the weird ""+ in below lines seems to be the only way to get gofmt to
	// arrange these text blocks sensibly. Grrr.
	fs := fss.FlagSet("misc")

	fs.BoolVar(&s.AllowPrivileged, "allow-privileged", s.AllowPrivileged,
		"If true, allow privileged containers. [default=false]")

# These ideally run in less than 10s.
QUICK_PATTERNS+=(
  "verify-api-groups.sh"
  "verify-boilerplate.sh"
  "verify-external-dependencies-version.sh"
  "verify-fieldname-docs.sh"
  "verify-gofmt.sh"
  "verify-imports.sh"
  "verify-non-mutating-validation.sh"
  "verify-pkg-names.sh"
  "verify-readonly-packages.sh"
  "verify-spelling.sh"
  "verify-staging-client-go.sh"
  "verify-staging-meta-files.sh"

		genAllocator(w, a)
	}
	for _, d := range deriveds {
		for _, base := range allocators {
			if base.name == d.base {
				genDerived(w, d, base)
				break
			}
		}
	}
	// gofmt result
	b := w.Bytes()
	var err error
	b, err = format.Source(b)
	if err != nil {
		fmt.Printf("%s\n", w.Bytes())
		panic(err)
	}

	if err := os.WriteFile("../allocators.go", b, 0666); err != nil {