cd m1
go mod tidy

go list -f '{{if eq .ImportPath "example.com/generics"}}{{.Module.GoVersion}}{{end}}' -deps -test example.com/m2/q
stdout 1.18
[!short] go test -o $devnull -c all

cat go.sum
replace 'example.com/generics v1.0.0/go.mod' 'example.com/notgenerics v1.0.0/go.mod' go.sum

! go list -f '{{if eq .ImportPath "example.com/generics"}}{{.Module.GoVersion}}{{end}}' -deps -test example.com/m2/q

			s.addTooNew(e)
		}

	case interface{ Unwrap() error }:
		s.addTooNew(err.Unwrap())

	case *gover.TooNewError:
		if s.TooNew == nil ||
			gover.Compare(err.GoVersion, s.TooNew.GoVersion) > 0 ||
			gover.Compare(err.GoVersion, s.TooNew.GoVersion) == 0 && err.What < s.TooNew.What {
			s.TooNew = err
		}
	}
}

// NeedSwitch reports whether Switch would attempt to switch toolchains.

		if prog.Program == meta["Program"] && prog.Version == meta["Version"] &&
			prog.GoVersion == meta["GoVersion"] && prog.GOOS == meta["GOOS"] &&
			prog.GOARCH == meta["GOARCH"] {
			return prog
		}
	}
	prog := telemetry.ProgramReport{
		Program:   meta["Program"],
		Version:   meta["Version"],
		GoVersion: meta["GoVersion"],
		GOOS:      meta["GOOS"],
		GOARCH:    meta["GOARCH"],

func IsVersionString(path string) bool {
	_, err := goversion.NewSemver(path)
	if err != nil {
		return false
	}
	vs := Version{}
	return yaml.Unmarshal([]byte(path), &vs) == nil
}

// TagToVersionString converts an istio container tag into a version string
func TagToVersionString(path string) (string, error) {
	path = strings.TrimPrefix(path, releasePrefix)
	ver, err := goversion.NewSemver(path)
	if err != nil {
		return "", err

	modload.ForceUseModules = true
	modload.RootMode = modload.NeedRoot

	goVersion := tidyGo.String()
	if goVersion != "" && gover.Compare(gover.Local(), goVersion) < 0 {
		toolchain.SwitchOrFatal(ctx, &gover.TooNewError{
			What:      "-go flag",
			GoVersion: goVersion,
		})
	}

	modload.LoadPackages(ctx, modload.PackageOpts{
		TidyGoVersion:            tidyGo.String(),

	Minor        string `json:"minor"`
	GitVersion   string `json:"gitVersion"`
	GitCommit    string `json:"gitCommit"`
	GitTreeState string `json:"gitTreeState"`
	BuildDate    string `json:"buildDate"`
	GoVersion    string `json:"goVersion"`
	Compiler     string `json:"compiler"`
	Platform     string `json:"platform"`
}

// String returns info as a human-friendly version string.
func (info Info) String() string {
	return info.GitVersion

		io.WriteString(w, line)

		goVersion := ""
		if includeGoVersions {
			goVersion = modload.ModuleInfo(ctx, m.Path).GoVersion
		}
		switch {
		case isExplicit[m] && goVersion != "":
			fmt.Fprintf(w, "## explicit; go %s\n", goVersion)
		case isExplicit[m]:
			io.WriteString(w, "## explicit\n")
		case goVersion != "":
			fmt.Fprintf(w, "## go %s\n", goVersion)
		}

		pkgs := modpkgs[m]

	}
	return NewConfig(&cfg), nil
}

func NewConfig(cfg *telemetry.UploadConfig) *Config {
	ucfg := Config{UploadConfig: cfg}
	ucfg.goos = set(ucfg.GOOS)
	ucfg.goarch = set(ucfg.GOARCH)
	ucfg.goversion = set(ucfg.GoVersion)
	ucfg.program = make(map[string]bool, len(ucfg.Programs))
	ucfg.pgversion = make(map[pgkey]bool, len(ucfg.Programs))
	ucfg.pgcounter = make(map[pgkey]bool, len(ucfg.Programs))

package telemetry

// Common types and directories used by multiple packages.

// An UploadConfig controls what data is uploaded.
type UploadConfig struct {
	GOOS       []string
	GOARCH     []string
	GoVersion  []string
	SampleRate float64
	Programs   []*ProgramConfig
}

type ProgramConfig struct {
	// the counter names may have to be
	// repeated for each program. (e.g., if the counters are in a package

					if entry == "explicit" {
						meta.Explicit = true
					}
					if goVersion, ok := strings.CutPrefix(entry, "go "); ok {
						meta.GoVersion = goVersion
						rawGoVersion.Store(mod, meta.GoVersion)
						if gover.Compare(goVersion, gover.Local()) > 0 {
							base.Fatal(&gover.TooNewError{What: mod.Path + " in " + base.ShortPath(vendorFile), GoVersion: goVersion})
						}
					}
					// All other tokens are reserved for future use.