ast

type ADTEnumBody struct {
	Lbrace   token.Pos      // position of "{"
	Variants []*EnumVariant // enum variants
	Methods  []Stmt         // methods
	Rbrace   token.Pos      // position of "}"
}

type AnyLiteral struct {
	ValuePos token.Pos
}

type ArrayLiteralExpr struct {
	Lbrack token.Pos // position of "["
	Elems  []Expr
	Rbrack token.Pos // position of "]"
}

type ArrayType struct {
	Name Expr
}

type AsExpr struct {
	X  Expr
	As token.Pos
	Y  Expr
}

type AssignStmt struct {
	Docs     *CommentGroup
	Scope    token.Token // const | var | let
	ScopePos token.Pos
	Lhs      Expr
	Colon    token.Pos // position of ":"
	Type     Expr
	Tok      token.Token // assignment token, e.g., := or =
	Rhs      Expr
}

type AssociatedEnumBody struct {
	Lbrace  token.Pos    // position of "{"
	Fields  *FieldList   // associated fields declaration
	Values  []*EnumValue // enum values with data
	Methods []Stmt       // methods
	Rbrace  token.Pos    // position of "}"
}

type BasicEnumBody struct {
	Lbrace token.Pos    // position of "{"
	Values []*EnumValue // enum values
	Rbrace token.Pos    // position of "}"
}

type BasicLit struct {
	Kind     token.Token // token.NUM, token.STR, token.IDENT
	Value    string      // literal string; e.g. 42, 0x7f, 3.14, "foo"
	ValuePos token.Pos   // literal position
}

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

type BlockStmt struct {
	Lbrace token.Pos // position of "{"
	List   []Stmt
	Rbrace token.Pos // position of "}"
}

type BreakStmt struct {
	Docs  *CommentGroup
	Break token.Pos // position of "break"
	Label *Ident
}

type CallExpr struct {
	Fun        Expr      // function expression
	Lt         token.Pos // position of "<"
	TypeParams []Expr    // type arguments for a generic function call
	Gt         token.Pos // position of ">"
	Lparen     token.Pos // position of "("
	Recv       []Expr    // function arguments; or nil
	Rparen     token.Pos // position of ")"
}

type CascadeExpr struct {
	X      Expr
	DblDot token.Pos // position of ".."
	Y      Expr
}

type CaseClause struct {
	Cond   Expr
	DArrow token.Pos // position of "=>"
	Body   *BlockStmt
	Comma  token.Pos // position of ","
}

type CatchClause struct {
	Docs   *CommentGroup
	Catch  token.Pos // position of "catch"
	Lparen token.Pos // position of "("
	Cond   Expr
	Rparen token.Pos // position of ")"
	Body   *BlockStmt
}

type ClassDecl struct {
	Docs       *CommentGroup      // associated documentation
	Decs       []*Decorator       // decorators
	Modifiers  []Modifier         // modifiers array (pub, etc.)
	Pub        token.Pos          // position of "pub" keyword, if any
	Class      token.Pos          // position of "class" keyword
	Name       *Ident             // class name
	Lt         token.Pos          // position of "<", if any
	TypeParams []Expr             // type parameters for a generic class
	Gt         token.Pos          // position of ">", if any
	Extends    token.Pos          // position of "extends" keyword, if any
	Parent     *Ident             // parent classes
	Lbrace     token.Pos          // position of "{"
	Fields     *FieldList         // list of fields
	Ctors      []*ConstructorDecl // list of constructors
	Methods    []*FuncDecl        // list of methods
	Rbrace     token.Pos          // position of "}"
}

type CmdExpr struct {
	Cmd         Expr   // command name/expression
	Args        []Expr // command arguments; or nil
	IsAsync     bool   // true if async is used, e.g., cmd &
	BuiltinArgs []Expr // builtin command arguments, e.g. cmd --- -a "str" 10 -b
}

type CmdStmt struct {
	Docs *CommentGroup
	Name Expr
	Recv []Expr
}

type CmdSubstExpr struct {
	Dollar token.Pos
	Lparen token.Pos
	Fun    Expr
	Recv   []Expr
	Rparen token.Pos
}

type Comment struct {
	Slash token.Pos // position of "/" starting the comment
	Text  string    // comment text (excluding '\n' for //-style comments)
}

