parser

type AbsSingularQuery struct {
	grammar.Seq
	RootIdentifier Token `tok:"op,$"`
	Segments       []SingularQuerySegment
}

type BasicExpr struct {
	grammar.OneOf
	*ParenExpr
	*ComparisonExpr
	*TestExpr
}

type BasicTestExpr struct {
	grammar.OneOf
	*FilterQuery
	*FunctionExpr
}

type BracketNameSegment struct {
	grammar.Seq
	OpenSquareBracket  Token `tok:"op,["`
	NameSelector       StringLiteral
	CloseSquareBracket Token `tok:"op,]"`
}

type BracketedSelection struct {
	grammar.Seq
	OpenSquareBracket  Token `tok:"op,["`
	FirstSelector      Selector
	SelectorRest       []SelectorRest
	CloseSquareBracket Token `tok:"op,]"`
}

type ChildSegment struct {
	grammar.OneOf
	*BracketedSelection
	*DotSelection
}

type Comparable struct {
	grammar.OneOf
	*Literal
	*SingularQuery
	*FunctionExpr
}

type ComparisonExpr struct {
	grammar.Seq
	Left  Comparable
	Op    Token `tok:"comparisonop"`
	Right Comparable
}

type DescendantBracketedSelection struct {
	grammar.Seq
	OpenSquareBracket  Token `tok:"op,..["`
	FirstSelector      Selector
	SelectorRest       []SelectorRest
	CloseSquareBracket Token `tok:"op,]"`
}

type DescendantSegment struct {
	grammar.OneOf
	*DescendantBracketedSelection
	DescendantWildcardSelector    *Token `tok:"op,..*"`
	DescendantMemberNameShorthand *Token `tok:"descendantmembernameshorthand"`
}

type DotSelection struct {
	grammar.OneOf
	WildcardSelector    *Token `tok:"op,.*"`
	MemberNameShorthand *Token `tok:"membernameshorthand"`
}

type FilterQuery struct {
	grammar.OneOf
	*RelQuery
	*Query
}

type FilterSelector struct {
	grammar.Seq
	FilterIdentifier Token `tok:"op,?"`
	LogicalExpr
}

type FunctionArgument struct {
	grammar.OneOf
	*Literal
	*FilterQuery
	*FunctionExpr
	*LogicalExpr
}

type FunctionExpr struct {
	grammar.Seq
	FunctionNameAndOpenBracket Token `tok:"functionname("`
	Arguments                  *FunctionExprArguments
	CloseBracket               Token `tok:"op,)"`
}

type FunctionExprArguments struct {
	grammar.Seq
	First FunctionArgument
	Rest  []FunctionExprArgumentsRest
}

type FunctionExprArgumentsRest struct {
	grammar.Seq
	Comma Token `tok:"op,,"`
	FunctionArgument
}

type IndexSegment struct {
	grammar.Seq
	OpenSquareBracket  Token `tok:"op,["`
	IndexSelector      Token `tok:"int"`
	CloseSquareBracket Token `tok:"op,]"`
}

type Literal struct {
	grammar.OneOf
	Number *Token `tok:"int|number"`
	*StringLiteral
	Boolean *Token `tok:"bool"`
	Null    *Token `tok:"null"`
}

type LogicalAndExpr struct {
	grammar.Seq
	First BasicExpr
	Rest  []LogicalAndRest
}

type LogicalAndRest struct {
	grammar.Seq
	And     Token `tok:"op,&&"`
	Operand BasicExpr
}

type LogicalExpr struct {
	grammar.Seq
	First LogicalAndExpr
	Rest  []LogicalOrRest
}

type LogicalOrRest struct {
	grammar.Seq
	Or      Token `tok:"op,||"`
	Operand LogicalAndExpr
}

type ParenExpr struct {
	grammar.Seq
	Not       *Token `tok:"op,!"`
	OpenParen Token  `tok:"op,("`
	LogicalExpr
	CloseParen Token `tok:"op,)"`
}

type Query struct {
	grammar.Seq
	RootIdentifier Token `tok:"op,$"`
	Segments       []Segment
}

type RelQuery struct {
	grammar.Seq
	CurrentNodeIdentifier Token `tok:"op,@"`
	Segments              []Segment
}

type RelSingularQuery struct {
	grammar.Seq
	CurrentNodeIdentifier Token `tok:"op,@"`
	Segments              []SingularQuerySegment
}

type Segment struct {
	grammar.OneOf
	*ChildSegment
	*DescendantSegment
}

type Selector struct {
	grammar.OneOf
	NameSelector     *StringLiteral
	WildcardSelector *Token `tok:"op,*"`
	*SliceSelector
	IndexSelector *Token `tok:"int"`
	*FilterSelector
}

type SelectorRest struct {
	grammar.Seq
	Comma Token `tok:"op,,"`
	Selector
}

type SingularQuery struct {
	grammar.OneOf
	*RelSingularQuery
	*AbsSingularQuery
}

type SingularQuerySegment struct {
	grammar.OneOf
	*BracketNameSegment
	DotNameSegment *Token `tok:"membernameshorthand"`
	*IndexSegment
}

type SliceSelector struct {
	grammar.Seq
	Start *Token `tok:"int"`
	Colon Token  `tok:"op,:"`
	End   *Token `tok:"int"`
	*SliceStep
}

type SliceStep struct {
	grammar.Seq
	StepColon Token  `tok:"op,:"`
	Step      *Token `tok:"int"`
}

type StringLiteral struct {
	grammar.OneOf
	DoubleQuotedString *Token `tok:"doublequotedstring"`
	SingleQuotedString *Token `tok:"singlequotedstring"`
}

type TestExpr struct {
	grammar.Seq
	Not *Token `tok:"op,!"`
	BasicTestExpr
}

type Token = grammar.SimpleToken