ast

type Annotation struct {
	At     token.Pos          // position of "@"
	Name   *Ident             // annotation name
	Lparen token.Pos          // position of "(" if any
	Params []*AnnotationParam // annotation parameters; or nil
	Rparen token.Pos          // position of ")" if any
}

type AnnotationGroup struct {
	List []*Annotation // len(List) > 0
}

type AnnotationParam struct {
	Name      *Ident    // name of parameter
	AssignPos token.Pos // position of "=" if any
	Value     Node      // parameter value (Expr or Type), or nil
}

type ArrayType struct {
	Array token.Pos // position of token.ARRAY
	T     Type      // element type
	N     Expr      // size of the array
	GT    token.Pos // position of ">"
}

type BadExpr struct {
	From, To token.Pos // position range of bad expression
}

type BadStmt struct {
	From, To token.Pos // position range of bad statement
}

type BasicLit struct {
	ValuePos token.Pos   // literal position
	Kind     token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
	Value    string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
}

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

type CallExpr struct {
	Fun    Expr      // function expression
	Lparen token.Pos // position of "("
	Args   []Expr    // function arguments; or nil
	Rparen token.Pos // position of ")"
}

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 CommentMap map[Node][]*CommentGroup

type ConstDecl = GenDecl[Expr]

type Decl interface {
	Node
	Token() token.Token
	// contains filtered or unexported methods
}

type EnumDecl = GenDecl[*EnumType]

type EnumMember struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Name        *Ident           // value name
	AssignPos   token.Pos        // position of "=" if any
	Value       Expr             // value; or nil
	Comment     *CommentGroup    // line comments; or nil
}

type EnumType struct {
	Members *MemberList // list of enum members
}

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

type ExprStmt struct {
	X Expr // expression
}

type FieldList = List[*StructField]

type File struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Package     token.Pos        // position of "package" keyword
	Name        *Ident           // package name
	Decls       []Decl           // top-level declarations except imports
	Stmts       []Stmt           // top-level statements; or nil

	FileStart, FileEnd token.Pos       // start and end of entire file
	Imports            []*ImportDecl   // imports in this file
	Comments           []*CommentGroup // list of all comments in the source file
}

type GenDecl[T Node] struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Tok         token.Token      // CONST, ENUM, STRUCT or INTERFACE
	TokPos      token.Pos        // position of Tok
	Name        *Ident           // value name
	Spec        T                // spec of the declaration
	Comment     *CommentGroup    // line comments const declarations; or nil
}

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

type ImportDecl struct {
	Doc       *CommentGroup // associated documentation; or nil
	ImportPos token.Pos     // position of "import" keyword
	Path      *BasicLit     // import path
	Comment   *CommentGroup // line comments; or nil
	EndPos    token.Pos     // end of spec (overrides Path.Pos if nonzero)
}

type InterfaceDecl = GenDecl[*InterfaceType]

type InterfaceType struct {
	Methods *MethodList // list of methods
}

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

type MapType struct {
	Map token.Pos // position of token.MAP
	K   Type      // key type
	V   Type      // value type
	GT  token.Pos // position of ">"
}

type MemberList = List[*EnumMember]

type Method struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Name        *Ident           // method name
	Params      *MethodParamList // method parameters
	Result      Type             // method result type; or nil
	Comment     *CommentGroup    // line comments; or nil
}

type MethodList = List[*Method]

type MethodParam struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Type        Type             // parameter type
	Name        *Ident           // parameter name
	Comment     *CommentGroup    // line comments; or nil
}

type MethodParamList = List[*MethodParam]

type Node interface {
	Pos() token.Pos // position of first character belonging to the node
	End() token.Pos // position of first character immediately after the node
}

type ParenExpr struct {
	Lparen token.Pos // position of "("
	X      Expr      // parenthesized expression
	Rparen token.Pos // position of ")"
}

type SelectorExpr struct {
	X   Expr   // expression
	Sel *Ident // field selector
}

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

type StructDecl = GenDecl[*StructType]

type StructField struct {
	Doc         *CommentGroup    // associated documentation; or nil
	Annotations *AnnotationGroup // associated annotations; or nil
	Type        Type             // field/method/parameter type; or nil
	Name        *Ident           // field/method/(type) parameter names; or nil
	Comment     *CommentGroup    // line comments; or nil
}

type StructType struct {
	Fields *FieldList // list of field declarations
}

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

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

type VectorType struct {
	Vector token.Pos // position of token.VECTOR
	T      Type      // element type
	GT     token.Pos // position of ">"
}

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