Remove paste from definition rule composition

bluejay-validator/Cargo.toml

@@ -13,7 +13,6 @@ description = "A GraphQL validator"
 [dependencies]
 bluejay-core = { workspace = true }
 bluejay-parser = { workspace = true, optional = true, features = ["format-errors"] }
-paste = "1.0"
 itertools = "0.15.0"
 serde_json = { version = "1.0", optional = true }
 seq-macro = "0.3.5"

bluejay-validator/src/definition/rule.rs

@@ -1,8 +1,28 @@
 use crate::definition::Visitor;
 use bluejay_core::definition::SchemaDefinition;
 
-pub trait Rule<'a, S: SchemaDefinition>: Visitor<'a, S> + IntoIterator<Item = Self::Error> {
+pub trait Rule<'a, S: SchemaDefinition>: Visitor<'a, S> {
     type Error;
+    type Errors: Iterator<Item = Self::Error>;
 
-    fn new(schema_definition: &'a S) -> Self;
+    fn into_errors(self) -> Self::Errors;
 }
+
+macro_rules! impl_rule {
+    ($n:literal) => {
+        seq_macro::seq!(N in 0..$n {
+            impl<'a, S: SchemaDefinition, ER, #(T~N: Rule<'a, S, Error = ER>,)*> Rule<'a, S> for (#(T~N,)*) {
+                type Error = ER;
+                type Errors = #(std::iter::Chain<)* std::iter::Empty<ER> #(, <T~N as Rule<'a, S>>::Errors>)*;
+
+                fn into_errors(self) -> Self::Errors {
+                    std::iter::empty() #(.chain(self.N.into_errors()))*
+                }
+            }
+        });
+    }
+}
+
+seq_macro::seq!(N in 2..=10 {
+    impl_rule!(N);
+});

bluejay-validator/src/definition/rules.rs

@@ -6,52 +6,8 @@ pub use enum_value_definition_uniqueness::EnumValueDefinitionUniqueness;
 pub use input_field_definition_uniqueness::InputFieldDefinitionUniqueness;
 pub use input_object_circular_references::InputObjectCircularReferences;
 
-#[macro_export]
-macro_rules! combine_definition_rules {
-    ( $name:ty, $err:ty, [$( $rule:ty ),* $(,)?] $(,)? ) => {
-        paste::paste! {
-            pub struct $name<'a, S: bluejay_core::definition::SchemaDefinition> {
-                $([<$rule:snake>]: $rule<'a, S>,)*
-            }
-
-            impl<'a, S: bluejay_core::definition::SchemaDefinition + 'a> $crate::definition::Rule<'a, S> for $name<'a, S> {
-                type Error = $err<'a, S>;
-
-                fn new(schema_definition: &'a S) -> Self {
-                    Self {
-                        $([<$rule:snake>]: $rule::new(schema_definition),)*
-                    }
-                }
-            }
-
-            impl<'a, S: bluejay_core::definition::SchemaDefinition + 'a> IntoIterator for $name<'a, S> {
-                type Item = $err<'a, S>;
-                type IntoIter = $crate::chain_types!($(std::iter::Map<<$rule<'a, S> as IntoIterator>::IntoIter, fn(<$rule<'a, S> as $crate::definition::Rule<'a, S>>::Error) -> $err<'a, S>>),*);
-
-                fn into_iter(self) -> Self::IntoIter {
-                    $crate::chain_iters!($(self.[<$rule:snake>].into_iter().map(Into::into as fn(<$rule<'a, S> as $crate::definition::Rule<'a, S>>::Error) -> $err<'a, S>)),*)
-                }
-            }
-
-            impl<'a, S: bluejay_core::definition::SchemaDefinition> $crate::definition::Visitor<'a, S> for $name<'a, S> {
-                fn visit_input_object_type_definition(&mut self, input_object_type_definition: &'a S::InputObjectTypeDefinition) {
-                    $(self.[<$rule:snake>].visit_input_object_type_definition(input_object_type_definition);)*
-                }
-
-                fn visit_enum_type_definition(&mut self, enum_type_definition: &'a S::EnumTypeDefinition) {
-                    $(self.[<$rule:snake>].visit_enum_type_definition(enum_type_definition);)*
-                }
-            }
-        }
-    };
-}
-
-combine_definition_rules!(
-    BuiltinRules,
-    crate::definition::Error,
-    [
-        EnumValueDefinitionUniqueness,
-        InputFieldDefinitionUniqueness,
-        InputObjectCircularReferences,
-    ],
+pub type BuiltinRules<'a, S> = (
+    EnumValueDefinitionUniqueness<'a, S>,
+    InputFieldDefinitionUniqueness<'a, S>,
+    InputObjectCircularReferences<'a, S>,
 );

bluejay-validator/src/definition/rules/enum_value_definition_uniqueness.rs

@@ -8,6 +8,10 @@ pub struct EnumValueDefinitionUniqueness<'a, S: SchemaDefinition + 'a> {
 }
 
 impl<'a, S: SchemaDefinition> Visitor<'a, S> for EnumValueDefinitionUniqueness<'a, S> {
+    fn new(_: &'a S) -> Self {
+        Self { errors: Vec::new() }
+    }
+
     fn visit_enum_type_definition(
         &mut self,
         enum_type_definition: &'a <S as SchemaDefinition>::EnumTypeDefinition,
@@ -27,19 +31,11 @@ impl<'a, S: SchemaDefinition> Visitor<'a, S> for EnumValueDefinitionUniqueness<'
     }
 }
 
