feat: schema coordinate parsing (#1185)

Author: obmarg

cynic-parser/parser-generator/src/main.rs

@@ -5,7 +5,17 @@ fn main() {
         .process()
         .unwrap();
 
-    for input in ["../src/parser/executable.rs", "../src/parser/schema.rs"] {
+    lalrpop::Configuration::new()
+        .set_in_dir("../src/schema_coordinates")
+        .set_out_dir("../src/schema_coordinates")
+        .process()
+        .unwrap();
+
+    for input in [
+        "../src/parser/executable.rs",
+        "../src/parser/schema.rs",
+        "../src/schema_coordinates/parser.rs",
+    ] {
         std::process::Command::new("cargo")
             .args(["fmt", "--", input])
             .spawn()

cynic-parser/src/errors.rs

@@ -60,6 +60,9 @@ pub enum Error {
 
     /// The GraphQl document was empty
     EmptyExecutableDocument,
+
+    /// The schema coordinate was empty
+    EmptySchemaCoordinate,
 }
 
 impl Error {
@@ -79,7 +82,9 @@ impl Error {
             Error::MalformedStringLiteral(error) => error.span().into(),
             Error::MalformedDirectiveLocation(lhs, _, rhs) => Span::new(*lhs, *rhs).into(),
             Error::VariableInConstPosition(lhs, _, rhs) => Span::new(*lhs, *rhs).into(),
-            Error::EmptyExecutableDocument | Error::EmptyTypeSystemDocument => None,
+            Error::EmptyExecutableDocument
+            | Error::EmptyTypeSystemDocument
+            | Error::EmptySchemaCoordinate => None,
         }
     }
 }
@@ -97,6 +102,7 @@ impl std::error::Error for Error {
             | Error::EmptyTypeSystemDocument
             | Error::EmptyExecutableDocument => None,
             Error::Lexical(error) => Some(error),
+            Error::EmptySchemaCoordinate => todo!(),
         }
     }
 }
@@ -177,6 +183,9 @@ impl fmt::Display for Error {
                     "the graphql document was empty, please provide at least one definition"
                 )
             }
+            Error::EmptySchemaCoordinate => {
+                write!(f, "the schema coordinate was empty")
+            }
         }
     }
 }

cynic-parser/src/errors/report.rs

@@ -108,6 +108,7 @@ impl Error {
             }
             Error::EmptyExecutableDocument => (self.to_string(), None, Some("graphql documents should contain at least one query, mutation or subscription".into())),
             Error::EmptyTypeSystemDocument => (self.to_string(), None, Some("graphql documents should contain at least one type, schema or directive definition".into())),
+            Error::EmptySchemaCoordinate => (self.to_string(), None, Some("schema coordinates should not be empty".into())),
         }
     }
 }

cynic-parser/src/lib.rs

@@ -1,5 +1,6 @@
 pub mod common;
 pub mod executable;
+pub mod schema_coordinates;
 pub mod type_system;
 pub mod values;
 
@@ -19,6 +20,7 @@ pub use errors::Report;
 pub use self::{
     errors::Error,
     executable::ExecutableDocument,
+    schema_coordinates::{SchemaCoordinate, parse_schema_coordinate},
     span::Span,
     type_system::TypeSystemDocument,
     values::{ConstValue, Value},

cynic-parser/src/parser/mod.rs

@@ -1,7 +1,7 @@
 // These are generated by LARLPOP
-#[expect(unused_braces)]
+#[allow(unused_braces)]
 mod executable;
-#[expect(unused_braces)]
+#[allow(unused_braces)]
 mod schema;
 
 pub use executable::*;

cynic-parser/src/schema_coordinates/argument.rs

@@ -0,0 +1,42 @@
+use std::fmt;
+
+use crate::Span;
+
+use super::{MemberCoordinate, Name};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct ArgumentCoordinate {
+    pub(super) member: MemberCoordinate,
+    pub(super) name: Name,
+}
+
+impl ArgumentCoordinate {
+    pub fn new(
+        ty: impl Into<String>,
+        field: impl Into<String>,
+        argument: impl Into<String>,
+    ) -> Self {
+        Self {
+            member: MemberCoordinate::new(ty, field),
+            name: Name::new(argument.into()),
+        }
+    }
+
+    pub fn member(&self) -> &MemberCoordinate {
+        &self.member
+    }
+
+    pub fn span(&self) -> Span {
+        self.name.span
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name.value
+    }
+}
+
+impl fmt::Display for ArgumentCoordinate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}({}:)", self.member, self.name.value)
+    }
+}

cynic-parser/src/schema_coordinates/directive.rs

@@ -0,0 +1,62 @@
+use core::fmt;
+
+use crate::Span;
+
+use super::Name;
+
+#[derive(Clone, Debug, Eq)]
+pub struct DirectiveCoordinate {
+    pub(super) name: Name,
+    pub(super) span: Span,
+}
+
+impl PartialEq for DirectiveCoordinate {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+    }
+}
+
+impl std::hash::Hash for DirectiveCoordinate {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+    }
+}
+
+impl PartialOrd for DirectiveCoordinate {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for DirectiveCoordinate {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
+impl DirectiveCoordinate {
+    pub fn new(name: impl Into<String>) -> Self {
+        Self {
+            name: Name::new(name.into()),
+            span: Span::default(),
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        self.span
+    }
+
+    pub fn name_span(&self) -> Span {
+        self.name.span
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name.value
+    }
+}
+
+impl fmt::Display for DirectiveCoordinate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "@{}", self.name.value)
+    }
+}

cynic-parser/src/schema_coordinates/directive_argument.rs