type CommentGroup struct {
	List []*Comment // len(List) > 0
}

type ComptimeExpr struct {
	Comptime token.Pos // position of comptime
	X        Expr
}

type ComptimeStmt struct {
	Comptime token.Pos // position of "comptime"
	When     token.Pos // position of "when"
	Cond     Expr      // optional condition
	Body     Stmt
	Else     Stmt
}

type ConditionalExpr struct {
	Cond      Expr
	Quest     token.Pos // position of "?"
	WhenTrue  Expr
	Colon     token.Pos // position of ":"
	WhneFalse Expr
}

type ConditionalType struct {
	CheckType   Expr
	Extends     token.Pos // position of "extends"
	ExtendsType Expr
	Quest       token.Pos // position of "?"
	TrueType    Expr
	Colon       token.Pos // position of ":"
	FalseType   Expr
}

type ConstModifier struct {
	Const token.Pos // position of "const" keyword
}

type ConstructorDecl struct {
	Docs       *CommentGroup // associated documentation
	Decs       []*Decorator  // decorators
	Modifiers  []Modifier    // modifiers array (const, pub, etc.)
	ClsName    *Ident        // class name (same as class name)
	Name       *Ident        // constructor name
	Lparen     token.Pos     // position of "("
	Recv       []Expr        // constructor parameters
	Rparen     token.Pos     // position of ")"
	InitFields []Expr        // init fields
	Body       *BlockStmt    // constructor body
}

type ContinueStmt struct {
	Docs     *CommentGroup
	Continue token.Pos // position of "continue"
}

type DeclareDecl struct {
	Docs    *CommentGroup
	Declare token.Pos // position of "declare"
	X       Node
}

type Decorator struct {
	At   token.Pos // position of "@"
	Name *Ident
	Recv []Expr
}

type DeferStmt struct {
	Docs  *CommentGroup
	Defer token.Pos // position of "defer"
	X     Node
}

type DoWhileStmt struct {
	Do     token.Pos // position of "do"
	Body   *BlockStmt
	Loop   token.Pos // position of "loop"
	Lparen token.Pos // position of "("
	Cond   Expr
	Rparen token.Pos // position of ")"
}

type EllipsisModifier struct {
	Ellipsis token.Pos // position of "..."
}

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

type EnumDecl struct {
	Docs       *CommentGroup // associated documentation
	Decs       []*Decorator  // decorators
	Modifiers  []Modifier    // modifiers array (final, const, pub, etc.)
	Enum       token.Pos     // position of "enum" keyword
	Name       *Ident        // enum name
	Lt         token.Pos     // position of "<", if any
	TypeParams []Expr        // type parameters for a generic enum
	Gt         token.Pos     // position of ">", if any
	Body       EnumBody      // enum body
}

type EnumMember struct{}

type EnumMethod struct {
	Mod Modifier
	Fn  token.Pos // position of "fn"
}

type EnumValue struct {
	Docs   *CommentGroup // associated documentation
	Name   *Ident        // value name
	Assign token.Pos     // position of "=", if any
	Value  Expr          // value expression, if any
	Lparen token.Pos     // position of "(", for associated values
	Data   []Expr        // associated data, if any
	Rparen token.Pos     // position of ")"
	Comma  token.Pos     // position of ","
}

type EnumVariant struct {
	Docs   *CommentGroup // associated documentation
	Name   *Ident        // variant name
	Lbrace token.Pos     // position of "{"
	Fields *FieldList    // variant fields
	Rbrace token.Pos     // position of "}"
	Comma  token.Pos     // position of ","
}

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

type ExprStmt struct {
	Docs *CommentGroup
	Decs []*Decorator
	X    Expr // expression
}

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

type ExtensionClass struct {
	Class token.Pos // position of "class"
	Body  *BlockStmt
}

type ExtensionDecl struct {
	Docs      *CommentGroup // associated documentation
	Extension token.Pos     // position of "extension" keyword
	Name      *Ident
	Body      ExtensionBody // the extension body
}

type ExtensionEnum struct {
	Enum token.Pos // position of "enum"
	Body *BlockStmt
}

type ExtensionMod struct {
	Mod  token.Pos // position of "mod"
	Body *BlockStmt
}

