package stdlib

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

Dependency Relation
	imports 5 packages, and imported by one package

Involved Source Files

	    deps.go
	    import.go
	    manifest.go
	  d stdlib.go
		Package stdlib provides a table of all exported symbols in the
		standard library, along with the version at which they first
		appeared. It also provides the import graph of std packages.
Package-Level Type Names (total 4, in which 3 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Kind int8 (basic type)
		A Kind indicates the kind of a symbol:
		function, variable, constant, type, and so on.

		Methods (only one, which is exported)
			( Kind) String() string
		Implements (at least 4, in which 2 are exported)
			 Kind : expvar.Var
			 Kind : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 Kind : context.stringer
			 Kind : runtime.stringer
		As Types Of (total 7, all are exported)
			const Const
			const Field
			const Func
			const Invalid
			const Method
			const Type
			const Var

	 type Symbol (struct)

		Fields (total 4, all are exported)
			Kind Kind
			Name string
			Signature string
				Signature provides the type of a function (defined only for Kind=Func).
				Imported types are denoted as pkg.T; pkg is not fully qualified.
				TODO(adonovan): use an unambiguous encoding that is parseable.
				
				Example2:
				   func[M ~map[K]V, K comparable, V any](m M) M
				   func(fi fs.FileInfo, link string) (*Header, error)
				// if Kind == stdlib.Func

			Version Version
				// Go version that first included the symbol

		Methods (total 2, both are exported)
			(*Symbol) SplitField() (typename, name string)
				SplitField splits the field symbol name into type and field
				components. It must be called only on Field symbols.
				
				Example: "File.Package" -> ("File", "Package")

			(*Symbol) SplitMethod() (ptr bool, recv, name string)
				SplitMethod splits the method symbol name into pointer, receiver,
				and method components. It must be called only on Method symbols.
				
				Example: "(*Buffer).Grow" -> (true, "Buffer", "Grow")


	 type Version int8 (basic type)
		A Version represents a version of Go of the form "go1.%d".

		Methods (only one, which is exported)
			( Version) String() string
				String returns a version string of the form "go1.23", without allocating.

		Implements (at least 4, in which 2 are exported)
			 Version : expvar.Var
			 Version : fmt.Stringer
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 Version : context.stringer
			 Version : runtime.stringer
		As Types Of (only one, which is exported)
			const BootstrapVersion

	/* one unexported ... *//* one unexported: */
	 type pkginfo (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			deps string
				// list of indices of dependencies, as varint-encoded deltas

			name string


Package-Level Functions (total 6, in which 4 are exported)

	 func Dependencies(pkgs ...string) iter.Seq[string]
		Dependencies returns the set of all dependencies of the named
		standard packages, including the initial package,
		in a deterministic topological order.
		The dependencies of an unknown package are the empty set.
		
		The graph is built into the application and may differ from the
		graph in the Go source tree being analyzed by the application.

	 func HasPackage(path string) bool
		HasPackage reports whether the specified package path is part of
		the standard library's public API.

	 func Imports(pkgs ...string) iter.Seq[string]
		Imports returns the sequence of packages directly imported by the
		named standard packages, in name order.
		The imports of an unknown package are the empty set.
		
		The graph is built into the application and may differ from the
		graph in the Go source tree being analyzed by the application.

	 func IsBootstrapPackage(pkg string) bool
		IsBootstrapPackage reports whether pkg is one of the low-level
		packages in the Go distribution that must compile with the older
		language version specified by [BootstrapVersion] during toolchain
		bootstrapping; see golang.org/s/go15bootstrap.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func find(pkg string) (int, bool)
		find returns the index of pkg in the deps table.

	 func init()
Package-Level Variables (total 4, in which 1 is exported)

	  var PackageSymbols map[string][]Symbol
	/* 3 unexporteds ... *//* 3 unexporteds: */
	  var bootstrap map[string]bool
		bootstrap is the list of bootstrap packages extracted from cmd/dist.

	  var deps [380]pkginfo
	  var versions [30]string // (increase constant as needed)
Package-Level Constants (total 8, all are exported)

	const BootstrapVersion Version = 24 // go1.24.6
		BootstrapVersion is the minor version of Go used during toolchain
		bootstrapping. Packages for which [IsBootstrapPackage] must not use
		features of Go newer than this version.

	const Const Kind = 4 // "Pi"
	const Field Kind = 5 // "Point.X"
	const Func Kind = 2 // "Println"
	const Invalid Kind = 0 // Example name:
	const Method Kind = 6 // "(*Buffer).Grow" or "(Reader).Read"
	const Type Kind = 1 // "Buffer"
	const Var Kind = 3 // "EOF"

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