fix: some value tweaks in parser (#1058)

1. TryFrom<Value> for ConstValue
2. Rename ListValue -> List, ConstListValue -> ConstList

cynic-parser/src/values/const_lists.rs

@@ -5,9 +5,9 @@ use crate::{common::IdRange, AstLookup, Span};
 use super::{const_value::ConstValue, iter::Iter, ConstValueId};
 
 #[derive(Clone, Copy)]
-pub struct ConstListValue<'a>(pub(super) super::Cursor<'a, ConstValueId>);
+pub struct ConstList<'a>(pub(super) super::Cursor<'a, ConstValueId>);
 
-impl<'a> ConstListValue<'a> {
+impl<'a> ConstList<'a> {
  pub fn is_empty(&self) -> bool {
  self.len() == 0
  }
@@ -33,7 +33,7 @@ impl<'a> ConstListValue<'a> {
  }
 }
 
-impl fmt::Debug for ConstListValue<'_> {
+impl fmt::Debug for ConstList<'_> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  f.debug_list().entries(self.items()).finish()
  }

cynic-parser/src/values/const_value.rs

@@ -1,7 +1,7 @@
 use crate::{AstLookup, Span};
 
 use super::{
- const_lists::ConstListValue,
+ const_lists::ConstList,
  const_objects::ConstObject,
  enums::EnumValue,
  iter::{Iter, ValueStoreReader},
@@ -18,7 +18,7 @@ pub enum ConstValue<'a> {
  Boolean(BooleanValue<'a>),
  Null(NullValue<'a>),
  Enum(EnumValue<'a>),
- List(ConstListValue<'a>),
+ List(ConstList<'a>),
  Object(ConstObject<'a>),
 }
 
@@ -99,7 +99,7 @@ impl<'a> ConstValue<'a> {
  matches!(self, Self::List(_))
  }
 
- pub fn as_list(&self) -> Option<ConstListValue<'a>> {
+ pub fn as_list(&self) -> Option<ConstList<'a>> {
  match self {
  Self::List(inner) => Some(*inner),
  _ => None,
@@ -176,8 +176,56 @@ impl super::ValueStoreId for ConstValueId {
  ValueKind::Boolean(_) => ConstValue::Boolean(BooleanValue(value_cursor)),
  ValueKind::Null => ConstValue::Null(NullValue(value_cursor)),
  ValueKind::Enum(_) => ConstValue::Enum(EnumValue(value_cursor)),
- ValueKind::List(_) => ConstValue::List(ConstListValue(cursor)),
+ ValueKind::List(_) => ConstValue::List(ConstList(cursor)),
  ValueKind::Object(_) => ConstValue::Object(ConstObject(cursor)),
  }
  }
 }
+
+impl<'a> TryFrom<Value<'a>> for ConstValue<'a> {
+ type Error = ();
+
+ fn try_from(value: Value<'a>) -> Result<Self, Self::Error> {
+ if !const_safe(value) {
+ return Err(());
+ }
+
+ Ok(match value {
+ Value::Variable(_) => unreachable!(),
+ Value::Int(int_value) => ConstValue::Int(int_value),
+ Value::Float(float_value) => ConstValue::Float(float_value),
+ Value::String(string_value) => ConstValue::String(string_value),
+ Value::Boolean(boolean_value) => ConstValue::Boolean(boolean_value),
+ Value::Null(null_value) => ConstValue::Null(null_value),
+ Value::Enum(enum_value) => ConstValue::Enum(enum_value),
+ Value::List(list_value) => {
+ let id = ConstValueId::new(list_value.0.id.get());
+ ConstValue::List(ConstList(Cursor {
+ id,
+ store: list_value.0.store,
+ }))
+ }
+ Value::Object(object) => {
+ let id = ConstValueId::new(object.0.id.get());
+ ConstValue::Object(ConstObject(Cursor {
+ id,
+ store: object.0.store,
+ }))
+ }
+ })
+ }
+}
+
+fn const_safe(value: Value<'_>) -> bool {
+ match value {
+ Value::Variable(_) => false,
+ Value::Int(_)
+ | Value::Float(_)
+ | Value::String(_)
+ | Value::Boolean(_)
+ | Value::Null(_)
+ | Value::Enum(_) => true,
+ Value::List(items) => items.items().any(const_safe),
+ Value::Object(object) => object.fields().any(|field| const_safe(field.value())),
+ }
+}

cynic-parser/src/values/lists.rs

@@ -2,12 +2,12 @@ use std::fmt;
 
 use crate::{AstLookup, Span};
 
-use super::{const_lists::ConstListValue, ids::ValueId, iter::Iter, value::Value, Cursor};
+use super::{const_lists::ConstList, ids::ValueId, iter::Iter, value::Value, Cursor};
 
 #[derive(Clone, Copy)]
-pub struct ListValue<'a>(pub(super) super::Cursor<'a, ValueId>);
+pub struct List<'a>(pub(super) super::Cursor<'a, ValueId>);
 
-impl<'a> ListValue<'a> {
+impl<'a> List<'a> {
  pub fn is_empty(&self) -> bool {
  self.len() == 0
  }
@@ -28,24 +28,24 @@ impl<'a> ListValue<'a> {
  }
 }
 
-impl PartialEq for ListValue<'_> {
+impl PartialEq for List<'_> {
  fn eq(&self, other: &Self) -> bool {
  self.len() == other.len() && self.items().zip(other.items()).all(|(lhs, rhs)| lhs == rhs)
  }
 }
 
-impl fmt::Debug for ListValue<'_> {
+impl fmt::Debug for List<'_> {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  f.debug_list().entries(self.items()).finish()
  }
 }
 
