sema

const (
	// TypeAny is the top type: any value is assignable to it. Used for
	// variables, parameters, and expressions whose type cannot be statically
	// narrowed.
	TypeAny CypherType = iota

	// TypeNull is the type of the literal null value.
	TypeNull

	// TypeBoolean is the type of boolean expressions.
	TypeBoolean

	// TypeInteger is the type of integer literals and integer-valued functions.
	TypeInteger

	// TypeFloat is the type of floating-point literals and float-valued
	// functions, as well as the result of mixed Int+Float arithmetic.
	TypeFloat

	// TypeString is the type of string literals and string-valued functions.
	TypeString

	// TypeNode is the type of graph node entities.
	TypeNode

	// TypeRelationship is the type of graph relationship entities.
	TypeRelationship

	// TypePath is the type of graph path values.
	TypePath

	// TypeList is the type of list values. The element type is not tracked at
	// this level of inference; use TypeList for all list expressions.
	TypeList

	// TypeMap is the type of map literals and map-valued expressions.
	TypeMap
)

const (
	// KindUndefinedVar is reported when an expression references a variable
	// that has not been introduced by any preceding clause in the current scope.
	KindUndefinedVar ErrorKind = "UNDEFINED_VAR"

	// KindRedeclaration is reported when a variable is introduced a second time
	// within the same scope without a WITH boundary that would shadow it.
	KindRedeclaration ErrorKind = "REDECLARATION"

	// KindScopeLeak is reported when a variable introduced inside a sub-scope
	// (e.g. a list comprehension) is referenced outside that scope.
	KindScopeLeak ErrorKind = "SCOPE_LEAK"

	// KindInvalidArgumentType is reported when a literal expression of a
	// statically known non-boolean type is used as the operand of a logical
	// operator (AND / OR / XOR / NOT). Variables and other expressions whose
	// type is only known at runtime are not flagged.
	KindInvalidArgumentType ErrorKind = "INVALID_ARGUMENT_TYPE"

	// KindInvalidAggregation is reported when an aggregation function call
	// appears in an ORDER BY item but the surrounding projection does not
	// itself contain any aggregation. Aggregations only fold over groups
	// defined by the projection; standing alone in an ORDER BY is illegal.
	KindInvalidAggregation ErrorKind = "INVALID_AGGREGATION"

	// KindVariableAlreadyBound is reported when CREATE re-uses a previously
	// bound variable AND attempts to add new labels or properties to it.
	// openCypher 9 §3.5.1: a bound node may be referenced from CREATE (so
	// the pattern can describe edges around it) but cannot have its labels
	// or properties augmented.
	KindVariableAlreadyBound ErrorKind = "VARIABLE_ALREADY_BOUND"

	// KindColumnNameConflict is reported when a RETURN or WITH projection
	// declares two columns with the same output name (e.g.
	// `RETURN 1 AS a, 2 AS a`). openCypher 9 §3.3.3 rejects this at
	// compile time because the downstream consumer cannot disambiguate
	// the columns.
	KindColumnNameConflict ErrorKind = "COLUMN_NAME_CONFLICT"

	// KindUnknownFunction is reported when a function-call expression
	// names a function that is not registered in the engine's function
	// registry and is not a recognised aggregate (count, sum, avg, min,
	// max, collect, stdev, stdevp, percentileCont, percentileDisc).
	// openCypher 9 §6.1 requires compile-time rejection of unknown
	// function calls.
	KindUnknownFunction ErrorKind = "UNKNOWN_FUNCTION"

	// KindRelationshipUniqueness is reported when a relationship
	// variable is introduced more than once within the same path
	// pattern (e.g. `MATCH (a)-[r]->()-[r]->(a)`). openCypher 9
	// §3.3.1.2 forbids this: a single path pattern cannot bind two
	// distinct edges to the same relationship name.
	KindRelationshipUniqueness ErrorKind = "RELATIONSHIP_UNIQUENESS"

	// KindNegativeIntegerArgument is reported when a SKIP or LIMIT
	// clause is given a negative integer literal. openCypher 9 §3.6
	// requires the argument to be a non-negative INTEGER.
	KindNegativeIntegerArgument ErrorKind = "NEGATIVE_INTEGER_ARGUMENT"

	// KindAmbiguousAggregationExpression is reported when a projection
	// item contains an aggregating sub-expression nested inside a larger
	// expression (e.g. `me.age + count(you.age)`) and a Variable or
	// Property reference appearing OUTSIDE the aggregate call does not
	// match any standalone "simple" grouping-key projection item.
	// openCypher 9 §5.3.3 rejects this at compile time because the
	// runtime cannot decide which row of the group should supply the
	// non-grouped reference.
	KindAmbiguousAggregationExpression ErrorKind = "AMBIGUOUS_AGGREGATION_EXPRESSION"

	// KindNoVariablesInScope is reported when `RETURN *` or `WITH *`
	// appears in a projection but no variables are in scope at that
	// point (openCypher 9 §3.3.2 forbids a star projection with an
	// empty scope).
	KindNoVariablesInScope ErrorKind = "NO_VARIABLES_IN_SCOPE"

	// KindNoExpressionAlias is reported when a WITH projection item is
	// neither a bare Variable nor aliased via AS. openCypher 9 §5.1.2
	// requires every non-Variable WITH item to have an explicit alias
	// so the downstream scope can name it.
	KindNoExpressionAlias ErrorKind = "NO_EXPRESSION_ALIAS"
)