inspect

type AstInspector[X any] struct {
	WithUnexported bool
	Visitor        NodeVisitor[*AstInspector[X], X]
	X              X
	Pkg            *packages.Package
	File           *ast.File
	Object         *ast.Object
}

type BaseInspector[T Inspector] struct {
	Parser func(*packages.Config, ...string) ([]*packages.Package, error)

	Inspector T
}

type Dir int

type Face struct {
	Pkg       *types.Package
	Name      string
	Interface *types.Interface
}

type FnNodeVisitor[I Inspector, X any] struct {
	FnVisitFieldDecl NodeDeclVisit[I, *ast.Field, X]
	FnVisitFuncDecl  NodeDeclVisit[I, *ast.FuncDecl, X]
	FnVisitTypeDecl  NodeDeclVisit[I, *ast.TypeSpec, X]
	FnVisitValueDecl NodeDeclVisit[I, *ast.ValueSpec, X]

	FnVisitFieldList NodeVisit[I, *ast.FieldList, X]
	FnVisitField     NodeVisit[I, *ast.Field, X]

	FnVisitIdent         NodeExprVisit[I, *ast.Ident, X]
	FnVisitFuncType      NodeExprVisit[I, *ast.FuncType, X]
	FnVisitStructType    NodeExprVisit[I, *ast.StructType, X]
	FnVisitInterfaceType NodeExprVisit[I, *ast.InterfaceType, X]
	FnVisitArrayType     NodeExprVisit[I, *ast.ArrayType, X]
	FnVisitMapType       NodeExprVisit[I, *ast.MapType, X]
	FnVisitChanType      NodeExprVisit[I, *ast.ChanType, X]
	FnVisitStarExpr      NodeExprVisit[I, *ast.StarExpr, X]
	FnVisitSelectorExpr  NodeExprVisit[I, *ast.SelectorExpr, X]
	FnVisitBasicLit      NodeExprVisit[I, *ast.BasicLit, X]
	FnVisitEllipsis      NodeExprVisit[I, *ast.Ellipsis, X]
	FnVisitUnaryExpr     NodeExprVisit[I, *ast.UnaryExpr, X]
	FnVisitBinaryExpr    NodeExprVisit[I, *ast.BinaryExpr, X]
}

type FnTypeVisitor[I Inspector, X any] struct {
	FnVisitConst    TypeRootVisitor[I, *types.Const, X]
	FnVisitFunc     TypeRootVisitor[I, *types.Func, X]
	FnVisitTypeName TypeRootVisitor[I, *types.TypeName, X]
	FnVisitVar      TypeRootVisitor[I, *types.Var, X]

	FnVisitTypeVar  TypeElementVisitor[I, *types.Var, X]
	FnVisitTypeFunc TypeElementVisitor[I, *types.Func, X]

	FnVisitTypeBasic     TypeElementTypeVisitor[I, *types.Basic, X]
	FnVisitTypeMap       TypeElementTypeVisitor[I, *types.Map, X]
	FnVisitTypeArray     TypeElementTypeVisitor[I, *types.Array, X]
	FnVisitTypeStruct    TypeElementTypeVisitor[I, *types.Struct, X]
	FnVisitTypeTuple     TypeElementTypeVisitor[I, *types.Tuple, X]
	FnVisitTypeUnion     TypeElementTypeVisitor[I, *types.Union, X]
	FnVisitTypeSignature TypeElementTypeVisitor[I, *types.Signature, X]
	FnVisitTypeParam     TypeElementTypeVisitor[I, *types.TypeParam, X]
	FnVisitTypePointer   TypeElementTypeVisitor[I, *types.Pointer, X]
	FnVisitTypeSlice     TypeElementTypeVisitor[I, *types.Slice, X]
	FnVisitTypeInterface TypeElementTypeVisitor[I, *types.Interface, X]
	FnVisitTypeChan      TypeElementTypeVisitor[I, *types.Chan, X]
	FnVisitTypeNamed     TypeElementTypeVisitor[I, *types.Named, X]
}

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

type NodeDeclVisit[I Inspector, T ast.Node, X any] func(i I, d Dir, name string, o *ast.Object, x T, seen Nodes, cx X) bool

type NodeExprVisit[I Inspector, T ast.Expr, X any] func(i I, d Dir, o *ast.Object, x T, seen Nodes, cx X) bool

type NodeVisit[I Inspector, T ast.Node, X any] func(i I, d Dir, o *ast.Object, x T, seen Nodes, cx X) bool

