Resculpt ast::Type, vol.3

tyranron · tyranron · commit d9d8f3a1495c · 2025-05-21T19:34:07.000+02:00
diff --git a/juniper/src/ast.rs b/juniper/src/ast.rs
@@ -18,6 +18,8 @@ pub enum TypeModifier {
 
 pub(crate) type BorrowedType<'a> = Type<&'a str, &'a [TypeModifier]>;
 
+impl Copy for BorrowedType<'_> {}
+
 /// Type literal in a syntax tree.
 ///
 /// Carries no semantic information and might refer to types that don't exist.
@@ -80,6 +82,13 @@ impl<'a> BorrowedType<'a> {
             },
         }
     }
+    pub(crate) fn list_inner_borrowed(&self) -> Option<BorrowedType<'a>> {
+        match self.modifiers.as_ref().last() {
+            Some(TypeModifier::NonNull) => self.inner_borrowed().list_inner_borrowed(),
+            Some(TypeModifier::List(..)) => Some(self.inner_borrowed()),
+            None => None,
+        }
+    }
 
     pub(crate) fn borrowed_name(&self) -> &'a str {
         self.name
diff --git a/juniper/src/schema/model.rs b/juniper/src/schema/model.rs
@@ -746,86 +746,6 @@ mod concrete_type_sort {
     }
 }
 
