Enum GraphQLParseErrorKind 

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

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

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.

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

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

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., ")").

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.

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., "{", "[", "(").

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.

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 "}").

UnsupportedFeature

Feature not representable in the target format.

Emitted by compatibility conversion functions when the source AST contains features that the target format cannot represent (e.g., variable directives and schema extensions when converting to graphql_parser v0.4). May also apply to future spec-version-gated features.

Fields

feature: String

Description of the unsupported feature.

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.

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