package ast

Import Path
	go/ast (on golang.org and go.dev)

Dependency Relation
	imports 10 packages, and imported by 2 packages

Involved Source Files
	d-> ast.go
	    commentmap.go
	    filter.go
	    import.go
	    print.go
	    resolve.go
	    scope.go
	    walk.go

Exported Type Names

	 type ArrayType (struct)
		An ArrayType node represents an array or slice type.

		Exported Fields (3)
			Elt Expr
			Lbrack token.Pos
			Len Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type AssignStmt (struct)
		An AssignStmt node represents an assignment or
		a short variable declaration.

		Exported Fields (4)
			Lhs []Expr
			Rhs []Expr
			Tok token.Token
			TokPos token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type BadDecl (struct)
		A BadDecl node is a placeholder for a declaration containing
		syntax errors for which a correct declaration node cannot be
		created.

		Exported Fields (2)
			From token.Pos
			To token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Decl
			*T : Node
	 type BadExpr (struct)
		A BadExpr node is a placeholder for an expression containing
		syntax errors for which a correct expression node cannot be
		created.

		Exported Fields (2)
			From token.Pos
			To token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type BadStmt (struct)
		A BadStmt node is a placeholder for statements containing
		syntax errors for which no correct statement nodes can be
		created.

		Exported Fields (2)
			From token.Pos
			To token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type BasicLit (struct)
		A BasicLit node represents a literal of basic type.

		Exported Fields (3)
			Kind token.Token
			Value string
			ValuePos token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type BinaryExpr (struct)
		A BinaryExpr node represents a binary expression.

		Exported Fields (4)
			Op token.Token
			OpPos token.Pos
			X Expr
			Y Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type BlockStmt (struct)
		A BlockStmt node represents a braced statement list.

		Exported Fields (3)
			Lbrace token.Pos
			List []Stmt
			Rbrace token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type BranchStmt (struct)
		A BranchStmt node represents a break, continue, goto,
		or fallthrough statement.

		Exported Fields (3)
			Label *Ident
			Tok token.Token
			TokPos token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type CallExpr (struct)
		A CallExpr node represents an expression followed by an argument list.

		Exported Fields (5)
			Args []Expr
			Ellipsis token.Pos
			Fun Expr
			Lparen token.Pos
			Rparen token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type CaseClause (struct)
		A CaseClause represents a case of an expression or type switch statement.

		Exported Fields (4)
			Body []Stmt
			Case token.Pos
			Colon token.Pos
			List []Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type ChanDir int
		The direction of a channel type is indicated by a bit
		mask including one or both of the following constants.

		As Types Of (2+)
			const RECV
			const SEND
	 type ChanType (struct)
		A ChanType node represents a channel type.

		Exported Fields (4)
			Arrow token.Pos
			Begin token.Pos
			Dir ChanDir
			Value Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type CommClause (struct)
		A CommClause node represents a case of a select statement.

		Exported Fields (4)
			Body []Stmt
			Case token.Pos
			Colon token.Pos
			Comm Stmt
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Comment (struct)
		A Comment node represents a single //-style or /*-style comment.

		Exported Fields (2)
			Slash token.Pos
			Text string
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (1+)
			*T : Node
	 type CommentGroup (struct)
		A CommentGroup represents a sequence of comments
		with no other tokens and no empty lines between.

		One Exported Field
			List []*Comment
		Exported Methods (3)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
			(*T) Text() string
		Implements (1+)
			*T : Node
		As Outputs Of (1+)
			func CommentMap.Comments() []*CommentGroup
		As Inputs Of (1+)
			func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap
	 type CommentMap (map)
		A CommentMap maps an AST node to a list of comment groups
		associated with it. See NewCommentMap for a description of
		the association.

		Exported Methods (4)
			 (T) Comments() []*CommentGroup
			 (T) Filter(node Node) CommentMap
			 (T) String() string
			 (T) Update(old, new Node) Node
		Implements (1+)
			 T : fmt.Stringer
		As Outputs Of (2+)
			func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap
			func CommentMap.Filter(node Node) CommentMap
	 type CompositeLit (struct)
		A CompositeLit node represents a composite literal.

		Exported Fields (5)
			Elts []Expr
			Incomplete bool
			Lbrace token.Pos
			Rbrace token.Pos
			Type Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type Decl (interface)
		All declaration nodes implement the Decl interface.

		Exported Methods (2)
			 (T) End() token.Pos
			 (T) Pos() token.Pos
		Implemented By (3+)
			*BadDecl
			*FuncDecl
			*GenDecl
		Implements (1+)
			 T : Node
		As Inputs Of (1+)
			func FilterDecl(decl Decl, f Filter) bool
	 type DeclStmt (struct)
		A DeclStmt node represents a declaration in a statement list.

		One Exported Field
			Decl Decl
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type DeferStmt (struct)
		A DeferStmt node represents a defer statement.

		Exported Fields (2)
			Call *CallExpr
			Defer token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Ellipsis (struct)
		An Ellipsis node stands for the "..." type in a
		parameter list or the "..." length in an array type.

		Exported Fields (2)
			Ellipsis token.Pos
			Elt Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type EmptyStmt (struct)
		An EmptyStmt node represents an empty statement.
		The "position" of the empty statement is the position
		of the immediately following (explicit or implicit) semicolon.

		Exported Fields (2)
			Implicit bool
			Semicolon token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Expr (interface)
		All expression nodes implement the Expr interface.

		Exported Methods (2)
			 (T) End() token.Pos
			 (T) Pos() token.Pos
		Implemented By (22+)
			*ArrayType
			*BadExpr
			*BasicLit
			*BinaryExpr
			*CallExpr
			*ChanType
			*CompositeLit
			*Ellipsis
			*FuncLit
			*FuncType
			*Ident
			*IndexExpr
			*InterfaceType
			*KeyValueExpr
			*MapType
			*ParenExpr
			*SelectorExpr
			*SliceExpr
			*StarExpr
			*StructType
			*TypeAssertExpr
			*UnaryExpr
		Implements (1+)
			 T : Node
	 type ExprStmt (struct)
		An ExprStmt node represents a (stand-alone) expression
		in a statement list.

		One Exported Field
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Field (struct)
		A Field represents a Field declaration list in a struct type,
		a method list in an interface type, or a parameter/result declaration
		in a signature.
		Field.Names is nil for unnamed parameters (parameter lists which only contain types)
		and embedded struct fields. In the latter case, the field name is the type name.

		Exported Fields (5)
			Comment *CommentGroup
			Doc *CommentGroup
			Names []*Ident
			Tag *BasicLit
			Type Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (1+)
			*T : Node
	 type FieldFilter (func)
		A FieldFilter may be provided to Fprint to control the output.

		As Inputs Of (1+)
			func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) error
	 type FieldList (struct)
		A FieldList represents a list of Fields, enclosed by parentheses or braces.

		Exported Fields (3)
			Closing token.Pos
			List []*Field
			Opening token.Pos
		Exported Methods (3)
			(*T) End() token.Pos
			(*T) NumFields() int
			(*T) Pos() token.Pos
		Implements (1+)
			*T : Node
	 type File (struct)
		A File node represents a Go source file.

		The Comments list contains all comments in the source file in order of
		appearance, including the comments that are pointed to from other nodes
		via Doc and Comment fields.

		For correct printing of source code containing comments (using packages
		go/format and go/printer), special care must be taken to update comments
		when a File's syntax tree is modified: For printing, comments are interspersed
		between tokens based on their position. If syntax tree nodes are
		removed or moved, relevant comments in their vicinity must also be removed
		(from the File.Comments list) or moved accordingly (by updating their
		positions). A CommentMap may be used to facilitate some of these operations.

		Whether and how a comment is associated with a node depends on the
		interpretation of the syntax tree by the manipulating program: Except for Doc
		and Comment comments directly associated with nodes, the remaining comments
		are "free-floating" (see also issues #18593, #20744).

		Exported Fields (8)
			Comments []*CommentGroup
			Decls []Decl
			Doc *CommentGroup
			Imports []*ImportSpec
			Name *Ident
			Package token.Pos
			Scope *Scope
			Unresolved []*Ident
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (1+)
			*T : Node
		As Outputs Of (1+)
			func MergePackageFiles(pkg *Package, mode MergeMode) *File
		As Inputs Of (4+)
			func FileExports(src *File) bool
			func FilterFile(src *File, f Filter) bool
			func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)
			func SortImports(fset *token.FileSet, f *File)
	 type Filter (func)

		As Inputs Of (3+)
			func FilterDecl(decl Decl, f Filter) bool
			func FilterFile(src *File, f Filter) bool
			func FilterPackage(pkg *Package, f Filter) bool
	 type ForStmt (struct)
		A ForStmt represents a for statement.

		Exported Fields (5)
			Body *BlockStmt
			Cond Expr
			For token.Pos
			Init Stmt
			Post Stmt
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type FuncDecl (struct)
		A FuncDecl node represents a function declaration.

		Exported Fields (5)
			Body *BlockStmt
			Doc *CommentGroup
			Name *Ident
			Recv *FieldList
			Type *FuncType
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Decl
			*T : Node
	 type FuncLit (struct)
		A FuncLit node represents a function literal.

		Exported Fields (2)
			Body *BlockStmt
			Type *FuncType
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type FuncType (struct)
		A FuncType node represents a function type.

		Exported Fields (3)
			Func token.Pos
			Params *FieldList
			Results *FieldList
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type GenDecl (struct)
		A GenDecl node (generic declaration node) represents an import,
		constant, type or variable declaration. A valid Lparen position
		(Lparen.IsValid()) indicates a parenthesized declaration.

		Relationship between Tok value and Specs element type:

			token.IMPORT  *ImportSpec
			token.CONST   *ValueSpec
			token.TYPE    *TypeSpec
			token.VAR     *ValueSpec

		Exported Fields (6)
			Doc *CommentGroup
			Lparen token.Pos
			Rparen token.Pos
			Specs []Spec
			Tok token.Token
			TokPos token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Decl
			*T : Node
	 type GoStmt (struct)
		A GoStmt node represents a go statement.

		Exported Fields (2)
			Call *CallExpr
			Go token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Ident (struct)
		An Ident node represents an identifier.

		Exported Fields (3)
			Name string
			NamePos token.Pos
			Obj *Object
		Exported Methods (4)
			(*T) End() token.Pos
			(*T) IsExported() bool
			(*T) Pos() token.Pos
			(*T) String() string
		Implements (3+)
			*T : Expr
			*T : Node
			*T : fmt.Stringer
		As Outputs Of (1+)
			func NewIdent(name string) *Ident
	 type IfStmt (struct)
		An IfStmt node represents an if statement.

		Exported Fields (5)
			Body *BlockStmt
			Cond Expr
			Else Stmt
			If token.Pos
			Init Stmt
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Importer (func)
		An Importer resolves import paths to package Objects.
		The imports map records the packages already imported,
		indexed by package id (canonical import path).
		An Importer must determine the canonical import path and
		check the map to see if it is already present in the imports map.
		If so, the Importer can return the map entry. Otherwise, the
		Importer should load the package data for the given path into
		a new *Object (pkg), record pkg in the imports map, and then
		return pkg.

		As Inputs Of (1+)
			func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)
	 type ImportSpec (struct)
		An ImportSpec node represents a single package import.

		Exported Fields (5)
			Comment *CommentGroup
			Doc *CommentGroup
			EndPos token.Pos
			Name *Ident
			Path *BasicLit
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Spec
	 type IncDecStmt (struct)
		An IncDecStmt node represents an increment or decrement statement.

		Exported Fields (3)
			Tok token.Token
			TokPos token.Pos
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type IndexExpr (struct)
		An IndexExpr node represents an expression followed by an index.

		Exported Fields (4)
			Index Expr
			Lbrack token.Pos
			Rbrack token.Pos
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type InterfaceType (struct)
		An InterfaceType node represents an interface type.

		Exported Fields (3)
			Incomplete bool
			Interface token.Pos
			Methods *FieldList
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type KeyValueExpr (struct)
		A KeyValueExpr node represents (key : value) pairs
		in composite literals.

		Exported Fields (3)
			Colon token.Pos
			Key Expr
			Value Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type LabeledStmt (struct)
		A LabeledStmt node represents a labeled statement.

		Exported Fields (3)
			Colon token.Pos
			Label *Ident
			Stmt Stmt
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type MapType (struct)
		A MapType node represents a map type.

		Exported Fields (3)
			Key Expr
			Map token.Pos
			Value Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type MergeMode uint
		The MergeMode flags control the behavior of MergePackageFiles.

		As Inputs Of (1+)
			func MergePackageFiles(pkg *Package, mode MergeMode) *File
		As Types Of (3+)
			const FilterFuncDuplicates
			const FilterImportDuplicates
			const FilterUnassociatedComments
	 type Node (interface)
		All node types implement the Node interface.

		Exported Methods (2)
			 (T) End() token.Pos
			 (T) Pos() token.Pos
		Implemented By (59+)
			*ArrayType
			*AssignStmt
			*BadDecl
			*BadExpr
			*BadStmt
			*BasicLit
			*BinaryExpr
			*BlockStmt
			*BranchStmt
			*CallExpr
			*CaseClause
			*ChanType
			*CommClause
			*Comment
			*CommentGroup
			*CompositeLit
			Decl (interface)
			*DeclStmt
			*DeferStmt
			*Ellipsis
			*EmptyStmt
			Expr (interface)
			*ExprStmt
			*Field
			*FieldList
			*File
			*ForStmt
			*FuncDecl
			*FuncLit
			*FuncType
			*GenDecl
			*GoStmt
			*Ident
			*IfStmt
			*ImportSpec
			*IncDecStmt
			*IndexExpr
			*InterfaceType
			*KeyValueExpr
			*LabeledStmt
			*MapType
			*Package
			*ParenExpr
			*RangeStmt
			*ReturnStmt
			*SelectorExpr
			*SelectStmt
			*SendStmt
			*SliceExpr
			Spec (interface)
			*StarExpr
			Stmt (interface)
			*StructType
			*SwitchStmt
			*TypeAssertExpr
			*TypeSpec
			*TypeSwitchStmt
			*UnaryExpr
			*ValueSpec
		As Outputs Of (1+)
			func CommentMap.Update(old, new Node) Node
		As Inputs Of (6+)
			func Inspect(node Node, f func(Node) bool)
			func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap
			func Walk(v Visitor, node Node)
			func CommentMap.Filter(node Node) CommentMap
			func CommentMap.Update(old, new Node) Node
			func Visitor.Visit(node Node) (w Visitor)
	 type Object (struct)
		An Object describes a named language entity such as a package,
		constant, type, variable, function (incl. methods), or label.

		The Data fields contains object-specific data:

			Kind    Data type         Data value
			Pkg     *Scope            package scope
			Con     int               iota for the respective declaration

		Exported Fields (5)
			Data interface{}
			Decl interface{}
			Kind ObjKind
			Name string
			Type interface{}
		One Exported Method
			(*T) Pos() token.Pos
		As Outputs Of (3+)
			func NewObj(kind ObjKind, name string) *Object
			func (*Scope).Insert(obj *Object) (alt *Object)
			func (*Scope).Lookup(name string) *Object
		As Inputs Of (1+)
			func (*Scope).Insert(obj *Object) (alt *Object)
	 type ObjKind int
		ObjKind describes what an object represents.

		One Exported Method
			 (T) String() string
		Implements (1+)
			 T : fmt.Stringer
		As Inputs Of (1+)
			func NewObj(kind ObjKind, name string) *Object
		As Types Of (7+)
			const Bad
			const Con
			const Fun
			const Lbl
			const Pkg
			const Typ
			const Var
	 type Package (struct)
		A Package node represents a set of source files
		collectively building a Go package.

		Exported Fields (4)
			Files map[string]*File
			Imports map[string]*Object
			Name string
			Scope *Scope
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (1+)
			*T : Node
		As Outputs Of (1+)
			func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)
		As Inputs Of (3+)
			func FilterPackage(pkg *Package, f Filter) bool
			func MergePackageFiles(pkg *Package, mode MergeMode) *File
			func PackageExports(pkg *Package) bool
	 type ParenExpr (struct)
		A ParenExpr node represents a parenthesized expression.

		Exported Fields (3)
			Lparen token.Pos
			Rparen token.Pos
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type RangeStmt (struct)
		A RangeStmt represents a for statement with a range clause.

		Exported Fields (7)
			Body *BlockStmt
			For token.Pos
			Key Expr
			Tok token.Token
			TokPos token.Pos
			Value Expr
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type ReturnStmt (struct)
		A ReturnStmt node represents a return statement.

		Exported Fields (2)
			Results []Expr
			Return token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type Scope (struct)
		A Scope maintains the set of named language entities declared
		in the scope and a link to the immediately surrounding (outer)
		scope.

		Exported Fields (2)
			Objects map[string]*Object
			Outer *Scope
		Exported Methods (3)
			(*T) Insert(obj *Object) (alt *Object)
			(*T) Lookup(name string) *Object
			(*T) String() string
		Implements (1+)
			*T : fmt.Stringer
		As Outputs Of (1+)
			func NewScope(outer *Scope) *Scope
		As Inputs Of (2+)
			func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)
			func NewScope(outer *Scope) *Scope
	 type SelectorExpr (struct)
		A SelectorExpr node represents an expression followed by a selector.

		Exported Fields (2)
			Sel *Ident
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type SelectStmt (struct)
		A SelectStmt node represents a select statement.

		Exported Fields (2)
			Body *BlockStmt
			Select token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type SendStmt (struct)
		A SendStmt node represents a send statement.

		Exported Fields (3)
			Arrow token.Pos
			Chan Expr
			Value Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type SliceExpr (struct)
		A SliceExpr node represents an expression followed by slice indices.

		Exported Fields (7)
			High Expr
			Lbrack token.Pos
			Low Expr
			Max Expr
			Rbrack token.Pos
			Slice3 bool
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type Spec (interface)
		The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.

		Exported Methods (2)
			 (T) End() token.Pos
			 (T) Pos() token.Pos
		Implemented By (3+)
			*ImportSpec
			*TypeSpec
			*ValueSpec
		Implements (1+)
			 T : Node
	 type StarExpr (struct)
		A StarExpr node represents an expression of the form "*" Expression.
		Semantically it could be a unary "*" expression, or a pointer type.

		Exported Fields (2)
			Star token.Pos
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type Stmt (interface)
		All statement nodes implement the Stmt interface.

		Exported Methods (2)
			 (T) End() token.Pos
			 (T) Pos() token.Pos
		Implemented By (21+)
			*AssignStmt
			*BadStmt
			*BlockStmt
			*BranchStmt
			*CaseClause
			*CommClause
			*DeclStmt
			*DeferStmt
			*EmptyStmt
			*ExprStmt
			*ForStmt
			*GoStmt
			*IfStmt
			*IncDecStmt
			*LabeledStmt
			*RangeStmt
			*ReturnStmt
			*SelectStmt
			*SendStmt
			*SwitchStmt
			*TypeSwitchStmt
		Implements (1+)
			 T : Node
	 type StructType (struct)
		A StructType node represents a struct type.

		Exported Fields (3)
			Fields *FieldList
			Incomplete bool
			Struct token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type SwitchStmt (struct)
		A SwitchStmt node represents an expression switch statement.

		Exported Fields (4)
			Body *BlockStmt
			Init Stmt
			Switch token.Pos
			Tag Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type TypeAssertExpr (struct)
		A TypeAssertExpr node represents an expression followed by a
		type assertion.

		Exported Fields (4)
			Lparen token.Pos
			Rparen token.Pos
			Type Expr
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type TypeSpec (struct)
		A TypeSpec node represents a type declaration (TypeSpec production).

		Exported Fields (5)
			Assign token.Pos
			Comment *CommentGroup
			Doc *CommentGroup
			Name *Ident
			Type Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Spec
	 type TypeSwitchStmt (struct)
		A TypeSwitchStmt node represents a type switch statement.

		Exported Fields (4)
			Assign Stmt
			Body *BlockStmt
			Init Stmt
			Switch token.Pos
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Stmt
	 type UnaryExpr (struct)
		A UnaryExpr node represents a unary expression.
		Unary "*" expressions are represented via StarExpr nodes.

		Exported Fields (3)
			Op token.Token
			OpPos token.Pos
			X Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Expr
			*T : Node
	 type ValueSpec (struct)
		A ValueSpec node represents a constant or variable declaration
		(ConstSpec or VarSpec production).

		Exported Fields (5)
			Comment *CommentGroup
			Doc *CommentGroup
			Names []*Ident
			Type Expr
			Values []Expr
		Exported Methods (2)
			(*T) End() token.Pos
			(*T) Pos() token.Pos
		Implements (2+)
			*T : Node
			*T : Spec
	 type Visitor (interface)
		A Visitor's Visit method is invoked for each node encountered by Walk.
		If the result visitor w is not nil, Walk visits each of the children
		of node with the visitor w, followed by a call of w.Visit(nil).

		One Exported Method
			 (T) Visit(node Node) (w Visitor)
		As Outputs Of (1+)
			func Visitor.Visit(node Node) (w Visitor)
		As Inputs Of (1+)
			func Walk(v Visitor, node Node)
