syntax

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
}

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

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

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

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

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

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 struct {
	Fun     Expr
	ArgList []Expr // nil means no arguments
	HasDots bool   // last argument is followed by ...
	// contains filtered or unexported fields
}

type CallStmt struct {
	Tok     token // Go or Defer
	Call    Expr
	DeferAt Expr // argument to runtime.deferprocat
	// contains filtered or unexported fields
}

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

type ChanDir uint

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

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

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

type CommentKind uint

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 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
}

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

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

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

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

type Error struct {
	Pos Pos
	Msg string
}

type ErrorHandler func(err error)

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

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

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

type File struct {
	Pragma    Pragma
	PkgName   *Name
	DeclList  []Decl
	EOF       Pos
	GoVersion string
	// contains filtered or unexported fields
}

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

type Form uint

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

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

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

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

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

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

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

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

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

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

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

type LitKind uint8

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

type Mode uint

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

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
	SetPos(Pos)
	// contains filtered or unexported methods
}

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

type Operator uint

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

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

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

type Pragma interface{}

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

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 struct {
	Results Expr // nil means no explicit return values
	// contains filtered or unexported fields
}

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

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

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

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

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
}

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

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

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

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

type Token uint

type Type interface {
	// Underlying returns the underlying type of a type.
	Underlying() Type

	// String returns a string representation of a type.
	String() string
}

type TypeAndValue struct {
	Type  Type
	Value constant.Value
	// contains filtered or unexported fields
}

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

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

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
}

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