ast

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

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

type BadDecl struct {
	token.Position // beginning position of bad declaration
}

type BadExpr struct {
	token.Position // beginning position of bad expression
}

type BadStmt struct {
	token.Position // beginning position of bad statement
}

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

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

type BlockStmt struct {
	token.Position // position of "{"
	List           []Stmt
	Rbrace         token.Position // position of "}"
}

type BranchStmt struct {
	token.Position             // position of Tok
	Tok            token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
	Label          *Ident
}

type CallExpr struct {
	Fun    Expr           // function expression
	Lparen token.Position // position of "("
	Args   []Expr         // function arguments
	Rparen token.Position // positions of ")"
}

type CaseClause struct {
	token.Position                // position of "case" or "default" keyword
	Values         []Expr         // nil means default case
	Colon          token.Position // position of ":"
	Body           []Stmt         // statement list; or nil
}

type ChanDir int

type ChanType struct {
	token.Position         // position of "chan" keyword or "<-" (whichever comes first)
	Dir            ChanDir // channel direction
	Value          Expr    // value type
}

type CommClause struct {
	token.Position                // position of "case" or "default" keyword
	Tok            token.Token    // ASSIGN or DEFINE (valid only if Lhs != nil)
	Lhs, Rhs       Expr           // Rhs == nil means default case
	Colon          token.Position // position of ":"
	Body           []Stmt         // statement list; or nil
}

type Comment struct {
	token.Position        // beginning position of the comment
	Text           []byte // comment text (excluding '\n' for //-style comments)
}

type CommentGroup struct {
	List []*Comment
}

type CompositeLit struct {
	Type   Expr           // literal type
	Lbrace token.Position // position of "{"
	Elts   []Expr         // list of composite elements
	Rbrace token.Position // position of "}"
}

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

type DeclStmt struct {
	Decl Decl
}

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

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

type EmptyStmt struct {
	token.Position // position of preceeding ";"
}

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

type ExprStmt struct {
	X Expr // expression
}

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

type FieldList struct {
	Opening token.Position // position of opening parenthesis/brace
	List    []*Field       // field list
	Closing token.Position // position of closing parenthesis/brace
}

type File struct {
	Doc            *CommentGroup   // associated documentation; or nil
	token.Position                 // position of "package" keyword
	Name           *Ident          // package name
	Decls          []Decl          // top-level declarations
	Comments       []*CommentGroup // list of all comments in the source file
}

type ForStmt struct {
	token.Position // position of "for" keyword
	Init           Stmt
	Cond           Expr
	Post           Stmt
	Body           *BlockStmt
}

type FuncDecl struct {
	Doc  *CommentGroup // associated documentation; or nil
	Recv *FieldList    // receiver (methods); or nil (functions)
	Name *Ident        // function/method name
	Type *FuncType     // position of Func keyword, parameters and results
	Body *BlockStmt    // function body; or nil (forward declaration)
}

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

type FuncType struct {
	token.Position            // position of "func" keyword
	Params         *FieldList // (incoming) parameters
	Results        *FieldList // (outgoing) results
}

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

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

type Ident struct {
	token.Position         // identifier position
	Obj            *Object // denoted object
}

type IfStmt struct {
	token.Position // position of "if" keyword
	Init           Stmt
	Cond           Expr
	Body           *BlockStmt
	Else           Stmt
}

type ImportSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Name    *Ident        // local package name (including "."); or nil
	Path    *BasicLit     // package path
	Comment *CommentGroup // line comments; or nil
}

type IncDecStmt struct {
	X   Expr
	Tok token.Token // INC or DEC
}

type IndexExpr struct {
	X     Expr // expression
	Index Expr // index expression
}

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

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

type LabeledStmt struct {
	Label *Ident
	Stmt  Stmt
}

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

type Node interface {
	// Pos returns the (beginning) position of the node.
	Pos() token.Position
}

type ObjKind int

type Object struct {
	Kind ObjKind
	Pos  token.Position // declaration position
	Name string         // declared name
}

type Package struct {
	Name  string           // package name
	Scope *Scope           // package scope
	Files map[string]*File // Go source files by filename
}

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

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

type ReturnStmt struct {
	token.Position // position of "return" keyword
	Results        []Expr
}

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

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

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

type SliceExpr struct {
	X     Expr // expression
	Index Expr // beginning of slice range
	End   Expr // end of slice range; or nil
}

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

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

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

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

type SwitchStmt struct {
	token.Position // position of "switch" keyword
	Init           Stmt
	Tag            Expr
	Body           *BlockStmt // CaseClauses only
}

type TypeAssertExpr struct {
	X    Expr // expression
	Type Expr // asserted type; nil means type switch X.(type)
}

type TypeCaseClause struct {
	token.Position                // position of "case" or "default" keyword
	Types          []Expr         // nil means default case
	Colon          token.Position // position of ":"
	Body           []Stmt         // statement list; or nil
}

type TypeSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Name    *Ident        // type name
	Type    Expr          // *ArrayType, *StructType, *FuncType, *InterfaceType, *MapType, *ChanType or *Ident
	Comment *CommentGroup // line comments; or nil
}

type TypeSwitchStmt struct {
	token.Position // position of "switch" keyword
	Init           Stmt
	Assign         Stmt       // x := y.(type)
	Body           *BlockStmt // TypeCaseClauses only
}

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

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

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