Documentation

Overview

    Package ast declares the types used to represent syntax trees for Go packages.

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func FileExports

    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

      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

        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.

          func FilterPackage

          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.

            func Fprint

            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.

              func Inspect

              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).

                Example

                  This example demonstrates how to inspect the AST of a Go program.

                  Output:
                  
                  src.go:2:9:	p
                  src.go:3:7:	c
                  src.go:3:11:	1.0
                  src.go:4:5:	X
                  src.go:4:9:	f
                  src.go:4:11:	3.14
                  src.go:4:17:	2
                  src.go:4:21:	c
                  

                  func IsExported

                  func IsExported(name string) bool

                    IsExported reports whether name starts with an upper-case letter.

                    func NotNilFilter

                    func NotNilFilter(_ string, v reflect.Value) bool

                      NotNilFilter returns true for field values that are not nil; it returns false otherwise.

                      func PackageExports

                      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.

                        func Print

                        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).

                          Example

                            This example shows what an AST looks like when printed for debugging.

                            Output:
                            
                                 0  *ast.File {
                                 1  .  Package: 2:1
                                 2  .  Name: *ast.Ident {
                                 3  .  .  NamePos: 2:9
                                 4  .  .  Name: "main"
                                 5  .  }
                                 6  .  Decls: []ast.Decl (len = 1) {
                                 7  .  .  0: *ast.FuncDecl {
                                 8  .  .  .  Name: *ast.Ident {
                                 9  .  .  .  .  NamePos: 3:6
                                10  .  .  .  .  Name: "main"
                                11  .  .  .  .  Obj: *ast.Object {
                                12  .  .  .  .  .  Kind: func
                                13  .  .  .  .  .  Name: "main"
                                14  .  .  .  .  .  Decl: *(obj @ 7)
                                15  .  .  .  .  }
                                16  .  .  .  }
                                17  .  .  .  Type: *ast.FuncType {
                                18  .  .  .  .  Func: 3:1
                                19  .  .  .  .  Params: *ast.FieldList {
                                20  .  .  .  .  .  Opening: 3:10
                                21  .  .  .  .  .  Closing: 3:11
                                22  .  .  .  .  }
                                23  .  .  .  }
                                24  .  .  .  Body: *ast.BlockStmt {
                                25  .  .  .  .  Lbrace: 3:13
                                26  .  .  .  .  List: []ast.Stmt (len = 1) {
                                27  .  .  .  .  .  0: *ast.ExprStmt {
                                28  .  .  .  .  .  .  X: *ast.CallExpr {
                                29  .  .  .  .  .  .  .  Fun: *ast.Ident {
                                30  .  .  .  .  .  .  .  .  NamePos: 4:2
                                31  .  .  .  .  .  .  .  .  Name: "println"
                                32  .  .  .  .  .  .  .  }
                                33  .  .  .  .  .  .  .  Lparen: 4:9
                                34  .  .  .  .  .  .  .  Args: []ast.Expr (len = 1) {
                                35  .  .  .  .  .  .  .  .  0: *ast.BasicLit {
                                36  .  .  .  .  .  .  .  .  .  ValuePos: 4:10
                                37  .  .  .  .  .  .  .  .  .  Kind: STRING
                                38  .  .  .  .  .  .  .  .  .  Value: "\"Hello, World!\""
                                39  .  .  .  .  .  .  .  .  }
                                40  .  .  .  .  .  .  .  }
                                41  .  .  .  .  .  .  .  Ellipsis: -
                                42  .  .  .  .  .  .  .  Rparen: 4:25
                                43  .  .  .  .  .  .  }
                                44  .  .  .  .  .  }
                                45  .  .  .  .  }
                                46  .  .  .  .  Rbrace: 5:1
                                47  .  .  .  }
                                48  .  .  }
                                49  .  }
                                50  .  Scope: *ast.Scope {
                                51  .  .  Objects: map[string]*ast.Object (len = 1) {
                                52  .  .  .  "main": *(obj @ 11)
                                53  .  .  }
                                54  .  }
                                55  .  Unresolved: []*ast.Ident (len = 1) {
                                56  .  .  0: *(obj @ 29)
                                57  .  }
                                58  }
                            

                            func SortImports

                            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.

                              func Walk

                              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).

                                Types

                                type ArrayType

                                type ArrayType struct {
                                	Lbrack token.Pos // position of "["
                                	Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
                                	Elt    Expr      // element type
                                }

                                  An ArrayType node represents an array or slice type.

                                  func (*ArrayType) End

                                  func (x *ArrayType) End() token.Pos

                                  func (*ArrayType) Pos

                                  func (x *ArrayType) Pos() token.Pos

                                  type AssignStmt

                                  type AssignStmt struct {
                                  	Lhs    []Expr
                                  	TokPos token.Pos   // position of Tok
                                  	Tok    token.Token // assignment token, DEFINE
                                  	Rhs    []Expr
                                  }

                                    An AssignStmt node represents an assignment or a short variable declaration.

                                    func (*AssignStmt) End

                                    func (s *AssignStmt) End() token.Pos

                                    func (*AssignStmt) Pos

                                    func (s *AssignStmt) Pos() token.Pos

                                    type BadDecl

                                    type BadDecl struct {
                                    	From, To token.Pos // position range of bad declaration
                                    }

                                      A BadDecl node is a placeholder for a declaration containing syntax errors for which a correct declaration node cannot be created.

                                      func (*BadDecl) End

                                      func (d *BadDecl) End() token.Pos

                                      func (*BadDecl) Pos

                                      func (d *BadDecl) Pos() token.Pos

                                      type BadExpr

                                      type BadExpr struct {
                                      	From, To token.Pos // position range of bad expression
                                      }

                                        A BadExpr node is a placeholder for an expression containing syntax errors for which a correct expression node cannot be created.

                                        func (*BadExpr) End

                                        func (x *BadExpr) End() token.Pos

                                        func (*BadExpr) Pos

                                        func (x *BadExpr) Pos() token.Pos

                                        type BadStmt

                                        type BadStmt struct {
                                        	From, To token.Pos // position range of bad statement
                                        }

                                          A BadStmt node is a placeholder for statements containing syntax errors for which no correct statement nodes can be created.

                                          func (*BadStmt) End

                                          func (s *BadStmt) End() token.Pos

                                          func (*BadStmt) Pos

                                          func (s *BadStmt) Pos() token.Pos

                                          type BasicLit

                                          type BasicLit struct {
                                          	ValuePos token.Pos   // literal position
                                          	Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
                                          	Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
                                          }

                                            A BasicLit node represents a literal of basic type.

                                            Note that for the CHAR and STRING kinds, the literal is stored with its quotes. For example, for a double-quoted STRING, the first and the last rune in the Value field will be ". The Unquote and UnquoteChar functions in the strconv package can be used to unquote STRING and CHAR values, respectively.

                                            func (*BasicLit) End

                                            func (x *BasicLit) End() token.Pos

                                            func (*BasicLit) Pos

                                            func (x *BasicLit) Pos() token.Pos

                                            type BinaryExpr

                                            type BinaryExpr struct {
                                            	X     Expr        // left operand
                                            	OpPos token.Pos   // position of Op
                                            	Op    token.Token // operator
                                            	Y     Expr        // right operand
                                            }

                                              A BinaryExpr node represents a binary expression.

                                              func (*BinaryExpr) End

                                              func (x *BinaryExpr) End() token.Pos

                                              func (*BinaryExpr) Pos

                                              func (x *BinaryExpr) Pos() token.Pos

                                              type BlockStmt

                                              type BlockStmt struct {
                                              	Lbrace token.Pos // position of "{"
                                              	List   []Stmt
                                              	Rbrace token.Pos // position of "}", if any (may be absent due to syntax error)
                                              }

                                                A BlockStmt node represents a braced statement list.

                                                func (*BlockStmt) End

                                                func (s *BlockStmt) End() token.Pos

                                                func (*BlockStmt) Pos

                                                func (s *BlockStmt) Pos() token.Pos

                                                type BranchStmt

                                                type BranchStmt struct {
                                                	TokPos token.Pos   // position of Tok
                                                	Tok    token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
                                                	Label  *Ident      // label name; or nil
                                                }

                                                  A BranchStmt node represents a break, continue, goto, or fallthrough statement.

                                                  func (*BranchStmt) End

                                                  func (s *BranchStmt) End() token.Pos

                                                  func (*BranchStmt) Pos

                                                  func (s *BranchStmt) Pos() token.Pos

                                                  type CallExpr

                                                  type CallExpr struct {
                                                  	Fun      Expr      // function expression
                                                  	Lparen   token.Pos // position of "("
                                                  	Args     []Expr    // function arguments; or nil
                                                  	Ellipsis token.Pos // position of "..." (token.NoPos if there is no "...")
                                                  	Rparen   token.Pos // position of ")"
                                                  }

                                                    A CallExpr node represents an expression followed by an argument list.

                                                    func (*CallExpr) End

                                                    func (x *CallExpr) End() token.Pos

                                                    func (*CallExpr) Pos

                                                    func (x *CallExpr) Pos() token.Pos

                                                    type CaseClause

                                                    type CaseClause struct {
                                                    	Case  token.Pos // position of "case" or "default" keyword
                                                    	List  []Expr    // list of expressions or types; nil means default case
                                                    	Colon token.Pos // position of ":"
                                                    	Body  []Stmt    // statement list; or nil
                                                    }

                                                      A CaseClause represents a case of an expression or type switch statement.

                                                      func (*CaseClause) End

                                                      func (s *CaseClause) End() token.Pos

                                                      func (*CaseClause) Pos

                                                      func (s *CaseClause) Pos() token.Pos

                                                      type ChanDir

                                                      type ChanDir int

                                                        The direction of a channel type is indicated by a bit mask including one or both of the following constants.

                                                        const (
                                                        	SEND ChanDir = 1 << iota
                                                        	RECV
                                                        )

                                                        type ChanType

                                                        type ChanType struct {
                                                        	Begin token.Pos // position of "chan" keyword or "<-" (whichever comes first)
                                                        	Arrow token.Pos // position of "<-" (token.NoPos if there is no "<-")
                                                        	Dir   ChanDir   // channel direction
                                                        	Value Expr      // value type
                                                        }

                                                          A ChanType node represents a channel type.

                                                          func (*ChanType) End

                                                          func (x *ChanType) End() token.Pos

                                                          func (*ChanType) Pos

                                                          func (x *ChanType) Pos() token.Pos

                                                          type CommClause

                                                          type CommClause struct {
                                                          	Case  token.Pos // position of "case" or "default" keyword
                                                          	Comm  Stmt      // send or receive statement; nil means default case
                                                          	Colon token.Pos // position of ":"
                                                          	Body  []Stmt    // statement list; or nil
                                                          }

                                                            A CommClause node represents a case of a select statement.

                                                            func (*CommClause) End

                                                            func (s *CommClause) End() token.Pos

                                                            func (*CommClause) Pos

                                                            func (s *CommClause) Pos() token.Pos

                                                            type Comment

                                                            type Comment struct {
                                                            	Slash token.Pos // position of "/" starting the comment
                                                            	Text  string    // comment text (excluding '\n' for //-style comments)
                                                            }

                                                              A Comment node represents a single //-style or /*-style comment.

                                                              The Text field contains the comment text without carriage returns (\r) that may have been present in the source. Because a comment's end position is computed using len(Text), the position reported by End() does not match the true source end position for comments containing carriage returns.

                                                              func (*Comment) End

                                                              func (c *Comment) End() token.Pos

                                                              func (*Comment) Pos

                                                              func (c *Comment) Pos() token.Pos

                                                              type CommentGroup

                                                              type CommentGroup struct {
                                                              	List []*Comment // len(List) > 0
                                                              }

                                                                A CommentGroup represents a sequence of comments with no other tokens and no empty lines between.

                                                                func (*CommentGroup) End

                                                                func (g *CommentGroup) End() token.Pos

                                                                func (*CommentGroup) Pos

                                                                func (g *CommentGroup) Pos() token.Pos

                                                                func (*CommentGroup) Text

                                                                func (g *CommentGroup) Text() string

                                                                  Text returns the text of the comment. Comment markers (//, /*, and */), the first space of a line comment, and leading and trailing empty lines are removed. Comment directives like "//line" and "//go:noinline" are also removed. Multiple empty lines are reduced to one, and trailing space on lines is trimmed. Unless the result is empty, it is newline-terminated.

                                                                  type CommentMap

                                                                  type CommentMap map[Node][]*CommentGroup

                                                                    A CommentMap maps an AST node to a list of comment groups associated with it. See NewCommentMap for a description of the association.

                                                                    Example

                                                                      This example illustrates how to remove a variable declaration in a Go program while maintaining correct comment association using an ast.CommentMap.

                                                                      Output:
                                                                      
                                                                      // This is the package comment.
                                                                      package main
                                                                      
                                                                      // This comment is associated with the hello constant.
                                                                      const hello = "Hello, World!" // line comment 1
                                                                      
                                                                      // This comment is associated with the main function.
                                                                      func main() {
                                                                      	fmt.Println(hello) // line comment 3
                                                                      }
                                                                      

                                                                      func NewCommentMap

                                                                      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 (CommentMap) Comments

                                                                        func (cmap CommentMap) Comments() []*CommentGroup

                                                                          Comments returns the list of comment groups in the comment map. The result is sorted in source order.

                                                                          func (CommentMap) Filter

                                                                          func (cmap CommentMap) Filter(node Node) CommentMap

                                                                            Filter returns a new comment map consisting of only those entries of cmap for which a corresponding node exists in the AST specified by node.

                                                                            func (CommentMap) String

                                                                            func (cmap CommentMap) String() string

                                                                            func (CommentMap) Update

                                                                            func (cmap CommentMap) Update(old, new Node) Node

                                                                              Update replaces an old node in the comment map with the new node and returns the new node. Comments that were associated with the old node are associated with the new node.

                                                                              type CompositeLit

                                                                              type CompositeLit struct {
                                                                              	Type       Expr      // literal type; or nil
                                                                              	Lbrace     token.Pos // position of "{"
                                                                              	Elts       []Expr    // list of composite elements; or nil
                                                                              	Rbrace     token.Pos // position of "}"
                                                                              	Incomplete bool      // true if (source) expressions are missing in the Elts list
                                                                              }

                                                                                A CompositeLit node represents a composite literal.

                                                                                func (*CompositeLit) End

                                                                                func (x *CompositeLit) End() token.Pos

                                                                                func (*CompositeLit) Pos

                                                                                func (x *CompositeLit) Pos() token.Pos

                                                                                type Decl

                                                                                type Decl interface {
                                                                                	Node
                                                                                	// contains filtered or unexported methods
                                                                                }

                                                                                  All declaration nodes implement the Decl interface.

                                                                                  type DeclStmt

                                                                                  type DeclStmt struct {
                                                                                  	Decl Decl // *GenDecl with CONST, TYPE, or VAR token
                                                                                  }

                                                                                    A DeclStmt node represents a declaration in a statement list.

                                                                                    func (*DeclStmt) End

                                                                                    func (s *DeclStmt) End() token.Pos

                                                                                    func (*DeclStmt) Pos

                                                                                    func (s *DeclStmt) Pos() token.Pos

                                                                                    type DeferStmt

                                                                                    type DeferStmt struct {
                                                                                    	Defer token.Pos // position of "defer" keyword
                                                                                    	Call  *CallExpr
                                                                                    }

                                                                                      A DeferStmt node represents a defer statement.

                                                                                      func (*DeferStmt) End

                                                                                      func (s *DeferStmt) End() token.Pos

                                                                                      func (*DeferStmt) Pos

                                                                                      func (s *DeferStmt) Pos() token.Pos

                                                                                      type Ellipsis

                                                                                      type Ellipsis struct {
                                                                                      	Ellipsis token.Pos // position of "..."
                                                                                      	Elt      Expr      // ellipsis element type (parameter lists only); or nil
                                                                                      }

                                                                                        An Ellipsis node stands for the "..." type in a parameter list or the "..." length in an array type.

                                                                                        func (*Ellipsis) End

                                                                                        func (x *Ellipsis) End() token.Pos

                                                                                        func (*Ellipsis) Pos

                                                                                        func (x *Ellipsis) Pos() token.Pos

                                                                                        type EmptyStmt

                                                                                        type EmptyStmt struct {
                                                                                        	Semicolon token.Pos // position of following ";"
                                                                                        	Implicit  bool      // if set, ";" was omitted in the source
                                                                                        }

                                                                                          An EmptyStmt node represents an empty statement. The "position" of the empty statement is the position of the immediately following (explicit or implicit) semicolon.

                                                                                          func (*EmptyStmt) End

                                                                                          func (s *EmptyStmt) End() token.Pos

                                                                                          func (*EmptyStmt) Pos

                                                                                          func (s *EmptyStmt) Pos() token.Pos

                                                                                          type Expr

                                                                                          type Expr interface {
                                                                                          	Node
                                                                                          	// contains filtered or unexported methods
                                                                                          }

                                                                                            All expression nodes implement the Expr interface.

                                                                                            type ExprStmt

                                                                                            type ExprStmt struct {
                                                                                            	X Expr // expression
                                                                                            }

                                                                                              An ExprStmt node represents a (stand-alone) expression in a statement list.

                                                                                              func (*ExprStmt) End

                                                                                              func (s *ExprStmt) End() token.Pos

                                                                                              func (*ExprStmt) Pos

                                                                                              func (s *ExprStmt) Pos() token.Pos

                                                                                              type Field

                                                                                              type Field struct {
                                                                                              	Doc     *CommentGroup // associated documentation; or nil
                                                                                              	Names   []*Ident      // field/method/parameter names; or nil
                                                                                              	Type    Expr          // field/method/parameter type
                                                                                              	Tag     *BasicLit     // field tag; or nil
                                                                                              	Comment *CommentGroup // line comments; or nil
                                                                                              }

                                                                                                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.

                                                                                                func (*Field) End

                                                                                                func (f *Field) End() token.Pos

                                                                                                func (*Field) Pos

                                                                                                func (f *Field) Pos() token.Pos

                                                                                                type FieldFilter

                                                                                                type FieldFilter func(name string, value reflect.Value) bool

                                                                                                  A FieldFilter may be provided to Fprint to control the output.

                                                                                                  type FieldList

                                                                                                  type FieldList struct {
                                                                                                  	Opening token.Pos // position of opening parenthesis/brace, if any
                                                                                                  	List    []*Field  // field list; or nil
                                                                                                  	Closing token.Pos // position of closing parenthesis/brace, if any
                                                                                                  }

                                                                                                    A FieldList represents a list of Fields, enclosed by parentheses or braces.

                                                                                                    func (*FieldList) End

                                                                                                    func (f *FieldList) End() token.Pos

                                                                                                    func (*FieldList) NumFields

                                                                                                    func (f *FieldList) NumFields() int

                                                                                                      NumFields returns the number of parameters or struct fields represented by a FieldList.

                                                                                                      func (*FieldList) Pos

                                                                                                      func (f *FieldList) Pos() token.Pos

                                                                                                      type File

                                                                                                      type File struct {
                                                                                                      	Doc        *CommentGroup   // associated documentation; or nil
                                                                                                      	Package    token.Pos       // position of "package" keyword
                                                                                                      	Name       *Ident          // package name
                                                                                                      	Decls      []Decl          // top-level declarations; or nil
                                                                                                      	Scope      *Scope          // package scope (this file only)
                                                                                                      	Imports    []*ImportSpec   // imports in this file
                                                                                                      	Unresolved []*Ident        // unresolved identifiers in this file
                                                                                                      	Comments   []*CommentGroup // list of all comments in the source file
                                                                                                      }

                                                                                                        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).

                                                                                                        func MergePackageFiles

                                                                                                        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 (*File) End

                                                                                                          func (f *File) End() token.Pos

                                                                                                          func (*File) Pos

                                                                                                          func (f *File) Pos() token.Pos

                                                                                                          type Filter

                                                                                                          type Filter func(string) bool

                                                                                                          type ForStmt

                                                                                                          type ForStmt struct {
                                                                                                          	For  token.Pos // position of "for" keyword
                                                                                                          	Init Stmt      // initialization statement; or nil
                                                                                                          	Cond Expr      // condition; or nil
                                                                                                          	Post Stmt      // post iteration statement; or nil
                                                                                                          	Body *BlockStmt
                                                                                                          }

                                                                                                            A ForStmt represents a for statement.

                                                                                                            func (*ForStmt) End

                                                                                                            func (s *ForStmt) End() token.Pos

                                                                                                            func (*ForStmt) Pos

                                                                                                            func (s *ForStmt) Pos() token.Pos

                                                                                                            type FuncDecl

                                                                                                            type FuncDecl struct {
                                                                                                            	Doc  *CommentGroup // associated documentation; or nil
                                                                                                            	Recv *FieldList    // receiver (methods); or nil (functions)
                                                                                                            	Name *Ident        // function/method name
                                                                                                            	Type *FuncType     // function signature: parameters, results, and position of "func" keyword
                                                                                                            	Body *BlockStmt    // function body; or nil for external (non-Go) function
                                                                                                            }

                                                                                                              A FuncDecl node represents a function declaration.

                                                                                                              func (*FuncDecl) End

                                                                                                              func (d *FuncDecl) End() token.Pos

                                                                                                              func (*FuncDecl) Pos

                                                                                                              func (d *FuncDecl) Pos() token.Pos

                                                                                                              type FuncLit

                                                                                                              type FuncLit struct {
                                                                                                              	Type *FuncType  // function type
                                                                                                              	Body *BlockStmt // function body
                                                                                                              }

                                                                                                                A FuncLit node represents a function literal.

                                                                                                                func (*FuncLit) End

                                                                                                                func (x *FuncLit) End() token.Pos

                                                                                                                func (*FuncLit) Pos

                                                                                                                func (x *FuncLit) Pos() token.Pos

                                                                                                                type FuncType

                                                                                                                type FuncType struct {
                                                                                                                	Func    token.Pos  // position of "func" keyword (token.NoPos if there is no "func")
                                                                                                                	Params  *FieldList // (incoming) parameters; non-nil
                                                                                                                	Results *FieldList // (outgoing) results; or nil
                                                                                                                }

                                                                                                                  A FuncType node represents a function type.

                                                                                                                  func (*FuncType) End

                                                                                                                  func (x *FuncType) End() token.Pos

                                                                                                                  func (*FuncType) Pos

                                                                                                                  func (x *FuncType) Pos() token.Pos

                                                                                                                  type GenDecl

                                                                                                                  type GenDecl struct {
                                                                                                                  	Doc    *CommentGroup // associated documentation; or nil
                                                                                                                  	TokPos token.Pos     // position of Tok
                                                                                                                  	Tok    token.Token   // IMPORT, CONST, TYPE, VAR
                                                                                                                  	Lparen token.Pos     // position of '(', if any
                                                                                                                  	Specs  []Spec
                                                                                                                  	Rparen token.Pos // position of ')', if any
                                                                                                                  }

                                                                                                                    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
                                                                                                                    

                                                                                                                    func (*GenDecl) End

                                                                                                                    func (d *GenDecl) End() token.Pos

                                                                                                                    func (*GenDecl) Pos

                                                                                                                    func (d *GenDecl) Pos() token.Pos

                                                                                                                    type GoStmt

                                                                                                                    type GoStmt struct {
                                                                                                                    	Go   token.Pos // position of "go" keyword
                                                                                                                    	Call *CallExpr
                                                                                                                    }

                                                                                                                      A GoStmt node represents a go statement.

                                                                                                                      func (*GoStmt) End

                                                                                                                      func (s *GoStmt) End() token.Pos

                                                                                                                      func (*GoStmt) Pos

                                                                                                                      func (s *GoStmt) Pos() token.Pos

                                                                                                                      type Ident

                                                                                                                      type Ident struct {
                                                                                                                      	NamePos token.Pos // identifier position
                                                                                                                      	Name    string    // identifier name
                                                                                                                      	Obj     *Object   // denoted object; or nil
                                                                                                                      }

                                                                                                                        An Ident node represents an identifier.

                                                                                                                        func NewIdent

                                                                                                                        func NewIdent(name string) *Ident

                                                                                                                          NewIdent creates a new Ident without position. Useful for ASTs generated by code other than the Go parser.

                                                                                                                          func (*Ident) End

                                                                                                                          func (x *Ident) End() token.Pos

                                                                                                                          func (*Ident) IsExported

                                                                                                                          func (id *Ident) IsExported() bool

                                                                                                                            IsExported reports whether id starts with an upper-case letter.

                                                                                                                            func (*Ident) Pos

                                                                                                                            func (x *Ident) Pos() token.Pos

                                                                                                                            func (*Ident) String

                                                                                                                            func (id *Ident) String() string

                                                                                                                            type IfStmt

                                                                                                                            type IfStmt struct {
                                                                                                                            	If   token.Pos // position of "if" keyword
                                                                                                                            	Init Stmt      // initialization statement; or nil
                                                                                                                            	Cond Expr      // condition
                                                                                                                            	Body *BlockStmt
                                                                                                                            	Else Stmt // else branch; or nil
                                                                                                                            }

                                                                                                                              An IfStmt node represents an if statement.

                                                                                                                              func (*IfStmt) End

                                                                                                                              func (s *IfStmt) End() token.Pos

                                                                                                                              func (*IfStmt) Pos

                                                                                                                              func (s *IfStmt) Pos() token.Pos

                                                                                                                              type ImportSpec

                                                                                                                              type ImportSpec struct {
                                                                                                                              	Doc     *CommentGroup // associated documentation; or nil
                                                                                                                              	Name    *Ident        // local package name (including "."); or nil
                                                                                                                              	Path    *BasicLit     // import path
                                                                                                                              	Comment *CommentGroup // line comments; or nil
                                                                                                                              	EndPos  token.Pos     // end of spec (overrides Path.Pos if nonzero)
                                                                                                                              }

                                                                                                                                An ImportSpec node represents a single package import.

                                                                                                                                func (*ImportSpec) End

                                                                                                                                func (s *ImportSpec) End() token.Pos

                                                                                                                                func (*ImportSpec) Pos

                                                                                                                                func (s *ImportSpec) Pos() token.Pos

                                                                                                                                type Importer

                                                                                                                                type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)

                                                                                                                                  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.

                                                                                                                                  type IncDecStmt

                                                                                                                                  type IncDecStmt struct {
                                                                                                                                  	X      Expr
                                                                                                                                  	TokPos token.Pos   // position of Tok
                                                                                                                                  	Tok    token.Token // INC or DEC
                                                                                                                                  }

                                                                                                                                    An IncDecStmt node represents an increment or decrement statement.

                                                                                                                                    func (*IncDecStmt) End

                                                                                                                                    func (s *IncDecStmt) End() token.Pos

                                                                                                                                    func (*IncDecStmt) Pos

                                                                                                                                    func (s *IncDecStmt) Pos() token.Pos

                                                                                                                                    type IndexExpr

                                                                                                                                    type IndexExpr struct {
                                                                                                                                    	X      Expr      // expression
                                                                                                                                    	Lbrack token.Pos // position of "["
                                                                                                                                    	Index  Expr      // index expression
                                                                                                                                    	Rbrack token.Pos // position of "]"
                                                                                                                                    }

                                                                                                                                      An IndexExpr node represents an expression followed by an index.

                                                                                                                                      func (*IndexExpr) End

                                                                                                                                      func (x *IndexExpr) End() token.Pos

                                                                                                                                      func (*IndexExpr) Pos

                                                                                                                                      func (x *IndexExpr) Pos() token.Pos

                                                                                                                                      type InterfaceType

                                                                                                                                      type InterfaceType struct {
                                                                                                                                      	Interface  token.Pos  // position of "interface" keyword
                                                                                                                                      	Methods    *FieldList // list of methods
                                                                                                                                      	Incomplete bool       // true if (source) methods are missing in the Methods list
                                                                                                                                      }

                                                                                                                                        An InterfaceType node represents an interface type.

                                                                                                                                        func (*InterfaceType) End

                                                                                                                                        func (x *InterfaceType) End() token.Pos

                                                                                                                                        func (*InterfaceType) Pos

                                                                                                                                        func (x *InterfaceType) Pos() token.Pos

                                                                                                                                        type KeyValueExpr

                                                                                                                                        type KeyValueExpr struct {
                                                                                                                                        	Key   Expr
                                                                                                                                        	Colon token.Pos // position of ":"
                                                                                                                                        	Value Expr
                                                                                                                                        }

                                                                                                                                          A KeyValueExpr node represents (key : value) pairs in composite literals.

                                                                                                                                          func (*KeyValueExpr) End

                                                                                                                                          func (x *KeyValueExpr) End() token.Pos

                                                                                                                                          func (*KeyValueExpr) Pos

                                                                                                                                          func (x *KeyValueExpr) Pos() token.Pos

                                                                                                                                          type LabeledStmt

                                                                                                                                          type LabeledStmt struct {
                                                                                                                                          	Label *Ident
                                                                                                                                          	Colon token.Pos // position of ":"
                                                                                                                                          	Stmt  Stmt
                                                                                                                                          }

                                                                                                                                            A LabeledStmt node represents a labeled statement.

                                                                                                                                            func (*LabeledStmt) End

                                                                                                                                            func (s *LabeledStmt) End() token.Pos

                                                                                                                                            func (*LabeledStmt) Pos

                                                                                                                                            func (s *LabeledStmt) Pos() token.Pos

                                                                                                                                            type MapType

                                                                                                                                            type MapType struct {
                                                                                                                                            	Map   token.Pos // position of "map" keyword
                                                                                                                                            	Key   Expr
                                                                                                                                            	Value Expr
                                                                                                                                            }

                                                                                                                                              A MapType node represents a map type.

                                                                                                                                              func (*MapType) End

                                                                                                                                              func (x *MapType) End() token.Pos

                                                                                                                                              func (*MapType) Pos

                                                                                                                                              func (x *MapType) Pos() token.Pos

                                                                                                                                              type MergeMode

                                                                                                                                              type MergeMode uint

                                                                                                                                                The MergeMode flags control the behavior of MergePackageFiles.

                                                                                                                                                const (
                                                                                                                                                	// If set, duplicate function declarations are excluded.
                                                                                                                                                	FilterFuncDuplicates MergeMode = 1 << iota
                                                                                                                                                	// If set, comments that are not associated with a specific
                                                                                                                                                	// AST node (as Doc or Comment) are excluded.
                                                                                                                                                	FilterUnassociatedComments
                                                                                                                                                	// If set, duplicate import declarations are excluded.
                                                                                                                                                	FilterImportDuplicates
                                                                                                                                                )

                                                                                                                                                type Node

                                                                                                                                                type Node interface {
                                                                                                                                                	Pos() token.Pos // position of first character belonging to the node
                                                                                                                                                	End() token.Pos // position of first character immediately after the node
                                                                                                                                                }

                                                                                                                                                  All node types implement the Node interface.

                                                                                                                                                  type ObjKind

                                                                                                                                                  type ObjKind int

                                                                                                                                                    ObjKind describes what an object represents.

                                                                                                                                                    const (
                                                                                                                                                    	Bad ObjKind = iota // for error handling
                                                                                                                                                    	Pkg                // package
                                                                                                                                                    	Con                // constant
                                                                                                                                                    	Typ                // type
                                                                                                                                                    	Var                // variable
                                                                                                                                                    	Fun                // function or method
                                                                                                                                                    	Lbl                // label
                                                                                                                                                    )

                                                                                                                                                      The list of possible Object kinds.

                                                                                                                                                      func (ObjKind) String

                                                                                                                                                      func (kind ObjKind) String() string

                                                                                                                                                      type Object

                                                                                                                                                      type Object struct {
                                                                                                                                                      	Kind ObjKind
                                                                                                                                                      	Name string      // declared name
                                                                                                                                                      	Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil
                                                                                                                                                      	Data interface{} // object-specific data; or nil
                                                                                                                                                      	Type interface{} // placeholder for type information; may be nil
                                                                                                                                                      }

                                                                                                                                                        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
                                                                                                                                                        

                                                                                                                                                        func NewObj

                                                                                                                                                        func NewObj(kind ObjKind, name string) *Object

                                                                                                                                                          NewObj creates a new object of a given kind and name.

                                                                                                                                                          func (*Object) Pos

                                                                                                                                                          func (obj *Object) Pos() token.Pos

                                                                                                                                                            Pos computes the source position of the declaration of an object name. The result may be an invalid position if it cannot be computed (obj.Decl may be nil or not correct).

                                                                                                                                                            type Package

                                                                                                                                                            type Package struct {
                                                                                                                                                            	Name    string             // package name
                                                                                                                                                            	Scope   *Scope             // package scope across all files
                                                                                                                                                            	Imports map[string]*Object // map of package id -> package object
                                                                                                                                                            	Files   map[string]*File   // Go source files by filename
                                                                                                                                                            }

                                                                                                                                                              A Package node represents a set of source files collectively building a Go package.

                                                                                                                                                              func NewPackage

                                                                                                                                                              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 (*Package) End

                                                                                                                                                                func (p *Package) End() token.Pos

                                                                                                                                                                func (*Package) Pos

                                                                                                                                                                func (p *Package) Pos() token.Pos

                                                                                                                                                                type ParenExpr

                                                                                                                                                                type ParenExpr struct {
                                                                                                                                                                	Lparen token.Pos // position of "("
                                                                                                                                                                	X      Expr      // parenthesized expression
                                                                                                                                                                	Rparen token.Pos // position of ")"
                                                                                                                                                                }

                                                                                                                                                                  A ParenExpr node represents a parenthesized expression.

                                                                                                                                                                  func (*ParenExpr) End

                                                                                                                                                                  func (x *ParenExpr) End() token.Pos

                                                                                                                                                                  func (*ParenExpr) Pos

                                                                                                                                                                  func (x *ParenExpr) Pos() token.Pos

                                                                                                                                                                  type RangeStmt

                                                                                                                                                                  type RangeStmt struct {
                                                                                                                                                                  	For        token.Pos   // position of "for" keyword
                                                                                                                                                                  	Key, Value Expr        // Key, Value may be nil
                                                                                                                                                                  	TokPos     token.Pos   // position of Tok; invalid if Key == nil
                                                                                                                                                                  	Tok        token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE
                                                                                                                                                                  	X          Expr        // value to range over
                                                                                                                                                                  	Body       *BlockStmt
                                                                                                                                                                  }

                                                                                                                                                                    A RangeStmt represents a for statement with a range clause.

                                                                                                                                                                    func (*RangeStmt) End

                                                                                                                                                                    func (s *RangeStmt) End() token.Pos

                                                                                                                                                                    func (*RangeStmt) Pos

                                                                                                                                                                    func (s *RangeStmt) Pos() token.Pos

                                                                                                                                                                    type ReturnStmt

                                                                                                                                                                    type ReturnStmt struct {
                                                                                                                                                                    	Return  token.Pos // position of "return" keyword
                                                                                                                                                                    	Results []Expr    // result expressions; or nil
                                                                                                                                                                    }

                                                                                                                                                                      A ReturnStmt node represents a return statement.

                                                                                                                                                                      func (*ReturnStmt) End

                                                                                                                                                                      func (s *ReturnStmt) End() token.Pos

                                                                                                                                                                      func (*ReturnStmt) Pos

                                                                                                                                                                      func (s *ReturnStmt) Pos() token.Pos

                                                                                                                                                                      type Scope

                                                                                                                                                                      type Scope struct {
                                                                                                                                                                      	Outer   *Scope
                                                                                                                                                                      	Objects map[string]*Object
                                                                                                                                                                      }

                                                                                                                                                                        A Scope maintains the set of named language entities declared in the scope and a link to the immediately surrounding (outer) scope.

                                                                                                                                                                        func NewScope

                                                                                                                                                                        func NewScope(outer *Scope) *Scope

                                                                                                                                                                          NewScope creates a new scope nested in the outer scope.

                                                                                                                                                                          func (*Scope) Insert

                                                                                                                                                                          func (s *Scope) Insert(obj *Object) (alt *Object)

                                                                                                                                                                            Insert attempts to insert a named object obj into the scope s. If the scope already contains an object alt with the same name, Insert leaves the scope unchanged and returns alt. Otherwise it inserts obj and returns nil.

                                                                                                                                                                            func (*Scope) Lookup

                                                                                                                                                                            func (s *Scope) Lookup(name string) *Object

                                                                                                                                                                              Lookup returns the object with the given name if it is found in scope s, otherwise it returns nil. Outer scopes are ignored.

                                                                                                                                                                              func (*Scope) String

                                                                                                                                                                              func (s *Scope) String() string

                                                                                                                                                                                Debugging support

                                                                                                                                                                                type SelectStmt

                                                                                                                                                                                type SelectStmt struct {
                                                                                                                                                                                	Select token.Pos  // position of "select" keyword
                                                                                                                                                                                	Body   *BlockStmt // CommClauses only
                                                                                                                                                                                }

                                                                                                                                                                                  A SelectStmt node represents a select statement.

                                                                                                                                                                                  func (*SelectStmt) End

                                                                                                                                                                                  func (s *SelectStmt) End() token.Pos

                                                                                                                                                                                  func (*SelectStmt) Pos

                                                                                                                                                                                  func (s *SelectStmt) Pos() token.Pos

                                                                                                                                                                                  type SelectorExpr

                                                                                                                                                                                  type SelectorExpr struct {
                                                                                                                                                                                  	X   Expr   // expression
                                                                                                                                                                                  	Sel *Ident // field selector
                                                                                                                                                                                  }

                                                                                                                                                                                    A SelectorExpr node represents an expression followed by a selector.

                                                                                                                                                                                    func (*SelectorExpr) End

                                                                                                                                                                                    func (x *SelectorExpr) End() token.Pos

                                                                                                                                                                                    func (*SelectorExpr) Pos

                                                                                                                                                                                    func (x *SelectorExpr) Pos() token.Pos

                                                                                                                                                                                    type SendStmt

                                                                                                                                                                                    type SendStmt struct {
                                                                                                                                                                                    	Chan  Expr
                                                                                                                                                                                    	Arrow token.Pos // position of "<-"
                                                                                                                                                                                    	Value Expr
                                                                                                                                                                                    }

                                                                                                                                                                                      A SendStmt node represents a send statement.

                                                                                                                                                                                      func (*SendStmt) End

                                                                                                                                                                                      func (s *SendStmt) End() token.Pos

                                                                                                                                                                                      func (*SendStmt) Pos

                                                                                                                                                                                      func (s *SendStmt) Pos() token.Pos

                                                                                                                                                                                      type SliceExpr

                                                                                                                                                                                      type SliceExpr struct {
                                                                                                                                                                                      	X      Expr      // expression
                                                                                                                                                                                      	Lbrack token.Pos // position of "["
                                                                                                                                                                                      	Low    Expr      // begin of slice range; or nil
                                                                                                                                                                                      	High   Expr      // end of slice range; or nil
                                                                                                                                                                                      	Max    Expr      // maximum capacity of slice; or nil
                                                                                                                                                                                      	Slice3 bool      // true if 3-index slice (2 colons present)
                                                                                                                                                                                      	Rbrack token.Pos // position of "]"
                                                                                                                                                                                      }

                                                                                                                                                                                        A SliceExpr node represents an expression followed by slice indices.

                                                                                                                                                                                        func (*SliceExpr) End

                                                                                                                                                                                        func (x *SliceExpr) End() token.Pos

                                                                                                                                                                                        func (*SliceExpr) Pos

                                                                                                                                                                                        func (x *SliceExpr) Pos() token.Pos

                                                                                                                                                                                        type Spec

                                                                                                                                                                                        type Spec interface {
                                                                                                                                                                                        	Node
                                                                                                                                                                                        	// contains filtered or unexported methods
                                                                                                                                                                                        }

                                                                                                                                                                                          The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.

                                                                                                                                                                                          type StarExpr

                                                                                                                                                                                          type StarExpr struct {
                                                                                                                                                                                          	Star token.Pos // position of "*"
                                                                                                                                                                                          	X    Expr      // operand
                                                                                                                                                                                          }

                                                                                                                                                                                            A StarExpr node represents an expression of the form "*" Expression. Semantically it could be a unary "*" expression, or a pointer type.

                                                                                                                                                                                            func (*StarExpr) End

                                                                                                                                                                                            func (x *StarExpr) End() token.Pos

                                                                                                                                                                                            func (*StarExpr) Pos

                                                                                                                                                                                            func (x *StarExpr) Pos() token.Pos

                                                                                                                                                                                            type Stmt

                                                                                                                                                                                            type Stmt interface {
                                                                                                                                                                                            	Node
                                                                                                                                                                                            	// contains filtered or unexported methods
                                                                                                                                                                                            }

                                                                                                                                                                                              All statement nodes implement the Stmt interface.

                                                                                                                                                                                              type StructType

                                                                                                                                                                                              type StructType struct {
                                                                                                                                                                                              	Struct     token.Pos  // position of "struct" keyword
                                                                                                                                                                                              	Fields     *FieldList // list of field declarations
                                                                                                                                                                                              	Incomplete bool       // true if (source) fields are missing in the Fields list
                                                                                                                                                                                              }

                                                                                                                                                                                                A StructType node represents a struct type.

                                                                                                                                                                                                func (*StructType) End

                                                                                                                                                                                                func (x *StructType) End() token.Pos

                                                                                                                                                                                                func (*StructType) Pos

                                                                                                                                                                                                func (x *StructType) Pos() token.Pos

                                                                                                                                                                                                type SwitchStmt

                                                                                                                                                                                                type SwitchStmt struct {
                                                                                                                                                                                                	Switch token.Pos  // position of "switch" keyword
                                                                                                                                                                                                	Init   Stmt       // initialization statement; or nil
                                                                                                                                                                                                	Tag    Expr       // tag expression; or nil
                                                                                                                                                                                                	Body   *BlockStmt // CaseClauses only
                                                                                                                                                                                                }

                                                                                                                                                                                                  A SwitchStmt node represents an expression switch statement.

                                                                                                                                                                                                  func (*SwitchStmt) End

                                                                                                                                                                                                  func (s *SwitchStmt) End() token.Pos

                                                                                                                                                                                                  func (*SwitchStmt) Pos

                                                                                                                                                                                                  func (s *SwitchStmt) Pos() token.Pos

                                                                                                                                                                                                  type TypeAssertExpr

                                                                                                                                                                                                  type TypeAssertExpr struct {
                                                                                                                                                                                                  	X      Expr      // expression
                                                                                                                                                                                                  	Lparen token.Pos // position of "("
                                                                                                                                                                                                  	Type   Expr      // asserted type; nil means type switch X.(type)
                                                                                                                                                                                                  	Rparen token.Pos // position of ")"
                                                                                                                                                                                                  }

                                                                                                                                                                                                    A TypeAssertExpr node represents an expression followed by a type assertion.

                                                                                                                                                                                                    func (*TypeAssertExpr) End

                                                                                                                                                                                                    func (x *TypeAssertExpr) End() token.Pos

                                                                                                                                                                                                    func (*TypeAssertExpr) Pos

                                                                                                                                                                                                    func (x *TypeAssertExpr) Pos() token.Pos

                                                                                                                                                                                                    type TypeSpec

                                                                                                                                                                                                    type TypeSpec struct {
                                                                                                                                                                                                    	Doc     *CommentGroup // associated documentation; or nil
                                                                                                                                                                                                    	Name    *Ident        // type name
                                                                                                                                                                                                    	Assign  token.Pos     // position of '=', if any
                                                                                                                                                                                                    	Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
                                                                                                                                                                                                    	Comment *CommentGroup // line comments; or nil
                                                                                                                                                                                                    }

                                                                                                                                                                                                      A TypeSpec node represents a type declaration (TypeSpec production).

                                                                                                                                                                                                      func (*TypeSpec) End

                                                                                                                                                                                                      func (s *TypeSpec) End() token.Pos

                                                                                                                                                                                                      func (*TypeSpec) Pos

                                                                                                                                                                                                      func (s *TypeSpec) Pos() token.Pos

                                                                                                                                                                                                      type TypeSwitchStmt

                                                                                                                                                                                                      type TypeSwitchStmt struct {
                                                                                                                                                                                                      	Switch token.Pos  // position of "switch" keyword
                                                                                                                                                                                                      	Init   Stmt       // initialization statement; or nil
                                                                                                                                                                                                      	Assign Stmt       // x := y.(type) or y.(type)
                                                                                                                                                                                                      	Body   *BlockStmt // CaseClauses only
                                                                                                                                                                                                      }

                                                                                                                                                                                                        A TypeSwitchStmt node represents a type switch statement.

                                                                                                                                                                                                        func (*TypeSwitchStmt) End

                                                                                                                                                                                                        func (s *TypeSwitchStmt) End() token.Pos

                                                                                                                                                                                                        func (*TypeSwitchStmt) Pos

                                                                                                                                                                                                        func (s *TypeSwitchStmt) Pos() token.Pos

                                                                                                                                                                                                        type UnaryExpr

                                                                                                                                                                                                        type UnaryExpr struct {
                                                                                                                                                                                                        	OpPos token.Pos   // position of Op
                                                                                                                                                                                                        	Op    token.Token // operator
                                                                                                                                                                                                        	X     Expr        // operand
                                                                                                                                                                                                        }

                                                                                                                                                                                                          A UnaryExpr node represents a unary expression. Unary "*" expressions are represented via StarExpr nodes.

                                                                                                                                                                                                          func (*UnaryExpr) End

                                                                                                                                                                                                          func (x *UnaryExpr) End() token.Pos

                                                                                                                                                                                                          func (*UnaryExpr) Pos

                                                                                                                                                                                                          func (x *UnaryExpr) Pos() token.Pos

                                                                                                                                                                                                          type ValueSpec

                                                                                                                                                                                                          type ValueSpec struct {
                                                                                                                                                                                                          	Doc     *CommentGroup // associated documentation; or nil
                                                                                                                                                                                                          	Names   []*Ident      // value names (len(Names) > 0)
                                                                                                                                                                                                          	Type    Expr          // value type; or nil
                                                                                                                                                                                                          	Values  []Expr        // initial values; or nil
                                                                                                                                                                                                          	Comment *CommentGroup // line comments; or nil
                                                                                                                                                                                                          }

                                                                                                                                                                                                            A ValueSpec node represents a constant or variable declaration (ConstSpec or VarSpec production).

                                                                                                                                                                                                            func (*ValueSpec) End

                                                                                                                                                                                                            func (s *ValueSpec) End() token.Pos

                                                                                                                                                                                                            func (*ValueSpec) Pos

                                                                                                                                                                                                            func (s *ValueSpec) Pos() token.Pos

                                                                                                                                                                                                            type Visitor

                                                                                                                                                                                                            type Visitor interface {
                                                                                                                                                                                                            	Visit(node Node) (w Visitor)
                                                                                                                                                                                                            }

                                                                                                                                                                                                              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).