-impl<'a, S: SchemaDefinition> IntoIterator for EnumValueDefinitionUniqueness<'a, S> {
-    type Item = Error<'a, S>;
-    type IntoIter = std::vec::IntoIter<Error<'a, S>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.errors.into_iter()
-    }
-}
-
 impl<'a, S: SchemaDefinition> Rule<'a, S> for EnumValueDefinitionUniqueness<'a, S> {
     type Error = Error<'a, S>;
+    type Errors = std::vec::IntoIter<Error<'a, S>>;
 
-    fn new(_: &'a S) -> Self {
-        Self { errors: Vec::new() }
+    fn into_errors(self) -> Self::Errors {
+        self.errors.into_iter()
     }
 }

bluejay-validator/src/definition/rules/input_field_definition_uniqueness.rs

@@ -8,6 +8,10 @@ pub struct InputFieldDefinitionUniqueness<'a, S: SchemaDefinition + 'a> {
 }
 
 impl<'a, S: SchemaDefinition> Visitor<'a, S> for InputFieldDefinitionUniqueness<'a, S> {
+    fn new(_: &'a S) -> Self {
+        Self { errors: Vec::new() }
+    }
+
     fn visit_input_object_type_definition(
         &mut self,
         input_object_type_definition: &'a <S as SchemaDefinition>::InputObjectTypeDefinition,
@@ -29,19 +33,11 @@ impl<'a, S: SchemaDefinition> Visitor<'a, S> for InputFieldDefinitionUniqueness<
     }
 }
 
-impl<'a, S: SchemaDefinition> IntoIterator for InputFieldDefinitionUniqueness<'a, S> {
-    type Item = Error<'a, S>;
-    type IntoIter = std::vec::IntoIter<Error<'a, S>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.errors.into_iter()
-    }
-}
-
 impl<'a, S: SchemaDefinition> Rule<'a, S> for InputFieldDefinitionUniqueness<'a, S> {
     type Error = Error<'a, S>;
+    type Errors = std::vec::IntoIter<Error<'a, S>>;
 
-    fn new(_: &'a S) -> Self {
-        Self { errors: Vec::new() }
+    fn into_errors(self) -> Self::Errors {
+        self.errors.into_iter()
     }
 }

bluejay-validator/src/definition/rules/input_object_circular_references.rs

@@ -12,6 +12,13 @@ pub struct InputObjectCircularReferences<'a, S: SchemaDefinition + 'a> {
 }
 
 impl<'a, S: SchemaDefinition> Visitor<'a, S> for InputObjectCircularReferences<'a, S> {
