Documentation

Index

Constants

View Source
const (
	// for BranchStmt
	Break       = _Break
	Continue    = _Continue
	Fallthrough = _Fallthrough
	Goto        = _Goto

	// for CallStmt
	Go    = _Go
	Defer = _Defer
)
View Source
const PosMax = 1 << 30

    PosMax is the largest line or column value that can be represented without loss. Incoming values (arguments) larger than PosMax will be set to PosMax.

    Variables

    View Source
    var ImplicitOne = &BasicLit{Value: "1"}

      We represent x++, x-- as assignments x += ImplicitOne, x -= ImplicitOne. ImplicitOne should not be used elsewhere.

      Functions

      func Fdump

      func Fdump(w io.Writer, n Node) (err error)

        Fdump dumps the structure of the syntax tree rooted at n to w. It is intended for debugging purposes; no specific output format is guaranteed.

        func Fprint

        func Fprint(w io.Writer, x Node, linebreaks bool) (n int, err error)

        func String

        func String(n Node) string

        Types

        type ArrayType

        type ArrayType struct {
        	// TODO(gri) consider using Name{"..."} instead of nil (permits attaching of comments)
        	Len  Expr // nil means Len is ...
        	Elem Expr
        	// contains filtered or unexported fields
        }

          [Len]Elem

          type AssertExpr

          type AssertExpr struct {
          	X    Expr
          	Type Expr
          	// contains filtered or unexported fields
          }

            X.(Type)

            type AssignStmt

            type AssignStmt struct {
            	Op       Operator // 0 means no operation
            	Lhs, Rhs Expr     // Rhs == ImplicitOne means Lhs++ (Op == Add) or Lhs-- (Op == Sub)
            	// contains filtered or unexported fields
            }

            type BadExpr

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

              Placeholder for an expression that failed to parse correctly and where we can't provide a better node.

              type BasicLit

              type BasicLit struct {
              	Value string
              	Kind  LitKind
              	Bad   bool // true means the literal Value has syntax errors
              	// contains filtered or unexported fields
              }

                Value

                type BlockStmt

                type BlockStmt struct {
                	List   []Stmt
                	Rbrace Pos
                	// contains filtered or unexported fields
                }

                type BranchStmt

                type BranchStmt struct {
                	Tok   token // Break, Continue, Fallthrough, or Goto
                	Label *Name
                	// Target is the continuation of the control flow after executing
                	// the branch; it is computed by the parser if CheckBranches is set.
                	// Target is a *LabeledStmt for gotos, and a *SwitchStmt, *SelectStmt,
                	// or *ForStmt for breaks and continues, depending on the context of
                	// the branch. Target is not set for fallthroughs.
                	Target Stmt
                	// contains filtered or unexported fields
                }

                type CallExpr

                type CallExpr struct {
                	Fun     Expr
                	ArgList []Expr // nil means no arguments
                	HasDots bool   // last argument is followed by ...
                	// contains filtered or unexported fields
                }

                  Fun(ArgList[0], ArgList[1], ...)

                  type CallStmt

                  type CallStmt struct {
                  	Tok  token // Go or Defer
                  	Call *CallExpr
                  	// contains filtered or unexported fields
                  }

                  type CaseClause

                  type CaseClause struct {
                  	Cases Expr // nil means default clause
                  	Body  []Stmt
                  	Colon Pos
                  	// contains filtered or unexported fields
                  }

                  func (*CaseClause) Pos

                  func (n *CaseClause) Pos() Pos

                  type ChanDir

                  type ChanDir uint
                  const (
                  	SendOnly ChanDir
                  	RecvOnly
                  )

                  type ChanType

                  type ChanType struct {
                  	Dir  ChanDir // 0 means no direction
                  	Elem Expr
                  	// contains filtered or unexported fields
                  }
                    chan Elem
                    

                    <-chan Elem chan<- Elem

                    type CommClause

                    type CommClause struct {
                    	Comm  SimpleStmt // send or receive stmt; nil means default clause
                    	Body  []Stmt
                    	Colon Pos
                    	// contains filtered or unexported fields
                    }

                    func (*CommClause) Pos

                    func (n *CommClause) Pos() Pos

                    type Comment

                    type Comment struct {
                    	Kind CommentKind
                    	Text string
                    	Next *Comment
                    }

                    type CommentKind

                    type CommentKind uint

                      TODO(gri) Consider renaming to CommentPos, CommentPlacement, etc.

                      Kind = Above doesn't make much sense.
                      
                      const (
                      	Above CommentKind = iota
                      	Below
                      	Left
                      	Right
                      )

                      type CompositeLit

                      type CompositeLit struct {
                      	Type     Expr // nil means no literal type
                      	ElemList []Expr
                      	NKeys    int // number of elements with keys
                      	Rbrace   Pos
                      	// contains filtered or unexported fields
                      }

                        Type { ElemList[0], ElemList[1], ... }

                        type ConstDecl

                        type ConstDecl struct {
                        	Group    *Group // nil means not part of a group
                        	Pragma   Pragma
                        	NameList []*Name
                        	Type     Expr // nil means no type
                        	Values   Expr // nil means no values
                        	// contains filtered or unexported fields
                        }

                          NameList NameList = Values NameList Type = Values

                          type Decl

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

                          type DeclStmt

                          type DeclStmt struct {
                          	DeclList []Decl
                          	// contains filtered or unexported fields
                          }

                          type DotsType

                          type DotsType struct {
                          	Elem Expr
                          	// contains filtered or unexported fields
                          }

                            ...Elem

                            type EmptyStmt

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

                            type Error

                            type Error struct {
                            	Pos Pos
                            	Msg string
                            }

                              Error describes a syntax error. Error implements the error interface.

                              func (Error) Error

                              func (err Error) Error() string

                              type ErrorHandler

                              type ErrorHandler func(err error)

                                An ErrorHandler is called for each error encountered reading a .go file.

                                type Expr

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

                                type ExprStmt

                                type ExprStmt struct {
                                	X Expr
                                	// contains filtered or unexported fields
                                }

                                type Field

                                type Field struct {
                                	Name *Name // nil means anonymous field/parameter (structs/parameters), or embedded interface (interfaces)
                                	Type Expr  // field names declared in a list share the same Type (identical pointers)
                                	// contains filtered or unexported fields
                                }

                                  Name Type

                                  Type
                                  

                                  func (*Field) Pos

                                  func (n *Field) Pos() Pos

                                  type File

                                  type File struct {
                                  	Pragma   Pragma
                                  	PkgName  *Name
                                  	DeclList []Decl
                                  	Lines    uint
                                  	// contains filtered or unexported fields
                                  }

                                    package PkgName; DeclList[0], DeclList[1], ...

                                    func Parse

                                    func Parse(base *PosBase, src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, first error)

                                      Parse parses a single Go source file from src and returns the corresponding syntax tree. If there are errors, Parse will return the first error found, and a possibly partially constructed syntax tree, or nil.

                                      If errh != nil, it is called with each error encountered, and Parse will process as much source as possible. In this case, the returned syntax tree is only nil if no correct package clause was found. If errh is nil, Parse will terminate immediately upon encountering the first error, and the returned syntax tree is nil.

                                      If pragh != nil, it is called with each pragma encountered.

                                      func ParseFile

                                      func ParseFile(filename string, errh ErrorHandler, pragh PragmaHandler, mode Mode) (*File, error)

                                        ParseFile behaves like Parse but it reads the source from the named file.

                                        func (*File) Pos

                                        func (n *File) Pos() Pos

                                        type ForStmt

                                        type ForStmt struct {
                                        	Init SimpleStmt // incl. *RangeClause
                                        	Cond Expr
                                        	Post SimpleStmt
                                        	Body *BlockStmt
                                        	// contains filtered or unexported fields
                                        }

                                        type FuncDecl

                                        type FuncDecl struct {
                                        	Pragma Pragma
                                        	Recv   *Field // nil means regular function
                                        	Name   *Name
                                        	Type   *FuncType
                                        	Body   *BlockStmt // nil means no body (forward declaration)
                                        	// contains filtered or unexported fields
                                        }

                                          func Name Type { Body } func Name Type func Receiver Name Type { Body } func Receiver Name Type

                                          type FuncLit

                                          type FuncLit struct {
                                          	Type *FuncType
                                          	Body *BlockStmt
                                          	// contains filtered or unexported fields
                                          }

                                            func Type { Body }

                                            type FuncType

                                            type FuncType struct {
                                            	ParamList  []*Field
                                            	ResultList []*Field
                                            	// contains filtered or unexported fields
                                            }

                                            type Group

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

                                              All declarations belonging to the same group point to the same Group node.

                                              type IfStmt

                                              type IfStmt struct {
                                              	Init SimpleStmt
                                              	Cond Expr
                                              	Then *BlockStmt
                                              	Else Stmt // either nil, *IfStmt, or *BlockStmt
                                              	// contains filtered or unexported fields
                                              }

                                              type ImportDecl

                                              type ImportDecl struct {
                                              	Group        *Group // nil means not part of a group
                                              	Pragma       Pragma
                                              	LocalPkgName *Name // including "."; nil means no rename present
                                              	Path         *BasicLit
                                              	// contains filtered or unexported fields
                                              }
                                                Path
                                                

                                                LocalPkgName Path

                                                type IndexExpr

                                                type IndexExpr struct {
                                                	X     Expr
                                                	Index Expr
                                                	// contains filtered or unexported fields
                                                }

                                                  X[Index]

                                                  type InterfaceType

                                                  type InterfaceType struct {
                                                  	MethodList []*Field
                                                  	// contains filtered or unexported fields
                                                  }

                                                    interface { MethodList[0]; MethodList[1]; ... }

                                                    type KeyValueExpr

                                                    type KeyValueExpr struct {
                                                    	Key, Value Expr
                                                    	// contains filtered or unexported fields
                                                    }

                                                      Key: Value

                                                      type LabeledStmt

                                                      type LabeledStmt struct {
                                                      	Label *Name
                                                      	Stmt  Stmt
                                                      	// contains filtered or unexported fields
                                                      }

                                                      type ListExpr

                                                      type ListExpr struct {
                                                      	ElemList []Expr
                                                      	// contains filtered or unexported fields
                                                      }

                                                        ElemList[0], ElemList[1], ...

                                                        type LitKind

                                                        type LitKind uint8
                                                        const (
                                                        	IntLit LitKind = iota
                                                        	FloatLit
                                                        	ImagLit
                                                        	RuneLit
                                                        	StringLit
                                                        )

                                                          TODO(gri) With the 'i' (imaginary) suffix now permitted on integer

                                                          and floating-point numbers, having a single ImagLit does
                                                          not represent the literal kind well anymore. Remove it?
                                                          

                                                          type MapType

                                                          type MapType struct {
                                                          	Key, Value Expr
                                                          	// contains filtered or unexported fields
                                                          }

                                                            map[Key]Value

                                                            type Mode

                                                            type Mode uint

                                                              Mode describes the parser mode.

                                                              const (
                                                              	CheckBranches Mode = 1 << iota // check correct use of labels, break, continue, and goto statements
                                                              )

                                                                Modes supported by the parser.

                                                                type Name

                                                                type Name struct {
                                                                	Value string
                                                                	// contains filtered or unexported fields
                                                                }

                                                                  Value

                                                                  type Node

                                                                  type Node interface {
                                                                  	// Pos() returns the position associated with the node as follows:
                                                                  	// 1) The position of a node representing a terminal syntax production
                                                                  	//    (Name, BasicLit, etc.) is the position of the respective production
                                                                  	//    in the source.
                                                                  	// 2) The position of a node representing a non-terminal production
                                                                  	//    (IndexExpr, IfStmt, etc.) is the position of a token uniquely
                                                                  	//    associated with that production; usually the left-most one
                                                                  	//    ('[' for IndexExpr, 'if' for IfStmt, etc.)
                                                                  	Pos() Pos
                                                                  	// contains filtered or unexported methods
                                                                  }

                                                                  type Operation

                                                                  type Operation struct {
                                                                  	Op   Operator
                                                                  	X, Y Expr // Y == nil means unary expression
                                                                  	// contains filtered or unexported fields
                                                                  }

                                                                  type Operator

                                                                  type Operator uint
                                                                  const (
                                                                  
                                                                  	// Def is the : in :=
                                                                  	Def  Operator // :
                                                                  	Not           // !
                                                                  	Recv          // <-
                                                                  
                                                                  	// precOrOr
                                                                  	OrOr // ||
                                                                  
                                                                  	// precAndAnd
                                                                  	AndAnd // &&
                                                                  
                                                                  	// precCmp
                                                                  	Eql // ==
                                                                  	Neq // !=
                                                                  	Lss // <
                                                                  	Leq // <=
                                                                  	Gtr // >
                                                                  	Geq // >=
                                                                  
                                                                  	// precAdd
                                                                  	Add // +
                                                                  	Sub // -
                                                                  	Or  // |
                                                                  	Xor // ^
                                                                  
                                                                  	// precMul
                                                                  	Mul    // *
                                                                  	Div    // /
                                                                  	Rem    // %
                                                                  	And    // &
                                                                  	AndNot // &^
                                                                  	Shl    // <<
                                                                  	Shr    // >>
                                                                  )

                                                                  func (Operator) String

                                                                  func (i Operator) String() string

                                                                  type ParenExpr

                                                                  type ParenExpr struct {
                                                                  	X Expr
                                                                  	// contains filtered or unexported fields
                                                                  }

                                                                    (X)

                                                                    type Pos

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

                                                                      A Pos represents an absolute (line, col) source position with a reference to position base for computing relative (to a file, or line directive) position information. Pos values are intentionally light-weight so that they can be created without too much concern about space use.

                                                                      func MakePos

                                                                      func MakePos(base *PosBase, line, col uint) Pos

                                                                        MakePos returns a new Pos for the given PosBase, line and column.

                                                                        func (Pos) Base

                                                                        func (pos Pos) Base() *PosBase

                                                                        func (Pos) Col

                                                                        func (pos Pos) Col() uint

                                                                        func (Pos) IsKnown

                                                                        func (pos Pos) IsKnown() bool

                                                                        func (Pos) Line

                                                                        func (pos Pos) Line() uint

                                                                        func (Pos) RelCol

                                                                        func (pos Pos) RelCol() uint

                                                                        func (Pos) RelFilename

                                                                        func (pos Pos) RelFilename() string

                                                                        func (Pos) RelLine

                                                                        func (pos Pos) RelLine() uint

                                                                        func (Pos) String

                                                                        func (pos Pos) String() string

                                                                        type PosBase

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

                                                                          A PosBase represents the base for relative position information: At position pos, the relative position is filename:line:col.

                                                                          func NewFileBase

                                                                          func NewFileBase(filename string) *PosBase

                                                                            NewFileBase returns a new PosBase for the given filename. A file PosBase's position is relative to itself, with the position being filename:1:1.

                                                                            func NewLineBase

                                                                            func NewLineBase(pos Pos, filename string, line, col uint) *PosBase

                                                                              NewLineBase returns a new PosBase for a line directive "line filename:line:col" relative to pos, which is the position of the character immediately following the comment containing the line directive. For a directive in a line comment, that position is the beginning of the next line (i.e., the newline character belongs to the line comment).

                                                                              func (*PosBase) Col

                                                                              func (base *PosBase) Col() uint

                                                                              func (*PosBase) Filename

                                                                              func (base *PosBase) Filename() string

                                                                              func (*PosBase) IsFileBase

                                                                              func (base *PosBase) IsFileBase() bool

                                                                              func (*PosBase) Line

                                                                              func (base *PosBase) Line() uint

                                                                              func (*PosBase) Pos

                                                                              func (base *PosBase) Pos() (_ Pos)

                                                                              type Pragma

                                                                              type Pragma interface{}

                                                                                A Pragma value augments a package, import, const, func, type, or var declaration. Its meaning is entirely up to the PragmaHandler, except that nil is used to mean “no pragma seen.”

                                                                                type PragmaHandler

                                                                                type PragmaHandler func(pos Pos, blank bool, text string, current Pragma) Pragma

                                                                                  A PragmaHandler is used to process //go: directives while scanning. It is passed the current pragma value, which starts out being nil, and it returns an updated pragma value. The text is the directive, with the "//" prefix stripped. The current pragma is saved at each package, import, const, func, type, or var declaration, into the File, ImportDecl, ConstDecl, FuncDecl, TypeDecl, or VarDecl node.

                                                                                  If text is the empty string, the pragma is being returned to the handler unused, meaning it appeared before a non-declaration. The handler may wish to report an error. In this case, pos is the current parser position, not the position of the pragma itself. Blank specifies whether the line is blank before the pragma.

                                                                                  type RangeClause

                                                                                  type RangeClause struct {
                                                                                  	Lhs Expr // nil means no Lhs = or Lhs :=
                                                                                  	Def bool // means :=
                                                                                  	X   Expr // range X
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                  type ReturnStmt

                                                                                  type ReturnStmt struct {
                                                                                  	Results Expr // nil means no explicit return values
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                  type SelectStmt

                                                                                  type SelectStmt struct {
                                                                                  	Body   []*CommClause
                                                                                  	Rbrace Pos
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                  type SelectorExpr

                                                                                  type SelectorExpr struct {
                                                                                  	X   Expr
                                                                                  	Sel *Name
                                                                                  	// contains filtered or unexported fields
                                                                                  }

                                                                                    X.Sel

                                                                                    type SendStmt

                                                                                    type SendStmt struct {
                                                                                    	Chan, Value Expr // Chan <- Value
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                    type SimpleStmt

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

                                                                                    type SliceExpr

                                                                                    type SliceExpr struct {
                                                                                    	X     Expr
                                                                                    	Index [3]Expr
                                                                                    	// Full indicates whether this is a simple or full slice expression.
                                                                                    	// In a valid AST, this is equivalent to Index[2] != nil.
                                                                                    	// TODO(mdempsky): This is only needed to report the "3-index
                                                                                    	// slice of string" error when Index[2] is missing.
                                                                                    	Full bool
                                                                                    	// contains filtered or unexported fields
                                                                                    }

                                                                                      X[Index[0] : Index[1] : Index[2]]

                                                                                      type SliceType

                                                                                      type SliceType struct {
                                                                                      	Elem Expr
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                        []Elem

                                                                                        type Stmt

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

                                                                                        type StructType

                                                                                        type StructType struct {
                                                                                        	FieldList []*Field
                                                                                        	TagList   []*BasicLit // i >= len(TagList) || TagList[i] == nil means no tag for field i
                                                                                        	// contains filtered or unexported fields
                                                                                        }

                                                                                          struct { FieldList[0] TagList[0]; FieldList[1] TagList[1]; ... }

                                                                                          type SwitchStmt

                                                                                          type SwitchStmt struct {
                                                                                          	Init   SimpleStmt
                                                                                          	Tag    Expr // incl. *TypeSwitchGuard
                                                                                          	Body   []*CaseClause
                                                                                          	Rbrace Pos
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                          type TypeDecl

                                                                                          type TypeDecl struct {
                                                                                          	Group  *Group // nil means not part of a group
                                                                                          	Pragma Pragma
                                                                                          	Name   *Name
                                                                                          	Alias  bool
                                                                                          	Type   Expr
                                                                                          	// contains filtered or unexported fields
                                                                                          }

                                                                                            Name Type

                                                                                            type TypeSwitchGuard

                                                                                            type TypeSwitchGuard struct {
                                                                                            	Lhs *Name // nil means no Lhs :=
                                                                                            	X   Expr  // X.(type)
                                                                                            	// contains filtered or unexported fields
                                                                                            }

                                                                                              X.(type) Lhs := X.(type)

                                                                                              type VarDecl

                                                                                              type VarDecl struct {
                                                                                              	Group    *Group // nil means not part of a group
                                                                                              	Pragma   Pragma
                                                                                              	NameList []*Name
                                                                                              	Type     Expr // nil means no type
                                                                                              	Values   Expr // nil means no values
                                                                                              	// contains filtered or unexported fields
                                                                                              }

                                                                                                NameList Type NameList Type = Values NameList = Values