ast

type ArrayType struct {
	*Position              // position in the source.
	Len         Expression // length. It is nil for arrays specified with ... notation.
	ElementType Expression // element type.
	// contains filtered or unexported fields
}

type Assignment struct {
	*Position                // position in the source.
	Lhs       []Expression   // left-hand variables.
	Type      AssignmentType // type.
	Rhs       []Expression   // assigned values (nil for increment and decrement).
}

type AssignmentType int

type BasicLiteral struct {
	*Position             // position in the source.
	Type      LiteralType // type.
	Value     string      // value.
	// contains filtered or unexported fields
}

type BinaryOperator struct {
	*Position              // position in the source.
	Op        OperatorType // operator.
	Expr1     Expression   // first expression.
	Expr2     Expression   // second expression.
	// contains filtered or unexported fields
}

type Block struct {
	*Position
	Nodes []Node
}

type Break struct {
	*Position             // position in the source.
	Label     *Identifier // label.
}

type Call struct {
	*Position               // position in the source.
	Func       Expression   // function.
	Args       []Expression // arguments.
	IsVariadic bool         // reports whether it is variadic.

	IR struct {
		// AppendArg1, in transformed calls to the builtin function 'append',
		// is the argument with index 1.
		AppendArg1 *Call
	}
	// contains filtered or unexported fields
}

type Case struct {
	*Position
	Expressions []Expression
	Body        []Node
}

type ChanDirection int

type ChanType struct {
	*Position                 // position in the source.
	Direction   ChanDirection // direction.
	ElementType Expression    // type of chan elements.
	// contains filtered or unexported fields
}

type Comment struct {
	*Position        // position in the source.
	Text      string // comment text.
}

type CompositeLiteral struct {
	*Position            // position in the source.
	Type      Expression // type of the composite literal. nil for composite literals without type.
	KeyValues []KeyValue // nil for empty composite literals.
	// contains filtered or unexported fields
}

type Const struct {
	*Position               // position in the source.
	Lhs       []*Identifier // left-hand side identifiers.
	Type      Expression    // nil for non-typed constant declarations.
	Rhs       []Expression  // nil for implicit-value constant declarations.
	Index     int           // index of the declaration in the constant declaration group or 0 if not in a group.
}

type Context int

type Continue struct {
	*Position             // position in the source.
	Label     *Identifier // label.
}

type Cut struct {
	Left  int
	Right int
}

type Default struct {
	*Position            // position in the source.
	Expr1     Expression // left hand expression.
	Expr2     Expression // right hand expression.
	// contains filtered or unexported fields
}

type Defer struct {
	*Position            // position in the source.
	Call      Expression // function or method call (should be a Call node).
}

type Expression interface {
	Parenthesis() int
	SetParenthesis(int)
	Node
	String() string
}

type Extends struct {
	*Position        // position in the source.
	Path      string // path to extend.
	Format    Format // format.
	Tree      *Tree  // expanded tree of extends.
}

type Fallthrough struct {
	*Position
}

type Field struct {
	Idents []*Identifier // identifiers. If nil is an embedded field.
	Type   Expression
	Tag    string
}

type For struct {
	*Position            // position in the source.
	Init      Node       // initialization statement.
	Condition Expression // condition expression.
	Post      Node       // post iteration statement.
	Body      []Node     // nodes of the body.
}

type ForIn struct {
	*Position             // position in the source.
	Ident     *Identifier // identifier.
	Expr      Expression  // range expression.
	Body      []Node      // nodes of the body.
	Else      *Block      // nodes to run if the body is not executed.
}

type ForRange struct {
	*Position              // position in the source.
	Assignment *Assignment // assignment.
	Body       []Node      // nodes of the body.
	Else       *Block      // nodes to run if the body is not executed.
}

type Format int

