gtsocial-umbx

packages.go (42539B)

---

 // Copyright 2018 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package packages
 
 // See doc.go for package documentation and implementation notes.
 
 import (
 	"context"
 	"encoding/json"
 	"fmt"
 	"go/ast"
 	"go/parser"
 	"go/scanner"
 	"go/token"
 	"go/types"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
 	"runtime"
 	"strings"
 	"sync"
 	"time"
 
 	"golang.org/x/tools/go/gcexportdata"
 	"golang.org/x/tools/internal/gocommand"
 	"golang.org/x/tools/internal/packagesinternal"
 	"golang.org/x/tools/internal/typeparams"
 	"golang.org/x/tools/internal/typesinternal"
 )
 
 // A LoadMode controls the amount of detail to return when loading.
 // The bits below can be combined to specify which fields should be
 // filled in the result packages.
 // The zero value is a special case, equivalent to combining
 // the NeedName, NeedFiles, and NeedCompiledGoFiles bits.
 // ID and Errors (if present) will always be filled.
 // Load may return more information than requested.
 type LoadMode int
 
 const (
 	// NeedName adds Name and PkgPath.
 	NeedName LoadMode = 1 << iota
 
 	// NeedFiles adds GoFiles and OtherFiles.
 	NeedFiles
 
 	// NeedCompiledGoFiles adds CompiledGoFiles.
 	NeedCompiledGoFiles
 
 	// NeedImports adds Imports. If NeedDeps is not set, the Imports field will contain
 	// "placeholder" Packages with only the ID set.
 	NeedImports
 
 	// NeedDeps adds the fields requested by the LoadMode in the packages in Imports.
 	NeedDeps
 
 	// NeedExportFile adds ExportFile.
 	NeedExportFile
 
 	// NeedTypes adds Types, Fset, and IllTyped.
 	NeedTypes
 
 	// NeedSyntax adds Syntax.
 	NeedSyntax
 
 	// NeedTypesInfo adds TypesInfo.
 	NeedTypesInfo
 
 	// NeedTypesSizes adds TypesSizes.
 	NeedTypesSizes
 
 	// needInternalDepsErrors adds the internal deps errors field for use by gopls.
 	needInternalDepsErrors
 
 	// needInternalForTest adds the internal forTest field.
 	// Tests must also be set on the context for this field to be populated.
 	needInternalForTest
 
 	// typecheckCgo enables full support for type checking cgo. Requires Go 1.15+.
 	// Modifies CompiledGoFiles and Types, and has no effect on its own.
 	typecheckCgo
 
 	// NeedModule adds Module.
 	NeedModule
 
 	// NeedEmbedFiles adds EmbedFiles.
 	NeedEmbedFiles
 
 	// NeedEmbedPatterns adds EmbedPatterns.
 	NeedEmbedPatterns
 )
 
 const (
 	// Deprecated: LoadFiles exists for historical compatibility
 	// and should not be used. Please directly specify the needed fields using the Need values.
 	LoadFiles = NeedName | NeedFiles | NeedCompiledGoFiles
 
 	// Deprecated: LoadImports exists for historical compatibility
 	// and should not be used. Please directly specify the needed fields using the Need values.
 	LoadImports = LoadFiles | NeedImports
 
 	// Deprecated: LoadTypes exists for historical compatibility
 	// and should not be used. Please directly specify the needed fields using the Need values.
 	LoadTypes = LoadImports | NeedTypes | NeedTypesSizes
 
 	// Deprecated: LoadSyntax exists for historical compatibility
 	// and should not be used. Please directly specify the needed fields using the Need values.
 	LoadSyntax = LoadTypes | NeedSyntax | NeedTypesInfo
 
 	// Deprecated: LoadAllSyntax exists for historical compatibility
 	// and should not be used. Please directly specify the needed fields using the Need values.
 	LoadAllSyntax = LoadSyntax | NeedDeps
 
 	// Deprecated: NeedExportsFile is a historical misspelling of NeedExportFile.
 	NeedExportsFile = NeedExportFile
 )
 
 // A Config specifies details about how packages should be loaded.
 // The zero value is a valid configuration.
 // Calls to Load do not modify this struct.
 type Config struct {
 	// Mode controls the level of information returned for each package.
 	Mode LoadMode
 
 	// Context specifies the context for the load operation.
 	// If the context is cancelled, the loader may stop early
 	// and return an ErrCancelled error.
 	// If Context is nil, the load cannot be cancelled.
 	Context context.Context
 
 	// Logf is the logger for the config.
 	// If the user provides a logger, debug logging is enabled.
 	// If the GOPACKAGESDEBUG environment variable is set to true,
 	// but the logger is nil, default to log.Printf.
 	Logf func(format string, args ...interface{})
 
 	// Dir is the directory in which to run the build system's query tool
 	// that provides information about the packages.
 	// If Dir is empty, the tool is run in the current directory.
 	Dir string
 
 	// Env is the environment to use when invoking the build system's query tool.
 	// If Env is nil, the current environment is used.
 	// As in os/exec's Cmd, only the last value in the slice for
 	// each environment key is used. To specify the setting of only
 	// a few variables, append to the current environment, as in:
 	//
 	//	opt.Env = append(os.Environ(), "GOOS=plan9", "GOARCH=386")
 	//
 	Env []string
 
 	// gocmdRunner guards go command calls from concurrency errors.
 	gocmdRunner *gocommand.Runner
 
 	// BuildFlags is a list of command-line flags to be passed through to
 	// the build system's query tool.
 	BuildFlags []string
 
 	// modFile will be used for -modfile in go command invocations.
 	modFile string
 
 	// modFlag will be used for -modfile in go command invocations.
 	modFlag string
 
 	// Fset provides source position information for syntax trees and types.
 	// If Fset is nil, Load will use a new fileset, but preserve Fset's value.
 	Fset *token.FileSet
 
 	// ParseFile is called to read and parse each file
 	// when preparing a package's type-checked syntax tree.
 	// It must be safe to call ParseFile simultaneously from multiple goroutines.
 	// If ParseFile is nil, the loader will uses parser.ParseFile.
 	//
 	// ParseFile should parse the source from src and use filename only for
 	// recording position information.
 	//
 	// An application may supply a custom implementation of ParseFile
 	// to change the effective file contents or the behavior of the parser,
 	// or to modify the syntax tree. For example, selectively eliminating
 	// unwanted function bodies can significantly accelerate type checking.
 	ParseFile func(fset *token.FileSet, filename string, src []byte) (*ast.File, error)
 
 	// If Tests is set, the loader includes not just the packages
 	// matching a particular pattern but also any related test packages,
 	// including test-only variants of the package and the test executable.
 	//
 	// For example, when using the go command, loading "fmt" with Tests=true
 	// returns four packages, with IDs "fmt" (the standard package),
 	// "fmt [fmt.test]" (the package as compiled for the test),
 	// "fmt_test" (the test functions from source files in package fmt_test),
 	// and "fmt.test" (the test binary).
 	//
 	// In build systems with explicit names for tests,
 	// setting Tests may have no effect.
 	Tests bool
 
 	// Overlay provides a mapping of absolute file paths to file contents.
 	// If the file with the given path already exists, the parser will use the
 	// alternative file contents provided by the map.
 	//
 	// Overlays provide incomplete support for when a given file doesn't
 	// already exist on disk. See the package doc above for more details.
 	Overlay map[string][]byte
 }
 
 // driver is the type for functions that query the build system for the
 // packages named by the patterns.
 type driver func(cfg *Config, patterns ...string) (*driverResponse, error)
 
 // driverResponse contains the results for a driver query.
 type driverResponse struct {
 	// NotHandled is returned if the request can't be handled by the current
 	// driver. If an external driver returns a response with NotHandled, the
 	// rest of the driverResponse is ignored, and go/packages will fallback
 	// to the next driver. If go/packages is extended in the future to support
 	// lists of multiple drivers, go/packages will fall back to the next driver.
 	NotHandled bool
 
 	// Sizes, if not nil, is the types.Sizes to use when type checking.
 	Sizes *types.StdSizes
 
 	// Roots is the set of package IDs that make up the root packages.
 	// We have to encode this separately because when we encode a single package
 	// we cannot know if it is one of the roots as that requires knowledge of the
 	// graph it is part of.
 	Roots []string `json:",omitempty"`
 
 	// Packages is the full set of packages in the graph.
 	// The packages are not connected into a graph.
 	// The Imports if populated will be stubs that only have their ID set.
 	// Imports will be connected and then type and syntax information added in a
 	// later pass (see refine).
 	Packages []*Package
 
 	// GoVersion is the minor version number used by the driver
 	// (e.g. the go command on the PATH) when selecting .go files.
 	// Zero means unknown.
 	GoVersion int
 }
 
 // Load loads and returns the Go packages named by the given patterns.
 //
 // Config specifies loading options;
 // nil behaves the same as an empty Config.
 //
 // Load returns an error if any of the patterns was invalid
 // as defined by the underlying build system.
 // It may return an empty list of packages without an error,
 // for instance for an empty expansion of a valid wildcard.
 // Errors associated with a particular package are recorded in the
 // corresponding Package's Errors list, and do not cause Load to
 // return an error. Clients may need to handle such errors before
 // proceeding with further analysis. The PrintErrors function is
 // provided for convenient display of all errors.
 func Load(cfg *Config, patterns ...string) ([]*Package, error) {
 	l := newLoader(cfg)
 	response, err := defaultDriver(&l.Config, patterns...)
 	if err != nil {
 		return nil, err
 	}
 	l.sizes = response.Sizes
 	return l.refine(response)
 }
 
 // defaultDriver is a driver that implements go/packages' fallback behavior.
 // It will try to request to an external driver, if one exists. If there's
 // no external driver, or the driver returns a response with NotHandled set,
 // defaultDriver will fall back to the go list driver.
 func defaultDriver(cfg *Config, patterns ...string) (*driverResponse, error) {
 	driver := findExternalDriver(cfg)
 	if driver == nil {
 		driver = goListDriver
 	}
 	response, err := driver(cfg, patterns...)
 	if err != nil {
 		return response, err
 	} else if response.NotHandled {
 		return goListDriver(cfg, patterns...)
 	}
 	return response, nil
 }
 
 // A Package describes a loaded Go package.
 type Package struct {
 	// ID is a unique identifier for a package,
 	// in a syntax provided by the underlying build system.
 	//
 	// Because the syntax varies based on the build system,
 	// clients should treat IDs as opaque and not attempt to
 	// interpret them.
 	ID string
 
 	// Name is the package name as it appears in the package source code.
 	Name string
 
 	// PkgPath is the package path as used by the go/types package.
 	PkgPath string
 
 	// Errors contains any errors encountered querying the metadata
 	// of the package, or while parsing or type-checking its files.
 	Errors []Error
 
 	// TypeErrors contains the subset of errors produced during type checking.
 	TypeErrors []types.Error
 
 	// GoFiles lists the absolute file paths of the package's Go source files.
 	GoFiles []string
 
 	// CompiledGoFiles lists the absolute file paths of the package's source
 	// files that are suitable for type checking.
 	// This may differ from GoFiles if files are processed before compilation.
 	CompiledGoFiles []string
 
 	// OtherFiles lists the absolute file paths of the package's non-Go source files,
 	// including assembly, C, C++, Fortran, Objective-C, SWIG, and so on.
 	OtherFiles []string
 
 	// EmbedFiles lists the absolute file paths of the package's files
 	// embedded with go:embed.
 	EmbedFiles []string
 
 	// EmbedPatterns lists the absolute file patterns of the package's
 	// files embedded with go:embed.
 	EmbedPatterns []string
 
 	// IgnoredFiles lists source files that are not part of the package
 	// using the current build configuration but that might be part of
 	// the package using other build configurations.
 	IgnoredFiles []string
 
 	// ExportFile is the absolute path to a file containing type
 	// information for the package as provided by the build system.
 	ExportFile string
 
 	// Imports maps import paths appearing in the package's Go source files
 	// to corresponding loaded Packages.
 	Imports map[string]*Package
 
 	// Types provides type information for the package.
 	// The NeedTypes LoadMode bit sets this field for packages matching the
 	// patterns; type information for dependencies may be missing or incomplete,
 	// unless NeedDeps and NeedImports are also set.
 	Types *types.Package
 
 	// Fset provides position information for Types, TypesInfo, and Syntax.
 	// It is set only when Types is set.
 	Fset *token.FileSet
 
 	// IllTyped indicates whether the package or any dependency contains errors.
 	// It is set only when Types is set.
 	IllTyped bool
 
 	// Syntax is the package's syntax trees, for the files listed in CompiledGoFiles.
 	//
 	// The NeedSyntax LoadMode bit populates this field for packages matching the patterns.
 	// If NeedDeps and NeedImports are also set, this field will also be populated
 	// for dependencies.
 	//
 	// Syntax is kept in the same order as CompiledGoFiles, with the caveat that nils are
 	// removed.  If parsing returned nil, Syntax may be shorter than CompiledGoFiles.
 	Syntax []*ast.File
 
 	// TypesInfo provides type information about the package's syntax trees.
 	// It is set only when Syntax is set.
 	TypesInfo *types.Info
 
 	// TypesSizes provides the effective size function for types in TypesInfo.
 	TypesSizes types.Sizes
 
 	// forTest is the package under test, if any.
 	forTest string
 
 	// depsErrors is the DepsErrors field from the go list response, if any.
 	depsErrors []*packagesinternal.PackageError
 
 	// module is the module information for the package if it exists.
 	Module *Module
 }
 
 // Module provides module information for a package.
 type Module struct {
 	Path      string       // module path
 	Version   string       // module version
 	Replace   *Module      // replaced by this module
 	Time      *time.Time   // time version was created
 	Main      bool         // is this the main module?
 	Indirect  bool         // is this module only an indirect dependency of main module?
 	Dir       string       // directory holding files for this module, if any
 	GoMod     string       // path to go.mod file used when loading this module, if any
 	GoVersion string       // go version used in module
 	Error     *ModuleError // error loading module
 }
 
 // ModuleError holds errors loading a module.
 type ModuleError struct {
 	Err string // the error itself
 }
 
 func init() {
 	packagesinternal.GetForTest = func(p interface{}) string {
 		return p.(*Package).forTest
 	}
 	packagesinternal.GetDepsErrors = func(p interface{}) []*packagesinternal.PackageError {
 		return p.(*Package).depsErrors
 	}
 	packagesinternal.GetGoCmdRunner = func(config interface{}) *gocommand.Runner {
 		return config.(*Config).gocmdRunner
 	}
 	packagesinternal.SetGoCmdRunner = func(config interface{}, runner *gocommand.Runner) {
 		config.(*Config).gocmdRunner = runner
 	}
 	packagesinternal.SetModFile = func(config interface{}, value string) {
 		config.(*Config).modFile = value
 	}
 	packagesinternal.SetModFlag = func(config interface{}, value string) {
 		config.(*Config).modFlag = value
 	}
 	packagesinternal.TypecheckCgo = int(typecheckCgo)
 	packagesinternal.DepsErrors = int(needInternalDepsErrors)
 	packagesinternal.ForTest = int(needInternalForTest)
 }
 
 // An Error describes a problem with a package's metadata, syntax, or types.
 type Error struct {
 	Pos  string // "file:line:col" or "file:line" or "" or "-"
 	Msg  string
 	Kind ErrorKind
 }
 
 // ErrorKind describes the source of the error, allowing the user to
 // differentiate between errors generated by the driver, the parser, or the
 // type-checker.
 type ErrorKind int
 
 const (
 	UnknownError ErrorKind = iota
 	ListError
 	ParseError
 	TypeError
 )
 
 func (err Error) Error() string {
 	pos := err.Pos
 	if pos == "" {
 		pos = "-" // like token.Position{}.String()
 	}
 	return pos + ": " + err.Msg
 }
 
 // flatPackage is the JSON form of Package
 // It drops all the type and syntax fields, and transforms the Imports
 //
 // TODO(adonovan): identify this struct with Package, effectively
 // publishing the JSON protocol.
 type flatPackage struct {
 	ID              string
 	Name            string            `json:",omitempty"`
 	PkgPath         string            `json:",omitempty"`
 	Errors          []Error           `json:",omitempty"`
 	GoFiles         []string          `json:",omitempty"`
 	CompiledGoFiles []string          `json:",omitempty"`
 	OtherFiles      []string          `json:",omitempty"`
 	EmbedFiles      []string          `json:",omitempty"`
 	EmbedPatterns   []string          `json:",omitempty"`
 	IgnoredFiles    []string          `json:",omitempty"`
 	ExportFile      string            `json:",omitempty"`
 	Imports         map[string]string `json:",omitempty"`
 }
 
 // MarshalJSON returns the Package in its JSON form.
 // For the most part, the structure fields are written out unmodified, and
 // the type and syntax fields are skipped.
 // The imports are written out as just a map of path to package id.
 // The errors are written using a custom type that tries to preserve the
 // structure of error types we know about.
 //
 // This method exists to enable support for additional build systems.  It is
 // not intended for use by clients of the API and we may change the format.
 func (p *Package) MarshalJSON() ([]byte, error) {
 	flat := &flatPackage{
 		ID:              p.ID,
 		Name:            p.Name,
 		PkgPath:         p.PkgPath,
 		Errors:          p.Errors,
 		GoFiles:         p.GoFiles,
 		CompiledGoFiles: p.CompiledGoFiles,
 		OtherFiles:      p.OtherFiles,
 		EmbedFiles:      p.EmbedFiles,
 		EmbedPatterns:   p.EmbedPatterns,
 		IgnoredFiles:    p.IgnoredFiles,
 		ExportFile:      p.ExportFile,
 	}
 	if len(p.Imports) > 0 {
 		flat.Imports = make(map[string]string, len(p.Imports))
 		for path, ipkg := range p.Imports {
 			flat.Imports[path] = ipkg.ID
 		}
 	}
 	return json.Marshal(flat)
 }
 
 // UnmarshalJSON reads in a Package from its JSON format.
 // See MarshalJSON for details about the format accepted.
 func (p *Package) UnmarshalJSON(b []byte) error {
 	flat := &flatPackage{}
 	if err := json.Unmarshal(b, &flat); err != nil {
 		return err
 	}
 	*p = Package{
 		ID:              flat.ID,
 		Name:            flat.Name,
 		PkgPath:         flat.PkgPath,
 		Errors:          flat.Errors,
 		GoFiles:         flat.GoFiles,
 		CompiledGoFiles: flat.CompiledGoFiles,
 		OtherFiles:      flat.OtherFiles,
 		EmbedFiles:      flat.EmbedFiles,
 		EmbedPatterns:   flat.EmbedPatterns,
 		ExportFile:      flat.ExportFile,
 	}
 	if len(flat.Imports) > 0 {
 		p.Imports = make(map[string]*Package, len(flat.Imports))
 		for path, id := range flat.Imports {
 			p.Imports[path] = &Package{ID: id}
 		}
 	}
 	return nil
 }
 
 func (p *Package) String() string { return p.ID }
 
 // loaderPackage augments Package with state used during the loading phase
 type loaderPackage struct {
 	*Package
 	importErrors map[string]error // maps each bad import to its error
 	loadOnce     sync.Once
 	color        uint8 // for cycle detection
 	needsrc      bool  // load from source (Mode >= LoadTypes)
 	needtypes    bool  // type information is either requested or depended on
 	initial      bool  // package was matched by a pattern
 	goVersion    int   // minor version number of go command on PATH
 }
 
 // loader holds the working state of a single call to load.
 type loader struct {
 	pkgs map[string]*loaderPackage
 	Config
 	sizes        types.Sizes
 	parseCache   map[string]*parseValue
 	parseCacheMu sync.Mutex
 	exportMu     sync.Mutex // enforces mutual exclusion of exportdata operations
 
 	// Config.Mode contains the implied mode (see impliedLoadMode).
 	// Implied mode contains all the fields we need the data for.
 	// In requestedMode there are the actually requested fields.
 	// We'll zero them out before returning packages to the user.
 	// This makes it easier for us to get the conditions where
 	// we need certain modes right.
 	requestedMode LoadMode
 }
 
 type parseValue struct {
 	f     *ast.File
 	err   error
 	ready chan struct{}
 }
 
 func newLoader(cfg *Config) *loader {
 	ld := &loader{
 		parseCache: map[string]*parseValue{},
 	}
 	if cfg != nil {
 		ld.Config = *cfg
 		// If the user has provided a logger, use it.
 		ld.Config.Logf = cfg.Logf
 	}
 	if ld.Config.Logf == nil {
 		// If the GOPACKAGESDEBUG environment variable is set to true,
 		// but the user has not provided a logger, default to log.Printf.
 		if debug {
 			ld.Config.Logf = log.Printf
 		} else {
 			ld.Config.Logf = func(format string, args ...interface{}) {}
 		}
 	}
 	if ld.Config.Mode == 0 {
 		ld.Config.Mode = NeedName | NeedFiles | NeedCompiledGoFiles // Preserve zero behavior of Mode for backwards compatibility.
 	}
 	if ld.Config.Env == nil {
 		ld.Config.Env = os.Environ()
 	}
 	if ld.Config.gocmdRunner == nil {
 		ld.Config.gocmdRunner = &gocommand.Runner{}
 	}
 	if ld.Context == nil {
 		ld.Context = context.Background()
 	}
 	if ld.Dir == "" {
 		if dir, err := os.Getwd(); err == nil {
 			ld.Dir = dir
 		}
 	}
 
 	// Save the actually requested fields. We'll zero them out before returning packages to the user.
 	ld.requestedMode = ld.Mode
 	ld.Mode = impliedLoadMode(ld.Mode)
 
 	if ld.Mode&NeedTypes != 0 || ld.Mode&NeedSyntax != 0 {
 		if ld.Fset == nil {
 			ld.Fset = token.NewFileSet()
 		}
 
 		// ParseFile is required even in LoadTypes mode
 		// because we load source if export data is missing.
 		if ld.ParseFile == nil {
 			ld.ParseFile = func(fset *token.FileSet, filename string, src []byte) (*ast.File, error) {
 				const mode = parser.AllErrors | parser.ParseComments
 				return parser.ParseFile(fset, filename, src, mode)
 			}
 		}
 	}
 
 	return ld
 }
 
 // refine connects the supplied packages into a graph and then adds type and
 // and syntax information as requested by the LoadMode.
 func (ld *loader) refine(response *driverResponse) ([]*Package, error) {
 	roots := response.Roots
 	rootMap := make(map[string]int, len(roots))
 	for i, root := range roots {
 		rootMap[root] = i
 	}
 	ld.pkgs = make(map[string]*loaderPackage)
 	// first pass, fixup and build the map and roots
 	var initial = make([]*loaderPackage, len(roots))
 	for _, pkg := range response.Packages {
 		rootIndex := -1
 		if i, found := rootMap[pkg.ID]; found {
 			rootIndex = i
 		}
 
 		// Overlays can invalidate export data.
 		// TODO(matloob): make this check fine-grained based on dependencies on overlaid files
 		exportDataInvalid := len(ld.Overlay) > 0 || pkg.ExportFile == "" && pkg.PkgPath != "unsafe"
 		// This package needs type information if the caller requested types and the package is
 		// either a root, or it's a non-root and the user requested dependencies ...
 		needtypes := (ld.Mode&NeedTypes|NeedTypesInfo != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0))
 		// This package needs source if the call requested source (or types info, which implies source)
 		// and the package is either a root, or itas a non- root and the user requested dependencies...
 		needsrc := ((ld.Mode&(NeedSyntax|NeedTypesInfo) != 0 && (rootIndex >= 0 || ld.Mode&NeedDeps != 0)) ||
 			// ... or if we need types and the exportData is invalid. We fall back to (incompletely)
 			// typechecking packages from source if they fail to compile.
 			(ld.Mode&(NeedTypes|NeedTypesInfo) != 0 && exportDataInvalid)) && pkg.PkgPath != "unsafe"
 		lpkg := &loaderPackage{
 			Package:   pkg,
 			needtypes: needtypes,
 			needsrc:   needsrc,
 			goVersion: response.GoVersion,
 		}
 		ld.pkgs[lpkg.ID] = lpkg
 		if rootIndex >= 0 {
 			initial[rootIndex] = lpkg
 			lpkg.initial = true
 		}
 	}
 	for i, root := range roots {
 		if initial[i] == nil {
 			return nil, fmt.Errorf("root package %v is missing", root)
 		}
 	}
 
 	// Materialize the import graph.
 
 	const (
 		white = 0 // new
 		grey  = 1 // in progress
 		black = 2 // complete
 	)
 
 	// visit traverses the import graph, depth-first,
 	// and materializes the graph as Packages.Imports.
 	//
 	// Valid imports are saved in the Packages.Import map.
 	// Invalid imports (cycles and missing nodes) are saved in the importErrors map.
 	// Thus, even in the presence of both kinds of errors, the Import graph remains a DAG.
 	//
 	// visit returns whether the package needs src or has a transitive
 	// dependency on a package that does. These are the only packages
 	// for which we load source code.
 	var stack []*loaderPackage
 	var visit func(lpkg *loaderPackage) bool
 	var srcPkgs []*loaderPackage
 	visit = func(lpkg *loaderPackage) bool {
 		switch lpkg.color {
 		case black:
 			return lpkg.needsrc
 		case grey:
 			panic("internal error: grey node")
 		}
 		lpkg.color = grey
 		stack = append(stack, lpkg) // push
 		stubs := lpkg.Imports       // the structure form has only stubs with the ID in the Imports
 		// If NeedImports isn't set, the imports fields will all be zeroed out.
 		if ld.Mode&NeedImports != 0 {
 			lpkg.Imports = make(map[string]*Package, len(stubs))
 			for importPath, ipkg := range stubs {
 				var importErr error
 				imp := ld.pkgs[ipkg.ID]
 				if imp == nil {
 					// (includes package "C" when DisableCgo)
 					importErr = fmt.Errorf("missing package: %q", ipkg.ID)
 				} else if imp.color == grey {
 					importErr = fmt.Errorf("import cycle: %s", stack)
 				}
 				if importErr != nil {
 					if lpkg.importErrors == nil {
 						lpkg.importErrors = make(map[string]error)
 					}
 					lpkg.importErrors[importPath] = importErr
 					continue
 				}
 
 				if visit(imp) {
 					lpkg.needsrc = true
 				}
 				lpkg.Imports[importPath] = imp.Package
 			}
 		}
 		if lpkg.needsrc {
 			srcPkgs = append(srcPkgs, lpkg)
 		}
 		if ld.Mode&NeedTypesSizes != 0 {
 			lpkg.TypesSizes = ld.sizes
 		}
 		stack = stack[:len(stack)-1] // pop
 		lpkg.color = black
 
 		return lpkg.needsrc
 	}
 
 	if ld.Mode&NeedImports == 0 {
 		// We do this to drop the stub import packages that we are not even going to try to resolve.
 		for _, lpkg := range initial {
 			lpkg.Imports = nil
 		}
 	} else {
 		// For each initial package, create its import DAG.
 		for _, lpkg := range initial {
 			visit(lpkg)
 		}
 	}
 	if ld.Mode&NeedImports != 0 && ld.Mode&NeedTypes != 0 {
 		for _, lpkg := range srcPkgs {
 			// Complete type information is required for the
 			// immediate dependencies of each source package.
 			for _, ipkg := range lpkg.Imports {
 				imp := ld.pkgs[ipkg.ID]
 				imp.needtypes = true
 			}
 		}
 	}
 	// Load type data and syntax if needed, starting at
 	// the initial packages (roots of the import DAG).
 	if ld.Mode&NeedTypes != 0 || ld.Mode&NeedSyntax != 0 {
 		var wg sync.WaitGroup
 		for _, lpkg := range initial {
 			wg.Add(1)
 			go func(lpkg *loaderPackage) {
 				ld.loadRecursive(lpkg)
 				wg.Done()
 			}(lpkg)
 		}
 		wg.Wait()
 	}
 
 	result := make([]*Package, len(initial))
 	for i, lpkg := range initial {
 		result[i] = lpkg.Package
 	}
 	for i := range ld.pkgs {
 		// Clear all unrequested fields,
 		// to catch programs that use more than they request.
 		if ld.requestedMode&NeedName == 0 {
 			ld.pkgs[i].Name = ""
 			ld.pkgs[i].PkgPath = ""
 		}
 		if ld.requestedMode&NeedFiles == 0 {
 			ld.pkgs[i].GoFiles = nil
 			ld.pkgs[i].OtherFiles = nil
 			ld.pkgs[i].IgnoredFiles = nil
 		}
 		if ld.requestedMode&NeedEmbedFiles == 0 {
 			ld.pkgs[i].EmbedFiles = nil
 		}
 		if ld.requestedMode&NeedEmbedPatterns == 0 {
 			ld.pkgs[i].EmbedPatterns = nil
 		}
 		if ld.requestedMode&NeedCompiledGoFiles == 0 {
 			ld.pkgs[i].CompiledGoFiles = nil
 		}
 		if ld.requestedMode&NeedImports == 0 {
 			ld.pkgs[i].Imports = nil
 		}
 		if ld.requestedMode&NeedExportFile == 0 {
 			ld.pkgs[i].ExportFile = ""
 		}
 		if ld.requestedMode&NeedTypes == 0 {
 			ld.pkgs[i].Types = nil
 			ld.pkgs[i].Fset = nil
 			ld.pkgs[i].IllTyped = false
 		}
 		if ld.requestedMode&NeedSyntax == 0 {
 			ld.pkgs[i].Syntax = nil
 		}
 		if ld.requestedMode&NeedTypesInfo == 0 {
 			ld.pkgs[i].TypesInfo = nil
 		}
 		if ld.requestedMode&NeedTypesSizes == 0 {
 			ld.pkgs[i].TypesSizes = nil
 		}
 		if ld.requestedMode&NeedModule == 0 {
 			ld.pkgs[i].Module = nil
 		}
 	}
 
 	return result, nil
 }
 
 // loadRecursive loads the specified package and its dependencies,
 // recursively, in parallel, in topological order.
 // It is atomic and idempotent.
 // Precondition: ld.Mode&NeedTypes.
 func (ld *loader) loadRecursive(lpkg *loaderPackage) {
 	lpkg.loadOnce.Do(func() {
 		// Load the direct dependencies, in parallel.
 		var wg sync.WaitGroup
 		for _, ipkg := range lpkg.Imports {
 			imp := ld.pkgs[ipkg.ID]
 			wg.Add(1)
 			go func(imp *loaderPackage) {
 				ld.loadRecursive(imp)
 				wg.Done()
 			}(imp)
 		}
 		wg.Wait()
 		ld.loadPackage(lpkg)
 	})
 }
 
 // loadPackage loads the specified package.
 // It must be called only once per Package,
 // after immediate dependencies are loaded.
 // Precondition: ld.Mode & NeedTypes.
 func (ld *loader) loadPackage(lpkg *loaderPackage) {
 	if lpkg.PkgPath == "unsafe" {
 		// Fill in the blanks to avoid surprises.
 		lpkg.Types = types.Unsafe
 		lpkg.Fset = ld.Fset
 		lpkg.Syntax = []*ast.File{}
 		lpkg.TypesInfo = new(types.Info)
 		lpkg.TypesSizes = ld.sizes
 		return
 	}
 
 	// Call NewPackage directly with explicit name.
 	// This avoids skew between golist and go/types when the files'
 	// package declarations are inconsistent.
 	lpkg.Types = types.NewPackage(lpkg.PkgPath, lpkg.Name)
 	lpkg.Fset = ld.Fset
 
 	// Subtle: we populate all Types fields with an empty Package
 	// before loading export data so that export data processing
 	// never has to create a types.Package for an indirect dependency,
 	// which would then require that such created packages be explicitly
 	// inserted back into the Import graph as a final step after export data loading.
 	// (Hence this return is after the Types assignment.)
 	// The Diamond test exercises this case.
 	if !lpkg.needtypes && !lpkg.needsrc {
 		return
 	}
 	if !lpkg.needsrc {
 		if err := ld.loadFromExportData(lpkg); err != nil {
 			lpkg.Errors = append(lpkg.Errors, Error{
 				Pos:  "-",
 				Msg:  err.Error(),
 				Kind: UnknownError, // e.g. can't find/open/parse export data
 			})
 		}
 		return // not a source package, don't get syntax trees
 	}
 
 	appendError := func(err error) {
 		// Convert various error types into the one true Error.
 		var errs []Error
 		switch err := err.(type) {
 		case Error:
 			// from driver
 			errs = append(errs, err)
 
 		case *os.PathError:
 			// from parser
 			errs = append(errs, Error{
 				Pos:  err.Path + ":1",
 				Msg:  err.Err.Error(),
 				Kind: ParseError,
 			})
 
 		case scanner.ErrorList:
 			// from parser
 			for _, err := range err {
 				errs = append(errs, Error{
 					Pos:  err.Pos.String(),
 					Msg:  err.Msg,
 					Kind: ParseError,
 				})
 			}
 
 		case types.Error:
 			// from type checker
 			lpkg.TypeErrors = append(lpkg.TypeErrors, err)
 			errs = append(errs, Error{
 				Pos:  err.Fset.Position(err.Pos).String(),
 				Msg:  err.Msg,
 				Kind: TypeError,
 			})
 
 		default:
 			// unexpected impoverished error from parser?
 			errs = append(errs, Error{
 				Pos:  "-",
 				Msg:  err.Error(),
 				Kind: UnknownError,
 			})
 
 			// If you see this error message, please file a bug.
 			log.Printf("internal error: error %q (%T) without position", err, err)
 		}
 
 		lpkg.Errors = append(lpkg.Errors, errs...)
 	}
 
 	// If the go command on the PATH is newer than the runtime,
 	// then the go/{scanner,ast,parser,types} packages from the
 	// standard library may be unable to process the files
 	// selected by go list.
 	//
 	// There is currently no way to downgrade the effective
 	// version of the go command (see issue 52078), so we proceed
 	// with the newer go command but, in case of parse or type
 	// errors, we emit an additional diagnostic.
 	//
 	// See:
 	// - golang.org/issue/52078 (flag to set release tags)
 	// - golang.org/issue/50825 (gopls legacy version support)
 	// - golang.org/issue/55883 (go/packages confusing error)
 	//
 	// Should we assert a hard minimum of (currently) go1.16 here?
 	var runtimeVersion int
 	if _, err := fmt.Sscanf(runtime.Version(), "go1.%d", &runtimeVersion); err == nil && runtimeVersion < lpkg.goVersion {
 		defer func() {
 			if len(lpkg.Errors) > 0 {
 				appendError(Error{
 					Pos:  "-",
 					Msg:  fmt.Sprintf("This application uses version go1.%d of the source-processing packages but runs version go1.%d of 'go list'. It may fail to process source files that rely on newer language features. If so, rebuild the application using a newer version of Go.", runtimeVersion, lpkg.goVersion),
 					Kind: UnknownError,
 				})
 			}
 		}()
 	}
 
 	if ld.Config.Mode&NeedTypes != 0 && len(lpkg.CompiledGoFiles) == 0 && lpkg.ExportFile != "" {
 		// The config requested loading sources and types, but sources are missing.
 		// Add an error to the package and fall back to loading from export data.
 		appendError(Error{"-", fmt.Sprintf("sources missing for package %s", lpkg.ID), ParseError})
 		_ = ld.loadFromExportData(lpkg) // ignore any secondary errors
 
 		return // can't get syntax trees for this package
 	}
 
 	files, errs := ld.parseFiles(lpkg.CompiledGoFiles)
 	for _, err := range errs {
 		appendError(err)
 	}
 
 	lpkg.Syntax = files
 	if ld.Config.Mode&NeedTypes == 0 {
 		return
 	}
 
 	lpkg.TypesInfo = &types.Info{
 		Types:      make(map[ast.Expr]types.TypeAndValue),
 		Defs:       make(map[*ast.Ident]types.Object),
 		Uses:       make(map[*ast.Ident]types.Object),
 		Implicits:  make(map[ast.Node]types.Object),
 		Scopes:     make(map[ast.Node]*types.Scope),
 		Selections: make(map[*ast.SelectorExpr]*types.Selection),
 	}
 	typeparams.InitInstanceInfo(lpkg.TypesInfo)
 	lpkg.TypesSizes = ld.sizes
 
 	importer := importerFunc(func(path string) (*types.Package, error) {
 		if path == "unsafe" {
 			return types.Unsafe, nil
 		}
 
 		// The imports map is keyed by import path.
 		ipkg := lpkg.Imports[path]
 		if ipkg == nil {
 			if err := lpkg.importErrors[path]; err != nil {
 				return nil, err
 			}
 			// There was skew between the metadata and the
 			// import declarations, likely due to an edit
 			// race, or because the ParseFile feature was
 			// used to supply alternative file contents.
 			return nil, fmt.Errorf("no metadata for %s", path)
 		}
 
 		if ipkg.Types != nil && ipkg.Types.Complete() {
 			return ipkg.Types, nil
 		}
 		log.Fatalf("internal error: package %q without types was imported from %q", path, lpkg)
 		panic("unreachable")
 	})
 
 	// type-check
 	tc := &types.Config{
 		Importer: importer,
 
 		// Type-check bodies of functions only in initial packages.
 		// Example: for import graph A->B->C and initial packages {A,C},
 		// we can ignore function bodies in B.
 		IgnoreFuncBodies: ld.Mode&NeedDeps == 0 && !lpkg.initial,
 
 		Error: appendError,
 		Sizes: ld.sizes,
 	}
 	if (ld.Mode & typecheckCgo) != 0 {
 		if !typesinternal.SetUsesCgo(tc) {
 			appendError(Error{
 				Msg:  "typecheckCgo requires Go 1.15+",
 				Kind: ListError,
 			})
 			return
 		}
 	}
 	types.NewChecker(tc, ld.Fset, lpkg.Types, lpkg.TypesInfo).Files(lpkg.Syntax)
 
 	lpkg.importErrors = nil // no longer needed
 
 	// If !Cgo, the type-checker uses FakeImportC mode, so
 	// it doesn't invoke the importer for import "C",
 	// nor report an error for the import,
 	// or for any undefined C.f reference.
 	// We must detect this explicitly and correctly
 	// mark the package as IllTyped (by reporting an error).
 	// TODO(adonovan): if these errors are annoying,
 	// we could just set IllTyped quietly.
 	if tc.FakeImportC {
 	outer:
 		for _, f := range lpkg.Syntax {
 			for _, imp := range f.Imports {
 				if imp.Path.Value == `"C"` {
 					err := types.Error{Fset: ld.Fset, Pos: imp.Pos(), Msg: `import "C" ignored`}
 					appendError(err)
 					break outer
 				}
 			}
 		}
 	}
 
 	// Record accumulated errors.
 	illTyped := len(lpkg.Errors) > 0
 	if !illTyped {
 		for _, imp := range lpkg.Imports {
 			if imp.IllTyped {
 				illTyped = true
 				break
 			}
 		}
 	}
 	lpkg.IllTyped = illTyped
 }
 
 // An importFunc is an implementation of the single-method
 // types.Importer interface based on a function value.
 type importerFunc func(path string) (*types.Package, error)
 
 func (f importerFunc) Import(path string) (*types.Package, error) { return f(path) }
 
 // We use a counting semaphore to limit
 // the number of parallel I/O calls per process.
 var ioLimit = make(chan bool, 20)
 
 func (ld *loader) parseFile(filename string) (*ast.File, error) {
 	ld.parseCacheMu.Lock()
 	v, ok := ld.parseCache[filename]
 	if ok {
 		// cache hit
 		ld.parseCacheMu.Unlock()
 		<-v.ready
 	} else {
 		// cache miss
 		v = &parseValue{ready: make(chan struct{})}
 		ld.parseCache[filename] = v
 		ld.parseCacheMu.Unlock()
 
 		var src []byte
 		for f, contents := range ld.Config.Overlay {
 			if sameFile(f, filename) {
 				src = contents
 			}
 		}
 		var err error
 		if src == nil {
 			ioLimit <- true // wait
 			src, err = ioutil.ReadFile(filename)
 			<-ioLimit // signal
 		}
 		if err != nil {
 			v.err = err
 		} else {
 			v.f, v.err = ld.ParseFile(ld.Fset, filename, src)
 		}
 
 		close(v.ready)
 	}
 	return v.f, v.err
 }
 
 // parseFiles reads and parses the Go source files and returns the ASTs
 // of the ones that could be at least partially parsed, along with a
 // list of I/O and parse errors encountered.
 //
 // Because files are scanned in parallel, the token.Pos
 // positions of the resulting ast.Files are not ordered.
 func (ld *loader) parseFiles(filenames []string) ([]*ast.File, []error) {
 	var wg sync.WaitGroup
 	n := len(filenames)
 	parsed := make([]*ast.File, n)
 	errors := make([]error, n)
 	for i, file := range filenames {
 		if ld.Config.Context.Err() != nil {
 			parsed[i] = nil
 			errors[i] = ld.Config.Context.Err()
 			continue
 		}
 		wg.Add(1)
 		go func(i int, filename string) {
 			parsed[i], errors[i] = ld.parseFile(filename)
 			wg.Done()
 		}(i, file)
 	}
 	wg.Wait()
 
 	// Eliminate nils, preserving order.
 	var o int
 	for _, f := range parsed {
 		if f != nil {
 			parsed[o] = f
 			o++
 		}
 	}
 	parsed = parsed[:o]
 
 	o = 0
 	for _, err := range errors {
 		if err != nil {
 			errors[o] = err
 			o++
 		}
 	}
 	errors = errors[:o]
 
 	return parsed, errors
 }
 
 // sameFile returns true if x and y have the same basename and denote
 // the same file.
 func sameFile(x, y string) bool {
 	if x == y {
 		// It could be the case that y doesn't exist.
 		// For instance, it may be an overlay file that
 		// hasn't been written to disk. To handle that case
 		// let x == y through. (We added the exact absolute path
 		// string to the CompiledGoFiles list, so the unwritten
 		// overlay case implies x==y.)
 		return true
 	}
 	if strings.EqualFold(filepath.Base(x), filepath.Base(y)) { // (optimisation)
 		if xi, err := os.Stat(x); err == nil {
 			if yi, err := os.Stat(y); err == nil {
 				return os.SameFile(xi, yi)
 			}
 		}
 	}
 	return false
 }
 
 // loadFromExportData ensures that type information is present for the specified
 // package, loading it from an export data file on the first request.
 // On success it sets lpkg.Types to a new Package.
 func (ld *loader) loadFromExportData(lpkg *loaderPackage) error {
 	if lpkg.PkgPath == "" {
 		log.Fatalf("internal error: Package %s has no PkgPath", lpkg)
 	}
 
 	// Because gcexportdata.Read has the potential to create or
 	// modify the types.Package for each node in the transitive
 	// closure of dependencies of lpkg, all exportdata operations
 	// must be sequential. (Finer-grained locking would require
 	// changes to the gcexportdata API.)
 	//
 	// The exportMu lock guards the lpkg.Types field and the
 	// types.Package it points to, for each loaderPackage in the graph.
 	//
 	// Not all accesses to Package.Pkg need to be protected by exportMu:
 	// graph ordering ensures that direct dependencies of source
 	// packages are fully loaded before the importer reads their Pkg field.
 	ld.exportMu.Lock()
 	defer ld.exportMu.Unlock()
 
 	if tpkg := lpkg.Types; tpkg != nil && tpkg.Complete() {
 		return nil // cache hit
 	}
 
 	lpkg.IllTyped = true // fail safe
 
 	if lpkg.ExportFile == "" {
 		// Errors while building export data will have been printed to stderr.
 		return fmt.Errorf("no export data file")
 	}
 	f, err := os.Open(lpkg.ExportFile)
 	if err != nil {
 		return err
 	}
 	defer f.Close()
 
 	// Read gc export data.
 	//
 	// We don't currently support gccgo export data because all
 	// underlying workspaces use the gc toolchain. (Even build
 	// systems that support gccgo don't use it for workspace
 	// queries.)
 	r, err := gcexportdata.NewReader(f)
 	if err != nil {
 		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
 	}
 
 	// Build the view.
 	//
 	// The gcexportdata machinery has no concept of package ID.
 	// It identifies packages by their PkgPath, which although not
 	// globally unique is unique within the scope of one invocation
 	// of the linker, type-checker, or gcexportdata.
 	//
 	// So, we must build a PkgPath-keyed view of the global
 	// (conceptually ID-keyed) cache of packages and pass it to
 	// gcexportdata. The view must contain every existing
 	// package that might possibly be mentioned by the
 	// current package---its transitive closure.
 	//
 	// In loadPackage, we unconditionally create a types.Package for
 	// each dependency so that export data loading does not
 	// create new ones.
 	//
 	// TODO(adonovan): it would be simpler and more efficient
 	// if the export data machinery invoked a callback to
 	// get-or-create a package instead of a map.
 	//
 	view := make(map[string]*types.Package) // view seen by gcexportdata
 	seen := make(map[*loaderPackage]bool)   // all visited packages
 	var visit func(pkgs map[string]*Package)
 	visit = func(pkgs map[string]*Package) {
 		for _, p := range pkgs {
 			lpkg := ld.pkgs[p.ID]
 			if !seen[lpkg] {
 				seen[lpkg] = true
 				view[lpkg.PkgPath] = lpkg.Types
 				visit(lpkg.Imports)
 			}
 		}
 	}
 	visit(lpkg.Imports)
 
 	viewLen := len(view) + 1 // adding the self package
 	// Parse the export data.
 	// (May modify incomplete packages in view but not create new ones.)
 	tpkg, err := gcexportdata.Read(r, ld.Fset, view, lpkg.PkgPath)
 	if err != nil {
 		return fmt.Errorf("reading %s: %v", lpkg.ExportFile, err)
 	}
 	if _, ok := view["go.shape"]; ok {
 		// Account for the pseudopackage "go.shape" that gets
 		// created by generic code.
 		viewLen++
 	}
 	if viewLen != len(view) {
 		log.Panicf("golang.org/x/tools/go/packages: unexpected new packages during load of %s", lpkg.PkgPath)
 	}
 
 	lpkg.Types = tpkg
 	lpkg.IllTyped = false
 	return nil
 }
 
 // impliedLoadMode returns loadMode with its dependencies.
 func impliedLoadMode(loadMode LoadMode) LoadMode {
 	if loadMode&(NeedDeps|NeedTypes|NeedTypesInfo) != 0 {
 		// All these things require knowing the import graph.
 		loadMode |= NeedImports
 	}
 
 	return loadMode
 }
 
 func usesExportData(cfg *Config) bool {
 	return cfg.Mode&NeedExportFile != 0 || cfg.Mode&NeedTypes != 0 && cfg.Mode&NeedDeps == 0
 }
 
 var _ interface{} = io.Discard // assert build toolchain is go1.16 or later