@@ -0,0 +1,38 @@
+use core::fmt;
+
+use crate::Span;
+
+use super::{DirectiveCoordinate, Name};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct DirectiveArgumentCoordinate {
+    pub(super) directive: DirectiveCoordinate,
+    pub(super) name: Name,
+}
+
+impl DirectiveArgumentCoordinate {
+    pub(crate) fn new(name: impl Into<String>, argument: impl Into<String>) -> Self {
+        Self {
+            directive: DirectiveCoordinate::new(name),
+            name: Name::new(argument.into()),
+        }
+    }
+
+    pub fn directive(&self) -> &DirectiveCoordinate {
+        &self.directive
+    }
+
+    pub fn span(&self) -> Span {
+        self.name.span
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name.value
+    }
+}
+
+impl fmt::Display for DirectiveArgumentCoordinate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}({}:)", self.directive, self.name.value)
+    }
+}

cynic-parser/src/schema_coordinates/lexer.rs

@@ -0,0 +1,116 @@
+use std::fmt;
+
+use logos::{Logos, SpannedIter};
+
+use crate::{
+    Span,
+    lexer::{LexicalError, Spanned, TokenExtras},
+    parser::AdditionalErrors,
+};
+
+pub struct Lexer<'input> {
+    // instead of an iterator over characters, we have a token iterator
+    token_stream: SpannedIter<'input, Token<'input>>,
+    input: &'input str,
+}
+
+impl<'input> Lexer<'input> {
+    pub fn new(input: &'input str) -> Self {
+        Self {
+            token_stream: Token::lexer(input).spanned(),
+            input,
+        }
+    }
+}
+
+impl<'input> Iterator for Lexer<'input> {
+    type Item = Spanned<Token<'input>, usize, AdditionalErrors>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.token_stream.next() {
+            None => None,
+            Some((Ok(token), span)) => Some(Ok((span.start, token, span.end))),
+            Some((Err(_), span)) => {
+                Some(Err(AdditionalErrors::Lexical(LexicalError::InvalidToken(
+                    self.input[span.start..span.end].to_string(),
+                    Span::new(span.start, span.end),
+                ))))
+            }
+        }
+    }
+}
+
+/// Lexer for GraphQL schema coordinates: https://spec.graphql.org/September2025/#sec-Schema-Coordinates.Parsing-a-Schema-Coordinate
+#[derive(Logos, Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[logos(extras = TokenExtras, skip r"[ \t\r\n\f,\ufeff]+|#[^\n\r]*")]
+pub enum Token<'a> {
+    // Valid tokens
+    #[token("@")]
+    At,
+
+    #[token(")")]
+    CloseParen,
+
+    #[token(":")]
+    Colon,
+
+    #[regex("[a-zA-Z_][a-zA-Z0-9_]*", |lex| lex.slice())]
+    Identifier(&'a str),
+
+    #[token("(")]
+    OpenParen,
+
+    #[token(".")]
+    Dot,
+}
+
+impl fmt::Display for Token<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Token::At => "at ('@')",
+            Token::CloseParen => "closing paren (')')",
+            Token::Colon => "colon (':')",
+            Token::Identifier(_) => "identifier",
+            Token::OpenParen => "opening paren ('(')",
+            Token::Dot => "dot ('.')",
+        })
+    }
+}
+
+impl From<lalrpop_util::ParseError<usize, Token<'_>, AdditionalErrors>> for crate::Error {
+    fn from(value: lalrpop_util::ParseError<usize, Token<'_>, AdditionalErrors>) -> Self {
+        use crate::Error;
+        use lalrpop_util::ParseError;
+
+        match value {
+            ParseError::InvalidToken { location } => Error::InvalidToken { location },
+            ParseError::UnrecognizedEof { location, expected } => {
+                Error::UnrecognizedEof { location, expected }
+            }
+            ParseError::UnrecognizedToken {
+                token: (lspan, token, rspan),
+                expected,
+            } => Error::UnrecognizedToken {
+                token: (lspan, token.to_string(), rspan),
+                expected,
+            },
+            ParseError::ExtraToken {
+                token: (lspan, token, rspan),
+            } => Error::ExtraToken {
+                token: (lspan, token.to_string(), rspan),
+            },
+            ParseError::User {
+                error: AdditionalErrors::Lexical(error),
+            } => Error::Lexical(error),
+            ParseError::User {
+                error: AdditionalErrors::MalformedString(error),
+            } => Error::MalformedStringLiteral(error),
+            ParseError::User {
+                error: AdditionalErrors::MalformedDirectiveLocation(lhs, location, rhs),
+            } => Error::MalformedDirectiveLocation(lhs, location, rhs),
+            ParseError::User {
+                error: AdditionalErrors::VariableInConstPosition(lhs, name, rhs),
+            } => Error::MalformedDirectiveLocation(lhs, name, rhs),
+        }
+    }
+}

cynic-parser/src/schema_coordinates/member.rs

@@ -0,0 +1,38 @@
+use std::fmt;
+
+use crate::Span;
+
+use super::{Name, TypeCoordinate};
+
+#[derive(Clone, Debug, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub struct MemberCoordinate {
+    pub(super) ty: TypeCoordinate,
+    pub(super) name: Name,
+}
+
+impl MemberCoordinate {
+    pub fn new(ty: impl Into<String>, field: impl Into<String>) -> Self {
+        MemberCoordinate {
+            ty: TypeCoordinate::new(ty),
+            name: Name::new(field.into()),
+        }
+    }
+
+    pub fn ty(&self) -> &TypeCoordinate {
+        &self.ty
+    }
+
+    pub fn span(&self) -> Span {
+        self.name.span
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name.value
+    }
+}
+
+impl fmt::Display for MemberCoordinate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}.{}", self.ty.name.value, self.name.value)
+    }
+}