ast

type AnonymousField struct {
	*common.Node
	IsPointerReceiver bool
	Type              string
}

type Arguments struct {
	*common.Node
	TemplateSpec *TemplateSpec
	Expressions  *ExpressionList
	Type         *Type
	IsVariadic   bool
}

type ArrayType struct {
	*common.Node
	Length      *Expression
	ElementType *Type
}

type Assignment struct {
	*common.Node
	Left  *ExpressionList
	Op    string
	Right *ExpressionList
}

type Block struct {
	*common.Node
	Statements []*Statement
}

type BreakStmt struct {
	*common.Node
	Name string
}

type ChannelType struct {
	*common.Node
	ChannelDecl string
	Type        *Type
}

type CommCase struct {
	*common.Node
	SendStmt  *SendStmt
	RecvStmt  *RecvStmt
	IsDefault bool
}

type CommClause struct {
	*common.Node
	CommCase *CommCase
	Block    *Block
}

type CompositeLit struct {
	*common.Node
	LiteralType  *LiteralType
	TemplateSpec *TemplateSpec
	LiteralValue *LiteralValue
}

type ConstDecl struct {
	*common.Node
	ConstSpecs []*ConstSpec
}

type ConstSpec struct {
	*common.Node
	IdentifierList *IdentifierList
	Type           *Type
	ExpressionList *ExpressionList
}

type ContinueStmt struct {
	*common.Node
	Name string
}

type Conversion struct {
	*common.Node
	Type       *Type
	Expression *Expression
}

type Declaration struct {
	*common.Node
	ConstDecl *ConstDecl
	TypeDecl  *TypeDecl
	VarDecl   *VarDecl
}

type DeferStmt struct {
	*common.Node
	Expression *Expression
}

type Element struct {
	*common.Node
	Expression   *Expression
	LiteralValue *LiteralValue
}

type ExprCaseClause struct {
	*common.Node
	ExprSwitchCase *ExprSwitchCase
	Statements     []*Statement
}

type ExprSwitchCase struct {
	*common.Node
	Expressions *ExpressionList
	IsDefault   bool
}

type ExprSwitchStmt struct {
	*common.Node
	SimpleStmt      *SimpleStmt
	Expression      *Expression
	ExprCaseClauses []*ExprCaseClause
}

type Expression struct {
	*common.Node
	UnaryExpr       *UnaryExpr
	LeftExpression  *Expression
	Op              string
	RightExpression *Expression
}

type ExpressionList struct {
	*common.Node
	Expressions []*Expression
}

type FallthroughStmt struct {
	*common.Node
}

type FieldDecl struct {
	*common.Node
	IdentifierList     *IdentifierList
	Type               *Type
	Anonymous          *AnonymousField
	Tag                string
	InlineStructMethod *InlineStructMethod
}

type ForClause struct {
	*common.Node
	LeftSimpleStmt  *SimpleStmt
	Expression      *Expression
	RightSimpleStmt *SimpleStmt
}

type ForStmt struct {
	*common.Node
	Expression  *Expression
	ForClause   *ForClause
	RangeClause *RangeClause
	Block       *Block
}

type Function struct {
	*common.Node
	Signature *Signature
	Block     *Block
}

type FunctionDecl struct {
	*common.Node
	Name      string
	Function  *Function
	Signature *Signature
}

type FunctionLit struct {
	*common.Node
	Function *Function
}

type FunctionType struct {
	*common.Node
	Signature *Signature
}

type GoStmt struct {
	*common.Node
	Function   *Function
	Expression *Expression
}

type GotoStmt struct {
	*common.Node
	Name string
}

type IdentifierList struct {
	*common.Node
	List []string
}

type IfStmt struct {
	*common.Node
	SimpleStmt *SimpleStmt
	Expression *Expression
	Block      *Block
	IfStmt     *IfStmt
	BlockElse  *Block
}

type Import struct {
	*common.Node
	Items []*ImportSpec
}

type ImportSpec struct {
	*common.Node
	Path  string
	Alias string
}

type IncDecStmt struct {
	*common.Node
	Expression *Expression
	IsInc      bool
}

type Index struct {
	*common.Node
	Expression *Expression
}

type InlineStructMethod struct {
	*common.Node
	IsPointerReceiver bool
	FunctionDecl      *FunctionDecl
}

type InterfaceType struct {
	*common.Node
	Name        string
	MethodSpecs []*MethodSpec
}

type Interpret struct {
	*common.Node
	Statement *Statement
	TopLevel  *TopLevel
}

type Key struct {
	*common.Node
	Name         string
	Expression   *Expression
	LiteralValue *LiteralValue
}

type KeyedElement struct {
	*common.Node
	Key     *Key
	Element *Element
}

type LabeledStmt struct {
	*common.Node
	Name      string
	Statement *Statement
}

type Literal struct {
	*common.Node
	Basic       string
	Composite   *CompositeLit
	FunctionLit *FunctionLit
}

type LiteralType struct {
	*common.Node
	Struct  *StructType
	Array   *ArrayType
	Element *Type
	Slice   *SliceType
	Map     *MapType
	Type    string
}

type LiteralValue struct {
	*common.Node
	Elements []*KeyedElement
}

type MapType struct {
	*common.Node
	InnerType *Type
	OuterType *Type
}

type MethodDecl struct {
	*common.Node
	Receiver  *Receiver
	Function  *Function
	Signature *Signature
}

type MethodExpr struct {
	*common.Node
	ReceiverType *ReceiverType
	Name         string
}

