mainModule,
				{Path: "go", Version: goVersion},
				{Path: "toolchain", Version: gover.LocalToolchain()},
			}
		} else {
			goVersion = gover.Local()
			pruning = pruningForGoVersion(goVersion)
			roots = []module.Version{
				{Path: "go", Version: goVersion},
				{Path: "toolchain", Version: gover.LocalToolchain()},
			}
		}
		rawGoVersion.Store(mainModule, goVersion)

	"context"
	"errors"
	"fmt"
	"strings"
)

// FromToolchain returns the Go version for the named toolchain,
// derived from the name itself (not by running the toolchain).
// A toolchain is named "goVERSION".
// A suffix after the VERSION introduced by a -, space, or tab is removed.
// Examples:
//
//	FromToolchain("go1.2.3") == "1.2.3"
//	FromToolchain("go1.2.3-bigcorp") == "1.2.3"
//	FromToolchain("invalid") == ""

	// awkwardness from the user.
	bi.GoVersion = runtime.Version()

	return bi, true
}

// BuildInfo represents the build information read from a Go binary.
type BuildInfo struct {
	// GoVersion is the version of the Go toolchain that built the binary
	// (for example, "go1.19.2").
	GoVersion string

	// Path is the package path of the main package for the binary

				m.Version = q.Version
				m.Time = &q.Time
			}
		}

		if m.GoVersion == "" && checksumOk("/go.mod") {
			// Load the go.mod file to determine the Go version, since it hasn't
			// already been populated from rawGoVersion.
			if summary, err := rawGoModSummary(mod); err == nil && summary.goVersion != "" {
				m.GoVersion = summary.goVersion
			}
		}

		if m.Version != "" {
			if checksumOk("/go.mod") {

}

func main() {
	telemetry.Start()
	flag.Usage = usage
	flag.Parse()
	telemetry.Inc("fix/invocations")
	telemetry.CountFlags("fix/flag:", *flag.CommandLine)

	if !version.IsValid(*goVersion) {
		report(fmt.Errorf("invalid -go=%s", *goVersion))
		os.Exit(exitCode)
	}

	sort.Sort(byDate(fixes))

	if *allowedRewrites != "" {
		allowed = make(map[string]bool)
		for _, f := range strings.Split(*allowedRewrites, ",") {

					// information to accurately correlate with the stderr output.
				} else {
					t.Parallel()
				}
			} else {
				old := *goVersion
				*goVersion = tt.Version
				defer func() {
					*goVersion = old
				}()
			}

			// Apply fix: should get tt.Out.
			out, fixed, ok := parseFixPrint(t, tt.Fn, tt.Name, tt.In, true)
			if !ok {
				return
			}

// See the License for the specific language governing permissions and
// limitations under the License.

package k8sversion

import (
	"fmt"

	goversion "github.com/hashicorp/go-version"
	"k8s.io/apimachinery/pkg/version"

	"istio.io/istio/operator/pkg/util/clog"
	"istio.io/istio/pkg/kube"
	pkgVersion "istio.io/istio/pkg/version"
)

const (

cmpenv go.work $WORK/go.work.want

-- go.mod --
module example
go 1.18
-- dir/go.mod --
module example
go 1.18
-- dir/foo/bar/go.mod --
module example
go 1.18
-- $WORK/go.work.want --
go $goversion

use (
	.
	..
	./foo/bar

			}
		}
		if summary.goVersion != "" && gover.Compare(summary.goVersion, gover.GoStrictVersion) >= 0 {
			if gover.Compare(summary.goVersion, gover.Local()) > 0 {
				return nil, &gover.TooNewError{What: "module " + m.String(), GoVersion: summary.goVersion}
			}
			summary.require = append(summary.require, module.Version{Path: "go", Version: summary.goVersion})
		}
		if len(f.Retract) > 0 {

// license that can be found in the LICENSE file.

//go:build !go1.21

package cgocall

import "go/types"

func setGoVersion(tc *types.Config, pkg *types.Package) {
	// no types.Package.GoVersion until Go 1.21