code

type AstValueSpecOwner interface {
	AstValueSpec() *ast.ValueSpec
	Package() *Package
}

type Attribute uint32

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

type Constant struct {
	*types.Const

	Type    *TypeInfo
	Pkg     *Package // some duplicated with types.Const.Pkg()
	AstDecl *ast.GenDecl
	AstSpec *ast.ValueSpec
}

type EmbedMode uint8

type EmbeddedField struct {
	*Field
	Prev *EmbeddedField
}

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

type Field struct {
	AstField *ast.Field

	Pkg  *Package // (nil for exported. ??? Seems not true.)
	Name string
	Type *TypeInfo

	Tag  string
	Mode EmbedMode
	// contains filtered or unexported fields
}

type Function struct {
	*types.Func
	*types.Builtin // for builtin functions

	Type    *TypeInfo
	Pkg     *Package // some duplicated with types.Func.Pkg(), except builtin functions
	AstDecl *ast.FuncDecl
	// contains filtered or unexported fields
}

type FunctionResource interface {
	ValueResource
	IsMethod() bool
	//ReceiverTypeName() (paramField *ast.Field, typeIdent *ast.Ident, isStar bool)
	ReceiverTypeName() (paramField *ast.Field, typename *TypeName, isStar bool)
	AstFuncType() *ast.FuncType

	// For *Function, the result is the same as ValueResource.Package().
	// For *InterfaceMethod, this might be different (caused by embedding, or other reasons).
	AstPackage() *Package
}

type Identifier struct {
	FileInfo *SourceFileInfo
	AstIdent *ast.Ident
}

type Implementation struct {
	Impler    *TypeInfo // a struct or named type (same as the owner), or a pointer to such a type
	Interface *TypeInfo // an interface type
}

type Import struct {
	*types.PkgName

	Pkg     *Package // some duplicated with types.PkgName.Pkg()
	AstDecl *ast.GenDecl
	AstSpec *ast.ImportSpec
}

type InstantiatedInfo struct {
	TypeArgs []TypeExpr
}

type InterfaceMethod struct {
	InterfaceTypeName *TypeName
	//Method            *Method // .AstFunc == nil, .AstField  != nil
	Selector *Selector // .Method.AstFunc == nil,.Method .AstField  != nil

}

type LoadError struct {
	Errs []error
}

type Method struct {
	AstFunc *ast.FuncDecl // for concrete methods
	//AstInterface *ast.InterfaceType // for interface methods (the owner interface)
	AstField *ast.Field // for interface methods

	Pkg  *Package // (nil for exported. ??? Seems not true.)
	Name string
	Type *TypeInfo // ToDo: use custom struct including PointerRecv instead.

	PointerRecv         bool // duplicated info, for faster access
	ImplementsSomething bool // false if the method is unimportant for its reveiver to implement some interface type

	//>> 1.18, ToDo
	Parameterized bool // Containing parameter types which are parameterized.
	// contains filtered or unexported fields
}

type MethodSignature struct {
	Name string // must be an identifier other than "_"
	Pkg  string // the import path, for unepxorted method names only

	//InOutTypes []int32 // global type indexes
	InOutTypes string

	NumInOutAndVariadic int
}

type Module struct {
	Index int // users might make some optimizations by using the index

	Dir string // might be blank for vendored modules

	Path    string
	Version string

	// ...
	Replace moduleReplacement

	RepositoryCommit string // might be the same as Version, or not.
	RepositoryURL    string
	RepositoryDir    string // no much useful

	// Generally blank. But
	// 1. "/src" for std and "/src/cmd" for toolchain.
	// 2. Some modules are not at the root of their repositories.
	//    (Often, such a repository contains multiple modules.
	//    ex., for github.com/aws/aws-sdk-go-v2/service/{ec2,s3},
	//    they are service/s3, service/ec2)
	ExtraPathInRepository string

	Pkgs []*Package // seen packages
	// contains filtered or unexported fields
}

type Package struct {
	Index int               // ToDo: use this to do some optimizations
	PPkg  *packages.Package // ToDo: renamed to PP to be consistent with TypeInfo.TT?
	Path  string

	Deps      []*Package
	DepedBys  []*Package
	DepHeight int32 // 0 means the height is not determined yet. The order determines the parse order.
	DepDepth  int32 // 0 means the depth is not determined yet. The value mains how close to main pacakges. (Moved to user space).

	// This field might be shared with PackageForDisplay
	// for concurrent reads.
	*PackageAnalyzeResult                     // ToDo: not as pointer?
	AllResources          map[string]Resource // ToDo: use a slice to save memory
	SourceFiles           []SourceFileInfo
	ExampleFiles          []*ast.File
	Examples              []*doc.Example

	OneLineDoc string
	Directory  string
	// contains filtered or unexported fields
}