Exported Values

	const Bad ObjKind = 0 // for error handling
		The list of possible Object kinds.
	const Con ObjKind = 2 // constant
		The list of possible Object kinds.
	 func FileExports(src *File) bool
		FileExports trims the AST for a Go source file in place such that
		only exported nodes remain: all top-level identifiers which are not exported
		and their associated information (such as type, initial value, or function
		body) are removed. Non-exported fields and methods of exported types are
		stripped. The File.Comments list is not changed.

		FileExports reports whether there are exported declarations.
	 func FilterDecl(decl Decl, f Filter) bool
		FilterDecl trims the AST for a Go declaration in place by removing
		all names (including struct field and interface method names, but
		not from parameter lists) that don't pass through the filter f.

		FilterDecl reports whether there are any declared names left after
		filtering.
	 func FilterFile(src *File, f Filter) bool
		FilterFile trims the AST for a Go file in place by removing all
		names from top-level declarations (including struct field and
		interface method names, but not from parameter lists) that don't
		pass through the filter f. If the declaration is empty afterwards,
		the declaration is removed from the AST. Import declarations are
		always removed. The File.Comments list is not changed.

		FilterFile reports whether there are any top-level declarations
		left after filtering.
	const FilterFuncDuplicates MergeMode = 1
		If set, duplicate function declarations are excluded.
	const FilterImportDuplicates MergeMode = 4
		If set, duplicate import declarations are excluded.
	 func FilterPackage(pkg *Package, f Filter) bool
		FilterPackage trims the AST for a Go package in place by removing
		all names from top-level declarations (including struct field and
		interface method names, but not from parameter lists) that don't
		pass through the filter f. If the declaration is empty afterwards,
		the declaration is removed from the AST. The pkg.Files list is not
		changed, so that file names and top-level package comments don't get
		lost.

		FilterPackage reports whether there are any top-level declarations
		left after filtering.
	const FilterUnassociatedComments MergeMode = 2
		If set, comments that are not associated with a specific
		AST node (as Doc or Comment) are excluded.
	 func Fprint(w io.Writer, fset *token.FileSet, x interface{}, f FieldFilter) error
		Fprint prints the (sub-)tree starting at AST node x to w.
		If fset != nil, position information is interpreted relative
		to that file set. Otherwise positions are printed as integer
		values (file set specific offsets).

		A non-nil FieldFilter f may be provided to control the output:
		struct fields for which f(fieldname, fieldvalue) is true are
		printed; all others are filtered from the output. Unexported
		struct fields are never printed.
	const Fun ObjKind = 5 // function or method
		The list of possible Object kinds.
	 func Inspect(node Node, f func(Node) bool)
		Inspect traverses an AST in depth-first order: It starts by calling
		f(node); node must not be nil. If f returns true, Inspect invokes f
		recursively for each of the non-nil children of node, followed by a
		call of f(nil).
	 func IsExported(name string) bool
		IsExported reports whether name starts with an upper-case letter.
	const Lbl ObjKind = 6 // label
		The list of possible Object kinds.
	 func MergePackageFiles(pkg *Package, mode MergeMode) *File
		MergePackageFiles creates a file AST by merging the ASTs of the
		files belonging to a package. The mode flags control merging behavior.
	 func NewCommentMap(fset *token.FileSet, node Node, comments []*CommentGroup) CommentMap
		NewCommentMap creates a new comment map by associating comment groups
		of the comments list with the nodes of the AST specified by node.

		A comment group g is associated with a node n if:

		  - g starts on the same line as n ends
		  - g starts on the line immediately following n, and there is
		    at least one empty line after g and before the next node
		  - g starts before n and is not associated to the node before n
		    via the previous rules

		NewCommentMap tries to associate a comment group to the "largest"
		node possible: For instance, if the comment is a line comment
		trailing an assignment, the comment is associated with the entire
		assignment rather than just the last operand in the assignment.
	 func NewIdent(name string) *Ident
		NewIdent creates a new Ident without position.
		Useful for ASTs generated by code other than the Go parser.
	 func NewObj(kind ObjKind, name string) *Object
		NewObj creates a new object of a given kind and name.
	 func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)
		NewPackage creates a new Package node from a set of File nodes. It resolves
		unresolved identifiers across files and updates each file's Unresolved list
		accordingly. If a non-nil importer and universe scope are provided, they are
		used to resolve identifiers not declared in any of the package files. Any
		remaining unresolved identifiers are reported as undeclared. If the files
		belong to different packages, one package name is selected and files with
		different package names are reported and then ignored.
		The result is a package node and a scanner.ErrorList if there were errors.
	 func NewScope(outer *Scope) *Scope
		NewScope creates a new scope nested in the outer scope.
	 func NotNilFilter(_ string, v reflect.Value) bool
		NotNilFilter returns true for field values that are not nil;
		it returns false otherwise.
	 func PackageExports(pkg *Package) bool
		PackageExports trims the AST for a Go package in place such that
		only exported nodes remain. The pkg.Files list is not changed, so that
		file names and top-level package comments don't get lost.

		PackageExports reports whether there are exported declarations;
		it returns false otherwise.
	const Pkg ObjKind = 1 // package
		The list of possible Object kinds.
	 func Print(fset *token.FileSet, x interface{}) error
		Print prints x to standard output, skipping nil fields.
		Print(fset, x) is the same as Fprint(os.Stdout, fset, x, NotNilFilter).
	const RECV ChanDir = 2
	const SEND ChanDir = 1
	 func SortImports(fset *token.FileSet, f *File)
		SortImports sorts runs of consecutive import lines in import blocks in f.
		It also removes duplicate imports when it is possible to do so without data loss.
	const Typ ObjKind = 3 // type
		The list of possible Object kinds.
	const Var ObjKind = 4 // variable
		The list of possible Object kinds.
	 func Walk(v Visitor, node Node)
		Walk traverses an AST in depth-first order: It starts by calling
		v.Visit(node); node must not be nil. If the visitor w returned by
		v.Visit(node) is not nil, Walk is invoked recursively with visitor
		w for each of the non-nil children of node, followed by a call of
		w.Visit(nil).

The pages are generated with Golds v0.1.6. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project and developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.