+    fn new(schema_definition: &'a S) -> Self {
+        Self {
+            schema_definition,
+            errors: Vec::new(),
+        }
+    }
+
     fn visit_input_object_type_definition(
         &mut self,
         input_object_type_definition: &'a <S as SchemaDefinition>::InputObjectTypeDefinition,
@@ -66,22 +73,11 @@ impl<'a, S: SchemaDefinition + 'a> InputObjectCircularReferences<'a, S> {
     }
 }
 
-impl<'a, S: SchemaDefinition> IntoIterator for InputObjectCircularReferences<'a, S> {
-    type Item = Error<'a, S>;
-    type IntoIter = std::vec::IntoIter<Error<'a, S>>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.errors.into_iter()
-    }
-}
-
 impl<'a, S: SchemaDefinition> Rule<'a, S> for InputObjectCircularReferences<'a, S> {
     type Error = Error<'a, S>;
+    type Errors = std::vec::IntoIter<Error<'a, S>>;
 
-    fn new(schema_definition: &'a S) -> Self {
-        Self {
-            schema_definition,
-            errors: Vec::new(),
-        }
+    fn into_errors(self) -> Self::Errors {
+        self.errors.into_iter()
     }
 }

bluejay-validator/src/definition/validator.rs

@@ -1,4 +1,4 @@
-use crate::definition::{BuiltinRules, Rule};
+use crate::definition::{BuiltinRules, Rule, Visitor};
 use bluejay_core::definition::{SchemaDefinition, TypeDefinitionReference};
 
 pub struct Validator<'a, S: SchemaDefinition, R: Rule<'a, S>> {
@@ -12,7 +12,7 @@ impl<'a, S: SchemaDefinition, R: Rule<'a, S>> Validator<'a, S, R> {
     fn new(schema_definition: &'a S) -> Self {
         Self {
             schema_definition,
-            rule: Rule::new(schema_definition),
+            rule: Visitor::new(schema_definition),
         }
     }
 
@@ -49,9 +49,9 @@ impl<'a, S: SchemaDefinition, R: Rule<'a, S>> Validator<'a, S, R> {
 
 impl<'a, S: SchemaDefinition, R: Rule<'a, S>> IntoIterator for Validator<'a, S, R> {
     type Item = R::Error;
-    type IntoIter = <R as IntoIterator>::IntoIter;
+    type IntoIter = R::Errors;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.rule.into_iter()
+        self.rule.into_errors()
     }
 }

bluejay-validator/src/definition/visitor.rs

@@ -1,6 +1,8 @@
 use bluejay_core::definition::SchemaDefinition;
 
 pub trait Visitor<'a, S: SchemaDefinition> {
+    fn new(schema_definition: &'a S) -> Self;
+
     fn visit_input_object_type_definition(
         &mut self,
         _input_object_type_definition: &'a S::InputObjectTypeDefinition,
@@ -9,3 +11,34 @@ pub trait Visitor<'a, S: SchemaDefinition> {
 
     fn visit_enum_type_definition(&mut self, _enum_type_definition: &'a S::EnumTypeDefinition) {}
 }
+
+macro_rules! impl_visitor {
+    ($n:literal) => {
+        seq_macro::seq!(N in 0..$n {
+            #[warn(clippy::missing_trait_methods)]
+            impl<'a, S: SchemaDefinition, #(T~N: Visitor<'a, S>,)*> Visitor<'a, S> for (#(T~N,)*) {
+                fn new(schema_definition: &'a S) -> Self {
+                    (#(T~N::new(schema_definition),)*)
+                }
+
+                fn visit_input_object_type_definition(
+                    &mut self,
+                    input_object_type_definition: &'a S::InputObjectTypeDefinition,
+                ) {
+                    #(self.N.visit_input_object_type_definition(input_object_type_definition);)*
+                }
+
+                fn visit_enum_type_definition(
+                    &mut self,
+                    enum_type_definition: &'a S::EnumTypeDefinition,
+                ) {
+                    #(self.N.visit_enum_type_definition(enum_type_definition);)*
+                }
+            }
+        });
+    }
+}
+
+seq_macro::seq!(N in 2..=10 {
+    impl_visitor!(N);
+});

bluejay-validator/src/lib.rs

@@ -1,4 +1,3 @@
-mod chain_iters;
 pub mod definition;
 pub mod executable;
 mod path;