Fix additional clippy warnings

Author: ishitatsuyuki

src/future/join_all.rs

@@ -1,4 +1,4 @@
-//! Definition of the JoinAll combinator, waiting for all of a list of futures
+//! Definition of the `JoinAll` combinator, waiting for all of a list of futures
 //! to finish.
 
 use std::prelude::v1::*;
@@ -94,8 +94,8 @@ impl<I> Future for JoinAll<I>
         let mut all_done = true;
 
         for idx in 0 .. self.elems.len() {
-            let done_val = match &mut self.elems[idx] {
-                &mut ElemState::Pending(ref mut t) => {
+            let done_val = match self.elems[idx] {
+                ElemState::Pending(ref mut t) => {
                     match t.poll() {
                         Ok(Async::Ready(v)) => Ok(v),
                         Ok(Async::NotReady) => {
@@ -105,7 +105,7 @@ impl<I> Future for JoinAll<I>
                         Err(e) => Err(e),
                     }
                 }
-                &mut ElemState::Done(ref mut _v) => continue,
+                ElemState::Done(ref mut _v) => continue,
             };
 
             match done_val {

src/future/select2.rs

@@ -23,10 +23,10 @@ impl<A, B> Future for Select2<A, B> where A: Future, B: Future {
         let (mut a, mut b) = self.inner.take().expect("cannot poll Select2 twice");
         match a.poll() {
             Err(e) => Err(Either::A((e, b))),
-            Ok(Async::Ready(x)) => Ok(Async::Ready((Either::A((x, b))))),
+            Ok(Async::Ready(x)) => Ok(Async::Ready(Either::A((x, b)))),
             Ok(Async::NotReady) => match b.poll() {
                 Err(e) => Err(Either::B((e, a))),
-                Ok(Async::Ready(x)) => Ok(Async::Ready((Either::B((x, a))))),
+                Ok(Async::Ready(x)) => Ok(Async::Ready(Either::B((x, a)))),
                 Ok(Async::NotReady) => {
                     self.inner = Some((a, b));
                     Ok(Async::NotReady)

src/future/select_all.rs

@@ -1,4 +1,4 @@
-//! Definition of the SelectAll, finding the first future in a list that
+//! Definition of the `SelectAll`, finding the first future in a list that
 //! finishes.
 
 use std::mem;

src/future/shared.rs

@@ -25,7 +25,7 @@ use std::sync::atomic::Ordering::SeqCst;
 use std::collections::HashMap;
 
 /// A future that is cloneable and can be polled in multiple threads.
-/// Use Future::shared() method to convert any future into a `Shared` future.
+/// Use `Future::shared()` method to convert any future into a `Shared` future.
 #[must_use = "futures do nothing unless polled"]
 pub struct Shared<F: Future> {
     inner: Arc<Inner<F>>,

src/sink/send.rs

@@ -45,7 +45,7 @@ impl<S: Sink> Future for Send<S> {
         if let Some(item) = self.item.take() {
             if let AsyncSink::NotReady(item) = try!(self.sink_mut().start_send(item)) {
                 self.item = Some(item);
-                return Ok(Async::NotReady)
+                return Ok(Async::NotReady);
             }
         }
 
@@ -54,6 +54,6 @@ impl<S: Sink> Future for Send<S> {
         try_ready!(self.sink_mut().poll_complete());
 
         // now everything's emptied, so return the sink for further use
-        return Ok(Async::Ready(self.take_sink()))
+        Ok(Async::Ready(self.take_sink()))
     }
 }

src/sink/send_all.rs

@@ -43,7 +43,7 @@ impl<T, U> SendAll<T, U>
             .expect("Attempted to poll Forward after completion");
         let fuse = self.stream.take()
             .expect("Attempted to poll Forward after completion");
-        return (sink, fuse.into_inner());
+        (sink, fuse.into_inner())
     }
 
     fn try_start_send(&mut self, item: U::Item) -> Poll<(), T::SinkError> {

src/stream/buffered.rs

@@ -133,7 +133,7 @@ impl<S> Stream for Buffered<S>
         }
 
         // Next, try and step all the futures forward
-        for future in self.futures.iter_mut() {
+        for future in &mut self.futures {
             let result = match *future {
                 State::Running(ref mut s) => {
                     match s.poll() {

src/stream/forward.rs

@@ -45,7 +45,7 @@ impl<T, U> Forward<T, U>
             .expect("Attempted to poll Forward after completion");
         let fuse = self.stream.take()
             .expect("Attempted to poll Forward after completion");
-        return (fuse.into_inner(), sink)
+        (fuse.into_inner(), sink)
     }
 
     fn try_start_send(&mut self, item: T::Item) -> Poll<(), U::SinkError> {

src/stream/select.rs

@@ -55,11 +55,10 @@ impl<S1, S2> Stream for Select<S1, S2>
                 if !a_done {
                     self.flag = !self.flag;
                 }
-                return Ok(Some(item).into())
+                Ok(Some(item).into())
             }
             Async::Ready(None) if a_done => Ok(None.into()),
-            Async::Ready(None) => Ok(Async::NotReady),
-            Async::NotReady => Ok(Async::NotReady),
+            Async::Ready(None) | Async::NotReady => Ok(Async::NotReady),
         }
     }
 }

src/stream/zip.rs

@@ -35,16 +35,14 @@ impl<S1, S2> Stream for Zip<S1, S2>
     fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
         if self.queued1.is_none() {
             match try!(self.stream1.poll()) {
-                Async::NotReady => {}
                 Async::Ready(Some(item1)) => self.queued1 = Some(item1),
-                Async::Ready(None) => {}
+                Async::Ready(None) | Async::NotReady => {}
             }
         }
         if self.queued2.is_none() {
             match try!(self.stream2.poll()) {
-                Async::NotReady => {}
                 Async::Ready(Some(item2)) => self.queued2 = Some(item2),
-                Async::Ready(None) => {}
+                Async::Ready(None) | Async::NotReady => {}
             }
         }