pkginfo

Documentation

Index

• func UpdateGoPath(goRoot paths.FS)
• type File
  • func (f *File) AST() *ast.File
  • func (f *File) ASTInspector() *inspector.Inspector
  • func (f *File) Contents() []byte
  • func (f *File) GoString() string
  • func (f *File) Names() *FileNames
  • func (f *File) Token() *token.File
• type FileNames
  • func (n *FileNames) GoString() string
  • func (f *FileNames) ResolvePkgLevelRef(expr ast.Expr) (name QualifiedName, ok bool)
  • func (f *FileNames) ResolvePkgPath(cause token.Pos, name string) (pkgPath paths.Pkg, ok bool)
• type Loader
  • func New(c *parsectx.Context) *Loader
  • func (l *Loader) LoadPkg(cause token.Pos, pkgPath paths.Pkg) (pkg *Package, ok bool)
  • func (l *Loader) MainModule() *Module
  • func (l *Loader) MustLoadPkg(cause token.Pos, pkgPath paths.Pkg) (pkg *Package)
  • func (l *Loader) RuntimeModule() *Module
• type Module
  • func (m *Module) FSPathToPkg(pkgPath paths.Pkg) (path paths.FS, ok bool)
• type Package
  • func (p *Package) GoString() string
  • func (p *Package) Names() *PkgNames
• type PkgDeclInfo
  • func (i *PkgDeclInfo) QualifiedName() QualifiedName
• type PkgNames
  • func (n *PkgNames) FuncDecl(name string) option.Option[*ast.FuncDecl]
  • func (n *PkgNames) GoString() string
• type QualifiedName
  • func Q(pkgPath paths.Pkg, name string) QualifiedName
  • func (q QualifiedName) NaiveDisplayName() string

Functions

func UpdateGoPath

func UpdateGoPath(goRoot paths.FS)

UpdateGoPath updates the PATH environment variable to use the "go" binary from Encore's GOROOT. This is necessary because packages.Load invokes "go list" under the hood, and we want to ensure it uses the same 'go' binary as Encore.

Types

type File

type File struct {
	Name     string                 // file name ("foo.go")
	Pkg      *Package               // package it belongs to
	FSPath   paths.FS               // where the file lives on disk
	Imports  map[paths.Pkg]ast.Node // imports in the file, keyed by import path pointed at the import spec
	TestFile bool                   // whether the file is a test file
	// contains filtered or unexported fields
}

func (*File) AST

func (f *File) AST() *ast.File

AST returns the parsed AST for this file.

func (*File) ASTInspector

func (f *File) ASTInspector() *inspector.Inspector

ASTInspector returns an AST inspector that's optimized for finding nodes of particular types. See inspector.Inspector for more information.

func (*File) Contents

func (f *File) Contents() []byte

Contents returns the full file contents.

func (*File) GoString

func (f *File) GoString() string

func (*File) Names

func (f *File) Names() *FileNames

Names returns the computed file-level names.

func (*File) Token

func (f *File) Token() *token.File

type FileNames

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

FileNames contains name resolution results for a single file.

func (*FileNames) GoString

func (n *FileNames) GoString() string

func (*FileNames) ResolvePkgLevelRef

func (f *FileNames) ResolvePkgLevelRef(expr ast.Expr) (name QualifiedName, ok bool)

ResolvePkgLevelRef resolves the node to the package-level reference it refers to. Expr must be either *ast.Ident or *ast.SelectorExpr. If it doesn't refer to a package-level reference it returns ok == false.

func (*FileNames) ResolvePkgPath

func (f *FileNames) ResolvePkgPath(cause token.Pos, name string) (pkgPath paths.Pkg, ok bool)

ResolvePkgPath resolves the package path a given identifier name resolves to.

type Loader

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

A Loader provides lazy loading of package information.

func New

func New(c *parsectx.Context) *Loader

New creates a new Loader.

func (*Loader) LoadPkg

func (l *Loader) LoadPkg(cause token.Pos, pkgPath paths.Pkg) (pkg *Package, ok bool)

LoadPkg loads a package. If the package contains no Go files to build, it returns (nil, false).

func (*Loader) MainModule

func (l *Loader) MainModule() *Module

MainModule returns the parsed main module.

func (*Loader) MustLoadPkg

func (l *Loader) MustLoadPkg(cause token.Pos, pkgPath paths.Pkg) (pkg *Package)

MustLoadPkg loads a package. If the package contains no Go files, it bails out.

func (*Loader) RuntimeModule

func (l *Loader) RuntimeModule() *Module

RuntimeModule returns the parsed runtime module.

type Module

type Module struct {
	RootDir paths.FS  // the dir containing go.mod
	Path    paths.Mod // module path
	Version string    // module version
	// contains filtered or unexported fields
}

Module describes a Go module.

func (*Module) FSPathToPkg

func (m *Module) FSPathToPkg(pkgPath paths.Pkg) (path paths.FS, ok bool)

FSPathToPkg computes the filesystem path to the given package. The package must lexically live within the given module, otherwise it reports ok == false.

type Package

type Package struct {
	AST        *ast.Package
	Name       string
	Doc        string
	ImportPath paths.Pkg
	FSPath     paths.FS
	Files      []*File
	Imports    map[paths.Pkg]ast.Node // union of all imports from files
	// contains filtered or unexported fields
}

func (*Package) GoString

func (p *Package) GoString() string

func (*Package) Names

func (p *Package) Names() *PkgNames

Names returns the computed package-level names.

type PkgDeclInfo

type PkgDeclInfo struct {
	Name string
	File *File
	Pos  token.Pos
	Doc  string

	// Type describes what type of declaration this is.
	// It's one of CONST, TYPE, VAR, or FUNC.
	Type token.Token

	// Spec is the spec for this declaration and GenDecl the declaration block
	// it belongs to. They are set only when Type != FUNC.
	Spec    ast.Spec
	GenDecl *ast.GenDecl

	// Func is the function declaration, if Type == FUNC.
	Func *ast.FuncDecl // for Type == FUNC
	// Recv is the receiver type, if Type == FUNC and the function is a method.
	Recv *PkgDeclInfo
}

PkgDeclInfo provides metadata for a package-level declaration.

func (*PkgDeclInfo) QualifiedName

func (i *PkgDeclInfo) QualifiedName() QualifiedName

type PkgNames

type PkgNames struct {
	// PkgDecls contains package-level declarations, keyed by name.
	PkgDecls map[string]*PkgDeclInfo

	// Funcs are all the func declarations.
	Funcs []*PkgDeclInfo
	// contains filtered or unexported fields
}

PkgNames contains name information that's package-global.

func (*PkgNames) FuncDecl

func (n *PkgNames) FuncDecl(name string) option.Option[*ast.FuncDecl]

func (*PkgNames) GoString

func (n *PkgNames) GoString() string

type QualifiedName

type QualifiedName struct {
	PkgPath paths.Pkg
	Name    string
}

A QualifiedName is the combination of a package path and a package-level name. It can be used to uniquely reference a package-level declaration.

func Q

func Q(pkgPath paths.Pkg, name string) QualifiedName

Q is a helper function to construct a QualifiedName.

func (QualifiedName) NaiveDisplayName

func (q QualifiedName) NaiveDisplayName() string

NaiveDisplayName returns the name as "pkgname.Name" by assuming the package name is equal to the last path component.