ast

type BinaryOp struct {
	Pos      Position
	EndPos   Position
	Left     Expression
	Operator string // e.g. "+", "-", "=", "<>", "AND", "OR", "IN", "CONTAINS"
	Right    Expression
	// 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 {
	Pos       Position
	EndPos    Position
	Namespace []string
	Procedure string
	Args      []Expression // nil or empty means no argument list
	Yield     []*YieldItem // nil means no YIELD clause; empty slice means YIELD *
	Where     *Where       // nil when no WHERE predicate on YIELD
}

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

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

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

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

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

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

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

type ExistsSubquery struct {
	Pos     Position
	EndPos  Position
	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 … }
}

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

type FloatLiteral struct {
	Pos    Position
	EndPos Position
	Value  float64
}

type FunctionInvocation struct {
	Pos       Position
	EndPos    Position
	Namespace []string // e.g. ["apoc", "path"] for apoc.path.expand
	Name      string
	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
	Args      []Expression
}

type IntLiteral struct {
	Pos    Position
	EndPos Position
	Value  int64
}

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

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

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

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

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

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

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

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

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

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

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

type NullLiteral struct {
	Pos    Position
	EndPos Position
}

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

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

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

type PathPattern struct {
	Pos      Position
	EndPos   Position
	Variable *string      // path variable, nil when absent
	Head     *PathElement // linked list of alternating node/rel steps
}

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

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

type Position struct {
	Line   uint32
	Column uint32
	Offset uint32
}

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

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

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

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

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

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

type RelDirection int8

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

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

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

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

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

type SetItem struct {
	Pos      Position
	EndPos   Position
	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
}

type SingleQuery struct {
	Pos             Position
	EndPos          Position
	ReadingClauses  []ReadingClause
	UpdatingClauses []UpdatingClause
	Return          *Return // nil when the query has no RETURN
	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
	// 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 {
	Pos    Position
	EndPos Position
	Expr   Expression
	From   Expression // nil when absent
	To     Expression // nil when absent
}

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

type StarLiteral struct {
	Pos    Position
	EndPos Position
}

type StringLiteral struct {
	Pos    Position
	EndPos Position
	Value  string
}

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

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

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

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

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

type Variable struct {
	Pos    Position
	EndPos Position
	Name   string
}

type Where struct {
	Pos       Position
	EndPos    Position
	Predicate Expression
}

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

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