feat: ConstValue in parser (#1057)

GraphQL allows Values to appear in two different positions: labelled as
whether those positions are constant or not. Const position values
cannot have variables - for example in the schema where variables don't
exist.

This PR adds support for these constant values, based off the same
underlying value store but with the reader layer exposing a slightly
more limited API.

cynic-parser/ast-generator/domain/executable.graphql

@@ -61,7 +61,7 @@ type Argument @file(name: "argument") {
 type VariableDefinition @file(name: "variable") {
  name: String!
  ty: Type!
- default_value: Value
+ default_value: ConstValue
  directives: [Directive]
 }
 
@@ -73,6 +73,7 @@ scalar OperationType @inline
 # so we make them scalars and implement them by hand
 scalar Type @file(name: "types")
 scalar Value @file(name: "value")
+scalar ConstValue @file(name: "value")
 
 # String is built in, but easier to implement stuff if its just in the .graphql file
 # It is also special cased a bit in the rust code

cynic-parser/ast-generator/domain/type_system.graphql

@@ -85,7 +85,7 @@ type InputValueDefinition @file(name: "input_values") {
  name: String!
  ty: Type!
  description: Description
- default_value: Value
+ default_value: ConstValue
  default_value_span: Span!
  directives: [Directive!]!
  span: Span!
@@ -107,7 +107,7 @@ type Directive @file(name: "directives") {
 
 type Argument @file(name: "arguments") {
  name: String!
- value: Value!
+ value: ConstValue!
  span: Span!
 }
 
@@ -123,7 +123,7 @@ scalar OperationType @inline
 # Type & Value are kind of special cases that aren't worth automating
 # so we make them scalars and implement them by hand
 scalar Type @file(name: "types")
-scalar Value @file(name: "value")
+scalar ConstValue @file(name: "value")
 
 # String is built in, but easier to implement stuff if its just in the .graphql file
 # It is also special cased a bit in the rust code

cynic-parser/ast-generator/src/file.rs

@@ -92,7 +92,7 @@ pub fn imports(
  use super::{
  #(#reader_imports)*
  ids::{#(#id_imports)*},
- ReadContext, #id_trait
+ #id_trait
  };
  })
 }

cynic-parser/src/errors.rs

@@ -50,8 +50,11 @@ pub enum Error {
  /// Malformed string literal
  MalformedStringLiteral(crate::common::MalformedStringError),
 
- /// Malformed string literal
+ /// Malformed directive location
  MalformedDirectiveLocation(usize, String, usize),
+
+ /// Variable found in const position
+ VariableInConstPosition(usize, String, usize),
 }
 
 impl Error {
@@ -70,6 +73,7 @@ impl Error {
  Error::Lexical(error) => error.span(),
  Error::MalformedStringLiteral(error) => error.span(),
  Error::MalformedDirectiveLocation(lhs, _, rhs) => Span::new(*lhs, *rhs),
+ Error::VariableInConstPosition(lhs, _, rhs) => Span::new(*lhs, *rhs),
  }
  }
 }
@@ -81,9 +85,10 @@ impl std::error::Error for Error {
  | Error::UnrecognizedEof { .. }
  | Error::UnrecognizedToken { .. }
  | Error::ExtraToken { .. }
- | Error::MalformedDirectiveLocation(..) => None,
+ | Error::MalformedStringLiteral(..)
+ | Error::MalformedDirectiveLocation(..)
+ | Error::VariableInConstPosition(..) => None,
  Error::Lexical(error) => Some(error),
- Error::MalformedStringLiteral(error) => Some(error),
  }
  }
 }
@@ -145,6 +150,13 @@ impl fmt::Display for Error {
  }
  Ok(())
  }
+ Error::VariableInConstPosition(_, name, _) => {
+ write!(
+ f,
+ "the variable ${name} was found in a position that does not allow variables"
+ )?;
+ Ok(())
+ }
  }
  }
 }
@@ -178,6 +190,9 @@ impl From<lalrpop_util::ParseError<usize, lexer::Token<'_>, AdditionalErrors>> f
  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/errors/report.rs

@@ -80,6 +80,16 @@ impl Error {
  None,
  )
  }
+
+ Error::VariableInConstPosition(_, _, _) => {
+ let span = self.span();
+ (
+ self.to_string(),
+ Label::new(span.start..span.end)
+ .with_message("only non-variable values can be used here"),
+ None,
+ )
+ }
  }
  }
 }

cynic-parser/src/executable/generated.rs

