imports

Documentation

Overview

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

Index

• func ApplyFixes(fixes []*ImportFix, filename string, src []byte, opt *Options) (formatted []byte, err error)
• func Process(filename string, src []byte, opt *Options) (formatted []byte, err error)
• func VendorlessPath(ipath string) string
• type ImportFix
  • func FixImports(filename string, src []byte, opt *Options) (fixes []*ImportFix, err error)
  • func GetAllCandidates(filename string, opt *Options) (pkgs []ImportFix, err error)
• type ImportFixType
• type ImportInfo
• type ModuleErrorJSON
• type ModuleJSON
• type ModuleResolver
• type Options
• type ProcessEnv
  • func (e *ProcessEnv) GetResolver() Resolver
• type Resolver

Functions

func ApplyFixes

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

ApplyFix will apply all of the fixes to the file and format it.

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 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
}

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.

func GetAllCandidates

func GetAllCandidates(filename string, opt *Options) (pkgs []ImportFix, err error)

GetAllCandidates gets all of the standard library candidate packages to import in sorted order on import path.

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 ModuleErrorJSON

type ModuleErrorJSON struct {
	Err string // the error itself
}

type ModuleJSON

type ModuleJSON struct {
	Path     string           // module path
	Version  string           // module version
	Versions []string         // available module versions (with -versions)
	Replace  *ModuleJSON      // replaced by this module
	Time     *time.Time       // time version was created
	Update   *ModuleJSON      // available update, if any (with -u)
	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
	Error    *ModuleErrorJSON // error loading module
}

type ModuleResolver

type ModuleResolver struct {
	Initialized   bool
	Main          *ModuleJSON
	ModsByModPath []*ModuleJSON // All modules, ordered by # of path components in module Path...
	ModsByDir     []*ModuleJSON // ...or Dir.

	// ModCachePkgs contains the canonicalized importPath and directory of packages
	// in the module cache. Keyed by absolute directory.
	ModCachePkgs map[string]*pkg
	// contains filtered or unexported fields
}

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

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 ProcessEnv

type ProcessEnv struct {
	LocalPrefix string
	Debug       bool

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

	// If true, use go/packages regardless of the environment.
	ForceGoPackages bool

	// Logf is the default logger for the ProcessEnv.
	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) GetResolver

func (e *ProcessEnv) GetResolver() Resolver

type Resolver

type Resolver interface {
	// contains filtered or unexported methods
}

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