ast

type ASTNode interface {
	Compile(c *CompileContext)
	SetLhs()
	SetRequiredType(dt *common.DataType)

	GetDataType() *common.DataType
	SetDataType(*common.DataType)

	IsVariadic() bool

	GetInstructions() []common.Instruction

	AppendInstruction(instruction ...common.Instruction)

	GetConstantValue() interface{}

	CheckIsConstant()
	PostProcess()

	SetSource(ctx antlr.ParserRuleContext)
	GetText() string
	ErrorWithSource(string) string

	SetStackPtr()
	IsStackPtr() bool
	GetStackIncrement() int
}

type AssertNode struct {
	Node
	Type  ASTNode
	Value ASTNode
}

type AssignNode struct {
	Node
	Lhs ASTNode
	Rhs ASTNode
	Op  string
}

type BinaryNode struct {
	Node
	Lhs ASTNode
	Rhs ASTNode
	Op  string
}

type BlockNode struct {
	Node
	Executions []ASTNode
}

type BreakNode struct {
	Node
}

type BuiltinFunctionNode struct {
	Node
	Params      []ASTNode
	BuiltinName string
	Aux         interface{}
}

type ChanRecv struct {
	Node
	Chan     ASTNode
	NonBlock bool
}

type ChanSend struct {
	Node
	ToSend   ASTNode
	Chan     ASTNode
	NonBlock bool
}

type CompileContext struct {
	TypeRegistry *common.TypeRegistry
	Scope        *common.Scope
	FunctionInfo []*common.FunctionMeta
}

type ConstructorNode struct {
	Node
	Params []ASTNode
	Type   ASTNode
}

type ContinueNode struct {
	Node
}

type ConvertNode struct {
	Node
	Type  ASTNode
	Value ASTNode
}

type EnumNode struct {
	Node
	Name string
	Enum map[string]int32
}

type FetchSymbolNode struct {
	Node
	SymbolName string
	Symbol     *common.Symbol
}

type ForMapNode struct {
	Node
	KeyName string
	ValName string
	Map     ASTNode
	Serial  ASTNode
}

type ForNode struct {
	Node
	Init      ASTNode
	Condition ASTNode
	Step      ASTNode
	Block     ASTNode
}

type ForSliceNode struct {
	Node
	ItemName string
	Slice    ASTNode
	Serial   ASTNode
}

type FunctionAssignNode struct {
	Node
	Lhs      []ASTNode
	Function ASTNode
}

type FunctionCallNode struct {
	Node
	Function ASTNode
	Params   []ASTNode
	Meta     *common.FunctionMeta
}

type FunctionDefNode struct {
	Node
	FuncName  string
	Block     ASTNode
	InParam   []ASTNode
	OutParam  []ASTNode
	TailArray bool

	Function *common.Instruction
}

type IfNode struct {
	Node
	Condition ASTNode
	Block     ASTNode
	ElseBlock ASTNode
}

type IndexNode struct {
	Node
	ToIndex ASTNode
	Index   ASTNode
}

type IndicesNode struct {
	Node
	From ASTNode
	To   ASTNode
	Step ASTNode
}

type InitializationKVNode struct {
	Node
	Keys   []ASTNode
	Values []ASTNode
	Type   ASTNode
}

type InitializationSliceNode struct {
	Node
	Items []ASTNode
	Type  ASTNode
}

type LeftUnaryNode struct {
	Node
	Operand ASTNode
	Op      string
}

type MapMultiIndexNode struct {
	Node
	Map    ASTNode
	Fields []ASTNode
}

type MessageFieldDef struct {
	Node
	Name string
	Type ASTNode
}

type MessageTypeDef struct {
	Node
	Name       string
	Field      map[string]ASTNode
	OneOfGroup map[string][]string
}

type Node struct {
	LineNumber     int
	Text           string
	Instructions   []common.Instruction
	DataType       *common.DataType
	RequiredType   *common.DataType
	StackPtr       bool
	LhsFlag        bool
	Variadic       bool
	StackIncrement int
	ConstantValue  interface{}
}

type OneofFieldDef struct {
	Node
	Name    string
	Choices []*MessageFieldDef
}

type ParamNode struct {
	Node
	Symbol   string
	TypeNode ASTNode
}

type ProgramRoot struct {
	Node
	TypeDefNode   []ASTNode
	StatementNode []ASTNode
}

type RestoreStackNode struct {
	Node
	Line ASTNode
}

type ReturnNode struct {
	Node
	Expr []ASTNode
}

type RightUnaryNode struct {
	Node
	Operand ASTNode
	Op      string
}

type SelectorNode struct {
	Node
	Data      ASTNode // selector or var
	FieldName string
}

type SliceFilterNode struct {
	Node
	Slice ASTNode
	Expr  ASTNode
}

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

type SliceMultiIndexNode struct {
	Node
	Slice   ASTNode
	Indices []ASTNode
}

type SwitchNode struct {
	Node
	Expr       ASTNode
	Conditions []interface{}
	Blocks     []ASTNode
}

type SymbolNode struct {
	Node
	SymbolName    string
	SymbolType    common.SymbolType
	DataTypeNode  ASTNode
	ValueToAssign ASTNode
}

type TypeDefNode struct {
	Node
	SimpleTypeName string
	TypeNodeType   TypeNodeType
	Key            *common.DataType // map
	Value          ASTNode          // map slice chan
	InParam        []ASTNode        // func
	OutParam       []ASTNode        // func
	TailArray      bool
}

type TypeNode struct {
	Node
	SimpleTypeName string
	TypeNodeType   TypeNodeType
	Key            *common.DataType // map
	Value          ASTNode          // map slice chan
	InParam        []ASTNode        // func
	OutParam       []ASTNode        // func
	TailArray      bool
}

type TypeNodeType int

type ValueNode struct {
	Node
}