@@ -1,4 +1,4 @@
-use super::{ids, iter::Iter, types, ExecutableId, ReadContext};
+use super::{ids, iter::Iter, types, ExecutableId};
 
 /// A prelude module for all the generated modules
 ///
@@ -13,7 +13,7 @@ mod prelude {
  executable::{
  ids::StringId,
  iter::{IdReader, Iter},
- ExecutableDocument,
+ ExecutableDocument, ReadContext,
  },
  AstLookup,
  };
@@ -31,5 +31,5 @@ mod value {
  // Note: This is just a requirement for some of the generated stuff
  // that assumes it'll be here
 
- pub use crate::values::Value;
+ pub use crate::values::{ConstValue, Value};
 }

cynic-parser/src/executable/generated/argument.rs

@@ -2,7 +2,7 @@ use super::prelude::*;
 use super::{
  ids::{ArgumentId, ValueId},
  value::Value,
- ExecutableId, ReadContext,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};

cynic-parser/src/executable/generated/directive.rs

@@ -2,7 +2,7 @@ use super::prelude::*;
 use super::{
  argument::Argument,
  ids::{ArgumentId, DirectiveId},
- ExecutableId, ReadContext,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};

cynic-parser/src/executable/generated/fragment.rs

@@ -3,7 +3,7 @@ use super::{
  directive::Directive,
  ids::{DirectiveId, FragmentDefinitionId, SelectionId},
  selections::Selection,
- ExecutableId, ReadContext,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};

cynic-parser/src/executable/generated/operation.rs

@@ -4,7 +4,7 @@ use super::{
  ids::{DirectiveId, OperationDefinitionId, SelectionId, VariableDefinitionId},
  selections::Selection,
  variable::VariableDefinition,
- ExecutableId, ReadContext,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};

cynic-parser/src/executable/generated/selections.rs

@@ -5,7 +5,7 @@ use super::{
  ids::{
  ArgumentId, DirectiveId, FieldSelectionId, FragmentSpreadId, InlineFragmentId, SelectionId,
  },
- ExecutableId, ReadContext,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};

cynic-parser/src/executable/generated/variable.rs

@@ -1,18 +1,18 @@
 use super::prelude::*;
 use super::{
  directive::Directive,
- ids::{DirectiveId, TypeId, ValueId, VariableDefinitionId},
+ ids::{ConstValueId, DirectiveId, TypeId, VariableDefinitionId},
  types::Type,
- value::Value,
- ExecutableId, ReadContext,
+ value::ConstValue,
+ ExecutableId,
 };
 #[allow(unused_imports)]
 use std::fmt::{self, Write};
 
 pub struct VariableDefinitionRecord {
  pub name: StringId,
  pub ty: TypeId,
- pub default_value: Option<ValueId>,
+ pub default_value: Option<ConstValueId>,
  pub directives: IdRange<DirectiveId>,
 }
 
@@ -28,7 +28,7 @@ impl<'a> VariableDefinition<'a> {
  let document = self.0.document;
  document.read(document.lookup(self.0.id).ty)
  }
- pub fn default_value(&self) -> Option<Value<'a>> {
+ pub fn default_value(&self) -> Option<ConstValue<'a>> {
  let document = self.0.document;
  document
  .lookup(self.0.id)

cynic-parser/src/executable/ids.rs

@@ -3,7 +3,7 @@ use std::num::NonZeroU32;
 use super::{storage::*, types::TypeRecord, ExecutableDocument};
 use crate::{common::IdRange, AstLookup};
 
-pub use crate::values::ids::ValueId;
+pub use crate::values::ids::{ConstValueId, ValueId};
 
 macro_rules! make_id {
  ($name:ident, $output:ident, $field:ident) => {
@@ -70,7 +70,9 @@ make_id!(InlineFragmentId, InlineFragmentRecord, inline_fragments);
 make_id!(FragmentSpreadId, FragmentSpreadRecord, fragment_spreads);
 
 make_id!(DirectiveId, DirectiveRecord, directives);
+
 make_id!(ArgumentId, ArgumentRecord, arguments);
+
 impl_id_range_ops!(DirectiveId);
 impl_id_range_ops!(ArgumentId);
 

cynic-parser/src/executable/values.rs

@@ -7,3 +7,11 @@ impl ExecutableId for crate::values::ids::ValueId {
  document.values.read(self)
  }
 }
+
+impl ExecutableId for crate::values::ids::ConstValueId {
+ type Reader<'a> = crate::values::ConstValue<'a>;
+
+ fn read(self, document: &super::ExecutableDocument) -> Self::Reader<'_> {
+ document.values.read(self)
+ }
+}

