ast

type ArrayExpr struct {
	At     token.Pos // position of '@'
	Lparen token.Pos // position of '('
	Elems  []Expr
	Rparen token.Pos // position of ')'
}

type AssignStmt struct {
	Lhs    Expr
	TokPos token.Pos // position of '=' or '+=', '-=', '*=', etc.
	Tok    token.Token
	Rhs    Expr
}

type Attribute struct {
	Lparen token.Pos // position of '['
	Name   *Ident
	Recv   []Expr
	Rparen token.Pos // position of ']'
}

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

type BlockExpr struct {
	Lbrace token.Pos // position of '{'
	List   []Expr    // list of expressions in the block
	Rbrace token.Pos // position of '}'
}

type BlockStmt struct {
	List []Stmt
}

type BoolLit struct {
	ValPos token.Pos
	Val    bool
}

type BreakStmt struct {
	Break token.Pos
}

type CallExpr struct {
	Func Expr
	Recv []Expr
}

type CaseClause struct {
	Cond Expr
	Body *BlockStmt
}

type CastExpr struct {
	Lbrack token.Pos // position of '['
	Type   Expr
	Rbrack token.Pos // position of ']'
	X      Expr
}

type CatchClause struct {
	Catch  token.Pos // position of 'catch'
	Lbrack token.Pos // position of '['
	Type   Expr
	Rbrack token.Pos // position of ']'
	Body   *BlockStmt
}

type ClassDecl struct {
	Class      token.Pos // position of class keyword
	Name       *Ident
	Ctors      []*ConstructorDecl
	Properties []*PropertyDecl
	Methods    []*MethodDecl
}

type CmdExpr struct {
	Cmd  Expr
	Args []Expr
}

type CommaExpr struct {
	Elems []Expr
}

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

type CommentGroup struct {
	List []Comment
}

type ConstructorDecl struct {
	Name   *Ident
	Lparen token.Pos
	Params []Expr
	Rparen token.Pos
	Body   *BlockStmt
}

type ContinueStmt struct {
	Continue token.Pos // position of 'continue'
	Label    *Ident
}

type DataStmt struct {
	Data token.Pos // position of 'data'
	Recv []Expr
	Body *BlockStmt
}

type DelimitedComment struct {
	Opening token.Pos // position of '<#'
	Text    string
	Closing token.Pos // position of '#>'
}

type DoUntilStmt struct {
	Do     token.Pos // position of 'do'
	Body   *BlockStmt
	Until  token.Pos // position of 'until'
	Lparen token.Pos // position of '('
	Cond   Expr
	Rparen token.Pos // position of ')'
}

type DoWhileStmt struct {
	Do     token.Pos // position of 'do'
	Body   *BlockStmt
	While  token.Pos // position of 'while'
	Lparen token.Pos // position of '('
	Cond   Expr
	Rparen token.Pos // position of ')'
}

type DynamicparamStmt struct {
	Dynamicparam token.Pos // position of 'dynamicparam'
	Body         *BlockStmt
}

type EnumDecl struct {
	Attrs          []*Attribute
	Enum           token.Pos // position of enum keyword
	Name           *Ident
	Colon          token.Pos // position of ':'
	UnderlyingType *Ident
	Lbrace         token.Pos // position of '{'
	List           []*EnumKeyValue
	Rbrace         token.Pos // position of '}'
}

type EnumKeyValue struct {
	Label  *Ident
	Assign token.Pos
	Value  Expr
}

type ExplictExpr struct {
	X Expr
	Y Expr
}

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

type ExprStmt struct {
	X Expr
}

type File struct {
	Docs  []*CommentGroup
	Name  *Ident
	Stmts []Stmt
}

type ForStmt struct {
	For   token.Pos // position of 'for'
	Init  Expr
	Semi  token.Pos // position of ';'
	Cond  Expr
	Semi2 token.Pos // position of ';'
	Post  Expr
	Body  *BlockStmt
}

type ForeachStmt struct {
	Foreach token.Pos   // position of 'foreach'
	Opt     token.Token // TODO: -Parallel
	Lparen  token.Pos   // position of '('
	Elm     Expr
	In      token.Pos // position of 'in'
	Elms    Expr
	Rparen  token.Pos // position of ')'
	Body    *BlockStmt
}

type FuncDecl struct {
	Function token.Pos // position of function keyword
	Name     *Ident
	Body     *BlockStmt
}

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

type GroupExpr struct {
	Sep    token.Token
	Lparen token.Pos // position of '('
	Elems  []Expr
	Rparen token.Pos // position of ')'
}

type HashEntry struct {
	Key    *Ident
	Assign token.Pos // position of '='
	Value  Expr
}

type HashTable struct {
	At      token.Pos // position of '@'
	Lbrace  token.Pos // position of '{'
	Entries []*HashEntry
	Rbrace  token.Pos // position of '}'
}

