packages

type AssignPos int

type BlankId struct {
	// Filename identifies the source file of the node.
	Filename string

	// FilePos uniquely identifes the node within its file.
	//
	// It is 0-indexed and based on a counter of the occurence of blank identifiers within the file.
	FilePos int

	// GenDeclPos uniquely identifes the node within its parent ast.GenDecl node.
	//
	// It is 0-indexed and based on a counter of the occurence of blank identifiers within the ast.GenDecl.
	GenDeclPos int
}

type Cache struct {
	// Enabled is true if Cache.data reads and writes should be performed. If false, full queries always occur.
	Enabled bool

	// OnHit is called for each hit processed by LoadImportPath/LoadDir.
	OnHit OnHitFunc

	// OnMiss is called for each hit processed by LoadImportPath/LoadDir.
	OnMiss OnMissFunc
	// contains filtered or unexported fields
}

type CacheHit struct {
	// Key is the NewCacheKey value used in the query.
	Key string

	// Mode is the value used in the past query which populated the cached Package.
	//
	// It is a PkgIdx map key.
	Mode std_packages.LoadMode

	// Package is the cached query result.
	Value CacheValue
}

type CacheMiss struct {
	// Key is the NewCacheKey value used in the query.
	Key string

	// Mode is the value used in the current query.
	Mode std_packages.LoadMode
}

type CacheValue struct {
	*Package

	// WriteId is the value of Cache.writeId at creation time.
	WriteId int

	// Hits is a counter.
	Hits int
}

type Config struct {
	*std_packages.Config
}

type DirGlobalIdNodes map[string]PkgGlobalIdNodes

type DirGlobalIdShadows map[string]PkgGlobalIdShadows

type DirImportPaths map[string]PkgImportPaths

type DirImports map[string]PkgImports

type DirPkgs map[string]PkgsByName

type FileGlobalIdShadows map[string]Shadows

type FileImportPaths map[string]*cage_strings.Set

type FileImports map[string]PathImport

type FileNodes map[string]Node

type FilePkgs map[string]*Package

type FuncDeclShadows map[*ast.Ident]FuncDeclWithShadow

type FuncDeclWithShadow struct {
	// Name is the function/method name. Method names take this form: "<type name>.<method name>".
	Name string
}

type GlobalId struct {
	// Filename is the absolute path to the source file which declared the identifier.
	Filename string

	// PkgName is the package name as declared in the source file which declared the identifier.
	PkgName string

	// PkgPath is the package's import path.
	PkgPath string

	// Name is the global's name.
	Name GlobalIdName
}

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

type GlobalIdName = string

type GlobalInAstNode struct {
	// Ast is the identifier of the global's name.
	Ast ast.Node

	// BlankIdAssignPos is the position of the global in a blank identifier assignment, if applicable.
	BlankIdAssignPos AssignPos
}

type GlobalNode struct {
	Id          GlobalId
	InspectInfo NodeInspectInfo
}

type GlobalNodes map[ast.Node]IdToGlobalNode

type GlobalRef struct {
	// Name is from the global's declaration node.
	Name *ast.Ident

	// Parent is the ast.GenDecl/ast.FuncDecl which contains the Name node.
	Parent ast.Node

	// IsType is true if the global defines/declares a type.
	IsType bool

	// Types holds the declaration-name nodes of inspected types on which the global directly depends.
	//
	// For example, if the global defines a struct, then it will include the inspected types
	// of the fields.
	Types []*ast.Ident
}

type IdFilenames map[string]string

type IdToGlobalNode map[string]GlobalNode

type IdToNode map[GlobalIdName]Node

type IdUsedByNode struct {
	// BlankIdAssignPos describes where the identifier was used in a blank identifier assignment.
	// If it was not found in such an assignment, the value will be NonAssignUsage.
	//
	// It is only populated by full-node queries. Otherwise the value is always NonAssignUsage.
	BlankIdAssignPos AssignPos

	// Name identifies a global ast.Ident.
	Name GlobalIdName

	// IdentInfo describes the identifier itself, the global identifier to which the former refers
	// (which in declarations will be the same node, and the direct/transitive type dependencies.
	IdentInfo *IdentInfo
}

type IdUsedByNodeWalkFunc func(IdUsedByNode)

type IdentContext struct {
	// ImportQuals holds import paths, indexed by the ast.Ident of the field
	// in a "<import name>.<field>" ast.SelectorExpr.
	ImportQuals map[*ast.Ident]string
}