type NodeVisitor[I Inspector, X any] interface {
	VisitFieldDecl(i I, d Dir, name string, o *ast.Object, x *ast.Field, seen Nodes, cx X) bool
	VisitFuncDecl(i I, d Dir, name string, o *ast.Object, x *ast.FuncDecl, nodes Nodes, cx X) bool
	VisitTypeDecl(i I, d Dir, name string, o *ast.Object, x *ast.TypeSpec, nodes Nodes, cx X) bool
	VisitValueDecl(i I, d Dir, name string, o *ast.Object, x *ast.ValueSpec, nodes Nodes, cx X) bool

	VisitFieldList(i I, d Dir, o *ast.Object, x *ast.FieldList, nodes Nodes, cx X) bool
	VisitField(i I, d Dir, o *ast.Object, x *ast.Field, seen Nodes, cx X) bool

	VisitIdent(i I, d Dir, o *ast.Object, x *ast.Ident, nodes Nodes, cx X) bool
	VisitFuncType(i I, d Dir, o *ast.Object, x *ast.FuncType, nodes Nodes, cx X) bool
	VisitStructType(i I, d Dir, o *ast.Object, x *ast.StructType, nodes Nodes, cx X) bool
	VisitInterfaceType(i I, d Dir, o *ast.Object, x *ast.InterfaceType, nodes Nodes, cx X) bool
	VisitArrayType(i I, d Dir, o *ast.Object, x *ast.ArrayType, nodes Nodes, cx X) bool
	VisitMapType(i I, d Dir, o *ast.Object, x *ast.MapType, nodes Nodes, cx X) bool
	VisitChanType(i I, d Dir, o *ast.Object, x *ast.ChanType, nodes Nodes, cx X) bool
	VisitStarExpr(i I, d Dir, o *ast.Object, x *ast.StarExpr, nodes Nodes, cx X) bool
	VisitSelectorExpr(i I, d Dir, o *ast.Object, x *ast.SelectorExpr, nodes Nodes, cx X) bool
	VisitBasicLit(i I, d Dir, o *ast.Object, x *ast.BasicLit, nodes Nodes, cx X) bool
	VisitEllipsis(i I, d Dir, o *ast.Object, x *ast.Ellipsis, nodes Nodes, cx X) bool
	VisitUnaryExpr(i I, d Dir, o *ast.Object, x *ast.UnaryExpr, nodes Nodes, cx X) bool
	VisitBinaryExpr(i I, d Dir, o *ast.Object, x *ast.BinaryExpr, nodes Nodes, cx X) bool
}

type Nodes = Stack[ast.Node]

type Stack[T comparable] []T

type TypeElementTypeVisitor[I Inspector, T types.Type, X any] func(i I, d Dir, o types.Object, x T, seen Types, cx X) bool

type TypeElementVisitor[I Inspector, T types.Object, X any] func(i I, d Dir, o types.Object, x T, seen Types, cx X) bool

type TypeInspector[X any] struct {
	WithUnexported bool
	Visitor        TypeVisitor[*TypeInspector[X], X]
	Pkg            *packages.Package
	Face           map[Face]struct{}
	X              X
	PopEach        bool //pop each Type when done
	TypePath            //the path from root to leaf, which is cutoff branches when current node is [ KMField ], [ KMParam ], [ KMResult ]; not include current visit node
}

type TypeKind int

type TypePath = Stack[TypeKind]

type TypeRootVisitor[I Inspector, T types.Object, X any] func(i I, d Dir, name string, e T, cx X) bool

type TypeVisitor[I Inspector, X any] interface {
	VisitConst(i I, d Dir, name string, e *types.Const, cx X) bool
	VisitFunc(i I, d Dir, name string, e *types.Func, cx X) bool
	VisitTypeName(i I, d Dir, name string, e *types.TypeName, cx X) bool
	VisitVar(i I, d Dir, name string, e *types.Var, cx X) bool

	VisitTypeVar(i I, d Dir, o types.Object, x *types.Var, seen Types, cx X) bool
	VisitTypeFunc(i I, d Dir, o types.Object, x *types.Func, seen Types, cx X) bool

	VisitTypeBasic(i I, d Dir, o types.Object, x *types.Basic, seen Types, cx X) bool
	VisitTypeMap(i I, d Dir, o types.Object, x *types.Map, seen Types, cx X) bool
	VisitTypeArray(i I, d Dir, o types.Object, x *types.Array, seen Types, cx X) bool
	VisitTypeStruct(i I, d Dir, o types.Object, x *types.Struct, seen Types, cx X) bool
	VisitTypeTuple(i I, d Dir, o types.Object, x *types.Tuple, seen Types, cx X) bool
	VisitTypeUnion(i I, d Dir, o types.Object, x *types.Union, seen Types, cx X) bool
	VisitTypeSignature(i I, d Dir, o types.Object, x *types.Signature, seen Types, cx X) bool
	VisitTypeParam(i I, d Dir, o types.Object, x *types.TypeParam, seen Types, cx X) bool
	VisitTypePointer(i I, d Dir, o types.Object, x *types.Pointer, seen Types, cx X) bool
	VisitTypeSlice(i I, d Dir, o types.Object, x *types.Slice, seen Types, cx X) bool
	VisitTypeInterface(i I, d Dir, o types.Object, x *types.Interface, seen Types, cx X) bool
	VisitTypeChan(i I, d Dir, o types.Object, x *types.Chan, seen Types, cx X) bool
	VisitTypeNamed(i I, d Dir, o types.Object, x *types.Named, seen Types, cx X) bool
}

type Types Stack[types.Type]

type Writer interface {
	Buffer() *bytes.Buffer
	Reset()
	UnWrite(n int)
	Format(format string, args ...any) Writer
	Append(w Writer) Writer
	Free()
	NotEmpty() bool
	LF() Writer
	Indent(n int) Writer
	Bytes() []byte
	fmt.Stringer
}