type PackageAnalyzeResult struct {
	AllTypeNames []*TypeName // not including instantiated ones
	AllFunctions []*Function // not including instantiated ones
	AllVariables []*Variable
	AllConstants []*Constant
	AllImports   []*Import

	CodeLinesWithBlankLines int32
	// contains filtered or unexported fields
}

type Resource interface {
	Name() string
	Exported() bool
	//IndexString() string
	Documentation() string
	Comment() string
	Position() token.Position
	Package() *Package
}

type Selector struct {
	Id string

	// One and only one of the two is nil.
	*Field
	*Method

	//>> 1.18
	Instantiated *InstantiatedInfo
	RealType     *TypeInfo

	EmbeddingChain *EmbeddedField // in the inverse order
	Depth          uint16         // the chain length
	Indirect       bool           // whether the chain contains indirects or not
	// contains filtered or unexported fields
}

type SelectorCond uint8

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

type SourceFileInfo struct {
	Pkg *Package // to remove one field in Identifier. Also good to external source line generation.

	// Filename only.
	BareFilename          string
	BareGeneratedFilename string

	// The full path of a (Go or others) source file.
	// It might be blank for some cgo generated files.
	OriginalFile string

	// The followings are blank for most files.
	GeneratedFile string

	// Non-nil for Go files.
	// If an original Go file has a corresponding generated file,
	// then the ast file is for that generated file.
	AstFile *ast.File

	// ...
	Content []byte
}

type Stats struct {
	Packages            int32
	StdPackages         int32
	AllPackageDeps      int32
	PackagesByDeps      [100]int32
	PackagesDepsTopList TopList

	FilesWithoutGenerateds int32 // without generated ones
	FilesWithGenerateds    int32 // with generated ones

	// To calculate imports per file.
	// Deps per packages are available in other ways.
	AstFiles                int32
	Imports                 int32
	FilesByImportCount      [100]int32
	FilesImportCountTopList TopList

	CodeLinesWithBlankLines           int32
	FilesByCodeLinesWithBlankLines    [100]int32
	FilesCodeLineTopList              TopList
	PackagesByCodeLinesWithBlankLines [100]int32
	PackagesCodeLineTopList           TopList

	// Types
	ExportedTypeNamesByKind    [KindCount]int32
	ExportedTypeNames          int32
	ExportedTypeAliases        int32
	ExportedCompositeTypeNames int32
	ExportedBasicTypeNames     int32
	ExportedNumericTypeNames   int32
	ExportedIntergerTypeNames  int32
	ExportedUnsignedTypeNames  int32

	//ExportedNamedStructTypeNames                        int32 // should be equal to ExportedTypeNamesByKind[reflect.Struct]
	ExportedNamedStructTypesWithEmbeddingFields   int32
	ExportedNamedStructTypesWithPromotedFields    int32
	ExportedNamedStructTypeFields                 int32
	ExportedNamedStructTypeExplicitFields         int32
	ExportedNamedStructTypeExportedFields         int32
	ExportedNamedStructTypeExportedExplicitFields int32

	ExportedNamedStructsByEmbeddingFieldCount        [100]int32
	ExportedNamedStructsEmbeddingFieldCountTopList   TopList
	ExportedNamedStructsByFieldCount                 [100]int32 // including promoteds and non-exporteds
	ExportedNamedStructsFieldCountTopList            TopList
	ExportedNamedStructsByExplicitFieldCount         [100]int32 // including non-exporteds but not including promoted
	ExportedNamedStructsExplicitFieldCountTopList    TopList
	ExportedNamedStructsByExportedFieldCount         [100]int32 // including promoteds
	ExportedNamedStructsExportedFieldCountTopList    TopList
	ExportedNamedStructsByExportedExplicitFieldCount [100]int32 // not including promoteds
	ExportedNamedStructsExportedExplicitFieldCount   TopList
	ExportedNamedStructsByExportedPromotedFieldCount [100]int32
	ExportedNamedStructsExportedPromotedFieldCount   TopList

	ExportedNamedNonInterfaceTypesByMethodCount              [100]int32 // T and *T combined
	ExportedNamedNonInterfaceTypesByExportedMethodCount      [100]int32 // T and *T combined
	ExportedNamedNonInterfaceTypesExportedMethodCountTopList TopList
	ExportedNamedNonInterfacesExportedMethods                int32
	ExportedNamedNonInterfacesWithExportedMethods            int32

	ExportedNamedInterfacesByMethodCount              [100]int32
	ExportedNamedInterfacesByExportedMethodCount      [100]int32 // the last element means (N-1)+
	ExportedNamedInterfacesExportedMethodCountTopList TopList
	ExportedNamedInterfacesExportedMethods            int32

	// Values
	ExportedVariables int32
	ExportedConstants int32
	ExportedFunctions int32
	ExportedMethods   int32 // non-interface methods

	ExportedVariablesByTypeKind [KindCount]int32
	ExportedConstantsByTypeKind [KindCount]int32

	// ToDo: Methods corresponding the same interface method should be viewed as one method in counting.
	ExportedFunctionParameters             int32      // including methods
	ExportedFunctionResults                int32      // including methods
	ExportedFunctionWithLastErrorResult    int32      // including methods
	ExportedFunctionsByParameterCount      [100]int32 // including methods
	ExportedFunctionsParameterCountTopList TopList
	ExportedFunctionsByResultCount         [100]int32 // including methods
	ExportedFunctionsResultCountTopList    TopList

	// Others.
	ExportedIdentifers             int32
	ExportedIdentifersSumLength    int32
	ExportedIdentifiersByLength    [100]int32
	ExportedIdentiferLengthTopList TopList
	// contains filtered or unexported fields
}