-/// Allows seeing [`Type`] with different name/string representations
-/// as the same type without allocation.
-// TODO: Ideally this type should not exist, but the reason it currently does is that `Type` has a
-//       recursive design to allow arbitrary number of list wrappings.
-//       The list layout could instead be modelled as a modifier so that type becomes a tuple of
-//       (name, modifier).
-//       If `Type` is modelled like this it becomes easier to project it as a borrowed version of
-//       itself, i.e. [Type<ArcStr>] vs [Type<&str>].
-#[derive(Clone, Copy, Debug)]
-pub enum DynType<'a> {
-    Named(&'a str),
-    List(&'a dyn AsDynType, Option<usize>),
-    NonNullNamed(&'a str),
-    NonNullList(&'a dyn AsDynType, Option<usize>),
-}
-
-impl<'a> DynType<'a> {
-    pub fn equals(&self, other: &DynType) -> bool {
-        match (self, other) {
-            (Self::Named(n0), DynType::Named(n1)) => n0 == n1,
-            (Self::List(t0, s0), DynType::List(t1, s1)) => {
-                t0.as_dyn_type().equals(&t1.as_dyn_type()) && s0 == s1
-            }
-            (Self::NonNullNamed(n0), DynType::NonNullNamed(n1)) => n0 == n1,
-            (Self::NonNullList(t0, s0), DynType::NonNullList(t1, s1)) => {
-                t0.as_dyn_type().equals(&t1.as_dyn_type()) && s0 == s1
-            }
-            _ => false,
-        }
-    }
-
-    pub fn innermost_name(&self) -> &'a str {
-        match self {
-            Self::Named(n) | Self::NonNullNamed(n) => n,
-            Self::List(l, _) | Self::NonNullList(l, _) => l.as_dyn_type().innermost_name(),
-        }
-    }
-}
-
-impl fmt::Display for DynType<'_> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Named(n) => write!(f, "{n}"),
-            Self::NonNullNamed(n) => write!(f, "{n}!"),
-            Self::List(t, _) => write!(f, "[{}]", t.as_dyn_type()),
-            Self::NonNullList(t, _) => write!(f, "[{}]!", t.as_dyn_type()),
-        }
-    }
-}
-
-/// Conversion of a [`Type`] into a [`DynType`].
-pub trait AsDynType: fmt::Debug {
-    /// Project this value as a [`DynType`].
-    ///
-    /// Should not allocate memory.
-    fn as_dyn_type(&self) -> DynType<'_>;
-}
-
-impl AsDynType for Type<ArcStr> {
-    fn as_dyn_type(&self) -> DynType<'_> {
-        match self {
-            Self::Named(n) => DynType::Named(n.as_str()),
-            Self::List(t, s) => DynType::List(t.as_ref(), *s),
-            Self::NonNullNamed(n) => DynType::NonNullNamed(n.as_str()),
-            Self::NonNullList(t, s) => DynType::NonNullList(t.as_ref(), *s),
-        }
-    }
-}
-
-impl AsDynType for Type<&str> {
-    fn as_dyn_type(&self) -> DynType<'_> {
-        match self {
-            Self::Named(n) => DynType::Named(n),
-            Self::List(t, s) => DynType::List(t.as_ref(), *s),
-            Self::NonNullNamed(n) => DynType::NonNullNamed(n),
-            Self::NonNullList(t, s) => DynType::NonNullList(t.as_ref(), *s),
-        }
-    }
-}
-
 #[cfg(test)]
 mod root_node_test {
     #[cfg(feature = "schema-language")]
diff --git a/juniper/src/validation/context.rs b/juniper/src/validation/context.rs
@@ -4,14 +4,11 @@ use std::{
 };
 
 use crate::{
-    ast::{Definition, Document},
-    schema::model::DynType,
+    ast::{BorrowedType, Definition, Document, Type, TypeModifier},
+    parser::SourcePosition,
+    schema::{meta::MetaType, model::SchemaType},
 };
 
-use crate::schema::{meta::MetaType, model::SchemaType};
-
-use crate::parser::SourcePosition;
-
 /// Query validation error
 #[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
 pub struct RuleError {
@@ -24,9 +21,9 @@ pub struct ValidatorContext<'a, S: Debug + 'a> {
     pub schema: &'a SchemaType<S>,
     errors: Vec<RuleError>,
     type_stack: Vec<Option<&'a MetaType<S>>>,
-    type_literal_stack: Vec<Option<DynType<'a>>>,
+    type_literal_stack: Vec<Option<BorrowedType<'a>>>,
     input_type_stack: Vec<Option<&'a MetaType<S>>>,
-    input_type_literal_stack: Vec<Option<DynType<'a>>>,
+    input_type_literal_stack: Vec<Option<BorrowedType<'a>>>,
     parent_type_stack: Vec<Option<&'a MetaType<S>>>,
     fragment_names: HashSet<&'a str>,
 }
@@ -112,10 +109,12 @@ impl<'a, S: Debug> ValidatorContext<'a, S> {
     }
 
     #[doc(hidden)]
-    pub fn with_pushed_type<F, R>(&mut self, t: Option<DynType<'a>>, f: F) -> R
+    pub fn with_pushed_type<F, R>(&mut self, t: Option<impl Into<BorrowedType<'a>>>, f: F) -> R
     where
         F: FnOnce(&mut ValidatorContext<'a, S>) -> R,
     {
+        let t = t.map(Into::into);
+        
         if let Some(t) = t {
             self.type_stack
                 .push(self.schema.concrete_type_by_name(t.innermost_name()));
@@ -147,10 +146,16 @@ impl<'a, S: Debug> ValidatorContext<'a, S> {
     }
 
     #[doc(hidden)]
-    pub fn with_pushed_input_type<F, R>(&mut self, t: Option<DynType<'a>>, f: F) -> R
+    pub fn with_pushed_input_type<F, R>(
+        &mut self,
+        t: Option<impl Into<BorrowedType<'a>>>,
+        f: F,
+    ) -> R
     where
         F: FnOnce(&mut ValidatorContext<'a, S>) -> R,
     {
+        let t = t.map(Into::into);
+
         if let Some(t) = t {
             self.input_type_stack
                 .push(self.schema.concrete_type_by_name(t.innermost_name()));
@@ -174,7 +179,7 @@ impl<'a, S: Debug> ValidatorContext<'a, S> {
     }
 
     #[doc(hidden)]
-    pub fn current_type_literal(&self) -> Option<DynType<'a>> {
+    pub fn current_type_literal(&self) -> Option<BorrowedType<'a>> {
         match self.type_literal_stack.last() {
             Some(Some(t)) => Some(*t),
             _ => None,
@@ -187,7 +192,7 @@ impl<'a, S: Debug> ValidatorContext<'a, S> {
     }
 
     #[doc(hidden)]
-    pub fn current_input_type_literal(&self) -> Option<DynType<'a>> {
+    pub fn current_input_type_literal(&self) -> Option<BorrowedType<'a>> {
         match self.input_type_literal_stack.last() {
             Some(Some(t)) => Some(*t),
             _ => None,
diff --git a/juniper/src/validation/rules/variables_in_allowed_position.rs b/juniper/src/validation/rules/variables_in_allowed_position.rs
@@ -5,9 +5,8 @@ use std::{
 
 use crate::{
     Span,
-    ast::{Document, Fragment, FragmentSpread, Operation, Type, TypeModifier, VariableDefinition},
+    ast::{Document, Fragment, FragmentSpread, Operation, BorrowedType, TypeModifier, VariableDefinition},
     parser::Spanning,
-    schema::model::{AsDynType, DynType},
     validation::{ValidatorContext, Visitor},
     value::ScalarValue,
 };
@@ -29,7 +28,7 @@ pub fn factory<'a, S: fmt::Debug>() -> VariableInAllowedPosition<'a, S> {
 
 pub struct VariableInAllowedPosition<'a, S: fmt::Debug + 'a> {
     spreads: HashMap<Scope<'a>, HashSet<&'a str>>,
-    variable_usages: HashMap<Scope<'a>, Vec<(SpannedInput<'a, String>, DynType<'a>)>>,
+    variable_usages: HashMap<Scope<'a>, Vec<(SpannedInput<'a, String>, BorrowedType<'a>)>>,
     #[expect(clippy::type_complexity, reason = "readable enough")]
     variable_defs: HashMap<Scope<'a>, Vec<&'a (Spanning<&'a str>, VariableDefinition<'a, S>)>>,
     current_scope: Option<Scope<'a>>,
diff --git a/juniper/src/validation/visitor.rs b/juniper/src/validation/visitor.rs
@@ -2,11 +2,11 @@ use crate::{
     ast::{
         Arguments, Definition, Directive, Document, Field, Fragment, FragmentSpread,
         InlineFragment, InputValue, Operation, OperationType, Selection, VariableDefinitions,
+        Type,
     },
     parser::Spanning,
     schema::{
         meta::Argument,
-        model::{AsDynType, DynType},
     },
     validation::{ValidatorContext, Visitor, multi_visitor::MultiVisitorCons},
     value::ScalarValue,
@@ -32,25 +32,23 @@ where
     V: Visitor<'a, S>,
 {
     for def in d {
-        let def_type = match *def {
+        let def_type = match def {
             Definition::Fragment(Spanning {
                 item:
                     Fragment {
                         type_condition: Spanning { item: name, .. },
                         ..
                     },
                 ..
-            }) => Some(DynType::NonNullNamed(name)),
+            }) => Some(Type::named(*name).wrap_non_null()),
             Definition::Operation(Spanning {
                 item:
                     Operation {
                         operation_type: OperationType::Query,
                         ..
                     },
                 ..
-            }) => Some(DynType::NonNullNamed(
-                ctx.schema.concrete_query_type().name().unwrap(),
-            )),
+            }) => Some(ctx.schema.concrete_query_type().as_type()),
             Definition::Operation(Spanning {
                 item:
                     Operation {
@@ -61,7 +59,7 @@ where
             }) => ctx
                 .schema
                 .concrete_mutation_type()
-                .map(|t| DynType::NonNullNamed(t.name().unwrap())),
+                .map(|t| t.as_type()),
             Definition::Operation(Spanning {
                 item:
                     Operation {
@@ -72,10 +70,10 @@ where
             }) => ctx
                 .schema
                 .concrete_subscription_type()
-                .map(|t| DynType::NonNullNamed(t.name().unwrap())),
+                .map(|t| t.as_type()),
         };
 
-        ctx.with_pushed_type(def_type, |ctx| {
+        ctx.with_pushed_type(def_type.as_ref(), |ctx| {
             enter_definition(v, ctx, def);
             visit_definition(v, ctx, def);
             exit_definition(v, ctx, def);
@@ -135,7 +133,7 @@ fn visit_variable_definitions<'a, S, V>(
         for def in defs.item.iter() {
             let var_type = &def.1.var_type.item;
 
-            ctx.with_pushed_input_type(Some(var_type.as_dyn_type()), |ctx| {
+            ctx.with_pushed_input_type(Some(var_type), |ctx| {
                 v.enter_variable_definition(ctx, def);
 
                 if let Some(ref default_value) = def.1.default_value {
@@ -196,8 +194,7 @@ fn visit_arguments<'a, S, V>(
         for argument in arguments.item.iter() {
             let arg_type = meta_args
                 .and_then(|args| args.iter().find(|a| a.name == argument.0.item))
-                .map(|a| &a.arg_type)
-                .map(|t| t.as_dyn_type());
+                .map(|a| &a.arg_type);
 
             ctx.with_pushed_input_type(arg_type, |ctx| {
                 v.enter_argument(ctx, argument);
@@ -256,7 +253,7 @@ fn visit_field<'a, S, V>(
         .parent_type()
         .and_then(|t| t.field_by_name(field.item.name.item));
 
-    let field_type = meta_field.map(|f| f.field_type.as_dyn_type());
+    let field_type = meta_field.map(|f| &f.field_type);
     let field_args = meta_field.and_then(|f| f.arguments.as_ref());
 
     ctx.with_pushed_type(field_type, |ctx| {
@@ -291,7 +288,7 @@ fn visit_fragment_spread<'a, S, V>(
 fn visit_inline_fragment<'a, S, V>(
     v: &mut V,
     ctx: &mut ValidatorContext<'a, S>,
-    fragment: &'a Spanning<InlineFragment<S>>,
+    fragment: &'a Spanning<InlineFragment<'a, S>>,
 ) where
     S: ScalarValue,
     V: Visitor<'a, S>,
@@ -309,7 +306,7 @@ fn visit_inline_fragment<'a, S, V>(
         item: type_name, ..
     }) = fragment.item.type_condition
     {
-        ctx.with_pushed_type(Some(DynType::NonNullNamed(type_name)), visit_fn);
+        ctx.with_pushed_type(Some(&Type::<&str>::named(type_name).wrap_non_null()), visit_fn);
     } else {
         visit_fn(ctx);
     }
@@ -325,20 +322,14 @@ fn visit_input_value<'a, S, V>(
 {
     enter_input_value(v, ctx, input_value);
 
-    match input_value.item {
-        InputValue::Object(ref fields) => {
+    match &input_value.item {
+        InputValue::Object(fields) => {
             for (key, value) in fields {
                 let inner_type = ctx
                     .current_input_type_literal()
-                    .and_then(|t| match t {
-                        DynType::NonNullNamed(name) | DynType::Named(name) => {
-                            ctx.schema.concrete_type_by_name(name)
-                        }
-                        _ => None,
-                    })
+                    .and_then(|t| t.name().and_then(|n| ctx.schema.concrete_type_by_name(n)))
                     .and_then(|ct| ct.input_field_by_name(&key.item))
-                    .map(|f| &f.arg_type)
-                    .map(|t| t.as_dyn_type());
+                    .map(|f| &f.arg_type);
 
                 ctx.with_pushed_input_type(inner_type, |ctx| {
                     v.enter_object_field(ctx, (key.as_ref(), value.as_ref()));
@@ -347,13 +338,8 @@ fn visit_input_value<'a, S, V>(
                 })
             }
         }
-        InputValue::List(ref ls) => {
-            let inner_type = ctx.current_input_type_literal().and_then(|t| match t {
-                DynType::List(inner, _) | DynType::NonNullList(inner, _) => {
-                    Some(inner.as_dyn_type())
-                }
-                _ => None,
-            });
+        InputValue::List(ls) => {
+            let inner_type = ctx.current_input_type_literal().and_then(|t| t.list_inner_borrowed());
 
             ctx.with_pushed_input_type(inner_type, |ctx| {
                 for value in ls {
