ast

type AssignExpr struct {
	Op  token.Kind
	LHS Expr
	RHS Expr
}

type BinaryExpr struct {
	Op    token.Kind
	OpPos token.Pos
	X     Expr
	Y     Expr
}

type Block struct {
	Lbrace token.Pos
	Stmts  []Stmt
	Rbrace token.Pos
}

type BoolLit struct {
	ValuePos token.Pos
	Value    bool
}

type BreakStmt struct {
	Break token.Pos
	Label *Ident // nil without a label
}

type CallExpr struct {
	Fun    Expr
	Lparen token.Pos
	Args   []Expr // may contain *Spread
}

type CaseLabel struct {
	Case  token.Pos
	Value Expr
}

type CharLit struct {
	ValuePos token.Pos
	Text     string
	Value    int64
}

type ClassDecl struct {
	Class      token.Pos
	Name       *Ident
	BaseModule *Ident // the module of the base class, or nil
	Base       *Ident // nil without a base class
	Members    []Member
}

type CommaExpr struct {
	List []Expr
}

type CondExpr struct {
	Cond Expr
	Then Expr
	Else Expr
}

type ConstDecl struct {
	Const token.Pos
	Vars  []*VarSpec
}

type ContinueStmt struct {
	Continue token.Pos
	Label    *Ident
}

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

type DefaultLabel struct {
	Default token.Pos
}

type DoStmt struct {
	Do   token.Pos
	Body Stmt
	Cond Expr
}

type EmptyStmt struct {
	Semi token.Pos
}

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

type ExprStmt struct {
	X Expr
}

type FieldDecl struct {
	Start  token.Pos
	Static bool
	Names  []*Ident
}

type File struct {
	Name   string
	Module string // the module the file is, "" for the program's own files (set by the loader)
	Decls  []Decl // the use declarations come first

	// Compiled is set for a module loaded from a .kkc file (kukel build
	// -module): the file holds the module's header, the compiler links
	// this code instead of compiling function bodies.
	Compiled *bytecode.Module
}

type FloatLit struct {
	ValuePos token.Pos
	Text     string
	Value    float64
}

type ForEachStmt struct {
	For   token.Pos
	Key   *Ident // the only name with one name
	Value *Ident // nil with one name
	X     Expr
	Body  Stmt
}

type ForStmt struct {
	For      token.Pos
	InitVars []*VarSpec // "for (local i = 0, j; ...)"
	Init     Expr
	Cond     Expr // nil: loop until break
	Post     Expr
	Body     Stmt
}

type FuncDecl struct {
	Class  *Ident // nil for a plain function
	Name   *Ident
	Params *ParamList
	Body   *Block
}

type FuncLit struct {
	Fn     token.Pos
	Params *ParamList
	Body   *Block
}

type GlobalDecl struct {
	Global token.Pos
	Vars   []*VarSpec
}

type Ident struct {
	NamePos token.Pos
	Name    string
}

type IfStmt struct {
	If   token.Pos
	Cond Expr
	Then Stmt
	Else Stmt // nil without else
}

type IncDecExpr struct {
	Op     token.Kind // token.INC or token.DEC
	OpPos  token.Pos
	Prefix bool
	X      Expr
}

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

type IntLit struct {
	ValuePos token.Pos
	Text     string
	Value    int64
}

type LabeledStmt struct {
	Label *Ident
	Stmt  Stmt
}

type LocalDecl struct {
	Local token.Pos
	Vars  []*VarSpec
}

type MapEntry struct {
	Key   Expr
	Value Expr
}

type MapLit struct {
	Lbrace  token.Pos
	Entries []*MapEntry
}

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

type MemberExpr struct {
	X    Expr
	Name *Ident
}

type MethodCall struct {
	X    Expr
	Name *Ident
	Args []Expr // may contain *Spread
}

type MethodDecl struct {
	Start  token.Pos
	Static bool
	Name   *Ident
	Params []*Ident
	Rest   bool // the last parameter is a rest parameter
}

type NewExpr struct {
	New    token.Pos
	Module *Ident // nil without a module
	Class  *Ident
	Args   []Expr // may contain *Spread
}

type NilLit struct {
	ValuePos token.Pos
}

type Node interface {
	Pos() token.Pos
}

type Param struct {
	Name    *Ident
	Default Expr // nil for a required or rest parameter
	Rest    bool
}

type ParamList struct {
	Params []*Param
}

type ReturnStmt struct {
	Return token.Pos
	Value  Expr // nil: return nil
}

type Spread struct {
	X Expr
}

type StaticRef struct {
	Module *Ident // set only for module::Class::name
	Class  *Ident
	Name   *Ident
}

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

type StringLit struct {
	ValuePos token.Pos
	Text     string
	Value    string
}

type SwitchStmt struct {
	Switch token.Pos
	Tag    Expr
	Body   *Block
}

type ThisExpr struct {
	This token.Pos
}

type ThrowStmt struct {
	Throw token.Pos
	Value Expr
}

type TryStmt struct {
	Try      token.Pos
	Body     *Block
	CatchVar *Ident
	Catch    *Block
	Finally  *Block
}

type UnaryExpr struct {
	Op    token.Kind
	OpPos token.Pos
	X     Expr
}

type UseDecl struct {
	Use  token.Pos
	Name *Ident
}

type VarSpec struct {
	Name  *Ident
	Value Expr // nil without an initializer
}

type VectorLit struct {
	Lbrack token.Pos
	Elems  []Expr // may contain *Spread
}

type WhileStmt struct {
	While token.Pos
	Cond  Expr
	Body  Stmt
}

type WithStmt struct {
	With token.Pos
	Vars []*VarSpec // each with a value
	Body Stmt
}