Minor clippy and rustfmt fixes

Author: weiznich

src/run_query_dsl/mod.rs

@@ -135,6 +135,7 @@ pub mod methods {
         }
     }
 
+    #[allow(clippy::type_complexity)]
     fn map_result_stream_future<'s, 'a, U, S, R, DB, ST>(
         stream: S,
     ) -> futures::stream::Map<S, fn(QueryResult<R>) -> QueryResult<U>>
@@ -401,8 +402,7 @@ pub trait RunQueryDsl<Conn>: Sized {
         // this function pointer
 
         let f = collect_result::<U, _> as _;
-        let r = load_future.and_then(f);
-        r
+        load_future.and_then(f)
     }
 
     /// Executes the given query, returning a [`Stream`] with the returned rows.
@@ -593,6 +593,7 @@ pub trait RunQueryDsl<Conn>: Sized {
         Conn: AsyncConnection,
         Self: methods::LoadQuery<'query, Conn, U> + 'query,
     {
+        #[allow(clippy::type_complexity)]
         fn get_next_stream_element<S, U>(
             stream: S,
         ) -> futures::future::Map<
@@ -613,8 +614,7 @@ pub trait RunQueryDsl<Conn>: Sized {
 
             let stream = Box::pin(stream);
             let f = map_option_to_result as _;
-            let s = stream.into_future().map(f);
-            s
+            stream.into_future().map(f)
         }
         let f = get_next_stream_element as _;
         self.load_stream(conn).and_then(f)

src/stmt_cache.rs

@@ -13,6 +13,11 @@ pub struct StmtCache<DB: Backend, S> {
     cache: HashMap<StatementCacheKey<DB>, S>,
 }
 
+type PrepareFuture<'a, F, S> = futures::future::Either<
+    futures::future::Ready<QueryResult<(MaybeCached<'a, S>, F)>>,
+    BoxFuture<'a, QueryResult<(MaybeCached<'a, S>, F)>>,
+>;
+
 #[async_trait::async_trait]
 pub trait PrepareCallback<S, M> {
     async fn prepare(
@@ -38,21 +43,18 @@ impl<S, DB: Backend> StmtCache<DB, S> {
         metadata: &[DB::TypeMetadata],
         prepare_fn: F,
         backend: &DB,
-    ) -> futures::future::Either<
-        futures::future::Ready<QueryResult<(MaybeCached<'a, S>, F)>>,
-        BoxFuture<'a, QueryResult<(MaybeCached<'a, S>, F)>>,
-    >
+    ) -> PrepareFuture<'a, F, S>
     where
         S: Send,
         DB::QueryBuilder: Default,
         DB::TypeMetadata: Clone + Send + Sync,
         T: QueryFragment<DB> + QueryId + Send,
-        F: PrepareCallback<S, DB::TypeMetadata> + Send  + 'a,
+        F: PrepareCallback<S, DB::TypeMetadata> + Send + 'a,
         StatementCacheKey<DB>: Hash + Eq,
     {
         use std::collections::hash_map::Entry::{Occupied, Vacant};
 
-        let cache_key = match StatementCacheKey::for_source(&query, &metadata, backend) {
+        let cache_key = match StatementCacheKey::for_source(&query, metadata, backend) {
             Ok(key) => key,
             Err(e) => return futures::future::Either::Left(futures::future::ready(Err(e))),
         };
@@ -80,9 +82,10 @@ impl<S, DB: Backend> StmtCache<DB, S> {
         }
 
         match self.cache.entry(cache_key) {
-            Occupied(entry) => futures::future::Either::Left(futures::future::ready(Ok(
-                (MaybeCached::Cached(entry.into_mut()), prepare_fn)
-            ))),
+            Occupied(entry) => futures::future::Either::Left(futures::future::ready(Ok((
+                MaybeCached::Cached(entry.into_mut()),
+                prepare_fn,
+            )))),
             Vacant(entry) => {
                 let sql = match entry.key().sql(&query, backend) {
                     Ok(sql) => sql.into_owned(),