cynic-parser/src/parser/executable.lalrpop

@@ -4,7 +4,7 @@ use crate::{
  executable::{
  storage::*, ids::*, writer::ExecutableAstWriter
  },
- values::{storage::*, ids::ValueId, self},
+ values::{storage::*, ids::{ValueId, ConstValueId}, self},
  common::{
  OperationType, IdRange, WrappingType, TypeWrappers,
  unquote_string, unquote_block_string, trim_block_string_whitespace
@@ -67,8 +67,8 @@ VariableDefinition: () = {
  }
 }
 
-DefaultValue: ValueId = {
- "=" <value:Value> => {
+DefaultValue: ConstValueId = {
+ "=" <value:ConstValue> => {
  value
  }
 }
@@ -156,6 +156,40 @@ Argument: ArgumentRecord = {
  }
 }
 
+ConstValue: ConstValueId = {
+ <record:ConstValueRecord> => {
+ ast.values.const_value(record)
+ }
+}
+
+ConstValueRecord: ValueRecord = {
+ <scalar:ScalarValueRecord> => scalar,
+ <start:@L> "[" <values:ConstValueRecord*> "]" <end:@R> => {
+ let id = ast.values.list(values);
+ ValueRecord {
+ span: Span::new(start, end),
+ kind: ValueKind::List(id)
+ }
+ },
+ <start:@L> "{" <fields:ConstObjectField*> "}" <end:@R> => {
+ let fields = ast.values.const_fields(fields);
+ ValueRecord {
+ span: Span::new(start, end),
+ kind: ValueKind::Object(fields)
+ }
+ },
+}
+
+ConstObjectField: (values::ids::StringId, Span, ConstValueId) = {
+ <name_start:@L> <name:Name> <name_end:@R> ":" <value:ConstValue> => {
+ (
+ values::ids::StringId::from_executable_id(name),
+ Span::new(name_start, name_end),
+ value
+ )
+ }
+}
+
 Value: ValueId = {
  <record:ValueRecord> => {
  ast.values.value(record)
@@ -169,6 +203,35 @@ ValueRecord: ValueRecord = {
  kind: ValueKind::Variable(values::ids::StringId::from_executable_id(name))
  }
  },
+ <scalar:ScalarValueRecord> => scalar,
+ <start:@L> "[" <values:ValueRecord*> "]" <end:@R> => {
+ let id = ast.values.list(values);
+ ValueRecord {
+ span: Span::new(start, end),
+ kind: ValueKind::List(id)
+ }
+ },
+ <start:@L> "{" <fields:ObjectField*> "}" <end:@R> => {
+ let fields = ast.values.fields(fields);
+ ValueRecord {
+ span: Span::new(start, end),
+ kind: ValueKind::Object(fields)
+ }
+ },
+}
+
+ObjectField: (values::ids::StringId, Span, ValueId) = {
+ <name_start:@L> <name:Name> <name_end:@R> ":" <value:Value> => {
+ (
+ values::ids::StringId::from_executable_id(name),
+ Span::new(name_start, name_end),
+ value
+ )
+ }
+}
+
+
+ScalarValueRecord: ValueRecord = {
  <start:@L> <int:IntegerLiteral> <end:@R> => {
  ValueRecord {
  span: Span::new(start, end),
@@ -217,20 +280,6 @@ ValueRecord: ValueRecord = {
  kind: ValueKind::Null
  }
  },
- <start:@L> "[" <values:ValueRecord*> "]" <end:@R> => {
- let id = ast.values.list(values);
- ValueRecord {
- span: Span::new(start, end),
- kind: ValueKind::List(id)
- }
- },
- <start:@L> "{" <fields:ObjectField*> "}" <end:@R> => {
- let fields = ast.values.fields(fields);
- ValueRecord {
- span: Span::new(start, end),
- kind: ValueKind::Object(fields)
- }
- },
  <start:@L> <value:EnumValue> <end:@R> => {
  ValueRecord {
  span: Span::new(start, end),
@@ -239,16 +288,6 @@ ValueRecord: ValueRecord = {
  },
 }
 
-ObjectField: (values::ids::StringId, Span, ValueId) = {
- <name_start:@L> <name:Name> <name_end:@R> ":" <value:Value> => {
- (
- values::ids::StringId::from_executable_id(name),
- Span::new(name_start, name_end),
- value
- )
- }
-}
-
 EnumValue: StringId = {
  <s:RawIdent> => ast.ident(s),
  schema => ast.ident("schema"),