ast

type BinaryOp struct {
	Left     Expression
	Right    Expression
	Operator string // e.g. "+", "-", "=", "<>", "AND", "OR", "IN", "CONTAINS"
	Pos      Position
	EndPos   Position
	// Parenthesized records that this BinaryOp was explicitly parenthesized in
	// the source. The precedence-rebalancing pass in cypher/parser uses this
	// flag to suppress lifting list/string-predicate operators (IN, CONTAINS,
	// STARTS WITH, ENDS WITH) out of arithmetic chains when the user wrote the
	// parentheses explicitly: `[1] + (2 IN [3]) + 4` must remain `[1] +
	// bool + 4`, but `[1] + 2 IN [3] + 4` must rebalance to `([1] + 2) IN
	// ([3] + 4)`. The flag is cleared once the rebalance pass completes;
	// downstream consumers ignore it.
	Parenthesized bool
}

type BoolLiteral struct {
	Pos    Position
	EndPos Position
	Value  bool
}

type Call struct {
	Where     *Where // nil when no WHERE predicate on YIELD
	Procedure string
	Namespace []string
	Args      []Expression // nil or empty means no argument list
	Yield     []*YieldItem // nil means no YIELD clause; empty slice means YIELD *
	Pos       Position
	EndPos    Position
}

type CaseAlternative struct {
	Condition  Expression
	Consequent Expression
	Pos        Position
	EndPos     Position
}

type CaseExpression struct {
	Subject      Expression // nil for generic CASE
	ElseExpr     Expression // nil when no ELSE clause
	Alternatives []*CaseAlternative
	Pos          Position
	EndPos       Position
}

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

type CountSubquery struct {
	Pattern *Pattern     // pattern form
	Query   *SingleQuery // full subquery form
	Pos     Position
	EndPos  Position
}

type Create struct {
	Pattern *Pattern
	Pos     Position
	EndPos  Position
}

type Delete struct {
	Expressions []Expression
	Pos         Position
	EndPos      Position
}

type DetachDelete struct {
	Expressions []Expression
	Pos         Position
	EndPos      Position
}

type ExistsSubquery struct {
	Pattern *Pattern     // pattern form: EXISTS { (a)-[r]->(b) }
	Where   *Where       // optional inline WHERE clause for the pattern form
	Query   *SingleQuery // full subquery form: EXISTS { MATCH … RETURN … }
	Pos     Position
	EndPos  Position
}

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

type FloatLiteral struct {
	Pos    Position
	EndPos Position
	Value  float64
}

type Foreach struct {
	Expr   Expression       // the list the loop iterates over
	Var    string           // the loop variable, scoped to Body
	Body   []UpdatingClause // updating clauses run per element
	Pos    Position
	EndPos Position
}

type FunctionInvocation struct {
	Name      string
	Namespace []string // e.g. ["apoc", "path"] for apoc.path.expand
	Args      []Expression
	Pos       Position
	EndPos    Position
	Distinct  bool
	// CountStar is true when this is COUNT(*). String() renders it as
	// "count(*)" and downstream aggregation detects it without needing
	// a wildcard argument expression.
	CountStar bool
}

type IntLiteral struct {
	Pos    Position
	EndPos Position
	Value  int64
}

type LabelPredicate struct {
	Receiver Expression
	Labels   []string
	Pos      Position
	EndPos   Position
}

type ListComprehension struct {
	Source     Expression
	Predicate  Expression // nil when no WHERE clause
	Projection Expression // nil when no projection expression
	Variable   string
	Pos        Position
	EndPos     Position
}

type ListLiteral struct {
	Elements []Expression
	Pos      Position
	EndPos   Position
}

type MapLiteral struct {
	Keys   []string
	Values []Expression
	Pos    Position
	EndPos Position
}

type MapProjection struct {
	Subject Expression
	Items   []*MapProjectionItem
	Pos     Position
	EndPos  Position
}

type MapProjectionItem struct {
	Value  Expression // nil for the property-selector shorthand (`.key`)
	Key    string     // explicit key when present; otherwise empty
	Pos    Position
	EndPos Position
	IsAll  bool // true for the .*  selector
}

type Match struct {
	Pattern *Pattern
	Where   *Where // nil when no WHERE predicate
	Pos     Position
	EndPos  Position
}

type Merge struct {
	Pattern  *PathPattern
	OnCreate []*SetItem // actions on ON CREATE SET
	OnMatch  []*SetItem // actions on ON MATCH SET
	Pos      Position
	EndPos   Position
}

type MultiQuery struct {
	Parts  []*SingleQuery
	Pos    Position
	EndPos Position
	All    bool // true for UNION ALL; false for UNION (deduplicating)
}

type Node interface {
	String() string
	// contains filtered or unexported methods
}

type NodePattern struct {
	Properties Expression // nil or a MapLiteral / Parameter
	Variable   *string    // nil when anonymous
	Labels     []string   // zero or more labels
	Pos        Position
	EndPos     Position
}

type NullLiteral struct {
	Pos    Position
	EndPos Position
}

type OptionalMatch struct {
	Pattern *Pattern
	Where   *Where // nil when no WHERE predicate
	Pos     Position
	EndPos  Position
}

type OverflowIntLit struct {
	// Text holds the raw decimal digits including any leading sign character.
	Text   string
	Pos    Position
	EndPos Position
}

type Parameter struct {
	Name   string // the name/index without the leading '$'
	Pos    Position
	EndPos Position
}