type Func struct {
	*Position
	Ident    *Identifier // name, nil for function literals.
	Type     *FuncType   // type.
	Body     *Block      // body.
	DistFree bool        // reports whether it is distraction free.
	Upvars   []Upvar     // Upvars of func.
	Format   Format      // macro format.
	// contains filtered or unexported fields
}

type FuncType struct {
	*Position               // position in the source.
	Macro      bool         // indicates whether it is declared as macro.
	Parameters []*Parameter // parameters.
	Result     []*Parameter // result.
	IsVariadic bool         // reports whether it is variadic.
	Reflect    reflect.Type // reflect type.
	// contains filtered or unexported fields
}

type Go struct {
	*Position            // position in the source.
	Call      Expression // function or method call (should be a Call node).
}

type Goto struct {
	*Position             // position in the source.
	Label     *Identifier // label.
}

type Identifier struct {
	*Position        // position in the source.
	Name      string // name.
	// contains filtered or unexported fields
}

type If struct {
	*Position            // position in the source.
	Init      Node       // init simple statement.
	Condition Expression // condition that once evaluated returns true or false.
	Then      *Block     // nodes to run if the expression is evaluated to true.
	Else      Node       // nodes to run if the expression is evaluated to false. Can be Block or If.
}

type Import struct {
	*Position               // position in the source.
	Ident     *Identifier   // name (including "." and "_") or nil.
	Path      string        // path to import.
	For       []*Identifier // exported identifiers that are enable for access.
	Tree      *Tree         // expanded tree of import.
}

type Index struct {
	*Position            // position in the source.
	Expr      Expression // expression.
	Index     Expression // index.
	// contains filtered or unexported fields
}

type Interface struct {
	*Position // position in the source.
	// contains filtered or unexported fields
}

type KeyValue struct {
	Key   Expression // nil for not-indexed values.
	Value Expression
}

type Label struct {
	*Position             // position in the source.
	Ident     *Identifier // identifier.
	Statement Node        // statement.
}

type LiteralType int

type MapType struct {
	*Position            // position in the source.
	KeyType   Expression // type of map keys.
	ValueType Expression // type of map values.
	// contains filtered or unexported fields
}

type Node interface {
	Pos() *Position // position in the original source
}

type Operator interface {
	Expression
	Operator() OperatorType
	Precedence() int
}

type OperatorType int

type Package struct {
	*Position
	Name         string // name.
	Declarations []Node

	IR struct {
		// IteaNameToVarIdents maps the name of the transformed 'itea'
		// identifier to the identifiers on the left side of a 'var'
		// declarations with an 'using' statement at package level.
		//
		// For example a package containing this declaration:
		//
		//    {% var V1, V2 = $itea2, len($itea2) using %} ... {% end using %}
		//
		//  will have a mapping in the form:
		//
		//    "$itea2" => [V1, V2]
		//
		IteaNameToVarIdents map[string][]*Identifier
	}
}

type Parameter struct {
	Ident *Identifier // name, can be nil.
	Type  Expression  // type.
}

type Placeholder struct {
	*Position // position in the source.
	// contains filtered or unexported fields
}

type Position struct {
	Line   int // line starting from 1
	Column int // column in characters starting from 1
	Start  int // index of the first byte
	End    int // index of the last byte
}

type Raw struct {
	*Position        // position in the source.
	Marker    string // marker.
	Tag       string // tag.
	Text      *Text  // text.
}

type Render struct {
	*Position        // position in the source.
	Path      string // path of the file to render.
	Tree      *Tree  // expanded tree of <path>.

	// IR holds the internal representation. The type checker transforms the
	// 'render' expression into a macro call, where the macro body is the
	// rendered file.
	IR struct {
		// Import is the 'import' declaration that imports the dummy file
		// declaring the dummy macro.
		Import *Import
		// Call is the call to the dummy macro.
		Call *Call
	}
	// contains filtered or unexported fields
}

type Return struct {
	*Position
	Values []Expression // return values.
}

