This section is empty.


This section is empty.


func CompatibleTypes

func CompatibleTypes(expected types.Type, actual types.Type) error

    CompatibleTypes isnt a strict comparison, it allows for pointer differences

    func ImportPathForDir

    func ImportPathForDir(dir string) (res string)

      ImportPathForDir takes a path and returns a golang import path for the package

      func NameForDir

      func NameForDir(dir string) string

        NameForDir manually looks for package stanzas in files located in the given directory. This can be much faster than having to consult go list, because we already know exactly where to look.

        func NormalizeVendor

        func NormalizeVendor(pkg string) string

          NormalizeVendor takes a qualified package path and turns it into normal one. eg . becomes

          func PkgAndType

          func PkgAndType(name string) (string, string)

            take a string in the form and split it into package and type

            func QualifyPackagePath

            func QualifyPackagePath(importPath string) string

              QualifyPackagePath takes an import and fully qualifies it with a vendor dir, if one is required. eg . becomes

              x/tools/packages only supports 'qualified package paths' so this will need to be done prior to calling it See

              func SanitizePackageName

              func SanitizePackageName(pkg string) string


              type Packages

              type Packages struct {
              	// contains filtered or unexported fields

                Packages is a wrapper around x/tools/go/packages that maintains a (hopefully prewarmed) cache of packages that can be invalidated as writes are made and packages are known to change.

                func (*Packages) Errors

                func (p *Packages) Errors() PkgErrors

                  Errors returns any errors that were returned by Load, either from the call itself or any of the loaded packages.

                  func (*Packages) Evict

                  func (p *Packages) Evict(importPath string)

                    Evict removes a given package import path from the cache, along with any packages that depend on it. Further calls to Load will fetch it from disk.

                    func (*Packages) Load

                    func (p *Packages) Load(importPath string) *packages.Package

                      Load works the same as LoadAll, except a single package at a time.

                      func (*Packages) LoadAll

                      func (p *Packages) LoadAll(importPaths ...string) []*packages.Package

                        LoadAll will call packages.Load and return the package data for the given packages, but if the package already have been loaded it will return cached values instead.

                        func (*Packages) LoadWithTypes

                        func (p *Packages) LoadWithTypes(importPath string) *packages.Package

                          LoadWithTypes tries a standard load, which may not have enough type info (TypesInfo== nil) available if the imported package is a second order dependency. Fortunately this doesnt happen very often, so we can just issue a load when we detect it.

                          func (*Packages) NameForPackage

                          func (p *Packages) NameForPackage(importPath string) string

                            NameForPackage looks up the package name from the package stanza in the go files at the given import path.

                            type PkgErrors

                            type PkgErrors []error

                            func (PkgErrors) Error

                            func (p PkgErrors) Error() string