type ExtensionTrait struct {
	Trait token.Pos // position of "trait"
	Body  *BlockStmt
}

type ExtensionType struct {
	Type token.Pos // position of "type"
	Body *BlockStmt
}

type ExternDecl struct {
	Extern token.Pos // position of "extern"
	List   []Expr
}

type FalseLiteral struct {
	ValuePos token.Pos
}

type Field struct {
	Docs      *CommentGroup
	Decs      []*Decorator
	Modifiers []Modifier
	Name      *Ident
	Colon     token.Pos // position of ":"
	Type      Expr
	Assign    token.Pos // position of '='
	Value     Expr      // default value
}

type FieldList struct {
	Opening token.Pos // position of opening parenthesis/brace/bracket, if any
	List    []*Field  // field list; or nil
	Closing token.Pos // position of closing parenthesis/brace/bracket, if any
}

type File struct {
	Docs    []*CommentGroup
	Name    *Ident // filename
	Imports map[string]*Import
	Stmts   []Stmt
	Decls   []Stmt
}

type FinalModifier struct {
	Final token.Pos // position of "final" keyword
}

type FinallyStmt struct {
	Docs    *CommentGroup
	Finally token.Pos // position of "finally"
	Body    *BlockStmt
}

type ForInStmt struct {
	Loop  token.Pos // position of "loop"
	Index *Ident
	In    token.Pos // position of "in"
	RangeExpr
	Body *BlockStmt
}

type ForStmt struct {
	Loop   token.Pos // position of "loop"
	Lparen token.Pos // position of "("
	Init   Stmt
	Comma1 token.Pos // position of ";"
	Cond   Expr
	Comma2 token.Pos // position of ";"
	Post   Expr
	Rparen token.Pos // position of ")"
	Body   *BlockStmt
}

type ForeachStmt struct {
	Loop   token.Pos // position of "loop"
	Lparen token.Pos // position of "("
	Index  Expr
	Value  Expr
	Rparen token.Pos   // position of ")"
	Tok    token.Token // Token.IN or Token.OF
	TokPos token.Pos   // position of "in" or "of"
	Var    Expr
	Body   *BlockStmt
}

type FuncDecl struct {
	Docs       *CommentGroup // associated documentation
	Decs       []*Decorator  // decorators
	Modifiers  []Modifier    // modifiers array (const, comptime, pub, etc.)
	Fn         token.Pos     // position of "fn" keyword
	Name       *Ident        // function name
	Lt         token.Pos     // position of "<", if any
	TypeParams []Expr        // type parameters for a generic function
	Gt         token.Pos     // position of ">", if any
	Recv       []Expr        // function parameters
	Throw      bool          // if the function can throw an exception
	Type       Expr          // result type
	Body       *BlockStmt    // function body
}

type FunctionType struct {
	Lparen  token.Pos
	Recv    []Expr
	Rparent token.Pos
	RetVal  Expr
}

type GetAccessor struct {
	Get  token.Pos // position of "get"
	Name *Ident
	Body *BlockStmt
}

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

type IfStmt struct {
	Docs *CommentGroup
	If   token.Pos // position of "if"
	Cond Expr
	Body *BlockStmt
	Else Stmt
}

type ImplDecl struct {
	Docs  *CommentGroup // associated documentation
	Impl  token.Pos     // position of "impl" keyword
	Trait *Ident        // trait being implemented
	For   token.Pos     // position of "for" keyword
	*ImplDeclBody
	*ImplDeclBinding
}

type ImplDeclBinding struct {
	Classes []*Ident // classes implementing the trait
}

type ImplDeclBody struct {
	Class *Ident     // class implementing the trait
	Body  *BlockStmt // implementation body
}

type Import struct {
	Docs      *CommentGroup
	ImportPos token.Pos // position of "import"
	*ImportAll
	*ImportSingle
	*ImportMulti
}

type ImportAll struct {
	Mul   token.Pos // position of "*"
	As    token.Pos // position of "as"
	Alias string
	From  token.Pos // position of "from"
	Path  string
}

type ImportField struct {
	Field string
	As    token.Pos // position of "as"
	Alias string
}