-impl<'a> From<ConstListValue<'a>> for ListValue<'a> {
- fn from(value: ConstListValue<'a>) -> Self {
+impl<'a> From<ConstList<'a>> for List<'a> {
+ fn from(value: ConstList<'a>) -> Self {
  let Cursor { id, store } = value.0;
 
  let id = id.into();
 
- ListValue(Cursor { id, store })
+ List(Cursor { id, store })
  }
 }

cynic-parser/src/values/mod.rs

@@ -15,11 +15,11 @@ pub mod writer;
 use std::sync::Arc;
 
 pub use self::{
- const_lists::ConstListValue,
+ const_lists::ConstList,
  const_objects::{ConstObject, ConstObjectField},
  const_value::ConstValue,
  enums::EnumValue,
- lists::ListValue,
+ lists::List,
  objects::{Object, ObjectField},
  scalars::{BooleanValue, FloatValue, IntValue, NullValue, StringValue},
  value::Value,

cynic-parser/src/values/value.rs

@@ -5,7 +5,7 @@ use super::{
  enums::EnumValue,
  ids::{FieldId, StringId},
  iter::{Iter, ValueStoreReader},
- lists::ListValue,
+ lists::List,
  objects::Object,
  scalars::{BooleanValue, FloatValue, IntValue, NullValue, StringValue},
  variables::VariableValue,
@@ -21,7 +21,7 @@ pub enum Value<'a> {
  Boolean(BooleanValue<'a>),
  Null(NullValue<'a>),
  Enum(EnumValue<'a>),
- List(ListValue<'a>),
+ List(List<'a>),
  Object(Object<'a>),
 }
 
@@ -133,7 +133,7 @@ impl<'a> Value<'a> {
  matches!(self, Value::List(_))
  }
 
- pub fn as_list(&self) -> Option<ListValue<'a>> {
+ pub fn as_list(&self) -> Option<List<'a>> {
  match self {
  Self::List(inner) => Some(*inner),
  _ => None,
@@ -201,7 +201,7 @@ impl super::ValueStoreId for ValueId {
  ValueKind::Boolean(_) => Value::Boolean(BooleanValue(cursor)),
  ValueKind::Null => Value::Null(NullValue(cursor)),
  ValueKind::Enum(_) => Value::Enum(EnumValue(cursor)),
- ValueKind::List(_) => Value::List(ListValue(cursor)),
+ ValueKind::List(_) => Value::List(List(cursor)),
  ValueKind::Object(_) => Value::Object(Object(cursor)),
  }
  }