package versions

Import Path
	golang.org/x/tools/internal/versions (on go.dev)

Dependency Relation
	imports 3 packages, and imported by 2 packages

Involved Source Files

	    features.go
	    gover.go
	    toolchain.go
	    toolchain_go119.go
	    toolchain_go120.go
	    toolchain_go121.go
	    types.go
	    types_go122.go
	    versions.go
Package-Level Type Names (only one, which is unexported)

	/* sort exporteds by: alphabet | popularity */
	/* one unexported ... *//* one unexported: */
	 type gover (struct)
		A gover is a parsed Go gover: major[.Minor[.Patch]][kind[pre]]
		The numbers are the original decimal strings to avoid integer overflows
		and since there is very little actual math. (Probably overflow doesn't matter in practice,
		but at the time this code was written, there was an existing test that used
		go1.99999999999, which does not fit in an int on 32-bit platforms.
		The "big decimal" representation avoids the problem entirely.)

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			kind string
				// "", "alpha", "beta", "rc"

			major string
				// decimal

			minor string
				// decimal or ""

			patch string
				// decimal or ""

			pre string
				// decimal or ""

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func parse(x string) gover


Package-Level Functions (total 18, in which 8 are exported)

	 func AtLeast(v, release string) bool
		AtLeast reports whether the file version v comes after a Go release.
		
		Use this predicate to enable a behavior once a certain Go release
		has happened (and stays enabled in the future).

	 func Before(v, release string) bool
		Before reports whether the file version v is strictly before a Go release.
		
		Use this predicate to disable a behavior once a certain Go release
		has happened (and stays enabled in the future).

	 func Compare(x, y string) int
		Compare returns -1, 0, or +1 depending on whether
		x < y, x == y, or x > y, interpreted as Go versions.
		The versions x and y must begin with a "go" prefix: "go1.21" not "1.21".
		Invalid versions, including the empty string, compare less than
		valid versions and equal to each other.
		The language version "go1.21" compares less than the
		release candidate and eventual releases "go1.21rc1" and "go1.21.0".
		Custom toolchain suffixes are ignored during comparison:
		"go1.21.0" and "go1.21.0-bigcorp" are equal.

	 func FileVersion(info *types.Info, file *ast.File) string
		FileVersion returns a file's Go version.
		The reported version is an unknown Future version if a
		version cannot be determined.

	 func GoVersion(pkg *types.Package) string
		GoVersion returns the Go version of the type package.
		It returns zero if no version can be determined.

	 func InitFileVersions(info *types.Info)
		InitFileVersions initializes info to record Go versions for Go files.

	 func IsValid(x string) bool
		IsValid reports whether the version x is valid.

	 func Lang(x string) string
		Lang returns the Go language version for version x.
		If x is not a valid version, Lang returns the empty string.
		For example:
		
			Lang("go1.21rc2") = "go1.21"
			Lang("go1.21.2") = "go1.21"
			Lang("go1.21") = "go1.21"
			Lang("go1") = "go1"
			Lang("bad") = ""
			Lang("1.21") = ""

	/* 10 unexporteds ... *//* 10 unexporteds: */
	 func cmpInt(x, y string) int
		cmpInt returns cmp.Compare(x, y) interpreting x and y as decimal numbers.
		(Copied from golang.org/x/mod/semver's compareInt.)

	 func compare(x, y string) int
		compare returns -1, 0, or +1 depending on whether
		x < y, x == y, or x > y, interpreted as toolchain versions.
		The versions x and y must not begin with a "go" prefix: just "1.21" not "go1.21".
		Malformed versions compare less than well-formed versions and equal to each other.
		The language version "1.21" compares less than the release candidate and eventual releases "1.21rc1" and "1.21.0".

	 func cutInt(x string) (n, rest string, ok bool)
		cutInt scans the leading decimal number at the start of x to an integer
		and returns that value and the rest of the string.

	 func init()
	 func init()
	 func init()
	 func isValid(x string) bool
		isValid reports whether the version x is valid.

	 func lang(x string) string
		lang returns the Go language version. For example, lang("1.2.3") == "1.2".

	 func parse(x string) gover
		parse parses the Go version string x into a version.
		It returns the zero version if x is malformed.

	 func stripGo(v string) string
		stripGo converts from a "go1.21" version to a "1.21" version.
		If v does not start with "go", stripGo returns the empty string (a known invalid version).


Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var toolchain string
		toolchain is maximum version (<1.22) that the go toolchain used
		to build the current tool is known to support.
		
		When a tool is built with >=1.22, the value of toolchain is unused.
		
		x/tools does not support building with go <1.18. So we take this
		as the minimum possible maximum.


Package-Level Constants (total 6, all are exported)

	const Future = ""
		Future is an invalid unknown Go version sometime in the future.
		Do not use directly with Compare.

	const Go1_18 = "go1.18"
		GoVersions that features in x/tools can be gated to.

	const Go1_19 = "go1.19"
		GoVersions that features in x/tools can be gated to.

	const Go1_20 = "go1.20"
		GoVersions that features in x/tools can be gated to.

	const Go1_21 = "go1.21"
		GoVersions that features in x/tools can be gated to.

	const Go1_22 = "go1.22"
		GoVersions that features in x/tools can be gated to.

The pages are generated with Golds v0.7.6. (GOOS=linux GOARCH=amd64)