search

type Def interface {
	ValueSpecs() []*ast.ValueSpec // var, const, field
	FuncDecls() []*ast.FuncDecl   // func, method
	TypeSpecs() []*ast.TypeSpec   // type alias, defined type
	// Iterate visits all specs and decls until given function returns false.
	Iterate(func(ast.Node) bool)
}

type DefExtractor interface {
	Extract(f *ast.File) Def
}

type DefNode interface {
	Node
}

type DefSet interface {
	Pkg() *packages.Package
	Defs() []Def
}

type DefSetExtractor interface {
	Extract(pkg *packages.Package) DefSet
}

type FieldSearcher interface {
	Search(pkg *types.Package, pos token.Pos) (*types.TypeName, bool)
}

type FieldSearcherBuilder interface {
	Add(*types.Package)
	Build() FieldSearcher
}

type Filter func(Target) bool

type Node interface {
	Pkg() Pkg
	Obj() Object
	Type() NodeType
	Name() string
	RecvString(opt ...NodeOption) string
	Info() *NodeInfo
}

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

type NodeInfo struct {
	// ValueSpecIndex is the index of the ValueSpec.Specs that correspond to Obj() if AST() is ValueSpec.
	// -1 is a invalid value.
	ValueSpecIndex int
	Recv           string
}

type NodeOption func(*NodeConfig)

type NodeType int

type ObjExtractor interface {
	// Extract extracts an object with the ident.
	Extract(pkg *packages.Package, ident *ast.Ident) (Object, bool)
}

type Object interface {
	Parent() *types.Scope
	Pos() token.Pos
	Pkg() *types.Package
	Name() string
	Type() types.Type
	Exported() bool
	Id() string
}

type Pkg interface {
	Pkg() *packages.Package
	Name() string
	Path() string
	IsBuiltin() bool
}

type RefNode interface {
	Node
	AST() ast.Node
	Ident() *ast.Ident
}

type RefPkgSearcher interface {
	Search(pkg *packages.Package, pos token.Pos) (ast.Node, bool)
}

type RefSearcher interface {
	// Search returns a node if the pos is contained in the node.
	Search(defSet DefSet, pos token.Pos) (node ast.Node, found bool)
}

type Target interface {
	Ident() *ast.Ident // ref
	Obj() Object       // def
}

type TargetExtractor interface {
	Extract(pkg *packages.Package, filter Filter) <-chan Target
}

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

type TargetExtractorOption func(*TargetExtractorConfig)

type Use interface {
	Ref() RefNode
	Def() DefNode
}

type UseSearcher interface {
	Search() <-chan Use
}

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

type UseSearcherOption func(*UseSearcherConfig)