golang

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

type AssignStmt struct {
	LHS []Expr
	Tok Token
	RHS []Expr
}

type BadDecl struct {
	Token Token
}

type BadExpr struct {
	Token Token
}

type BadStmt struct {
	Token Token
}

type BasicLit struct {
	Token Token
}

type BinaryExpr struct {
	X  Expr
	Op Token
	Y  Expr
}

type BlockStmt struct {
	Lbrace Token // "{"
	List   []Stmt
	Rbrace Token // "}"
}

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

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

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

type ChanType struct {
	Begin Token // "chan" keyword or "<-" (whichever comes first)
	Arrow Token // "<-" (token.NoPos if there is no "<-"); added in Go 1.1
	// Dir         {|"SEND", "RECV"|} powerset without {||}
	Dir   string
	Value Expr // value type
}

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

type Comment struct {
	Token Token
}

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

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

type Decl interface {
	fmt.Formatter
	GoIsDecl()
}

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

type DeferStmt struct {
	Defer Token // "defer" keyword
	Call  CallExpr
}

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

type EmptyStmt struct {
	Semicolon Token // following ";"
	Implicit  bool  // if set, ";" was omitted in the source; added in Go 1.5
}

type Expr interface {
	fmt.Formatter
	GoIsExpr()
}

type ExprStmt struct {
	X Expr // expression
}

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
}

type FieldList struct {
	Opening Token   // opening parenthesis/brace, if any
	List    []Field // field list; or nil
	Closing Token   // closing parenthesis/brace, if any
}

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

type ForStmt struct {
	For  Token // "for" keyword
	Init Stmt  // initialization statement; or nil
	Cond Expr  // condition; or nil
	Post Stmt  // post iteration statement; or nil
	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      // function signature: parameters, results, and "func" keyword
	Body *BlockStmt    // function body; or nil for external (non-Go) function
}

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

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

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

type GoStmt struct {
	Go   Token // "go" keyword
	Call CallExpr
}

type Ident struct {
	Name Token // identifier name
}

type IfStmt struct {
	If   Token // "if" keyword
	Init Stmt  // initialization statement; or nil
	Cond Expr  // condition
	Body BlockStmt
	Else Stmt // else branch; or nil
}

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         // end of spec (overrides Path.Pos if nonzero)
}

type IncDecStmt struct {
	X   Expr
	Tok Token
}

type IndexExpr struct {
	X      Expr
	Lbrack Token // "["
	Index  Expr
	Rbrack Token // "]"
}

type InterfaceType struct {
	Interface  Token     // "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
	Value Expr
}

type LabeledStmt struct {
	Label Ident
	Colon Token
	Stmt  Stmt
}

type MapType struct {
	Map   Token // "map" keyword
	Key   Expr
	Value Expr
}

type NoCommaSepFieldList FieldList

type ParenExpr struct {
	Lparen Token // "("
	X      Expr  // parenthesized expression
	Rparen Token // ")"
}

type RangeStmt struct {
	For   Token // "for" keyword
	Key   Expr  // Key may be nil
	Value Expr  // Value may be nil
	Tok   Token // invalid if Key == nil
	X     Expr  // value to range over
	Body  BlockStmt
}

type ReturnStmt struct {
	Return  Token  // "return" keyword
	Results []Expr // result expressions; or nil
}

type SelectStmt struct {
	Select Token     // "select" keyword
	Body   BlockStmt // CommClauses only
}

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

type SendStmt struct {
	Chan  Expr
	Arrow Token // "<-"
	Value Expr
}

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

type Spec interface {
	fmt.Formatter
	GoIsSpec()
}

type StarExpr struct {
	Star Token // "*"
	X    Expr  // operand
}

type Stmt interface {
	fmt.Formatter
	GoIsStmt()
}

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

type SwitchStmt struct {
	Switch Token     // "switch" keyword
	Init   Stmt      // initialization statement; or nil
	Tag    Expr      // tag expression; or nil
	Body   BlockStmt // CaseClauses only
}

type Token struct {
	Kind string
	// Text SliceOfString
	Text string
}

type TypeAssertExpr struct {
	X      Expr  // expression
	Lparen Token // "("; added in Go 1.2
	Type   Expr  // asserted type; nil means type switch X.(type)
	Rparen Token // ")"; added in Go 1.2
}

type TypeSpec struct {
	Doc     *CommentGroup // associated documentation; or nil
	Name    Ident         // type name
	Assign  Token         // '=', if any; added in Go 1.9
	Type    Expr          // Ident, ParenExpr, SelectorExpr, StarExpr, or any of the XxxTypes
	Comment *CommentGroup // line comments; or nil
}

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

type UnaryExpr struct {
	Op Token
	X  Expr
}

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
}