type IdentDecl struct {
	// Name is the subject identifier.
	Name *ast.Ident

	// Kind indicates what was declared: const, function, type, or var.
	Kind IdentDeclKind

	// Parent is the parent ast.GenDecl/ast.FuncDecl of the subject identifier.
	Parent ast.Node

	// SpecType is the type expression explicitly selected syntactically to the right
	// of the identifier, inferred from its const iota group, or inferred from the
	// value assigned to it.
	SpecType ast.Expr
}

type IdentDeclKind string

type IdentInfo struct {
	// Name is a copy of ast.Ident.Name.
	Name string

	// PkgName is the declared name of the package which contains  he node.
	PkgName string

	// PkgPath is the path of the package which contains the node.
	PkgPath string

	// Position provides source-file location details about the node.
	Position token.Position

	// IsTypeDecl is true if the node names a new type.
	IsTypeDecl bool

	// GlobalRef belongs to the global ast.Ident to which subject node ast.Ident refers.
	GlobalRef *IdentInfo

	// Type provides the node's direct type dependencies on inspected packages.
	//
	// The IdentInfo.Types elements type chains to determine all underlying types which
	// were also loaded by the same Inspector instance.
	//
	// Given "const C T = V", C's IdentInfo.Types would have one element because T is the
	// only direct/initial link in C's type chain.
	//
	// Given "type T1 func(T2, T3)", T2's IdentInfo.Types would have two elements because
	// T2 and T3 are both direct/initial links.
	//
	// If the node is just a use/reference of a type, rather than the declaration, then Type
	// will include the declaration.
	//
	// If the node is a struct field/method, then Type will include the struct type in addition
	// to the types directly used by the individual field/method.
	//
	// TypesString can assist with printing the type chains.
	Types IdentInfoSlice

	// IsCycle is true if the IdentInfo represents the start of a type dependency cycle.
	IsCycle bool
}

type IdentInfoSlice []*IdentInfo

type Import struct {
	// Dir is the absolute path of the source directory.
	Dir string

	// DeclName is the package name from the package clause.
	DeclName string

	// UsedName is the package name used in the importer file.
	//
	// By default it will equal DeclName unless initialized by a New* function which
	// has that information, or updated via SetUsedName (e.g. with an ast.ImportSpec.Name.Name).
	UsedName string

	// Path is the import path.
	Path string
}

type ImportIdx map[string]PkgIdx

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

type ImportPathGlobalIdNodes map[string]IdToNode

type InspectFunc func(n ast.Node, i NodeInspectInfo) bool

type Inspector struct {
	// BlankImports indexes `import _ "path/to/pkg"` occurrences.
	//
	// It is only populated if the query config includes x/tools/go/packages.NeedSyntax because
	// access to ast.ImportSpec nodes is required to know the import names.
	BlankImports DirImportPaths

	// DotImports indexes `import . "path/to/pkg"` occurrence.
	//
	// It is only populated if the query config includes x/tools/go/packages.NeedSyntax because
	// access to ast.ImportSpec nodes is required to know the import names.
	DotImports DirImportPaths

	// FuncDeclShadows indexes function/method declaration info by parameter and/or receiver identifiers.
	//
	// It supports queries to check if an ast.Ident in a declaration is known to shadow a global.
	FuncDeclShadows FuncDeclShadows

	// FileNodes holds the ast.Node of each file in discovered packages.
	FileNodes FileNodes

	// FilePkgs holds the Package of each file in discovered packages.
	FilePkgs FilePkgs

	// FileSet is the source file set that was parsed as a group during Inspect.
	FileSet *token.FileSet

	// GlobalIdNodes is first indexed by input directory names and then package names at the second level.
	//
	// It provides hierarchical access to the ast.Node of all global identifiers found during PreInspect.
	//
	// Unlike firstPassGlobalIdNames, it includes type methods using the format "<type name>.<method name>".
	//
	// Its leaf Node values may hold types such as ast.GenDecl. Therefore multiple FileNodes keys may
	// return the same Node value.
	//
	// GenDecl is an example of an ast.Node which can declare multiple identifiers, e.g. types
	// declared in a "type (...)" block. In such examples we store those identifiers in a group
	// in order to support use cases like AST rewriting, specifically node removal, which may
	// require more than simply remove an ast.Ident from the tree but instead modifying and
	// replacing the GenDecl as a whole.
	GlobalIdNodes DirGlobalIdNodes

	// ImportPathGlobalIdNodes holds the same node inventory as GlobalIdNodes but indexed by import path
	// instead of dir and package name.
	//
	// It supports cases such as verifying that a global identifier name exists in a package.
	ImportPathGlobalIdNodes ImportPathGlobalIdNodes

	// GlobalIdShadows is first indexed by input directory names and then package names at the second level.
	GlobalIdShadows DirGlobalIdShadows

	// GoFiles holds the files found in each input directory.
	GoFiles dirFiles

	// StdImports indexes Import values for standard library packages directly/transitively imported by
	// directories passed to NewInspector.
	//
	// If x/tools/go/packages.NeedSyntax, the filenames will instead be directory names because the former
	// are not available. Also, Import.UsedName may be inaccurate because the ast.ImportSpec values
	// were not available.
	//
	// Its Import values do not intersect with NonStdImports.
	StdImports DirImports

	// NonStdImports indexes Import values for packages declared in directories passed to NewInspector,
	// or directly/transitively imported by packages in those directories.
	//
	// If x/tools/go/packages.NeedSyntax, the filenames will instead be directory names because the former
	// are not available. Also, Import.UsedName may be inaccurate because the ast.ImportSpec values
	// were not available.
	//
	// Its Import values do not intersect with StdImports.
	NonStdImports DirImports

	// ImportPathToPkg is indexes packages import path.
	ImportPathToPkg map[string]*Package

	// pkgs describes the packages declared in each input directory.
	Pkgs DirPkgs

	// GlobalNodes holds details about AST nodes found in the global scope.
	GlobalNodes GlobalNodes

	// GlobalIdFilenames holds the filename of each global identifier declaration.
	GlobalIdFilenames PkgFilenames

	// UnsupportedTraits holds detected code traits which are not supported and may
	// cause the inspection results to be incorrect/incomplete.
	//
	// Instances of these traits are collected, instead of emitted in errors, to allow the
	// client to decide how to proceed based on its own needs.
	UnsupportedTraits []UnsupportedTrait
	// contains filtered or unexported fields
}

