Enum ParserError 

#[non_exhaustive]
pub enum ParserError {
    SyntaxError {
        status: GqlStatus,
        message: String,
        span: SourceSpan,
        hint: Option<String>,
    },
    UnsupportedFeature {
        feature_id: FeatureId,
        display_name: &'static str,
        span: SourceSpan,
        hint: &'static str,
    },
    NestingLimitExceeded {
        limit: u32,
        span: SourceSpan,
    },
    ComplexityLimitExceeded {
        limit: u32,
        span: SourceSpan,
    },
    NotImplemented {
        message: String,
        span: SourceSpan,
        hint: Option<String>,
    },
}

GQL parser and flagger error.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

SyntaxError

Source text did not parse as supported GQL syntax.

Fields

status: GqlStatus

ISO GQLSTATUS code.

message: String

Human-readable diagnostic message.

span: SourceSpan

Source span for the parse failure.

hint: Option<String>

Optional repair hint.

UnsupportedFeature

Parsed syntax requires a feature outside the current support set.

Fields

feature_id: FeatureId

ISO feature identifier.

display_name: &'static str

Human-readable feature name.

span: SourceSpan

Source span requiring the feature.

hint: &'static str

Static hint for enabling or avoiding the feature.

NestingLimitExceeded

Query nesting exceeded the parser’s recursion cap.

Fields

limit: u32

Maximum admitted syntactic nesting depth.

span: SourceSpan

Source span that crossed the limit.

ComplexityLimitExceeded

Query exceeded a parser complexity cap that bounds pest’s recursive descent before it begins.

Maps to GQLSTATUS 5GQL1 (PROGRAM_LIMIT_EXCEEDED), a selene-db implementation-defined class per ISO/IEC 39075:2024 section 23.1 (see GqlStatus::PROGRAM_LIMIT_EXCEEDED).

Distinct from Self::NestingLimitExceeded, which bounds all-bracket net delimiter nesting depth at a looser cap. This variant covers the parser’s complexity guards, each of which would otherwise drive pathological pest behavior or overflow the native stack on a small hostile input:

• [-depth (pre-pest byte scan). pest is not packrat-memoized, so a run of unclosed [ nests the three ambiguous [-prefixed grammar rules and recomputes their failed branches at every level, driving super-linear backtracking. Balanced, promptly closed [ (an edge pattern, a flat list) never accrue depth, so legitimate wide paths and lists are unaffected.
• Zero-delimiter recursion depth (pre-pest byte scan). A long run of leading unary signs (unary), NOT keywords (not_expr), or nested CASE … END expressions (case_expr) recurses pest’s descent one stack frame per level with no (/[/{ delimiter to bound it, overflowing the native stack (a non-unwindable crash) on a small input. Signs and NOT are bounded as runs; CASE is bounded by a monotone over-approximation — a real opener (counted only outside identifier positions: property names, map keys, aliases, YIELD columns, params) adds 1 plus its wrapping run and never decrements, because an identifier END cannot be soundly distinguished from the keyword closer. The conformant cost is that a statement whose combined CASE-count and nesting pressure exceeds the ceiling (256) is rejected.
• Expression nesting depth (post-build, iterative scan). A flat left-associative operator fold (a OR a OR …) or postfix chain (a.b.c.…) parses and builds iteratively but yields a depth-N Box<ValueExpr> tree whose recursive consumers (the Flagger, Drop, the analyzer) overflow the native stack at ~130k deep. The parser rejects any expression deeper than the shared recursion ceiling (256) before the Flagger walks it.

The pre-pest guards reject before recursive descent begins; the expression-depth guard runs after AST construction and before the Flagger. All are deterministic and cheap.

Fields

limit: u32

Maximum admitted depth for the complexity dimension that was exceeded.

span: SourceSpan

Source span of the token that crossed the limit.

NotImplemented

Source parsed at the grammar level, but no AST builder is implemented yet.

Distinct from Self::SyntaxError (parse failed) and Self::UnsupportedFeature (specific ISO feature not in the claim list). This variant covers grammar surfaces selene-db will support but whose builders land in a later brief.

Fields

message: String

Human-readable description of the missing capability.

span: SourceSpan

Source span requiring the missing capability.

hint: Option<String>

Pointer to the brief or milestone that lands the capability.

Implementations

impl ParserError

pub const fn gqlstatus(&self) -> GqlStatus

Map this error to its 5-character ISO GQLSTATUS code.

Trait Implementations

impl Debug for ParserError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Diagnostic for ParserError

fn code(&self) -> Option<Box<dyn Display + '_>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn help(&self) -> Option<Box<dyn Display + '_>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

impl Display for ParserError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for ParserError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.