Enum GraphQLParseErrorKind 

pub enum GraphQLParseErrorKind {
    UnexpectedToken {
        expected: Vec<String>,
        found: String,
    },
    UnexpectedEof {
        expected: Vec<String>,
    },
    LexerError,
    UnclosedDelimiter {
        delimiter: String,
    },
    MismatchedDelimiter {
        expected: String,
        found: String,
    },
    InvalidValue(ValueParsingError),
    ReservedName {
        name: String,
        context: ReservedNameContext,
    },
    WrongDocumentKind {
        found: DefinitionKind,
        document_kind: DocumentKind,
    },
    InvalidEmptyConstruct {
        construct: String,
    },
    InvalidSyntax,
}

Categorizes parse errors for programmatic handling.

Each variant contains minimal data needed for programmatic decisions. Human-readable context (suggestions, explanations) belongs in the notes field of GraphQLParseError.

The #[error(...)] messages are concise/programmatic. Full human-readable messages are in GraphQLParseError.message.

Variants

UnexpectedToken

Expected specific token(s) but found something else.

This is the most common error type — the parser expected certain tokens based on grammar rules but encountered something unexpected.

Example

type User { name String }
                 ^^^^^^ expected `:`, found `String`

Fields

expected: Vec<String>

What tokens were expected (e.g., [":"​, "{"​, "@"]).

found: String

Description of what was found (e.g., "String" or "}").

UnexpectedEof

Unexpected end of input while parsing.

The document ended before a complete construct was parsed.

Example

type User {
          ^ expected `}`, found end of input

Fields

expected: Vec<String>

What was expected when EOF was encountered.

LexerError

Lexer error encountered during parsing.

The parser encountered a GraphQLTokenKind::Error token from the lexer. The lexer’s error message and notes are preserved in the parent GraphQLParseError’s message and notes fields.

Example

type User { name: "unterminated string
                  ^ unterminated string literal

UnclosedDelimiter

Unclosed delimiter (bracket, brace, or parenthesis).

A delimiter was opened but EOF was reached before finding the matching closing delimiter. The opening location is typically included in the error’s notes.

Example

type User {
    name: String
# EOF here — missing `}`

Note: This is distinct from MismatchedDelimiter, which occurs when a wrong closing delimiter is found (e.g., [ closed with )).

Fields

delimiter: String

The unclosed delimiter (e.g., "{", "[", "(").

MismatchedDelimiter

Mismatched delimiter.

A closing delimiter was found that doesn’t match the most recently opened delimiter. This indicates a structural nesting error.

Example

type User { name: [String) }
                        ^ expected `]`, found `)`

Note: This is distinct from UnclosedDelimiter, which occurs when EOF is reached without any closing delimiter.

Fields

expected: String

The expected closing delimiter (e.g., "]").

found: String

The actual closing delimiter found (e.g., ")").

InvalidValue(ValueParsingError)

Invalid value (wraps value parsing errors).

Occurs when a literal value (string, int, float) cannot be parsed.

Example

query { field(limit: 99999999999999999999) }
                     ^^^^^^^^^^^^^^^^^^^^ integer overflow

ReservedName

Reserved name used in a context where it’s not allowed.

Certain names have special meaning in specific contexts:

• on cannot be a fragment name (it introduces type conditions)
• true, false, null cannot be enum values (ambiguous with literals)

Example

fragment on on User { name }
         ^^ fragment name cannot be `on`

Fields

name: String

The reserved name that was used (e.g., "on", "true").

context: ReservedNameContext

The context where this name is not allowed.

WrongDocumentKind

Definition kind not allowed in the document being parsed.

When parsing with parse_executable_document(), schema definitions (types, directives) are not allowed. When parsing with parse_schema_document(), operations and fragments are not allowed.

Example

# Parsing as executable document:
type User { name: String }
^^^^ type definition not allowed in executable document

Fields

found: DefinitionKind

What kind of definition was found.

document_kind: DocumentKind

What kind of document is being parsed.

InvalidEmptyConstruct

Empty construct that requires content.

Certain constructs cannot be empty per the GraphQL spec:

• Selection sets: { } is invalid (must have at least one selection)
• Argument lists: () is invalid (omit parentheses if no arguments)

Example

query { user { } }
             ^^^ selection set cannot be empty

Fields

construct: String

What construct is empty (e.g., "selection set").

InvalidSyntax

Invalid syntax that doesn’t fit other categories.

A catch-all for syntax errors without dedicated variants. The specific error is described in GraphQLParseError.message.

Trait Implementations

impl Clone for GraphQLParseErrorKind

fn clone(&self) -> GraphQLParseErrorKind

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphQLParseErrorKind

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

Formats the value using the given formatter.

impl Display for GraphQLParseErrorKind

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

Formats the value using the given formatter.

impl Error for GraphQLParseErrorKind

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.

impl PartialEq for GraphQLParseErrorKind

fn eq(&self, other: &GraphQLParseErrorKind) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for GraphQLParseErrorKind