imports

type DirInfoCache ¶ added in v0.18.0

type DirInfoCache struct {
	// contains filtered or unexported fields
}

DirInfoCache is a concurrency-safe map for storing information about directories that may contain packages.

The information in this cache is built incrementally. Entries are initialized in scan. No new keys should be added in any other functions, as all directories containing packages are identified in scan.

Other functions, including loadExports and findPackage, may update entries in this cache as they discover new things about the directory.

The information in the cache is not expected to change for the cache's lifetime, so there is no protection against competing writes. Users should take care not to hold the cache across changes to the underlying files.

func NewDirInfoCache() *DirInfoCache

func (d *DirInfoCache) CacheExports(ctx context.Context, env *ProcessEnv, info directoryPackageInfo) (string, []stdlib.Symbol, error)

func (d *DirInfoCache) CachePackageName(info directoryPackageInfo) (string, error)

func (d *DirInfoCache) Keys() (keys []string)

func (d *DirInfoCache) Load(dir string) (directoryPackageInfo, bool)

func (d *DirInfoCache) ScanAndListen(ctx context.Context, listener cacheListener) func()

func (d *DirInfoCache) Store(dir string, info directoryPackageInfo)

type ImportFix ¶

type ImportFix struct {
	// StmtInfo represents the import statement this fix will add, remove, or change.
	StmtInfo ImportInfo
	// IdentName is the identifier that this fix will add or remove.
	IdentName string
	// FixType is the type of fix this is (AddImport, DeleteImport, SetImportName).
	FixType   ImportFixType
	Relevance float64 // see pkg
}

func FixImports(ctx context.Context, filename string, src []byte, opt *Options) (fixes []*ImportFix, err error)

type ImportFixType ¶

type ImportFixType int

const (
	AddImport ImportFixType = iota
	DeleteImport
	SetImportName
)

type ImportInfo ¶

type ImportInfo struct {
	ImportPath string // import path, e.g. "crypto/rand".
	Name       string // import name, e.g. "crand", or "" if none.
}

An ImportInfo represents a single import statement.

type ModuleResolver ¶

type ModuleResolver struct {
	// contains filtered or unexported fields
}

ModuleResolver implements the Resolver interface for a workspace using modules.

A goal of the ModuleResolver is to invoke the Go command as little as possible. To this end, it runs the Go command only for listing module information (i.e. `go list -m -e -json ...`). Package scanning, the process of loading package information for the modules, is implemented internally via the scan method.

It has two types of state: the state derived from the go command, which is populated by init, and the state derived from scans, which is populated via scan. A root is considered scanned if it has been walked to discover directories. However, if the scan did not require additional information from the directory (such as package name or exports), the directory information itself may be partially populated. It will be lazily filled in as needed by scans, using the scanCallback.

func (r *ModuleResolver) ClearForNewScan() Resolver

type Options ¶

type Options struct {
	Env *ProcessEnv // The environment to use. Note: this contains the cached module and filesystem state.

	// LocalPrefix is a comma-separated string of import path prefixes, which, if
	// set, instructs Process to sort the import paths with the given prefixes
	// into another group after 3rd-party packages.
	LocalPrefix string

	Fragment  bool // Accept fragment of a source file (no package statement)
	AllErrors bool // Report all errors (not just the first 10 on different lines)

	Comments  bool // Print comments (true if nil *Options provided)
	TabIndent bool // Use tabs for indent (true if nil *Options provided)
	TabWidth  int  // Tab width (8 if nil *Options provided)

	FormatOnly bool // Disable the insertion and deletion of imports
}

Options is golang.org/x/tools/imports.Options with extra internal-only options.

type PackageExport ¶

type PackageExport struct {
	Fix     *ImportFix
	Exports []stdlib.Symbol
}

A PackageExport is a package and its exports.

type ProcessEnv ¶

type ProcessEnv struct {
	GocmdRunner *gocommand.Runner

	BuildFlags []string
	ModFlag    string

	// SkipPathInScan returns true if the path should be skipped from scans of
	// the RootCurrentModule root type. The function argument is a clean,
	// absolute path.
	SkipPathInScan func(string) bool

	// Env overrides the OS environment, and can be used to specify
	// GOPROXY, GO111MODULE, etc. PATH cannot be set here, because
	// exec.Command will not honor it.
	// Specifying all of requiredGoEnvVars avoids a call to `go env`.
	Env map[string]string

	WorkingDir string

	// If Logf is non-nil, debug logging is enabled through this function.
	Logf func(format string, args ...interface{})

	// If set, ModCache holds a shared cache of directory info to use across
	// multiple ProcessEnvs.
	ModCache *DirInfoCache
	// contains filtered or unexported fields
}

ProcessEnv contains environment variables and settings that affect the use of the go command, the go/build package, etc.

...a ProcessEnv *also* overwrites its Env along with derived state in the form of the resolver. And because it is lazily initialized, an env may just be broken and unusable, but there is no way for the caller to detect that: all queries will just fail.

TODO(rfindley): refactor this package so that this type (perhaps renamed to just Env or Config) is an immutable configuration struct, to be exchanged for an initialized object via a constructor that returns an error. Perhaps the signature should be `func NewResolver(*Env) (*Resolver, error)`, where resolver is a concrete type used for resolving imports. Via this refactoring, we can avoid the need to call ProcessEnv.init and ProcessEnv.GoEnv everywhere, and implicitly fix all the places where this these are misused. Also, we'd delegate the caller the decision of how to handle a broken environment.

func (e *ProcessEnv) ClearModuleInfo()

func (e *ProcessEnv) CopyConfig() *ProcessEnv

func (e *ProcessEnv) GetResolver() (Resolver, error)

func (e *ProcessEnv) UpdateResolver(r Resolver)

type Resolver ¶

type Resolver interface {

	// ClearForNewScan returns a new Resolver based on the receiver that has
	// cleared its internal caches of directory contents.
	//
	// The new resolver should be primed and then set via
	// [ProcessEnv.UpdateResolver].
	ClearForNewScan() Resolver
	// contains filtered or unexported methods
}

A Resolver does the build-system-specific parts of goimports.