type MethodSpec struct {
	*common.Node
	Name       string
	Parameters *Parameters
	Result     *Result
	Type       string
}

type Operand struct {
	*common.Node
	Literal     *Literal
	OperandName *OperandName
	MethodExpr  *MethodExpr
	Expression  *Expression
}

type OperandName struct {
	*common.Node
	Name string
}

type Package struct {
	*common.Node
	Name string
}

type Parameter struct {
	*common.Node
	IdentifierList *IdentifierList
	Type           *Type
	IsVariadic     bool
}

type Parameters struct {
	*common.Node
	List []*Parameter
}

type PointerType struct {
	*common.Node
	Type *Type
}

type PrimaryExpr struct {
	*common.Node
	Operand       *Operand
	Conversion    *Conversion
	PrimaryExpr   *PrimaryExpr
	SecondaryExpr *SecondaryExpr
}

type RangeClause struct {
	*common.Node
	IdentifierList *IdentifierList
	Expression     *Expression
}

type Receiver struct {
	*common.Node
	Package           string
	IsPointerReceiver bool
	Method            string
}

type ReceiverType struct {
	*common.Node
	Type         string
	IsPointer    bool
	ReceiverType *ReceiverType
}

type RecvStmt struct {
	*common.Node
	Expressions    *ExpressionList
	IdentifierList *IdentifierList
	Expression     *Expression
}

type Result struct {
	*common.Node
	Types []*Type
}

type ReturnStmt struct {
	*common.Node
	Expressions *ExpressionList
}

type SecondaryExpr struct {
	*common.Node
	Selector      string
	Index         *Index
	Slice         *Slice
	TypeAssertion *TypeAssertion
	Arguments     *Arguments
}

type SelectStmt struct {
	*common.Node
	CommClauses []*CommClause
}

type SendStmt struct {
	*common.Node
	Left  *Expression
	Right *Expression
}

type ShortVarDecl struct {
	*common.Node
	IdentifierList *IdentifierList
	Expressions    *ExpressionList
}

type Signature struct {
	*common.Node
	TemplateSpec *TemplateSpec
	Parameters   *Parameters
	Result       *Result
}

type SimpleStmt struct {
	*common.Node
	SendStmt     *SendStmt
	Expression   *Expression
	IncDecStmt   *IncDecStmt
	ShortVarDecl *ShortVarDecl
	Assignment   *Assignment
	EmptyStmt    bool
}

type Slice struct {
	*common.Node
	LeftExpr   *Expression
	MiddleExpr *Expression
	RightExpr  *Expression
}

type SliceType struct {
	*common.Node
	Type *Type
}

type SourceFile struct {
	*common.Node
	Package   *Package
	Import    *Import
	TopLevels []*TopLevel
}

type Statement struct {
	*common.Node
	SimpleStmt      *SimpleStmt
	LabeledStmt     *LabeledStmt
	GoStmt          *GoStmt
	ReturnStmt      *ReturnStmt
	BreakStmt       *BreakStmt
	ContinueStmt    *ContinueStmt
	GotoStmt        *GotoStmt
	FallthroughStmt *FallthroughStmt
	IfStmt          *IfStmt
	SwitchStmt      *SwitchStmt
	SelectStmt      *SelectStmt
	ForStmt         *ForStmt
	Block           *Block
	DeferStmt       *DeferStmt
	Declaration     *Declaration
}

type StructType struct {
	*common.Node
	Name         string
	TemplateSpec *TemplateSpec
	Fields       []*FieldDecl
}

type SwitchStmt struct {
	*common.Node
	ExprSwitchStmt *ExprSwitchStmt
	TypeSwitchStmt *TypeSwitchStmt
}

type TemplateSpec struct {
	*common.Node
	Result *Result
}

type TopLevel struct {
	*common.Node
	Declaration  *Declaration
	FunctionDecl *FunctionDecl
	MethodDecl   *MethodDecl
}

type Type struct {
	*common.Node
	TypeName string
	TypeLit  *TypeLit
	Type     *Type
}

type TypeAssertion struct {
	*common.Node
	Type *Type
}

type TypeCaseClause struct {
	*common.Node
	TypeSwitchCase *TypeSwitchCase
	Statements     []*Statement
}

type TypeDecl struct {
	*common.Node
	TypeSpecs     []*TypeSpec
	StructType    *StructType
	InterfaceType *InterfaceType
}

type TypeLit struct {
	*common.Node
	ArrayType     *ArrayType
	StructType    *StructType
	PointerType   *PointerType
	FunctionType  *FunctionType
	InterfaceType *InterfaceType
	SliceType     *SliceType
	MapType       *MapType
	ChannelType   *ChannelType
}

type TypeSpec struct {
	*common.Node
	Name string
	Type *Type
}

type TypeSwitchCase struct {
	*common.Node
	Types []*Type
}

type TypeSwitchGuard struct {
	*common.Node
	Name        string
	PrimaryExpr *PrimaryExpr
}

type TypeSwitchStmt struct {
	*common.Node
	SimpleStmt      *SimpleStmt
	TypeSwitchGuard *TypeSwitchGuard
	TypeCaseClauses []*TypeCaseClause
}

type UnaryExpr struct {
	*common.Node
	PrimaryExpr *PrimaryExpr
	Op          string
	UnaryExpr   *UnaryExpr
}

type VarDecl struct {
	*common.Node
	VarSpecs []*VarSpec
}

type VarSpec struct {
	*common.Node
	IdentifierList *IdentifierList
	Type           *Type
	ExpressionList *ExpressionList
	Statement      *Statement
}