fix clippy lints

Author: tontinton

src/async.rs

@@ -77,7 +77,7 @@ impl<'a, T> Deref for OwnedOrRef<'a, T> {
 
     fn deref(&self) -> &T {
         match self {
-            OwnedOrRef::Owned(arc) => &arc,
+            OwnedOrRef::Owned(arc) => arc,
             OwnedOrRef::Ref(r) => r,
         }
     }
@@ -90,9 +90,9 @@ impl<T> Sender<T> {
     ///
     /// In the current implementation, the returned future will not yield to the async runtime if the
     /// channel is unbounded. This may change in later versions.
-    pub fn send_async(&self, item: T) -> SendFut<T> {
+    pub fn send_async(&self, item: T) -> SendFut<'_, T> {
         SendFut {
-            sender: OwnedOrRef::Ref(&self),
+            sender: OwnedOrRef::Ref(self),
             hook: Some(SendState::NotYetSent(item)),
         }
     }
@@ -117,7 +117,7 @@ impl<T> Sender<T> {
     /// channel is unbounded. This may change in later versions.
     pub fn sink(&self) -> SendSink<'_, T> {
         SendSink(SendFut {
-            sender: OwnedOrRef::Ref(&self),
+            sender: OwnedOrRef::Ref(self),
             hook: None,
         })
     }

src/lib.rs

@@ -400,7 +400,7 @@ impl<T> Hook<T, SyncSignal> {
 
 #[cfg(feature = "spin")]
 #[inline]
-fn wait_lock<T>(lock: &Spinlock<T>) -> SpinlockGuard<T> {
+fn wait_lock<T>(lock: &Spinlock<T>) -> SpinlockGuard<'_, T> {
     // Some targets don't support `thread::sleep` (e.g. the `wasm32-unknown-unknown` target when
     // running in the main thread of a web browser) so we only use it on targets where we know it
     // will work
@@ -975,20 +975,20 @@ impl<T> Receiver<T> {
     /// when all senders have been dropped.
     ///
     /// You can also create a self-owned iterator with [`Receiver::into_iter`].
-    pub fn iter(&self) -> Iter<T> {
-        Iter { receiver: &self }
+    pub fn iter(&self) -> Iter<'_, T> {
+        Iter { receiver: self }
     }
 
     /// A non-blocking iterator over the values received on the channel that finishes iteration
     /// when all senders have been dropped or the channel is empty.
-    pub fn try_iter(&self) -> TryIter<T> {
-        TryIter { receiver: &self }
+    pub fn try_iter(&self) -> TryIter<'_, T> {
+        TryIter { receiver: self }
     }
 
     /// Take all msgs currently sitting in the channel and produce an iterator over them. Unlike
     /// `try_iter`, the iterator will not attempt to fetch any more values from the channel once
     /// the function has been called.
-    pub fn drain(&self) -> Drain<T> {
+    pub fn drain(&self) -> Drain<'_, T> {
         let mut chan = wait_lock(&self.shared.chan);
         chan.pull_pending(false);
         let queue = std::mem::take(&mut chan.queue);

src/select.rs

@@ -101,7 +101,7 @@ impl<'a, T> Selector<'a, T> {
             selections: Vec::new(),
             next_poll: 0,
             signalled: Arc::default(),
-            phantom: PhantomData::default(),
+            phantom: PhantomData,
             #[cfg(feature = "eventual-fairness")]
             rng: fastrand::Rng::new(),
         }
@@ -180,7 +180,7 @@ impl<'a, T> Selector<'a, T> {
                     return None;
                 };
 
-                Some((&mut self.mapper)(res))
+                Some((self.mapper)(res))
             }
 
             fn deinit(&mut self) {
@@ -274,7 +274,7 @@ impl<'a, T> Selector<'a, T> {
                     return None;
                 };
 
-                Some((&mut self.mapper)(res))
+                Some((self.mapper)(res))
             }
 
             fn deinit(&mut self) {
@@ -320,7 +320,7 @@ impl<'a, T> Selector<'a, T> {
             self.next_poll = self.rng.usize(0..self.selections.len());
         }
 
-        let res = 'outer: loop {
+        let res = 'outer: {
             // Init signals
             for _ in 0..self.selections.len() {
                 if let Some(val) = self.selections[self.next_poll].init() {

tests/array.rs

@@ -11,7 +11,7 @@ use std::time::Duration;
 
 use crossbeam_utils::thread::scope;
 use flume::{bounded, Receiver};
-use flume::{RecvError, RecvTimeoutError, TryRecvError};
+use flume::{RecvTimeoutError, TryRecvError};
 use flume::{SendError, SendTimeoutError, TrySendError};
 use rand::{thread_rng, Rng};
 
@@ -46,38 +46,38 @@ fn len_empty_full() {
     let (s, r) = bounded(2);
 
     assert_eq!(s.len(), 0);
-    assert_eq!(s.is_empty(), true);
-    assert_eq!(s.is_full(), false);
+    assert!(s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 0);
-    assert_eq!(r.is_empty(), true);
-    assert_eq!(r.is_full(), false);
+    assert!(r.is_empty());
+    assert!(!r.is_full());
 
     s.send(()).unwrap();
 
     assert_eq!(s.len(), 1);
-    assert_eq!(s.is_empty(), false);
-    assert_eq!(s.is_full(), false);
+    assert!(!s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 1);
-    assert_eq!(r.is_empty(), false);
-    assert_eq!(r.is_full(), false);
+    assert!(!r.is_empty());
+    assert!(!r.is_full());
 
     s.send(()).unwrap();
 
     assert_eq!(s.len(), 2);
-    assert_eq!(s.is_empty(), false);
-    assert_eq!(s.is_full(), true);
+    assert!(!s.is_empty());
+    assert!(s.is_full());
     assert_eq!(r.len(), 2);
-    assert_eq!(r.is_empty(), false);
-    assert_eq!(r.is_full(), true);
+    assert!(!r.is_empty());
+    assert!(r.is_full());
 
     r.recv().unwrap();
 
     assert_eq!(s.len(), 1);
-    assert_eq!(s.is_empty(), false);
-    assert_eq!(s.is_full(), false);
+    assert!(!s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 1);
-    assert_eq!(r.is_empty(), false);
-    assert_eq!(r.is_full(), false);
+    assert!(!r.is_empty());
+    assert!(!r.is_full());
 }
 
 #[test]

tests/async.rs

@@ -197,7 +197,7 @@ fn change_waker() {
             self.0.load(Ordering::SeqCst)
         }
 
-        fn ctx(&self) -> Context {
+        fn ctx(&self) -> Context<'_> {
             Context::from_waker(&self.1)
         }
     }

tests/basic.rs

@@ -277,7 +277,7 @@ fn hydra() {
     for _ in 0..10 {
         for tx in &txs {
             for _ in 0..msg_num {
-                tx.send(Default::default()).unwrap();
+                tx.send(()).unwrap();
             }
         }
 
@@ -314,7 +314,7 @@ fn robin() {
         let main_tx = main_tx.clone();
         std::thread::spawn(move || {
             for _ in 0..msg_num {
-                main_tx.send(Default::default()).unwrap();
+                main_tx.send(()).unwrap();
             }
         });
 
@@ -365,7 +365,7 @@ fn select_general() {
     t.join().unwrap();
 }
 
-struct MessageWithoutDebug(u32);
+struct MessageWithoutDebug;
 
 #[test]
 // This is a 'does it build' test, to make sure that the error types can turn
@@ -374,7 +374,7 @@ struct MessageWithoutDebug(u32);
 fn std_error_without_debug() {
     let (tx, rx) = unbounded::<MessageWithoutDebug>();
 
-    match tx.send(MessageWithoutDebug(1)) {
+    match tx.send(MessageWithoutDebug) {
         Ok(_) => {}
         Err(e) => {
             let _std_err: &dyn std::error::Error = &e;
@@ -388,7 +388,7 @@ fn std_error_without_debug() {
         }
     }
 
-    match tx.try_send(MessageWithoutDebug(2)) {
+    match tx.try_send(MessageWithoutDebug) {
         Ok(_) => {}
         Err(e) => {
             let _std_err: &dyn std::error::Error = &e;
@@ -402,7 +402,7 @@ fn std_error_without_debug() {
         }
     }
 
-    match tx.send_timeout(MessageWithoutDebug(3), Duration::from_secs(1000000)) {
+    match tx.send_timeout(MessageWithoutDebug, Duration::from_secs(1000000)) {
         Ok(_) => {}
         Err(e) => {
             let _std_err: &dyn std::error::Error = &e;

tests/iter.rs

@@ -95,7 +95,7 @@ fn recv_into_iter_owned() {
 
     assert_eq!(iter.next().unwrap(), 1);
     assert_eq!(iter.next().unwrap(), 2);
-    assert_eq!(iter.next().is_none(), true);
+    assert!(iter.next().is_none());
 }
 
 #[test]
@@ -108,5 +108,5 @@ fn recv_into_iter_borrowed() {
     let mut iter = (&r).into_iter();
     assert_eq!(iter.next().unwrap(), 1);
     assert_eq!(iter.next().unwrap(), 2);
-    assert_eq!(iter.next().is_none(), true);
+    assert!(iter.next().is_none());
 }

tests/list.rs

@@ -11,7 +11,7 @@ use std::time::Duration;
 
 use crossbeam_utils::thread::scope;
 use flume::{unbounded, Receiver};
-use flume::{RecvError, RecvTimeoutError, TryRecvError};
+use flume::{RecvTimeoutError, TryRecvError};
 use flume::{SendError, SendTimeoutError, TrySendError};
 use rand::{thread_rng, Rng};
 
@@ -44,29 +44,29 @@ fn len_empty_full() {
     let (s, r) = unbounded();
 
     assert_eq!(s.len(), 0);
-    assert_eq!(s.is_empty(), true);
-    assert_eq!(s.is_full(), false);
+    assert!(s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 0);
-    assert_eq!(r.is_empty(), true);
-    assert_eq!(r.is_full(), false);
+    assert!(r.is_empty());
+    assert!(!r.is_full());
 
     s.send(()).unwrap();
 
     assert_eq!(s.len(), 1);
-    assert_eq!(s.is_empty(), false);
-    assert_eq!(s.is_full(), false);
+    assert!(!s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 1);
-    assert_eq!(r.is_empty(), false);
-    assert_eq!(r.is_full(), false);
+    assert!(!r.is_empty());
+    assert!(!r.is_full());
 
     r.recv().unwrap();
 
     assert_eq!(s.len(), 0);
-    assert_eq!(s.is_empty(), true);
-    assert_eq!(s.is_full(), false);
+    assert!(s.is_empty());
+    assert!(!s.is_full());
     assert_eq!(r.len(), 0);
-    assert_eq!(r.is_empty(), true);
-    assert_eq!(r.is_full(), false);
+    assert!(r.is_empty());
+    assert!(!r.is_full());
 }
 
 #[test]