type PathElement struct {
	Node         *NodePattern
	Relationship *RelationshipPattern // nil for the first node
	Next         *PathElement         // nil for the last node
}

type PathPattern struct {
	Variable *string      // path variable, nil when absent
	Head     *PathElement // linked list of alternating node/rel steps
	Pos      Position
	EndPos   Position
	// Shortest classifies a shortestPath()/allShortestPaths() wrapper around
	// this path (ShortestNone for an ordinary path). Set by the parser's
	// post-AST shortest-path pass (rmp #1690).
	Shortest ShortestKind
}

type Pattern struct {
	Paths  []*PathPattern
	Pos    Position
	EndPos Position
}

type PatternComprehension struct {
	Predicate  Expression // nil when no WHERE clause
	Projection Expression
	Variable   *string // optional path variable
	Pattern    *PathPattern
	Pos        Position
	EndPos     Position
}

type Position struct {
	Line   uint32
	Column uint32
	Offset uint32
}

type Projection struct {
	Skip     Expression // nil if absent
	Limit    Expression // nil if absent
	Items    []*ProjectionItem
	OrderBy  []*SortItem
	Pos      Position
	EndPos   Position
	Distinct bool
	All      bool // SELECT *
}

type ProjectionItem struct {
	Expr   Expression
	Alias  *string // nil when no AS alias is present
	Pos    Position
	EndPos Position
}

type Property struct {
	Receiver Expression
	Key      string
	Pos      Position
	EndPos   Position
}

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

type RangeQuantifier struct {
	Min    *int64 // nil means no lower bound specified
	Max    *int64 // nil means no upper bound specified
	Pos    Position
	EndPos Position
}

type ReadingClause interface {
	Clause
	// contains filtered or unexported methods
}

type ReduceExpr struct {
	Init       Expression
	Source     Expression
	Projection Expression
	AccVar     string
	ElemVar    string
	Pos        Position
	EndPos     Position
}

type RelDirection int8

type RelationshipPattern struct {
	Properties Expression       // nil or MapLiteral / Parameter
	Variable   *string          // nil when anonymous
	Range      *RangeQuantifier // nil for fixed-length
	Types      []string         // zero or more relationship types (OR semantics)
	Pos        Position
	EndPos     Position
	Direction  RelDirection
}

type Remove struct {
	Items  []*RemoveItem
	Pos    Position
	EndPos Position
}

type RemoveItem struct {
	Target Expression // Property or Variable
	Labels []string   // populated for REMOVE n:Label form
	Pos    Position
	EndPos Position
}

type Return struct {
	Projection *Projection
	Pos        Position
	EndPos     Position
}

type Set struct {
	Items  []*SetItem
	Pos    Position
	EndPos Position
}

type SetItem struct {
	Target   Expression // Property or Variable
	Value    Expression // right-hand side; nil for label-set forms
	Operator string     // "=", "+=", or "" for label operations
	Labels   []string   // populated for SET n:Label1:Label2 form
	Pos      Position
	EndPos   Position
}

type ShortestKind uint8

type SingleQuery struct {
	Return          *Return // nil when the query has no RETURN
	ReadingClauses  []ReadingClause
	UpdatingClauses []UpdatingClause
	With            []*With // WITH clauses that appear before RETURN
	// LeadingClauseCount records how many ReadingClauses precede the first
	// With clause in the original query text.  Only meaningful when
	// LeadingCountSet is true; set by the parser for MultiPartQ queries.
	// Used by the IR translator to interleave reading clauses and WITH clauses
	// in the correct order: leading[0..LeadingClauseCount-1] → With[*] →
	// trailing[LeadingClauseCount..].
	//
	// When LeadingCountSet is false (the zero value, or manually-constructed
	// ASTs), the translator falls back to the legacy order: all ReadingClauses
	// first, then all With clauses.
	LeadingClauseCount int
	Pos                Position
	EndPos             Position
	// LeadingCountSet is true when the parser has explicitly populated
	// LeadingClauseCount.  False for SinglePartQ queries and for AST nodes
	// constructed directly in tests without going through the parser.
	LeadingCountSet bool
}

type SliceExpr struct {
	Expr   Expression
	From   Expression // nil when absent
	To     Expression // nil when absent
	Pos    Position
	EndPos Position
}

type SortItem struct {
	Expr       Expression
	Pos        Position
	EndPos     Position
	Descending bool
}

type StarLiteral struct {
	Pos    Position
	EndPos Position
}

type StringLiteral struct {
	Value  string
	Pos    Position
	EndPos Position
}

type SubscriptExpr struct {
	Expr   Expression
	Index  Expression
	Pos    Position
	EndPos Position
}

type UnaryOp struct {
	Operand  Expression
	Operator string // e.g. "-", "NOT", "IS NULL", "IS NOT NULL"
	Pos      Position
	EndPos   Position
}

type Union struct {
	Query  *SingleQuery
	Pos    Position
	EndPos Position
	All    bool
}

type Unwind struct {
	Expr     Expression
	Variable string
	Pos      Position
	EndPos   Position
}

type UpdatingClause interface {
	Clause
	// contains filtered or unexported methods
}

type Variable struct {
	Name   string
	Pos    Position
	EndPos Position
}

type Where struct {
	Predicate Expression
	Pos       Position
	EndPos    Position
}

type With struct {
	Projection *Projection
	Where      *Where // nil when no WHERE predicate
	Pos        Position
	EndPos     Position
}

type YieldItem struct {
	Alias  *string // nil when no AS alias
	Name   string
	Pos    Position
	EndPos Position
}