type ImportMulti struct {
	Lbrace token.Pos // position of "{"
	List   []*ImportField
	Rbrace token.Pos // position of "}"
	From   token.Pos // position of "from"
	Path   string
}

type ImportSingle struct {
	Path  string
	As    token.Pos // position of "as"
	Alias string
}

type IncDecExpr struct {
	Pre    bool // true if it's a prefix operator, false for postfix
	X      Expr
	Tok    token.Token // INC or DEC
	TokPos token.Pos   // position of "++" or "--"
}

type IndexExpr struct {
	X      Expr      // expression
	Quest  bool      // true if optional chaining is used, e.g., a?[i]
	Lbrack token.Pos // position of "["
	Index  Expr      // index expression
	Rbrack token.Pos // position of "]"
}

type IndexListExpr struct {
	X       Expr   // expression
	Indices []Expr // index expressions
}

type InferType struct {
	Infer token.Pos // position of "infer"
	X     Expr
}

type IntersectionType struct {
	Types []Expr
}

type KeyValueExpr struct {
	Docs  *CommentGroup
	Decs  []*Decorator
	Mod   Modifier
	Key   Expr
	Quest bool      // true if the key is optional
	Colon token.Pos // position of ":"
	Value Expr
}

type LabelStmt struct {
	Name  *Ident
	Colon token.Pos
}

type LambdaExpr struct {
	Lparen token.Pos // position of "("
	Recv   []Expr
	Rparen token.Pos // position of ")"
	DArrow token.Pos // position of "=>"
	Body   *BlockStmt
}

type LiteralType BasicLit

type MatchStmt struct {
	Docs    *CommentGroup
	Match   token.Pos // position of "match"
	Expr    Expr      // expression being matched
	Lbrace  token.Pos // position of "{"
	Cases   []*CaseClause
	Default *CaseClause
	Rbrace  token.Pos // position of "}"
}

type ModAccessExpr struct {
	X        Expr
	DblColon token.Pos // position of "::"
	Y        Expr
}

type ModDecl struct {
	Docs   *CommentGroup // associated documentation
	Pub    token.Pos     // position of "pub" keyword, if any
	Mod    token.Pos     // position of "mod" keyword
	Name   *Ident        // module name
	Lbrace token.Pos     // position of "{"
	Body   *BlockStmt    // module body
	Rbrace token.Pos     // position of "}"
}

type Modifier interface {
	Node
	Kind() ModifierKind
}

type ModifierKind uint8

type NamedObjectLiteralExpr struct {
	Name   Expr      // Type name, e.g., 'User'.
	Lbrace token.Pos // Position of "{"
	Props  []Expr    // List of elements, typically KeyValueExpr.
	Rbrace token.Pos // Position of "}"
}

type NamedParameters struct {
	Lbrace token.Pos // position of "{"
	Params []Expr
	Rbrace token.Pos // position of "}"
}

type NamedTupleLiteralExpr struct {
	Lparen token.Pos // position of "("
	Elems  []Expr
	Rparen token.Pos // position of ")"
}

type NewDelExpr struct {
	TokPos token.Pos   // position of "new" or "delete"
	Tok    token.Token // Token.NEW or Token.DELETE
	X      Expr
}

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

type NullLiteral struct {
	ValuePos token.Pos
}

type NullableType struct {
	X Expr
}

type NumericLiteral struct {
	ValuePos token.Pos
	Value    string
}

type ObjectLiteralExpr struct {
	Lbrace token.Pos // position of "{"
	Props  []Expr
	Rbrace token.Pos // position of "}"
}

type OperatorDecl struct {
	Docs     *CommentGroup // associated documentation
	Decs     []*Decorator  // decorators
	Operator token.Pos     // position of "operator" keyword
	Name     token.Token   // operator token
	Lparen   token.Pos     // position of "("
	Params   []Expr        // parameters
	Rparen   token.Pos     // position of ")"
	Arrow    token.Pos     // position of "->"
	Type     Expr          // result type
	Body     *BlockStmt    // function body
}

type Package struct {
	Name *Ident

	Files map[string]*File
}

type Parameter struct {
	TokPos   token.Pos // position of "required" or "..."
	Modifier Modifier
	Name     *Ident
	Colon    token.Pos // position of ":"
	Type     Expr
	Assign   token.Pos // position of "="
	Value    Expr      // default value
}

