Fix Clippy warnings

src/event/source.rs

@@ -121,7 +121,7 @@ where
         token: Token,
         interests: Interest,
     ) -> io::Result<()> {
-        (&mut **self).register(registry, token, interests)
+        (**self).register(registry, token, interests)
     }
 
     fn reregister(
@@ -130,10 +130,10 @@ where
         token: Token,
         interests: Interest,
     ) -> io::Result<()> {
-        (&mut **self).reregister(registry, token, interests)
+        (**self).reregister(registry, token, interests)
     }
 
     fn deregister(&mut self, registry: &Registry) -> io::Result<()> {
-        (&mut **self).deregister(registry)
+        (**self).deregister(registry)
     }
 }

src/interest.rs

@@ -163,7 +163,7 @@ impl fmt::Debug for Interest {
                 one = true
             }
         }
-        #[cfg(any(target_os = "freebsd"))]
+        #[cfg(target_os = "freebsd")]
         {
             if self.is_lio() {
                 if one {

src/io_source.rs

@@ -230,7 +230,7 @@ impl SelectorId {
     /// Associate an I/O source with `registry`, returning an error if its
     /// already registered.
     fn associate(&self, registry: &Registry) -> io::Result<()> {
-        let registry_id = poll::selector(&registry).id();
+        let registry_id = poll::selector(registry).id();
         let previous_id = self.id.swap(registry_id, Ordering::AcqRel);
 
         if previous_id == Self::UNASSOCIATED {
@@ -247,7 +247,7 @@ impl SelectorId {
     /// error if its registered with a different `Registry` or not registered at
     /// all.
     fn check_association(&self, registry: &Registry) -> io::Result<()> {
-        let registry_id = poll::selector(&registry).id();
+        let registry_id = poll::selector(registry).id();
         let id = self.id.load(Ordering::Acquire);
 
         if id == registry_id {
@@ -268,7 +268,7 @@ impl SelectorId {
     /// Remove a previously made association from `registry`, returns an error
     /// if it was not previously associated with `registry`.
     fn remove_association(&self, registry: &Registry) -> io::Result<()> {
-        let registry_id = poll::selector(&registry).id();
+        let registry_id = poll::selector(registry).id();
         let previous_id = self.id.swap(Self::UNASSOCIATED, Ordering::AcqRel);
 
         if previous_id == registry_id {

src/net/tcp/stream.rs

@@ -174,49 +174,49 @@ impl TcpStream {
 
 impl Read for TcpStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 
 impl<'a> Read for &'a TcpStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 
 impl Write for TcpStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|inner| (&*inner).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 
 impl<'a> Write for &'a TcpStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|inner| (&*inner).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 

src/net/uds/stream.rs

@@ -73,49 +73,49 @@ impl UnixStream {
 
 impl Read for UnixStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 
 impl<'a> Read for &'a UnixStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 
 impl Write for UnixStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|inner| (&*inner).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 
 impl<'a> Write for &'a UnixStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|inner| (&*inner).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|inner| (&*inner).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 

src/sys/unix/pipe.rs

@@ -244,29 +244,29 @@ impl event::Source for Sender {
 
 impl Write for Sender {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|sender| (&*sender).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 
 impl Write for &Sender {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).write(buf))
+        self.inner.do_io(|mut inner| inner.write(buf))
     }
 
     fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).write_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.write_vectored(bufs))
     }
 
     fn flush(&mut self) -> io::Result<()> {
-        self.inner.do_io(|sender| (&*sender).flush())
+        self.inner.do_io(|mut inner| inner.flush())
     }
 }
 
@@ -341,21 +341,21 @@ impl event::Source for Receiver {
 
 impl Read for Receiver {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 
 impl Read for &Receiver {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).read(buf))
+        self.inner.do_io(|mut inner| inner.read(buf))
     }
 
     fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
-        self.inner.do_io(|sender| (&*sender).read_vectored(bufs))
+        self.inner.do_io(|mut inner| inner.read_vectored(bufs))
     }
 }
 

src/sys/unix/selector/kqueue.rs

@@ -285,7 +285,7 @@ fn kevent_register(
             Err(err)
         }
     })
-    .and_then(|()| check_errors(&changes, ignored_errors))
+    .and_then(|()| check_errors(changes, ignored_errors))
 }
 
 /// Check all events for possible errors, it returns the first error found.

src/sys/unix/uds/mod.rs

@@ -40,7 +40,7 @@ cfg_os_poll! {
         sockaddr.sun_family = libc::AF_UNIX as libc::sa_family_t;
 
         let bytes = path.as_os_str().as_bytes();
-        match (bytes.get(0), bytes.len().cmp(&sockaddr.sun_path.len())) {
+        match (bytes.first(), bytes.len().cmp(&sockaddr.sun_path.len())) {
             // Abstract paths don't need a null terminator
             (Some(&0), Ordering::Greater) => {
                 return Err(io::Error::new(
@@ -64,7 +64,7 @@ cfg_os_poll! {
         let offset = path_offset(&sockaddr);
         let mut socklen = offset + bytes.len();
 
-        match bytes.get(0) {
+        match bytes.first() {
             // The struct has already been zeroes so the null byte for pathname
             // addresses is already there.
             Some(&0) | None => {}

src/waker.rs

@@ -84,7 +84,7 @@ impl Waker {
     pub fn new(registry: &Registry, token: Token) -> io::Result<Waker> {
         #[cfg(debug_assertions)]
         registry.register_waker();
-        sys::Waker::new(poll::selector(&registry), token).map(|inner| Waker { inner })
+        sys::Waker::new(poll::selector(registry), token).map(|inner| Waker { inner })
     }
 
     /// Wake up the [`Poll`] associated with this `Waker`.

tests/interest.rs

@@ -34,7 +34,7 @@ fn fmt_debug() {
     {
         assert_eq!(format!("{:?}", Interest::AIO), "AIO");
     }
-    #[cfg(any(target_os = "freebsd"))]
+    #[cfg(target_os = "freebsd")]
     {
         assert_eq!(format!("{:?}", Interest::LIO), "LIO");
     }