type HelpDirective interface {
	// contains filtered or unexported methods
}

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

type IfStmt struct {
	If     token.Pos // position of 'if'
	LParen token.Pos // position of '('
	Cond   Expr
	RParen token.Pos // position of ')'
	Body   *BlockStmt
	Else   Stmt
}

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

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

type IndicesExpr struct {
	X       Expr
	Lbrack  token.Pos // position of '['
	Indices []Expr
	Rbrack  token.Pos // position of ']'
}

type InlinescriptDecl struct {
	Inlinescript token.Pos // position of inlinescript keyword
	Body         *BlockStmt
}

type LabelStmt struct {
	Colon token.Pos // position of ':'
	X     Expr
}

type Lit struct {
	Val    string
	ValPos token.Pos
}

type MemberAccess struct {
	Dollar token.Pos // position of '$'
	Long   bool
	Lbrace token.Pos // position of '{'
	X      Expr
	Colon  token.Pos // position of ':'
	Y      Expr
	Rbrace token.Pos // position of '}'
}

type MethodDecl struct {
	StaticPos token.Pos
	Static    bool
	Type      Expr
	Name      *Ident
	Lparen    token.Pos
	Params    []Expr
	Rparen    token.Pos
	Body      *BlockStmt
}

type Modifier int

type MultiStringLit struct {
	LAt    token.Pos // position of '@'
	LQuote token.Pos // position of '"'
	Val    string
	Rquote token.Pos // position of '"'
	RAt    token.Pos // position of '@'
}

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

type NumericLit struct {
	ValPos token.Pos
	Val    string
}

type ParallelDecl struct {
	Parallel token.Pos // position of parallel keyword
	Body     *BlockStmt
}

type ParamBlock struct {
	Attributes []*Attribute
	Param      token.Pos // position of 'param'
	Lparen     token.Pos // position of '('
	Params     []*Parameter
	Rparen     token.Pos // position of ')'
}

type Parameter struct {
	Attrs  []*Attribute
	X      Expr
	Assign token.Pos // position of '='
	Value  Expr
}

type ProcessDecl struct {
	Process token.Pos // position of process keyword
	Body    *BlockStmt
}

type PropertyDecl struct {
	ModPos token.Pos
	Mod    Modifier
	Type   Expr
	Dollar token.Pos
	Name   *Ident
	Assign token.Pos
	Value  Expr
}

type RangeExpr struct {
	X      Expr
	DblDot token.Pos // position of '..'
	Y      Expr
}

type RedirectExpr struct {
	X     Expr
	CtrOp token.Token
	OpPos token.Pos
	Y     Expr
}

type ReturnStmt struct {
	Return token.Pos // position of 'return'
	X      Expr
}

type SelectExpr struct {
	X   Expr
	Dot token.Pos // position of '.'
	Sel Expr
}

type SequenceDecl struct {
	Sequence token.Pos // position of sequence keyword
	Body     *BlockStmt
}

type SingleLineComment struct {
	Hash token.Pos
	Text string
}

type StaticMemberAccess struct {
	X        Expr
	DblColon token.Pos // position of '::'
	Y        Expr
}

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

type StringLit struct {
	ValPos token.Pos
	Val    string
}

type SubExpr struct {
	Dollar token.Pos // position of '$'
	Lparen token.Pos // position of '('
	X      Expr
	Rparen token.Pos // position of ')'
}

type SwitchPattern int

type SwitchStmt struct {
	Switch        token.Pos // position of 'switch'
	Pattern       SwitchPattern
	Casesensitive bool
	Lparen        token.Pos // position of '('
	Value         Expr
	Rparen        token.Pos // position of ')'
	Lbrace        token.Pos // position of '{'
	Cases         []*CaseClause
	Default       *BlockStmt
	Rbrace        token.Pos // position of '}'
}

type ThrowStmt struct {
	Throw token.Pos // position of 'throw'
	X     Expr
}

type TrapStmt struct {
	Trap token.Pos // position of 'trap'
	Body *BlockStmt
}

type TryStmt struct {
	Try         token.Pos // position of 'try'
	Body        *BlockStmt
	Catches     []*CatchClause
	Finally     token.Pos // position of 'finally'
	FinallyBody *BlockStmt
}

type TypeLit struct {
	Lbrack token.Pos // position of '['
	Name   Expr
	Rbrack token.Pos // position of ']'
}

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 {
	Dollar token.Pos // position of '$'
	X      Expr
}

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

type WhileStmt struct {
	While  token.Pos // position of 'while'
	Lparen token.Pos // position of '('
	Cond   Expr
	Rparen token.Pos // position of ')'
	Body   *BlockStmt
}

type WorkflowDecl struct {
	Workflow token.Pos // position of workflow keyword
	Name     *Ident
	Body     *BlockStmt
}