type PrettyPrinterOption func(*prettyPrinter) error

type PubModifier struct {
	Pub token.Pos // position of "pub" keyword
}

type RangeExpr struct {
	Start     Expr
	DblColon1 token.Pos // position of ".."
	End_      Expr
	DblColon2 token.Pos // position of ".."
	Step      Expr
}

type ReadonlyModifier struct {
	Readonly token.Pos // position of "readonly" keyword
}

type RefExpr struct {
	Dollar token.Pos // position of "$"
	Lbrace token.Pos // position of "{"
	X      Expr
	Rbrace token.Pos // position of "}"
}

type RequiredModifier struct {
	Required token.Pos // position of "required" keyword
}

type ReturnStmt struct {
	Docs   *CommentGroup
	Return token.Pos // position of "return"
	X      Expr
}

type SelectExpr struct {
	X     Expr
	Quest bool      // true if optional chaining is used, e.g., X?.Y
	Dot   token.Pos // position of "."
	Y     Expr
}

type SetAccessor struct {
	Set  token.Pos // position of "set"
	Name *Ident
	Body *BlockStmt
}

type SetLiteralExpr struct {
	Lbrace token.Pos // position of "{"
	Elems  []Expr
	Rbrace token.Pos // position of "}"
}

type SetType struct {
	Types []Expr
}

type SliceExpr struct {
	X       Expr      // expression
	Lbrack  token.Pos // position of "["
	Low     Expr      // begin of slice range; or nil
	DblCol  token.Pos // position of ".."
	High    Expr      // end of slice range; or nil
	DblCol2 token.Pos // position of ".."
	Max     Expr      // maximum capacity of slice; or nil
	Rbrack  token.Pos // position of "]"
}

type StaticModifier struct {
	Static token.Pos // position of "static" keyword
}

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

type StringLiteral struct {
	ValuePos token.Pos
	Value    string
}

type ThrowStmt struct {
	Docs  *CommentGroup
	Throw token.Pos // position of "throw"
	X     Expr
}

type TraitDecl struct {
	Docs      *CommentGroup // associated documentation
	Modifiers []Modifier
	Trait     token.Pos  // position of "trait" keyword
	Name      *Ident     // trait name
	Lbrace    token.Pos  // position of "{"
	Fields    *FieldList // list of method signatures
	Rbrace    token.Pos  // position of "}"
}

type TrueLiteral struct {
	ValuePos token.Pos
}

type TryStmt struct {
	Docs    *CommentGroup
	Try     token.Pos // position of "try"
	Body    *BlockStmt
	Catches []*CatchClause
	Finally *FinallyStmt
}

type TupleLiteralExpr struct {
	Lbrack token.Pos // position of "["
	Elems  []Expr
	Rbrack token.Pos // position of "]"
}

type TupleType struct {
	Types []Expr
}

type TypeDecl struct {
	Docs   *CommentGroup // associated documentation
	Type   token.Pos     // position of "type" keyword
	Name   *Ident        // type name
	Assign token.Pos     // position of "="
	Value  Expr          // type value
}

type TypeLiteral struct {
	Members []Expr
}

type TypeParameter struct {
	Name        Expr
	Extends     token.Pos // position of "extends"
	Constraints []Expr
}

type TypeReference struct {
	Name       Expr
	TypeParams []Expr
}

type TypeofExpr struct {
	Typeof token.Pos // position of "typeof"
	X      Expr
}

type UnaryExpr struct {
	OpPos token.Pos   // position of Op
	Op    token.Token // operator
	X     Expr        // operand
}

type UnionType struct {
	Types []Expr
}

type UnsafeStmt struct {
	Docs   *CommentGroup
	Unsafe token.Pos // position of "unsafe" or "$"
	Start  token.Pos // position of `{`
	Text   string
	EndPos token.Pos // position of `}`
}

type UseDecl struct {
	Docs   *CommentGroup
	Use    token.Pos // position of "use"
	Lhs    Expr
	Assign token.Pos // position of "="
	Rhs    Expr
}

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

type WhileStmt struct {
	Loop token.Pos // position of "loop"
	Cond Expr
	Body *BlockStmt
}