ast

type ArrayType struct {
	Len    Expr
	Elt    Expr
	Lbrack token.Pos
}

type AssignStmt struct {
	Lhs     []Expr
	TokPos  token.Pos
	Tok     token.Token
	Rhs     []Expr
	IsRange bool
}

type BasicLit struct {
	Kind     token.Token // token.INT, token.CHAR, or token.STRING
	Value    string
	ValuePos token.Pos
}

type BinaryExpr struct {
	X  Expr
	Y  Expr
	Op token.Token
}

type BlockStmt struct {
	Lbrace token.Pos
	List   []Stmt
}

type BranchStmt struct {
	TokPos token.Pos
	Tok    token.Token
	Label  string
}

type CallExpr struct {
	Fun      Expr   // function expression
	Args     []Expr // function arguments; or nil
	Ellipsis token.Pos
}

type CaseClause struct {
	Case token.Pos
	List []Expr
	Body []Stmt
}

type CompositeLit struct {
	Type   Expr
	Elts   []Expr
	Lbrace token.Pos
}

type Decl interface {
}

type DeclStmt struct {
	Decl Decl
}

type Ellipsis struct {
	Elt      Expr
	Ellipsis token.Pos
}

type Expr interface {
}

type ExprStmt struct {
	X Expr
}

type Field struct {
	Names  []*Ident
	Type   Expr
	Offset int
}

type FieldList struct {
	Opening token.Pos
	List    []*Field
}

type File struct {
	Name       *Ident // package name that is in the package clause
	Package    token.Pos
	FileStart  token.Pos
	FileEnd    token.Pos
	Imports    []*ImportSpec
	Decls      []Decl
	Unresolved []*Ident
	Scope      *Scope
}

type ForStmt struct {
	For  token.Pos
	Init Stmt
	Cond Expr
	Post Stmt
	Body *BlockStmt
}

type FuncDecl struct {
	Recv *FieldList
	Name *Ident
	Type *FuncType
	Body *BlockStmt
}

type FuncType struct {
	Func    token.Pos
	Params  *FieldList
	Results *FieldList // this can be nil: e.g. func f() {}
}

type GenDecl struct {
	TokPos token.Pos
	Specs  []Spec
}

type GoStmt struct {
	Go   token.Pos
	Call *CallExpr
}

type Ident struct {
	NamePos token.Pos // identifier position
	Name    string
	Obj     *Object
}

type IfStmt struct {
	If   token.Pos
	Init Stmt
	Cond Expr
	Body *BlockStmt
	Else Stmt
}

type ImportSpec struct {
	Path *BasicLit
}

type IncDecStmt struct {
	X      Expr
	TokPos token.Pos
	Tok    token.Token
}

type IndexExpr struct {
	X     Expr
	Index Expr
}

type InterfaceType struct {
	Methods   []string
	Interface token.Pos
}

type KeyValueExpr struct {
	Key   Expr
	Value Expr
}

type MapType struct {
	Key   Expr
	Value Expr
	Map   token.Pos
}

type ObjKind string

type Object struct {
	Kind ObjKind
	Name string
	Decl interface{} // *ValueSpec|*FuncDecl|*TypeSpec|*Field|*AssignStmt
	Data interface{}
}

type ParenExpr struct {
	X      Expr
	Lparen token.Pos
}

type RangeStmt struct {
	For   token.Pos
	Key   Expr
	Value Expr
	X     Expr
	Body  *BlockStmt
	Tok   token.Token
}

type ReturnStmt struct {
	Return  token.Pos
	Results []Expr
}

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

type SelectorExpr struct {
	X   Expr
	Sel *Ident
}

type Signature struct {
	Params   *FieldList
	Results  *FieldList
	StartPos token.Pos
}

type SliceExpr struct {
	X      Expr
	Low    Expr
	High   Expr
	Max    Expr
	Slice3 bool
}

type Spec interface{}

type StarExpr struct {
	X    Expr
	Star token.Pos
}

type Stmt interface{}

type StructType struct {
	Fields *FieldList
	Struct token.Pos
}

type SwitchStmt struct {
	Switch token.Pos
	Init   Expr
	Tag    Expr
	Body   *BlockStmt
}

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

type TypeSpec struct {
	Name     *Ident
	IsAssign bool // isAlias
	Type     Expr
}

type TypeSwitchStmt struct {
	Switch token.Pos
	Assign Stmt
	Body   *BlockStmt
}

type UnaryExpr struct {
	X     Expr
	Op    token.Token
	OpPos token.Pos
}

type ValueSpec struct {
	Names  []*Ident
	Type   Expr
	Values []Expr
}