Rework core traits

juniper/src/ast.rs

@@ -1,4 +1,4 @@
-use std::{borrow::Cow, fmt, hash::Hash, slice, vec};
+use std::{any::TypeId, borrow::Cow, convert::Into, fmt, hash::Hash, mem, slice, vec};
 
 use indexmap::IndexMap;
 
@@ -256,30 +256,43 @@ impl<S> InputValue<S> {
         Self::Variable(v.as_ref().into())
     }
 
-    /// Construct a [`Spanning::unlocated`] list.
+    /// Constructs a [`Spanning::unlocated`] [`InputValue::List`].
     ///
-    /// Convenience function to make each [`InputValue`] in the input vector
-    /// not contain any location information. Can be used from [`ToInputValue`]
-    /// implementations, where no source code position information is available.
-    pub fn list(l: Vec<Self>) -> Self {
-        Self::List(l.into_iter().map(Spanning::unlocated).collect())
+    /// Convenience function to make each [`InputValue`] in the input `list` to
+    /// not contain any location information.
+    ///
+    /// Intended for [`resolve::ToInputValue`] implementations, where no source
+    /// code position information is available.
+    ///
+    /// [`resolve::ToInputValue`]: juniper::resolve::ToInputValue
+    pub fn list(list: impl IntoIterator<Item = Self>) -> Self {
+        Self::List(list.into_iter().map(Spanning::unlocated).collect())
     }
 
     /// Construct a located list.
     pub fn parsed_list(l: Vec<Spanning<Self>>) -> Self {
         Self::List(l)
     }
 
-    /// Construct aa [`Spanning::unlocated`] object.
+    /// Construct a [`Spanning::unlocated`] [`InputValue::Onject`].
+    ///
+    /// Similarly to [`InputValue::list()`] it makes each key and value in the
+    /// given `obj`ect to not contain any location information.
     ///
-    /// Similarly to [`InputValue::list`] it makes each key and value in the
-    /// given hash map not contain any location information.
-    pub fn object<K>(o: IndexMap<K, Self>) -> Self
+    /// Intended for [`resolve::ToInputValue`] implementations, where no source
+    /// code position information is available.
+    ///
+    /// [`resolve::ToInputValue`]: juniper::resolve::ToInputValue
+    // TODO: Use `impl IntoIterator<Item = (K, Self)>` argument once feature
+    //       `explicit_generic_args_with_impl_trait` hits stable:
+    //       https://github.com/rust-lang/rust/issues/83701
+    pub fn object<K, O>(obj: O) -> Self
     where
         K: AsRef<str> + Eq + Hash,
+        O: IntoIterator<Item = (K, Self)>,
     {
         Self::Object(
-            o.into_iter()
+            obj.into_iter()
                 .map(|(k, v)| {
                     (
                         Spanning::unlocated(k.as_ref().into()),
@@ -459,6 +472,42 @@ impl<S> InputValue<S> {
             _ => false,
         }
     }
+
+    /// Maps the [`ScalarValue`] type of this [`InputValue`] into the specified
+    /// one.
+    pub fn map_scalar_value<Into>(self) -> InputValue<Into>
+    where
+        S: ScalarValue,
+        Into: ScalarValue,
+    {
+        if TypeId::of::<Into>() == TypeId::of::<S>() {
+            // SAFETY: This is safe, because we're transmuting the value into
+            //         itself, so no invariants may change and we're just
+            //         satisfying the type checker.
+            //         As `mem::transmute_copy` creates a copy of data, we need
+            //         `mem::ManuallyDrop` here to omit double-free when
+            //         `S: Drop`.
+            let val = mem::ManuallyDrop::new(self);
+            unsafe { mem::transmute_copy(&*val) }
+        } else {
+            match self {
+                Self::Null => InputValue::Null,
+                Self::Scalar(s) => InputValue::Scalar(s.into_another()),
+                Self::Enum(v) => InputValue::Enum(v),
+                Self::Variable(n) => InputValue::Variable(n),
+                Self::List(l) => InputValue::List(
+                    l.into_iter()
+                        .map(|i| i.map(InputValue::map_scalar_value))
+                        .collect(),
+                ),
+                Self::Object(o) => InputValue::Object(
+                    o.into_iter()
+                        .map(|(k, v)| (k, v.map(InputValue::map_scalar_value)))
+                        .collect(),
+                ),
+            }
+        }
+    }
 }
 
 impl<S: ScalarValue> fmt::Display for InputValue<S> {

juniper/src/behavior.rs

@@ -0,0 +1,130 @@
+//! GraphQL types behavior machinery.
+
+use std::{marker::PhantomData, sync::atomic::AtomicPtr};
+
+use crate::{
+    graphql,
+    meta::MetaType,
+    parser::{ParseError, ScalarToken},
+    reflect, resolve, Registry,
+};
+
+/// Default standard behavior of GraphQL types implementation.
+#[derive(Debug)]
+pub enum Standard {}
+
+/// Transparent wrapper allowing coercion of behavior types and type parameters.
+#[repr(transparent)]
+pub struct Coerce<T: ?Sized, To: ?Sized = Standard>(PhantomData<AtomicPtr<Box<To>>>, T);
+
+impl<T, To: ?Sized> Coerce<T, To> {
+    /// Wraps the provided `value` into a [`Coerce`] wrapper.
+    #[must_use]
+    pub const fn wrap(value: T) -> Self {
+        Self(PhantomData, value)
+    }
+
+    /// Unwraps into the inner value.
+    #[must_use]
+    pub fn into_inner(self) -> T {
+        self.1
+    }
+}
+
+/// Wraps the provided `value` into a [`Coerce`] wrapper.
+#[must_use]
+pub const fn coerce<T, To: ?Sized>(value: T) -> Coerce<T, To> {
+    Coerce::wrap(value)
+}
+
+impl<T, TI, SV, B1, B2> resolve::Type<TI, SV, B1> for Coerce<T, B2>
+where
+    T: resolve::Type<TI, SV, B2> + ?Sized,
+    TI: ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    fn meta<'r, 'ti: 'r>(registry: &mut Registry<'r, SV>, type_info: &'ti TI) -> MetaType<'r, SV>
+    where
+        SV: 'r,
+    {
+        T::meta(registry, type_info)
+    }
+}
+
+impl<T, TI, B1, B2> resolve::TypeName<TI, B1> for Coerce<T, B2>
+where
+    T: resolve::TypeName<TI, B2> + ?Sized,
+    TI: ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    fn type_name(type_info: &TI) -> &str {
+        T::type_name(type_info)
+    }
+}
+
+impl<'i, T, SV, B1, B2> resolve::InputValue<'i, SV, B1> for Coerce<T, B2>
+where
+    T: resolve::InputValue<'i, SV, B2>,
+    SV: 'i,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    type Error = T::Error;
+
+    fn try_from_input_value(v: &'i graphql::InputValue<SV>) -> Result<Self, Self::Error> {
+        T::try_from_input_value(v).map(Self::wrap)
+    }
+
+    fn try_from_implicit_null() -> Result<Self, Self::Error> {
+        T::try_from_implicit_null().map(Self::wrap)
+    }
+}
+
+impl<T, SV, B1, B2> resolve::ScalarToken<SV, B1> for Coerce<T, B2>
+where
+    T: resolve::ScalarToken<SV, B2> + ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    fn parse_scalar_token(token: ScalarToken<'_>) -> Result<SV, ParseError> {
+        T::parse_scalar_token(token)
+    }
+}
+
+impl<T, B1, B2> reflect::BaseType<B1> for Coerce<T, B2>
+where
+    T: reflect::BaseType<B2> + ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    const NAME: reflect::Type = T::NAME;
+}
+
+impl<T, B1, B2> reflect::BaseSubTypes<B1> for Coerce<T, B2>
+where
+    T: reflect::BaseSubTypes<B2> + ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    const NAMES: reflect::Types = T::NAMES;
+}
+
+impl<T, B1, B2> reflect::WrappedType<B1> for Coerce<T, B2>
+where
+    T: reflect::WrappedType<B2> + ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    const VALUE: reflect::WrappedValue = T::VALUE;
+}
+
+impl<T, B1, B2> reflect::Implements<B1> for Coerce<T, B2>
+where
+    T: reflect::Implements<B2> + ?Sized,
+    B1: ?Sized,
+    B2: ?Sized,
+{
+    const NAMES: reflect::Types = T::NAMES;
+}