type Node struct {
	Ast         ast.Node
	InspectInfo NodeInspectInfo
}

type NodeInspectInfo struct {
	Dirname     string
	Filename    string
	GlobalScope bool

	// GlobalFuncName is name of the node's parent function or method.
	GlobalFuncName string

	// GlobalTypeName is name of the node's parent `type` declration.
	//
	// It differs from GlobalMethodTypeName which is only for method body nodes.
	GlobalTypeName string

	// InitFuncPos is -1 if the node is not an init function, otherwise it is the 0-indexed position
	// in the file among the other init functions (if any).
	InitFuncPos int

	PkgName string
	PkgPath string

	// IotaValuedNames holds the names of identifers in an ast.GenDecl which are iota-valued constants.
	IotaValuedNames *cage_strings.Set

	// NonStdImports is a copy of Inspector.NonStdImports[NodeInspectInfo.Dirname][NodeInspectInfo.PkgName].
	//
	// It is indexed by import paths.
	NonStdImports map[string]Import

	// MethodType holds the name of the parent type for all nodes inside a method body.
	//
	// If differs from the GlobalTypeName which is only for nodes in a `type` declaration.
	GlobalMethodTypeName string
}

type OnHitFunc func(CacheHit)

type OnMissFunc func(CacheMiss)

type Package struct {
	*std_packages.Package

	// Dir is derived from x/tools/go/packages.Package.GoFiles[0]
	Dir string

	// FileToName provides a mapping from ast.File pointers, returned by Load*, to the source filenames.
	FileToName map[*ast.File]string

	ImportPaths *cage_strings.Set

	// ImportPathToDir maps import paths to absolute paths of source directories.
	ImportPathToDir map[string]string

	// Goroot is true if the package is located under GOROOT.
	Goroot bool

	// Vendor is true if the package is located under a vendor directory.
	Vendor bool
}

type PackageUsedByNode struct {
	Name string
	Path string
}

type PackageUsedByNodeWalkFunc func(PackageUsedByNode)

type PathImport map[string]Import

type PkgFilenames map[string]IdFilenames

type PkgGlobalIdNodes map[string]IdToNode

type PkgGlobalIdShadows map[string]FileGlobalIdShadows

type PkgIdx map[std_packages.LoadMode]CacheValue

type PkgImportPaths map[string]FileImportPaths

type PkgImports map[string]FileImports

type PkgsByImportPath PkgsByString

type PkgsByName PkgsByString

type PkgsByString map[string]*Package

type Shadows map[string]*cage_strings.Set

type TraitType string

type UnsupportedTrait struct {
	// Type identifies the trait, e.g. blank identifier.
	Type TraitType

	// FileOrDir is the site's filename if possible, otherwise its directory.
	FileOrDir string

	// PkgPath is the site's import path
	PkgPath string

	// Msg provides additional detail specific to the trait.
	Msg string
}