ast

type AssignStmt struct {
	Lhs Expr
	Rhs Expr
}

type Attribute struct {
	Key   Expr
	Value Expr
}

type BasicLit struct {
	Kind  token.Token
	Value string
}

type BinaryExpr struct {
	X     Expr        // left operand
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	Y     Expr        // right operand
}

type BlcokStmt struct {
	List []Stmt
}

type BlockExpr struct {
	List []Expr
}

type BreakStmt struct {
	Break token.Pos
	Label *Ident
}

type CallExpr struct {
	Func  Expr
	Args  []Expr
	Brace bool
}

type CaseStmt struct {
	Cond Expr
	Body *BlcokStmt
}

type CatchStmt struct {
	Cond Expr
	Body *BlcokStmt
}

type ContinueStmt struct{}

type DataStmt struct {
	Param []Expr
	Body  *BlcokStmt
}

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

type ExplictExpr struct {
	X Expr
	Y Expr
}

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

type ExprStmt struct {
	Expr
}

type Fields struct {
	Sep string // " " "," ";"
}

type File struct {
	Name string

	Stmts []Stmt
}

type ForStmt struct {
	Lhs  Expr
	Cond Expr
	Rhs  Expr
	Body *BlcokStmt
}

type ForeachStmt struct {
	Lhs  Expr
	Rhs  Expr
	Body *BlcokStmt
}

type FuncStmt struct {
	Func Expr
	Recv []Expr
	Body *BlcokStmt
}

type HashTable map[any]any

type Ident struct {
	NamePos token.Pos // identifier position
	Name    string    // identifier name
}

type IfStmt struct {
	Cond Expr
	Body *BlcokStmt
	Else Stmt
}

type IncDecExpr struct {
	X      Expr
	Tok    token.Token // INC or DEC
	TokPos token.Pos   // position of "++" or "--"
}

type IndexExpr struct {
	X      Expr
	Lbrack token.Token
	Index  Expr
	Rbrack token.Token
}

type LabelStmt struct {
	X Expr
}

type List []Expr

type MemberAccess struct {
	Type    Expr
	Colon   token.Pos
	Method  Expr
	Generic Expr
	Recv    []Expr
}

type ModExpr struct {
	X Expr
	Y Expr
}

type Node interface {
	Pos() token.Pos
	End() token.Pos
}

type ReturnStmt struct {
	X Expr
}

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

type SubExpr struct {
	X Expr
}

type SwitchPattern int

type SwitchStmt struct {
	Pattern       SwitchPattern
	Casesensitive bool
	Cond          Expr
	Cases         []*CaseStmt
	Default       *CaseStmt
}

type ThrowStmt struct {
	X Expr
}

type TryStmt struct {
	Body    *BlcokStmt
	Catches []*CatchStmt
	Finally *BlcokStmt
}

type UsingAssembly struct {
	Assembly token.Pos
	Path     string
}

type UsingDecl struct {
	Using token.Pos
	*UsingModule
	*UsingNamespace
	*UsingAssembly
}

type UsingModule struct {
	Module token.Pos
	Name   *Ident
}

type UsingNamespace struct {
	Namespace token.Pos
	Name      *Ident
}

type VarExpr struct {
	Tok     token.Token // lbrace | lbrack
	Opening token.Pos
	X       Expr
	Closing token.Pos
}

type WhileStmt struct {
	Do   bool
	Cond Expr
	Body *BlcokStmt
}