fixes clippy

Author: dotansimha

src/validation/rules/unique_variable_names.rs

@@ -63,14 +63,14 @@ impl<'v> ValidationRule for UniqueVariableNames<'v> {
         "UniqueVariableNames"
     }
 
-    fn validate<'a>(
+    fn validate(
         &self,
-        ctx: &'a mut OperationVisitorContext,
+        ctx: &mut OperationVisitorContext,
         error_collector: &mut ValidationErrorContext,
     ) {
         visit_document(
             &mut UniqueVariableNames::new(),
-            &ctx.operation,
+            ctx.operation,
             ctx,
             error_collector,
         );

src/validation/rules/values_of_correct_type.rs

@@ -14,6 +14,7 @@ use crate::{
 
 use super::ValidationRule;
 
+#[derive(Default)]
 pub struct ValuesOfCorrectType {}
 
 impl ValuesOfCorrectType {
@@ -22,10 +23,7 @@ impl ValuesOfCorrectType {
     }
 
     pub fn is_custom_scalar(&self, type_name: &str) -> bool {
-        match type_name {
-            "String" | "Int" | "Float" | "Boolean" | "ID" => false,
-            _ => true,
-        }
+        !matches!(type_name, "String" | "Int" | "Float" | "Boolean" | "ID")
     }
 
     pub fn validate_value(
@@ -37,7 +35,7 @@ impl ValuesOfCorrectType {
         if let Some(input_type) = visitor_context.current_input_type_literal() {
             let named_type = input_type.inner_type();
 
-            if let Some(type_def) = visitor_context.schema.type_by_name(&named_type) {
+            if let Some(type_def) = visitor_context.schema.type_by_name(named_type) {
                 if !type_def.is_leaf_type() {
                     user_context.report_error(ValidationError {
                         error_code: self.error_code(),
@@ -78,12 +76,7 @@ impl ValuesOfCorrectType {
                 if let TypeDefinition::Enum(enum_type_def) = &type_def {
                     match raw_value {
                         Value::Enum(enum_value) => {
-                            if enum_type_def
-                                .values
-                                .iter()
-                                .find(|v| v.name.eq(enum_value))
-                                .is_none()
-                            {
+                            if enum_type_def.values.iter().any(|v| v.name.eq(enum_value)) {
                                 user_context.report_error(ValidationError {
                                     error_code: self.error_code(),
                                     message: format!(
@@ -193,14 +186,14 @@ impl ValidationRule for ValuesOfCorrectType {
         "ValuesOfCorrectType"
     }
 
-    fn validate<'a>(
+    fn validate(
         &self,
-        ctx: &'a mut OperationVisitorContext,
+        ctx: &mut OperationVisitorContext,
         error_collector: &mut ValidationErrorContext,
     ) {
         visit_document(
             &mut ValuesOfCorrectType::new(),
-            &ctx.operation,
+            ctx.operation,
             ctx,
             error_collector,
         );

src/validation/rules/variables_are_input_types.rs

@@ -12,6 +12,7 @@ use crate::validation::utils::ValidationErrorContext;
 /// input types (scalar, enum, or input object).
 ///
 /// See https://spec.graphql.org/draft/#sec-Variables-Are-Input-Types
+#[derive(Default)]
 pub struct VariablesAreInputTypes;
 
 impl VariablesAreInputTypes {
@@ -29,7 +30,7 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for VariablesAreInputTypes
     ) {
         if let Some(var_schema_type) = context
             .schema
-            .type_by_name(&variable_definition.var_type.inner_type())
+            .type_by_name(variable_definition.var_type.inner_type())
         {
             if !var_schema_type.is_input_type() {
                 user_context.report_error(ValidationError {
@@ -50,14 +51,14 @@ impl ValidationRule for VariablesAreInputTypes {
         "VariablesAreInputTypes"
     }
 
-    fn validate<'a>(
+    fn validate(
         &self,
-        ctx: &'a mut OperationVisitorContext,
+        ctx: &mut OperationVisitorContext,
         error_collector: &mut ValidationErrorContext,
     ) {
         visit_document(
             &mut VariablesAreInputTypes::new(),
-            &ctx.operation,
+            ctx.operation,
             ctx,
             error_collector,
         );

src/validation/rules/variables_in_allowed_position.rs

@@ -16,6 +16,7 @@ use super::ValidationRule;
 /// Variable usages must be compatible with the arguments they are passed to.
 ///
 /// See https://spec.graphql.org/draft/#sec-All-Variable-Usages-are-Allowed
+#[derive(Default)]
 pub struct VariablesInAllowedPosition<'a> {
     spreads: HashMap<Scope<'a>, HashSet<&'a str>>,
     variable_usages: HashMap<Scope<'a>, Vec<(&'a str, &'a Type)>>,
@@ -49,8 +50,7 @@ impl<'a> VariablesInAllowedPosition<'a> {
 
         if let Some(usages) = self.variable_usages.get(from) {
             for (var_name, var_type) in usages {
-                if let Some(ref var_def) = var_defs.iter().find(|var_def| var_def.name == *var_name)
-                {
+                if let Some(var_def) = var_defs.iter().find(|var_def| var_def.name == *var_name) {
                     let expected_type = match (&var_def.default_value, &var_def.var_type) {
                         (Some(_), Type::ListType(inner)) => Type::NonNullType(inner.clone()),
                         (Some(default_value), Type::NamedType(_)) => {
@@ -143,7 +143,7 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for VariablesInAllowedPosi
         if let Some(scope) = &self.current_scope {
             self.spreads
                 .entry(scope.clone())
-                .or_insert_with(HashSet::new)
+                .or_default()
                 .insert(&fragment_spread.fragment_name);
         }
     }
@@ -158,7 +158,7 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for VariablesInAllowedPosi
             self.variable_defs
                 .entry(scope.clone())
                 .or_default()
-                .push(&variable_definition);
+                .push(variable_definition);
         }
     }
 
@@ -168,13 +168,13 @@ impl<'a> OperationVisitor<'a, ValidationErrorContext> for VariablesInAllowedPosi
         _: &mut ValidationErrorContext,
         variable_name: &'a str,
     ) {
-        if let (&Some(ref scope), Some(input_type)) = (
+        if let (Some(scope), Some(input_type)) = (
             &self.current_scope,
             visitor_context.current_input_type_literal(),
         ) {
             self.variable_usages
                 .entry(scope.clone())
-                .or_insert_with(Vec::new)
+                .or_default()
                 .push((variable_name, input_type));
         }
     }
@@ -185,14 +185,14 @@ impl<'v> ValidationRule for VariablesInAllowedPosition<'v> {
         "VariablesInAllowedPosition"
     }
 
-    fn validate<'a>(
+    fn validate(
         &self,
-        ctx: &'a mut OperationVisitorContext,
+        ctx: &mut OperationVisitorContext,
         error_collector: &mut ValidationErrorContext,
     ) {
         visit_document(
             &mut VariablesInAllowedPosition::new(),
-            &ctx.operation,
+            ctx.operation,
             ctx,
             error_collector,
         );

src/validation/utils.rs

@@ -4,7 +4,7 @@ use serde::{Serialize, Serializer};
 use serde_with::{serde_as, SerializeAs};
 use std::fmt::Debug;
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct ValidationErrorContext {
     pub errors: Vec<ValidationError>,
 }

src/validation/validate.rs

@@ -26,6 +26,12 @@ impl ValidationPlan {
     }
 }
 
+impl Default for ValidationPlan {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 pub fn validate<'a>(
     schema: &'a schema::Document,
     operation: &'a query::Document,