func (r *Range) Children() []Node {
	return []Node{r.Start, r.End}
}
Children returns the Node's children.
package ast
import (
	"fmt"
	"io"
	"strings"
	"github.com/VirusTotal/gyp/pb"
	"github.com/golang/protobuf/proto"
)
type Node interface {
	WriteSource(io.Writer) error
	Children() []Node
}
type Expression interface {
	Node
	AsProto() *pb.Expression
}
type Keyword string
const (
	KeywordAll        Keyword = "all"
	KeywordAny        Keyword = "any"
	KeywordNone       Keyword = "none"
	KeywordEntrypoint Keyword = "entrypoint"
	KeywordFalse      Keyword = "false"
	KeywordFilesize   Keyword = "filesize"
	KeywordThem       Keyword = "them"
	KeywordTrue       Keyword = "true"
)
type Group struct {
	Expression
}
type LiteralInteger struct {
	Value int64
}
type LiteralFloat struct {
	Value float64
}
type LiteralString struct {
	Value string
}
type RegexpModifiers int
const (
	_ = iota
	RegexpCaseInsensitive RegexpModifiers = 1 << iota
	RegexpDotAll
)
type LiteralRegexp struct {
	Value     string
	Modifiers RegexpModifiers
}
type Minus struct {
	Expression
}
type Not struct {
	Expression
}
type BitwiseNot struct {
	Expression
}
type Range struct {
	Start Expression
	End   Expression
}
type Enum struct {
	Values []Expression
}
type Identifier struct {
	Identifier string
}
type StringIdentifier struct {
	Identifier string
	At         Expression
	In         *Range
}
type StringCount struct {
	Identifier string
}
type StringOffset struct {
	Identifier string
	Index      Expression
}
type StringLength struct {
	Identifier string
	Index      Expression
}
type FunctionCall struct {
	Callable  Expression
	Arguments []Expression
}
type MemberAccess struct {
	Container Expression
	Member    string
}
type Subscripting struct {
	Array Expression
	Index Expression
}
type Quantifier struct {
	Expression
}
type ForIn struct {
	Quantifier *Quantifier
	Variables  []string
	Iterator   Node
	Condition  Expression
}
type ForOf struct {
	Quantifier *Quantifier
	Strings    Node
	Condition  Expression
}
type Of struct {
	Quantifier *Quantifier
	Strings    Node
}
type Operation struct {
	Operator OperatorType
	Operands []Expression
}
func (l *LiteralString) String() string {
	return fmt.Sprintf(`"%s"`, l.Value)
}
func (l *LiteralRegexp) String() string {
	var modifiers string
	if l.Modifiers&RegexpCaseInsensitive != 0 {
		modifiers += "i"
	}
	if l.Modifiers&RegexpDotAll != 0 {
		modifiers += "s"
	}
	return fmt.Sprintf("/%s/%s", l.Value, modifiers)
}
func (k Keyword) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, string(k))
	return err
}
func (g *Group) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "(")
	if err == nil {
		err = g.Expression.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (l *LiteralInteger) WriteSource(w io.Writer) error {
	_, err := fmt.Fprint(w, l.Value)
	return err
}
func (l *LiteralFloat) WriteSource(w io.Writer) error {
	_, err := fmt.Fprintf(w, "%f", l.Value)
	return err
}
func (l *LiteralString) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, l.String())
	return err
}
func (l *LiteralRegexp) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, l.String())
	return err
}
func (m *Minus) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "-")
	if err == nil {
		err = m.Expression.WriteSource(w)
	}
	return err
}
func (n *Not) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "not ")
	if err == nil {
		err = n.Expression.WriteSource(w)
	}
	return err
}
func (b *BitwiseNot) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "~")
	if err == nil {
		err = b.Expression.WriteSource(w)
	}
	return err
}
func (r *Range) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "(")
	if err == nil {
		err = r.Start.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, "..")
	}
	if err == nil {
		err = r.End.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (e *Enum) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "(")
	for i, expr := range e.Values {
		err = expr.WriteSource(w)
		if err == nil && i < len(e.Values)-1 {
			_, err = io.WriteString(w, ", ")
		}
		if err != nil {
			return err
		}
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (i *Identifier) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, i.Identifier)
	return err
}
func (s *StringIdentifier) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, fmt.Sprintf("$%s", s.Identifier))
	if err == nil && s.At != nil {
		_, err = io.WriteString(w, " at ")
		if err == nil {
			err = s.At.WriteSource(w)
		}
	}
	if err == nil && s.In != nil {
		_, err = io.WriteString(w, " in ")
		if err == nil {
			err = s.In.WriteSource(w)
		}
	}
	return err
}
func (s *StringCount) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, fmt.Sprintf("#%s", s.Identifier))
	return err
}
func (s *StringOffset) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, fmt.Sprintf("@%s", s.Identifier))
	if err == nil && s.Index != nil {
		_, err = io.WriteString(w, "[")
	}
	if err == nil && s.Index != nil {
		err = s.Index.WriteSource(w)
	}
	if err == nil && s.Index != nil {
		_, err = io.WriteString(w, "]")
	}
	return err
}
func (s *StringLength) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, fmt.Sprintf("!%s", s.Identifier))
	if err == nil && s.Index != nil {
		_, err = io.WriteString(w, "[")
	}
	if err == nil && s.Index != nil {
		err = s.Index.WriteSource(w)
	}
	if err == nil && s.Index != nil {
		_, err = io.WriteString(w, "]")
	}
	return err
}
func (f *FunctionCall) WriteSource(w io.Writer) error {
	err := f.Callable.WriteSource(w)
	if err == nil {
		_, err = io.WriteString(w, "(")
	}
	if err == nil {
		for i, arg := range f.Arguments {
			err = arg.WriteSource(w)
			if err == nil && i < len(f.Arguments)-1 {
				_, err = io.WriteString(w, ", ")
			}
		}
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (m *MemberAccess) WriteSource(w io.Writer) error {
	err := m.Container.WriteSource(w)
	if err == nil {
		_, err = io.WriteString(w, ".")
	}
	if err == nil {
		_, err = io.WriteString(w, m.Member)
	}
	return err
}
func (s *Subscripting) WriteSource(w io.Writer) error {
	err := s.Array.WriteSource(w)
	if err == nil {
		_, err = io.WriteString(w, "[")
	}
	if err == nil {
		err = s.Index.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, "]")
	}
	return err
}
func (f *ForIn) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "for ")
	if err == nil {
		err = f.Quantifier.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w,
			fmt.Sprintf(" %s in ", strings.Join(f.Variables, ",")))
	}
	if err == nil {
		err = f.Iterator.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, " : (")
	}
	if err == nil {
		err = f.Condition.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (f *ForOf) WriteSource(w io.Writer) error {
	_, err := io.WriteString(w, "for ")
	if err == nil {
		err = f.Quantifier.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, " of ")
	}
	if err == nil {
		err = f.Strings.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, " : (")
	}
	if err == nil {
		err = f.Condition.WriteSource(w)
	}
	if err == nil {
		_, err = io.WriteString(w, ")")
	}
	return err
}
func (o *Of) WriteSource(w io.Writer) error {
	err := o.Quantifier.WriteSource(w)
	if err == nil {
		_, err = io.WriteString(w, " of ")
	}
	if err == nil {
		err = o.Strings.WriteSource(w)
	}
	return err
}
func (o *Operation) WriteSource(w io.Writer) error {
	if len(o.Operands) < 2 {
		panic("expecting two or more operands")
	}
	if err := o.Operands[0].WriteSource(w); err != nil {
		return err
	}
	for _, operand := range o.Operands[1:] {
		if _, err := fmt.Fprintf(w, " %s ", o.Operator); err != nil {
			return err
		}
		if err := operand.WriteSource(w); err != nil {
			return err
		}
	}
	return nil
}
func (k Keyword) Children() []Node {
	return []Node{}
}
func (l *LiteralInteger) Children() []Node {
	return []Node{}
}
func (l *LiteralFloat) Children() []Node {
	return []Node{}
}
func (l *LiteralString) Children() []Node {
	return []Node{}
}
func (l *LiteralRegexp) Children() []Node {
	return []Node{}
}
func (i *Identifier) Children() []Node {
	return []Node{}
}