Revert "Bikeshedding, vol.8 [skip ci]"

This reverts commit 63a005d.

Author: tyranron

juniper/src/ast.rs

@@ -1,10 +1,4 @@
-use std::{
-    borrow::{Borrow, Cow},
-    fmt,
-    hash::Hash,
-    ops::Deref,
-    slice, vec,
-};
+use std::{borrow::Cow, fmt, hash::Hash, slice, vec};
 
 use arcstr::ArcStr;
 
@@ -16,114 +10,29 @@ use crate::{
     value::{DefaultScalarValue, ScalarValue},
 };
 
-/// Name of a [`Type`] literal.
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub enum TypeName<'a> {
-    /// Owned version of this name.
-    Owned(ArcStr),
-
-    /// Borrowed version of this name.
-    Borrowed(&'a str),
-}
-
-impl fmt::Display for TypeName<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Owned(n) => fmt::Display::fmt(n, f),
-            Self::Borrowed(n) => fmt::Display::fmt(n, f),
-        }
-    }
-}
-
-impl AsRef<str> for TypeName<'_> {
-    fn as_ref(&self) -> &str {
-        match self {
-            Self::Owned(n) => n.as_ref(),
-            Self::Borrowed(n) => n,
-        }
-    }
-}
-
-impl Borrow<str> for TypeName<'_> {
-    fn borrow(&self) -> &str {
-        self.as_ref()
-    }
-}
-
-impl Deref for TypeName<'_> {
-    type Target = str;
-
-    fn deref(&self) -> &Self::Target {
-        self.as_ref()
-    }
-}
-
-impl<'a> From<&'a str> for TypeName<'a> {
-    fn from(v: &'a str) -> Self {
-        Self::Borrowed(v)
-    }
-}
-
-impl From<ArcStr> for TypeName<'_> {
-    fn from(v: ArcStr) -> Self {
-        Self::Owned(v)
-    }
-}
-
-impl<'a> From<&'a ArcStr> for TypeName<'a> {
-    fn from(v: &'a ArcStr) -> Self {
-        Self::Borrowed(v.as_ref())
-    }
-}
-
-impl From<TypeName<'_>> for Box<str> {
-    fn from(n: TypeName<'_>) -> Self {
-        n.as_ref().into()
-    }
-}
-
-impl From<&TypeName<'_>> for Box<str> {
-    fn from(n: &TypeName<'_>) -> Self {
-        n.as_ref().into()
-    }
-}
-
-impl TypeName<'_> {
-    /// Return owned value if this [`TypeName`].
-    ///
-    /// [`Clone`]s if it's [`ArcStr`] already, otherwise allocates a new one.
-    #[must_use]
-    pub fn to_owned(&self) -> ArcStr {
-        match self {
-            Self::Owned(n) => n.clone(),
-            Self::Borrowed(n) => (*n).into(),
-        }
-    }
-}
-
 /// Type literal in a syntax tree.
 ///
 /// This enum carries no semantic information and might refer to types that do not exist.
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub enum Type<'a> {
+pub enum Type<N = ArcStr> {
     /// `null`able named type, e.g. `String`.
-    Named(TypeName<'a>),
+    Named(N),
 
     /// `null`able list type, e.g. `[String]`.
     ///
     /// The list itself is `null`able, the containing [`Type`] might be non-`null`.
-    List(Box<Type<'a>>, Option<usize>),
+    List(Box<Type<N>>, Option<usize>),
 
     /// Non-`null` named type, e.g. `String!`.
-    NonNullNamed(TypeName<'a>),
+    NonNullNamed(N),
 
     /// Non-`null` list type, e.g. `[String]!`.
     ///
     /// The list itself is non-`null`, the containing [`Type`] might be `null`able.
-    NonNullList(Box<Type<'a>>, Option<usize>),
+    NonNullList(Box<Type<N>>, Option<usize>),
 }
 
-impl fmt::Display for Type<'_> {
+impl<N: fmt::Display> fmt::Display for Type<N> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Self::Named(n) => write!(f, "{n}"),
@@ -134,7 +43,7 @@ impl fmt::Display for Type<'_> {
     }
 }
 
-impl<'a> Type<'a> {
+impl<N: AsRef<str>> Type<N> {
     /// Returns the name of this named [`Type`].
     ///
     /// Only applies to named [`Type`]s. Lists will return [`None`].
@@ -150,24 +59,13 @@ impl<'a> Type<'a> {
     ///
     /// All [`Type`] literals contain exactly one named type.
     #[must_use]
-    pub fn innermost_name(&self) -> &TypeName<'_> {
+    pub fn innermost_name(&self) -> &str {
         match self {
-            Self::Named(n) | Self::NonNullNamed(n) => n,
+            Self::Named(n) | Self::NonNullNamed(n) => n.as_ref(),
             Self::List(l, ..) | Self::NonNullList(l, ..) => l.innermost_name(),
         }
     }
 
-    /// Returns the owned innermost name of this [`Type`] by unpacking lists.
-    ///
-    /// All [`Type`] literals contain exactly one named type.
-    #[must_use]
-    pub fn to_innermost_name(&self) -> ArcStr {
-        match self.innermost_name() {
-            TypeName::Owned(n) => n.clone(),
-            TypeName::Borrowed(n) => (*n).into(),
-        }
-    }
-
     /// Indicates whether this [`Type`] can only represent non-`null` values.
     #[must_use]
     pub fn is_non_null(&self) -> bool {
@@ -197,7 +95,7 @@ pub enum InputValue<S = DefaultScalarValue> {
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct VariableDefinition<'a, S> {
-    pub var_type: Spanning<Type<'a>>,
+    pub var_type: Spanning<Type<&'a str>>,
     pub default_value: Option<Spanning<InputValue<S>>>,
     pub directives: Option<Vec<Spanning<Directive<'a, S>>>>,
 }

juniper/src/executor/mod.rs

@@ -15,7 +15,7 @@ use futures::Stream;
 use crate::{
     ast::{
         Definition, Document, Fragment, FromInputValue, InputValue, Operation, OperationType,
-        Selection, ToInputValue, Type, TypeName,
+        Selection, ToInputValue, Type,
     },
     parser::{SourcePosition, Spanning},
     schema::{
@@ -1149,18 +1149,15 @@ impl<S> Registry<S> {
     ///
     /// If this [`Registry`] hasn't seen a [`Type`] with such [`GraphQLType::name`] before, it will
     /// construct the one and store it.
-    pub fn get_type<T>(&mut self, info: &T::TypeInfo) -> Type<'static>
+    pub fn get_type<T>(&mut self, info: &T::TypeInfo) -> Type
     where
         T: GraphQLType<S> + ?Sized,
         S: ScalarValue,
     {
         if let Some(name) = T::name(info) {
             let validated_name = Name::new(name.clone()).unwrap();
             if !self.types.contains_key(&name) {
-                self.insert_placeholder(
-                    validated_name.clone(),
-                    Type::NonNullNamed(TypeName::Owned(name.clone())),
-                );
+                self.insert_placeholder(validated_name.clone(), Type::NonNullNamed(name.clone()));
                 let meta = T::meta(info, self);
                 self.types.insert(validated_name, meta);
             }
@@ -1227,7 +1224,7 @@ impl<S> Registry<S> {
         Argument::new(name, self.get_type::<T>(info)).default_value(value.to_input_value())
     }
 
-    fn insert_placeholder(&mut self, name: Name, of_type: Type<'static>) {
+    fn insert_placeholder(&mut self, name: Name, of_type: Type) {
         self.types
             .entry(name)
             .or_insert(MetaType::Placeholder(PlaceholderMeta { of_type }));
@@ -1315,7 +1312,7 @@ impl<S> Registry<S> {
     }
 
     /// Creates an [`UnionMeta`] type of the given `types`.
-    pub fn build_union_type<T>(&mut self, info: &T::TypeInfo, types: &[Type<'static>]) -> UnionMeta
+    pub fn build_union_type<T>(&mut self, info: &T::TypeInfo, types: &[Type]) -> UnionMeta
     where
         T: GraphQLType<S> + ?Sized,
         S: ScalarValue,

juniper/src/parser/document.rs

@@ -507,7 +507,7 @@ where
     ))
 }
 
-pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<Type<'a>> {
+pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<Type<&'a str>> {
     let parsed_type = if let Some(Spanning {
         span: ref start_span,
         ..
@@ -521,7 +521,7 @@ pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<Type<'a>> {
             Type::List(Box::new(inner_type.item), None),
         )
     } else {
-        parser.expect_name()?.map(|n| Type::Named(n.into()))
+        parser.expect_name()?.map(Type::Named)
     };
 
     Ok(match *parser.peek() {
@@ -533,7 +533,10 @@ pub fn parse_type<'a>(parser: &mut Parser<'a>) -> ParseResult<Type<'a>> {
     })
 }
 
-fn wrap_non_null<'a>(parser: &mut Parser<'a>, inner: Spanning<Type<'a>>) -> ParseResult<Type<'a>> {
+fn wrap_non_null<'a>(
+    parser: &mut Parser<'a>,
+    inner: Spanning<Type<&'a str>>,
+) -> ParseResult<Type<&'a str>> {
     let end_pos = &parser.expect(&Token::ExclamationMark)?.span.end;
 
     let wrapped = match inner.item {

juniper/src/schema/meta.rs

@@ -1,6 +1,6 @@
 //! Types used to describe a `GraphQL` schema
 
-use std::fmt;
+use std::{borrow::ToOwned, fmt};
 
 use arcstr::ArcStr;
 
@@ -114,7 +114,7 @@ pub type ScalarTokenParseFn<S> = for<'b> fn(ScalarToken<'b>) -> Result<S, ParseE
 #[derive(Debug)]
 pub struct ListMeta {
     #[doc(hidden)]
-    pub of_type: Type<'static>,
+    pub of_type: Type,
 
     #[doc(hidden)]
     pub expected_size: Option<usize>,
@@ -125,7 +125,7 @@ impl ListMeta {
     ///
     /// Specifying `expected_size` will be used to ensure that values of this type will always match
     /// it.
-    pub fn new(of_type: Type<'static>, expected_size: Option<usize>) -> Self {
+    pub fn new(of_type: Type, expected_size: Option<usize>) -> Self {
         Self {
             of_type,
             expected_size,
@@ -142,12 +142,12 @@ impl ListMeta {
 #[derive(Debug)]
 pub struct NullableMeta {
     #[doc(hidden)]
-    pub of_type: Type<'static>,
+    pub of_type: Type,
 }
 
 impl NullableMeta {
     /// Builds a new [`NullableMeta`] type by wrapping the specified [`Type`].
-    pub fn new(of_type: Type<'static>) -> Self {
+    pub fn new(of_type: Type) -> Self {
         Self { of_type }
     }
 
@@ -197,10 +197,10 @@ impl<S> ObjectMeta<S> {
     ///
     /// Overwrites any previously set list of interfaces.
     #[must_use]
-    pub fn interfaces(mut self, interfaces: &[Type<'static>]) -> Self {
+    pub fn interfaces(mut self, interfaces: &[Type]) -> Self {
         self.interface_names = interfaces
             .iter()
-            .map(|t| t.innermost_name().to_owned())
+            .map(|t| t.innermost_name().into())
             .collect();
         self
     }
@@ -302,10 +302,10 @@ impl<S> InterfaceMeta<S> {
     ///
     /// Overwrites any previously set list of interfaces.
     #[must_use]
-    pub fn interfaces(mut self, interfaces: &[Type<'static>]) -> Self {
+    pub fn interfaces(mut self, interfaces: &[Type]) -> Self {
         self.interface_names = interfaces
             .iter()
-            .map(|t| t.innermost_name().to_owned())
+            .map(|t| t.innermost_name().into())
             .collect();
         self
     }
@@ -329,14 +329,11 @@ pub struct UnionMeta {
 
 impl UnionMeta {
     /// Builds a new [`UnionMeta`] type with the specified `name` and possible [`Type`]s.
-    pub fn new(name: impl Into<ArcStr>, of_types: &[Type<'static>]) -> Self {
+    pub fn new(name: impl Into<ArcStr>, of_types: &[Type]) -> Self {
         Self {
             name: name.into(),
             description: None,
-            of_type_names: of_types
-                .iter()
-                .map(|t| t.innermost_name().to_owned())
-                .collect(),
+            of_type_names: of_types.iter().map(|t| t.innermost_name().into()).collect(),
         }
     }
 
@@ -414,7 +411,7 @@ impl<S> InputObjectMeta<S> {
 #[derive(Debug)]
 pub struct PlaceholderMeta {
     #[doc(hidden)]
-    pub of_type: Type<'static>,
+    pub of_type: Type,
 }
 
 /// Metadata for a field
@@ -427,7 +424,7 @@ pub struct Field<S> {
     #[doc(hidden)]
     pub arguments: Option<Vec<Argument<S>>>,
     #[doc(hidden)]
-    pub field_type: Type<'static>,
+    pub field_type: Type,
     #[doc(hidden)]
     pub deprecation_status: DeprecationStatus,
 }
@@ -483,14 +480,14 @@ pub struct Argument<S> {
     #[doc(hidden)]
     pub description: Option<ArcStr>,
     #[doc(hidden)]
-    pub arg_type: Type<'static>,
+    pub arg_type: Type,
     #[doc(hidden)]
     pub default_value: Option<InputValue<S>>,
 }
 
 impl<S> Argument<S> {
     /// Builds a new [`Argument`] of the given [`Type`] with the given `name`.
-    pub fn new(name: impl Into<ArcStr>, arg_type: Type<'static>) -> Self {
+    pub fn new(name: impl Into<ArcStr>, arg_type: Type) -> Self {
         Self {
             name: name.into(),
             description: None,
@@ -705,14 +702,14 @@ impl<S> MetaType<S> {
     }
 
     /// Construct a [`Type`] literal out of this [`MetaType`].
-    pub fn as_type(&self) -> Type<'static> {
+    pub fn as_type(&self) -> Type {
         match self {
             Self::Enum(EnumMeta { name, .. })
             | Self::InputObject(InputObjectMeta { name, .. })
             | Self::Interface(InterfaceMeta { name, .. })
             | Self::Object(ObjectMeta { name, .. })
             | Self::Scalar(ScalarMeta { name, .. })
-            | Self::Union(UnionMeta { name, .. }) => Type::NonNullNamed(name.clone().into()),
+            | Self::Union(UnionMeta { name, .. }) => Type::NonNullNamed(name.clone()),
             Self::List(ListMeta {
                 of_type,
                 expected_size,