type Select struct {
	*Position
	LeadingText *Text
	Cases       []*SelectCase
}

type SelectCase struct {
	*Position
	Comm Node
	Body []Node
}

type Selector struct {
	*Position            // position in the source.
	Expr      Expression // expression.
	Ident     string     // identifier.
	// contains filtered or unexported fields
}

type Send struct {
	*Position            // position in the source.
	Channel   Expression // channel.
	Value     Expression // value to send on the channel.
}

type Show struct {
	*Position                // position in the source.
	Expressions []Expression // expressions that once evaluated return the values to show.
	Context     Context      // context.
}

type SliceType struct {
	*Position              // position in the source.
	ElementType Expression // element type.
	// contains filtered or unexported fields
}

type Slicing struct {
	*Position            // position in the source.
	Expr      Expression // expression.
	Low       Expression // low bound.
	High      Expression // high bound.
	Max       Expression // max bound.
	IsFull    bool       // reports whether is a full expression.
	// contains filtered or unexported fields
}

type Statements struct {
	*Position
	Nodes []Node // nodes.
}

type StructType struct {
	*Position
	Fields []*Field
	// contains filtered or unexported fields
}

type Switch struct {
	*Position
	Init        Node
	Expr        Expression
	LeadingText *Text
	Cases       []*Case
}

type Text struct {
	*Position        // position in the source.
	Text      []byte // text.
	Cut       Cut    // cut.
}

type Tree struct {
	*Position
	Path   string // path of the tree.
	Nodes  []Node // nodes of the first level of the tree.
	Format Format // content format.
}

type TypeAssertion struct {
	*Position            // position in the source.
	Expr      Expression // expression.
	Type      Expression // type, is nil if it is a type switch assertion ".(type)".
	// contains filtered or unexported fields
}

type TypeDeclaration struct {
	*Position                      // position in the source.
	Ident              *Identifier // identifier of the type.
	Type               Expression  // expression representing the type.
	IsAliasDeclaration bool        // reports whether it is an alias declaration or a type definition.
}

type TypeSwitch struct {
	*Position
	Init        Node
	Assignment  *Assignment
	LeadingText *Text
	Cases       []*Case
}

type URL struct {
	*Position        // position in the source.
	Tag       string // tag (in lowercase).
	Attribute string // attribute (in lowercase).
	Value     []Node // value nodes.
}

type UnaryOperator struct {
	*Position              // position in the source.
	Op        OperatorType // operator.
	Expr      Expression   // expression.
	// contains filtered or unexported fields
}

type Upvar struct {

	// NativePkg is the name of the native package which holds a native Upvar.
	// If Upvar is not a native Upvar then NativeName is an empty string.
	NativePkg string

	// NativeName is the name of the native declaration of a native Upvar. If
	// Upvar is not a native Upvar then NativeName is an empty string.
	NativeName string

	// NativeValue is the value of the native variable Upvar. If Upvar is not
	// native then Upvar is nil.
	NativeValue *reflect.Value

	// NativeValueType, in case of Upvar refers to a native variable, contains
	// the type of such variable. If not then NativeValueType is nil.
	//
	// NativeValueType is necessary because the type cannot be stored into
	// the NativeValue, as if the upvar is not initialized in the compiler
	// then NativeValue contains an invalid reflect.Value.
	NativeValueType reflect.Type

	// Declaration is the ast node where Upvar is defined. If Upvar is a
	// native var then Declaration is nil.
	Declaration Node
}

type Using struct {
	*Position            // position in the source.
	Statement Node       // statement preceding the using statement.
	Type      Expression // type, can be a format identifier or a macro.
	Body      *Block     // body.
	Format    Format     // using content format.
}

type Var struct {
	*Position               // position in the source.
	Lhs       []*Identifier // left-hand side of assignment.
	Type      Expression    // nil for non-typed variable declarations.
	Rhs       []Expression  // nil for non-initialized variable declarations.
}