type ToolchainInfo struct {
	// Three paths
	Root, Src, Cmd string

	// A commit hash or something like "go1.16".
	// ToDo: now lso might be blank, but need some handling ...
	Version string
}

type TopList struct {
	Criteria int
	Items    []interface{}
}

type TypeExpr struct {
	Expr ast.Expr
	Type *TypeInfo
	Pkg  *Package
}

type TypeInfo struct {
	TT types.Type

	// ToDo:
	Exprs []ast.Expr

	Underlying *TypeInfo

	//>> 1.18
	// For named types only.
	// For an origin named type, Instantiated is always nil, and this == TypeName.Denoting.
	// For an instantiated type, Instantiated should not be nil, and this != TypeName.Denoting.
	// But for some diffcualies, the Instantiated field if an instantiated type is nil,
	// in which case, the selectors of the instantiated type is incomplete.
	//
	// ToDo: the Origin field might be useless. It is this if TypeName is nil, otherwise, it is TypeName.Denoting.
	//Origin *TypeInfo
	TypeName     *TypeName
	Instantiated *InstantiatedInfo

	//Implements     []*TypeInfo
	//StarImplements []*TypeInfo // if TT is neither pointer nor interface.
	Implements []Implementation

	// For interface types.
	ImplementedBys []*TypeInfo

	//
	Aliases []*TypeName

	// ToDo: For unnamed and builtin basic types.
	Underlieds []*TypeName

	// Explicit fields and methods.
	// * For named types, only explicitly declared methods are included.
	//   The field is only built for T. (*T).DirectSelectors is always nil.
	// * For named interface types, all explicitly specified methods and embedded types (as fields).
	// * For unnamed struct types, only direct fields. Only built for strct{...}, not for *struct{...}.
	// ToDo: note, for a type may have many alias, the ast.Expr (for types)
	//       recorded in a Selector is just one of many possibilities.
	DirectSelectors []*Selector
	EmbeddingFields int32 // for struct types only now. ToDo: also for interface types.

	// All methods, including extended/promoted ones.
	AllMethods []*Selector

	// All fields, including promoted ones.
	AllFields []*Selector

	// Ror rendering links in doc comments.
	// Built as neede.
	AllSelectors map[string]*Selector

	// For .TypeName != nil
	AsTypesOf   []ValueResource // variables and constants
	AsInputsOf  []ValueResource // variables and functions
	AsOutputsOf []ValueResource // variables and functions
	// contains filtered or unexported fields
}

type TypeName struct {
	Pkg     *Package // some duplicated with types.TypeName.Pkg(), except builtin types
	AstDecl *ast.GenDecl
	AstSpec *ast.TypeSpec

	// For alias TypeName, Source.Type is the denoting type.
	Source TypeExpr

	TypeParams []TypeExpr

	// It this is an alias, then Denoting is also the Source type.
	Denoting *TypeInfo

	*types.TypeName
	// contains filtered or unexported fields
}

type ValueResource interface {
	Resource
	TType() types.Type // The result should not be used in comparisons.
	TypeInfo(d *CodeAnalyzer) *TypeInfo
}

type Variable struct {
	*types.Var

	Type    *TypeInfo
	Pkg     *Package // some duplicated with types.Var.Pkg()
	AstDecl *ast.GenDecl
	AstSpec *ast.ValueSpec
}