Make Clippy almost happy on latest Rust

Author: tyranron

juniper/src/ast.rs

@@ -146,7 +146,9 @@ pub enum Definition<'a, S> {
 }
 
 #[doc(hidden)]
-pub type Document<'a, S> = Vec<Definition<'a, S>>;
+pub type Document<'a, S> = [Definition<'a, S>];
+#[doc(hidden)]
+pub type OwnedDocument<'a, S> = Vec<Definition<'a, S>>;
 
 /// Parse an unstructured input value into a Rust data type.
 ///
@@ -381,7 +383,7 @@ where
     ///
     /// This constructs a new IndexMap that contain references to the keys
     /// and values in `self`.
-    pub fn to_object_value<'a>(&'a self) -> Option<IndexMap<&'a str, &'a Self>> {
+    pub fn to_object_value(&self) -> Option<IndexMap<&str, &Self>> {
         match *self {
             InputValue::Object(ref o) => Some(
                 o.iter()

juniper/src/executor/look_ahead.rs

@@ -440,15 +440,15 @@ impl<'a, S> LookAheadMethods<'a, S> for LookAheadSelection<'a, S> {
 mod tests {
     use super::*;
     use crate::{
-        ast::Document,
+        ast::{Document, OwnedDocument},
         parser::UnlocatedParseResult,
         schema::model::SchemaType,
         validation::test_harness::{MutationRoot, QueryRoot, SubscriptionRoot},
         value::{DefaultScalarValue, ScalarValue},
     };
     use std::collections::HashMap;
 
-    fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<Document<S>>
+    fn parse_document_source<S>(q: &str) -> UnlocatedParseResult<OwnedDocument<S>>
     where
         S: ScalarValue,
     {

juniper/src/executor/mod.rs

@@ -326,6 +326,7 @@ where
 {
     type Type = T;
 
+    #[allow(clippy::type_complexity)]
     fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S> {
         Ok(self.map(|(ctx, v)| (ctx, Some(v))))
     }
@@ -353,6 +354,7 @@ where
 {
     type Type = T;
 
+    #[allow(clippy::type_complexity)]
     fn into(self, _: &'a C) -> FieldResult<Option<(&'a T::Context, Option<T>)>, S2> {
         self.map(|o| o.map(|(ctx, v)| (ctx, Some(v))))
             .map_err(FieldError::map_scalar_value)

juniper/src/executor/owned_executor.rs

@@ -112,16 +112,8 @@ where
         Executor {
             fragments: &self.fragments,
             variables: &self.variables,
-            current_selection_set: if let Some(s) = &self.current_selection_set {
-                Some(&s[..])
-            } else {
-                None
-            },
-            parent_selection_set: if let Some(s) = &self.parent_selection_set {
-                Some(&s[..])
-            } else {
-                None
-            },
+            current_selection_set: self.current_selection_set.as_deref(),
+            parent_selection_set: self.parent_selection_set.as_deref(),
             current_type: self.current_type.clone(),
             schema: self.schema,
             context: self.context,

juniper/src/lib.rs

@@ -319,7 +319,7 @@ where
     SubscriptionT::TypeInfo: Sync,
     S: ScalarValue + Send + Sync,
 {
-    let document: crate::ast::Document<'a, S> =
+    let document: crate::ast::OwnedDocument<'a, S> =
         parse_document_source(document_source, &root_node.schema)?;
 
     {

juniper/src/parser/document.rs

@@ -1,8 +1,9 @@
 use std::borrow::Cow;
 
 use crate::ast::{
-    Arguments, Definition, Directive, Document, Field, Fragment, FragmentSpread, InlineFragment,
-    InputValue, Operation, OperationType, Selection, Type, VariableDefinition, VariableDefinitions,
+    Arguments, Definition, Directive, Field, Fragment, FragmentSpread, InlineFragment, InputValue,
+    Operation, OperationType, OwnedDocument, Selection, Type, VariableDefinition,
+    VariableDefinitions,
 };
 
 use crate::{
@@ -21,7 +22,7 @@ use crate::{
 pub fn parse_document_source<'a, 'b, S>(
     s: &'a str,
     schema: &'b SchemaType<'b, S>,
-) -> UnlocatedParseResult<'a, Document<'a, S>>
+) -> UnlocatedParseResult<'a, OwnedDocument<'a, S>>
 where
     S: ScalarValue,
 {
@@ -33,7 +34,7 @@ where
 fn parse_document<'a, 'b, S>(
     parser: &mut Parser<'a>,
     schema: &'b SchemaType<'b, S>,
-) -> UnlocatedParseResult<'a, Document<'a, S>>
+) -> UnlocatedParseResult<'a, OwnedDocument<'a, S>>
 where
     S: ScalarValue,
 {

juniper/src/parser/tests/document.rs

@@ -1,6 +1,7 @@
 use crate::{
     ast::{
-        Arguments, Definition, Document, Field, InputValue, Operation, OperationType, Selection,
+        Arguments, Definition, Field, InputValue, Operation, OperationType, OwnedDocument,
+        Selection,
     },
     parser::{document::parse_document_source, ParseError, SourcePosition, Spanning, Token},
     schema::model::SchemaType,
@@ -9,7 +10,7 @@ use crate::{
     value::{DefaultScalarValue, ScalarValue},
 };
 
-fn parse_document<S>(s: &str) -> Document<S>
+fn parse_document<S>(s: &str) -> OwnedDocument<S>
 where
     S: ScalarValue,
 {

juniper/src/schema/model.rs

@@ -293,14 +293,10 @@ impl<'a, S> SchemaType<'a, S> {
 
     /// Get the mutation type from the schema.
     pub fn mutation_type(&self) -> Option<TypeType<S>> {
-        if let Some(ref mutation_type_name) = self.mutation_type_name {
-            Some(
-                self.type_by_name(mutation_type_name)
-                    .expect("Mutation type does not exist in schema"),
-            )
-        } else {
-            None
-        }
+        self.mutation_type_name.as_ref().map(|name| {
+            self.type_by_name(name)
+                .expect("Mutation type does not exist in schema")
+        })
     }
 
     /// Get the concrete mutation type from the schema.
@@ -313,14 +309,10 @@ impl<'a, S> SchemaType<'a, S> {
 
     /// Get the subscription type.
     pub fn subscription_type(&self) -> Option<TypeType<S>> {
-        if let Some(ref subscription_type_name) = self.subscription_type_name {
-            Some(
-                self.type_by_name(subscription_type_name)
-                    .expect("Subscription type does not exist in schema"),
-            )
-        } else {
-            None
-        }
+        self.subscription_type_name.as_ref().map(|name| {
+            self.type_by_name(name)
+                .expect("Subscription type does not exist in schema")
+        })
     }
 
     /// Get the concrete subscription type.

juniper/src/types/containers.rs

@@ -299,16 +299,16 @@ where
     S: ScalarValue + Send + Sync,
 {
     use futures::stream::{FuturesOrdered, StreamExt as _};
-    use std::iter::FromIterator;
 
     let stop_on_null = executor
         .current_type()
         .list_contents()
         .expect("Current type is not a list type")
         .is_non_null();
 
-    let iter = items.map(|it| async move { executor.resolve_into_value_async(info, it).await });
-    let mut futures = FuturesOrdered::from_iter(iter);
+    let mut futures = items
+        .map(|it| async move { executor.resolve_into_value_async(info, it).await })
+        .collect::<FuturesOrdered<_>>();
 
     let mut values = Vec::with_capacity(futures.len());
     while let Some(value) = futures.next().await {

juniper/src/types/pointers.rs

@@ -94,10 +94,7 @@ where
     T: FromInputValue<S>,
 {
     fn from_input_value(v: &InputValue<S>) -> Option<Box<T>> {
-        match <T as FromInputValue<S>>::from_input_value(v) {
-            Some(v) => Some(Box::new(v)),
-            None => None,
-        }
+        <T as FromInputValue<S>>::from_input_value(v).map(Box::new)
     }
 }
 
@@ -289,10 +286,7 @@ where
     T: FromInputValue<S>,
 {
     fn from_input_value(v: &InputValue<S>) -> Option<Arc<T>> {
-        match <T as FromInputValue<S>>::from_input_value(v) {
-            Some(v) => Some(Arc::new(v)),
-            None => None,
-        }
+        <T as FromInputValue<S>>::from_input_value(v).map(Arc::new)
     }
 }
 

juniper/src/validation/multi_visitor.rs

@@ -230,19 +230,11 @@ where
         self.1.exit_list_value(ctx, l);
     }
 
-    fn enter_object_value(
-        &mut self,
-        ctx: &mut ValidatorContext<'a, S>,
-        o: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
+    fn enter_object_value(&mut self, ctx: &mut ValidatorContext<'a, S>, o: SpannedObject<'a, S>) {
         self.0.enter_object_value(ctx, o);
         self.1.enter_object_value(ctx, o);
     }
-    fn exit_object_value(
-        &mut self,
-        ctx: &mut ValidatorContext<'a, S>,
-        o: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
+    fn exit_object_value(&mut self, ctx: &mut ValidatorContext<'a, S>, o: SpannedObject<'a, S>) {
         self.0.exit_object_value(ctx, o);
         self.1.exit_object_value(ctx, o);
     }
@@ -264,3 +256,5 @@ where
         self.1.exit_object_field(ctx, f);
     }
 }
+
+type SpannedObject<'a, S> = Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>;

juniper/src/validation/rules/unique_input_field_names.rs

@@ -21,19 +21,11 @@ impl<'a, S> Visitor<'a, S> for UniqueInputFieldNames<'a>
 where
     S: ScalarValue,
 {
-    fn enter_object_value(
-        &mut self,
-        _: &mut ValidatorContext<'a, S>,
-        _: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
+    fn enter_object_value(&mut self, _: &mut ValidatorContext<'a, S>, _: SpannedObject<'a, S>) {
         self.known_name_stack.push(HashMap::new());
     }
 
-    fn exit_object_value(
-        &mut self,
-        _: &mut ValidatorContext<'a, S>,
-        _: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
+    fn exit_object_value(&mut self, _: &mut ValidatorContext<'a, S>, _: SpannedObject<'a, S>) {
         self.known_name_stack.pop();
     }
 
@@ -58,6 +50,8 @@ where
     }
 }
 
+type SpannedObject<'a, S> = Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>;
+
 fn error_message(field_name: &str) -> String {
     format!("There can only be one input field named \"{}\"", field_name)
 }

juniper/src/validation/test_harness.rs

@@ -865,7 +865,9 @@ where
     let mut ctx = ValidatorContext::new(unsafe { ::std::mem::transmute(&root.schema) }, &doc);
 
     let mut mv = MultiVisitorNil.with(factory());
-    visit(&mut mv, &mut ctx, unsafe { ::std::mem::transmute(&doc) });
+    visit(&mut mv, &mut ctx, unsafe {
+        ::std::mem::transmute(doc.as_slice())
+    });
 
     ctx.into_errors()
 }

juniper/src/validation/traits.rs

@@ -128,18 +128,8 @@ where
     ) {
     }
 
-    fn enter_object_value(
-        &mut self,
-        _: &mut ValidatorContext<'a, S>,
-        _: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
-    }
-    fn exit_object_value(
-        &mut self,
-        _: &mut ValidatorContext<'a, S>,
-        _: Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>,
-    ) {
-    }
+    fn enter_object_value(&mut self, _: &mut ValidatorContext<'a, S>, _: SpannedObject<'a, S>) {}
+    fn exit_object_value(&mut self, _: &mut ValidatorContext<'a, S>, _: SpannedObject<'a, S>) {}
 
     fn enter_object_field(
         &mut self,
@@ -154,3 +144,5 @@ where
     ) {
     }
 }
+
+type SpannedObject<'a, S> = Spanning<&'a Vec<(Spanning<String>, Spanning<InputValue<S>>)>>;

juniper_actix/src/lib.rs

@@ -73,10 +73,7 @@ where
             operation_name,
             variables,
         } = get_req;
-        let variables = match variables {
-            Some(variables) => Some(serde_json::from_str(&variables).unwrap()),
-            None => None,
-        };
+        let variables = variables.map(|s| serde_json::from_str(&s).unwrap());
         Self::new(query, operation_name, variables)
     }
 }