imports

Documentation

Overview

Package imports implements a Go pretty-printer (like package "go/format") that also adds or removes import statements as necessary.

Index

• Constants
• func ApplyFixes(fixes []*ImportFix, filename string, src []byte, opt *Options, ...) (formatted []byte, err error)
• func GetAllCandidates(ctx context.Context, callback func(ImportFix), ...) error
• func GetPackageExports(ctx context.Context, callback func(PackageExport), ...) error
• func ImportPathToAssumedName(importPath string) string
• func PrimeCache(ctx context.Context, env *ProcessEnv) error
• func Process(filename string, src []byte, opt *Options) (formatted []byte, err error)
• func ScoreImportPaths(ctx context.Context, env *ProcessEnv, paths []string) map[string]int
• func VendorlessPath(ipath string) string
• type ImportFix
  • func FixImports(filename string, src []byte, opt *Options) (fixes []*ImportFix, err error)
• type ImportFixType
• type ImportInfo
• type ModuleJSON
• type ModuleResolver
  • func (r *ModuleResolver) ClearForNewMod()
  • func (r *ModuleResolver) ClearForNewScan()
• type Options
• type PackageExport
• type ProcessEnv
  • func (e *ProcessEnv) CopyConfig() *ProcessEnv
  • func (e *ProcessEnv) GetResolver() Resolver
• type Resolver

Constants

const MaxRelevance = 7

Highest relevance, used for the standard library. Chosen arbitrarily to match pre-existing gopls code.

Functions

func ApplyFixes

func ApplyFixes(fixes []*ImportFix, filename string, src []byte, opt *Options, extraMode parser.Mode) (formatted []byte, err error)

ApplyFixes applies all of the fixes to the file and formats it. extraMode is added in when parsing the file.

func GetAllCandidates

func GetAllCandidates(ctx context.Context, callback func(ImportFix), searchPrefix, filename, filePkg string, opt *Options) error

GetAllCandidates gets all of the packages starting with prefix that can be imported by filename, sorted by import path.

func GetPackageExports

func GetPackageExports(ctx context.Context, callback func(PackageExport), searchPkg, filename, filePkg string, opt *Options) error

GetPackageExports returns all known packages with name pkg and their exports.

func ImportPathToAssumedName

func ImportPathToAssumedName(importPath string) string

ImportPathToAssumedName returns the assumed package name of an import path. It does this using only string parsing of the import path. It picks the last element of the path that does not look like a major version, and then picks the valid identifier off the start of that element. It is used to determine if a local rename should be added to an import for clarity. This function could be moved to a standard package and exported if we want for use in other tools.

func PrimeCache

func PrimeCache(ctx context.Context, env *ProcessEnv) error

func Process

func Process(filename string, src []byte, opt *Options) (formatted []byte, err error)

Process implements golang.org/x/tools/imports.Process with explicit context in env.

func ScoreImportPaths

func ScoreImportPaths(ctx context.Context, env *ProcessEnv, paths []string) map[string]int

func VendorlessPath

func VendorlessPath(ipath string) string

VendorlessPath returns the devendorized version of the import path ipath. For example, VendorlessPath("foo/bar/vendor/a/b") returns "a/b".

Types

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 int // see pkg
}

func FixImports

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

FixImports returns a list of fixes to the imports that, when applied, will leave the imports in the same state as Process.

Note that filename's directory influences which imports can be chosen, so it is important that filename be accurate.

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 ModuleJSON

type ModuleJSON struct {
	Path      string      // module path
	Replace   *ModuleJSON // replaced by this module
	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 for this module, if any
	GoVersion string      // go version used in module
}

type ModuleResolver

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

ModuleResolver implements resolver for modules using the go command as little as feasible.

func (*ModuleResolver) ClearForNewMod

func (r *ModuleResolver) ClearForNewMod()

func (*ModuleResolver) ClearForNewScan

func (r *ModuleResolver) ClearForNewScan()

type Options

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

	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 []string
}

A PackageExport is a package and its exports.

type ProcessEnv

type ProcessEnv struct {
	LocalPrefix string

	GocmdRunner *gocommand.Runner

	BuildFlags []string

	// If non-empty, these will be used instead of the
	// process-wide values.
	GOPATH, GOROOT, GO111MODULE, GOPROXY, GOFLAGS, GOSUMDB string
	WorkingDir                                             string

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

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

func (*ProcessEnv) CopyConfig

func (e *ProcessEnv) CopyConfig() *ProcessEnv

CopyConfig copies the env's configuration into a new env.

func (*ProcessEnv) GetResolver

func (e *ProcessEnv) GetResolver() Resolver

type Resolver

type Resolver interface {
	ClearForNewScan()
	// contains filtered or unexported methods
}

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