Fix some clippy warnings

examples/a-chat/main.rs

@@ -5,7 +5,7 @@ type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>
 
 fn main() -> Result<()> {
     let mut args = std::env::args();
-    match (args.nth(1).as_ref().map(String::as_str), args.next()) {
+    match (args.nth(1).as_deref(), args.next()) {
         (Some("client"), None) => client::main(),
         (Some("server"), None) => server::main(),
         _ => Err("Usage: a-chat [client|server]".into()),

src/fs/dir_builder.rs

@@ -36,7 +36,8 @@ impl DirBuilder {
     ///
     /// let builder = DirBuilder::new();
     /// ```
-    pub fn new() -> DirBuilder {
+    #[must_use]
+    pub const fn new() -> DirBuilder {
         #[cfg(not(unix))]
         let builder = DirBuilder { recursive: false };
 

src/fs/dir_entry.rs

@@ -47,6 +47,7 @@ impl DirEntry {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn path(&self) -> PathBuf {
         self.0.path().into()
     }
@@ -147,6 +148,7 @@ impl DirEntry {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn file_name(&self) -> OsString {
         self.0.file_name()
     }

src/fs/file.rs

@@ -871,6 +871,7 @@ impl LockGuard<State> {
 
     // This function does nothing because we're not sure about `AsyncWrite::poll_close()`'s exact
     // semantics nor whether it will stay in the `AsyncWrite` trait.
+    #[allow(clippy::unused_self)]
     fn poll_close(self, _: &mut Context<'_>) -> Poll<io::Result<()>> {
         Poll::Ready(Ok(()))
     }
@@ -899,7 +900,8 @@ mod tests {
                     drop(clone);
                     buf.len()
                 })
-            }).await;
+            })
+            .await;
             assert_eq!(len as u64, file.metadata().await.unwrap().len());
         });
     }

src/fs/open_options.rs

@@ -80,6 +80,7 @@ impl OpenOptions {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn new() -> OpenOptions {
         OpenOptions(std::fs::OpenOptions::new())
     }

src/fs/read_dir.rs

@@ -80,7 +80,7 @@ enum State {
 
 impl ReadDir {
     /// Creates an asynchronous `ReadDir` from a synchronous handle.
-    pub(crate) fn new(inner: std::fs::ReadDir) -> ReadDir {
+    pub(crate) const fn new(inner: std::fs::ReadDir) -> ReadDir {
         ReadDir(State::Idle(Some(inner)))
     }
 }

src/io/buf_reader.rs

@@ -115,7 +115,7 @@ impl<R> BufReader<R> {
     /// #
     /// # Ok(()) }) }
     /// ```
-    pub fn get_ref(&self) -> &R {
+    pub const fn get_ref(&self) -> &R {
         &self.inner
     }
 

src/io/buf_writer.rs

@@ -211,7 +211,7 @@ impl<W: Write> BufWriter<W> {
         self.project().inner
     }
 
-    /// Consumes BufWriter, returning the underlying writer
+    /// Consumes `BufWriter`, returning the underlying writer
     ///
     /// This method will not write leftover data, it will be lost.
     /// For method that will attempt to write before returning the writer see [`poll_into_inner`]
@@ -263,7 +263,7 @@ impl<W: Write> BufWriter<W> {
 
     /// Poll buffer flushing until completion
     ///
-    /// This is used in types that wrap around BufWrite, one such example: [`LineWriter`]
+    /// This is used in types that wrap around `BufWrite`, one such example: [`LineWriter`]
     ///
     /// [`LineWriter`]: struct.LineWriter.html
     fn poll_flush_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {

src/io/empty.rs

@@ -22,7 +22,8 @@ use crate::task::{Context, Poll};
 /// #
 /// # Ok(()) }) }
 /// ```
-pub fn empty() -> Empty {
+#[must_use]
+pub const fn empty() -> Empty {
     Empty { _private: () }
 }
 

src/io/mod.rs

@@ -39,7 +39,7 @@
 //! nickname: readers and writers. So you'll sometimes see 'a reader' instead
 //! of 'a type that implements the [`Read`] trait'. Much easier!
 //!
-//! ## Seek and BufRead
+//! ## `Seek` and `BufRead`
 //!
 //! Beyond that, there are two important traits that are provided: [`Seek`]
 //! and [`BufRead`]. Both of these build on top of a reader to control
@@ -70,7 +70,7 @@
 //! [`BufRead`] uses an internal buffer to provide a number of other ways to read, but
 //! to show it off, we'll need to talk about buffers in general. Keep reading!
 //!
-//! ## BufReader and BufWriter
+//! ## `BufReader` and `BufWriter`
 //!
 //! Byte-based interfaces are unwieldy and can be inefficient, as we'd need to be
 //! making near-constant calls to the operating system. To help with this,
@@ -214,7 +214,7 @@
 //!
 //! [functions-list]: #functions-1
 //!
-//! ## io::Result
+//! ## `io::Result`
 //!
 //! Last, but certainly not least, is [`io::Result`]. This type is used
 //! as the return type of many `std::io` functions that can cause an error, and

src/io/read/chain.rs

@@ -63,7 +63,7 @@ impl<T, U> Chain<T, U> {
     /// #
     /// # Ok(()) }) }
     /// ```
-    pub fn get_ref(&self) -> (&T, &U) {
+    pub const fn get_ref(&self) -> (&T, &U) {
         (&self.first, &self.second)
     }
 
@@ -157,10 +157,10 @@ impl<T: BufRead, U: BufRead> BufRead for Chain<T, U> {
 
     fn consume(self: Pin<&mut Self>, amt: usize) {
         let this = self.project();
-        if !*this.done_first {
-            this.first.consume(amt)
-        } else {
+        if *this.done_first {
             this.second.consume(amt)
+        } else {
+            this.first.consume(amt)
         }
     }
 }

src/io/read/mod.rs

@@ -485,7 +485,7 @@ mod tests {
     #[test]
     fn test_read_by_ref() {
         crate::task::block_on(async {
-            let mut f = io::Cursor::new(vec![0u8, 1, 2, 3, 4, 5, 6, 7, 8]);
+            let mut f = io::Cursor::new(vec![0_u8, 1, 2, 3, 4, 5, 6, 7, 8]);
             let mut buffer = Vec::new();
             let mut other_buffer = Vec::new();
 

src/io/read/take.rs

@@ -49,7 +49,7 @@ impl<T> Take<T> {
     /// #
     /// #     Ok(()) }) }
     /// ```
-    pub fn limit(&self) -> u64 {
+    pub const fn limit(&self) -> u64 {
         self.limit
     }
 
@@ -229,7 +229,7 @@ mod tests {
         let source: io::Cursor<Vec<u8>> = io::Cursor::new(vec![0, 1, 2, 3, 4, 5, 6, 7, 8]);
 
         task::block_on(async move {
-            let mut buffer = [0u8; 5];
+            let mut buffer = [0_u8; 5];
 
             // read at most five bytes
             let mut handle = source.take(5);

src/io/repeat.rs

@@ -23,7 +23,8 @@ use crate::task::{Context, Poll};
 /// #
 /// # Ok(()) }) }
 /// ```
-pub fn repeat(byte: u8) -> Repeat {
+#[must_use]
+pub const fn repeat(byte: u8) -> Repeat {
     Repeat { byte }
 }
 

src/io/sink.rs

@@ -19,7 +19,8 @@ use crate::task::{Context, Poll};
 /// #
 /// # Ok(()) }) }
 /// ```
-pub fn sink() -> Sink {
+#[must_use]
+pub const fn sink() -> Sink {
     Sink { _private: () }
 }
 

src/io/stderr.rs

@@ -1,6 +1,6 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::Mutex;
-use std::future::Future;
 
 use crate::io::{self, Write};
 use crate::task::{spawn_blocking, Context, JoinHandle, Poll};
@@ -30,6 +30,7 @@ use crate::task::{spawn_blocking, Context, JoinHandle, Poll};
 /// #
 /// # Ok(()) }) }
 /// ```
+#[must_use]
 pub fn stderr() -> Stderr {
     Stderr(Mutex::new(State::Idle(Some(Inner {
         stderr: std::io::stderr(),
@@ -150,16 +151,15 @@ impl Write for Stderr {
                     // Check if the operation has completed.
                     if let Some(Operation::Flush(res)) = inner.last_op.take() {
                         return Poll::Ready(res);
-                    } else {
-                        let mut inner = opt.take().unwrap();
-
-                        // Start the operation asynchronously.
-                        *state = State::Busy(spawn_blocking(move || {
-                            let res = std::io::Write::flush(&mut inner.stderr);
-                            inner.last_op = Some(Operation::Flush(res));
-                            State::Idle(Some(inner))
-                        }));
                     }
+                    let mut inner = opt.take().unwrap();
+
+                    // Start the operation asynchronously.
+                    *state = State::Busy(spawn_blocking(move || {
+                        let res = std::io::Write::flush(&mut inner.stderr);
+                        inner.last_op = Some(Operation::Flush(res));
+                        State::Idle(Some(inner))
+                    }));
                 }
                 // Poll the asynchronous operation the stderr is currently blocked on.
                 State::Busy(task) => *state = futures_core::ready!(Pin::new(task).poll(cx)),

src/io/stdin.rs

@@ -32,6 +32,7 @@ use crate::utils::Context as _;
 /// #
 /// # Ok(()) }) }
 /// ```
+#[must_use]
 pub fn stdin() -> Stdin {
     Stdin(Mutex::new(State::Idle(Some(Inner {
         stdin: std::io::stdin(),
@@ -125,17 +126,16 @@ impl Stdin {
                             // Copy the read data into the buffer and return.
                             buf.push_str(&inner.line);
                             return Poll::Ready(Ok(n));
-                        } else {
-                            let mut inner = opt.take().unwrap();
-
-                            // Start the operation asynchronously.
-                            *state = State::Busy(spawn_blocking(move || {
-                                inner.line.clear();
-                                let res = inner.stdin.read_line(&mut inner.line);
-                                inner.last_op = Some(Operation::ReadLine(res));
-                                State::Idle(Some(inner))
-                            }));
                         }
+                        let mut inner = opt.take().unwrap();
+
+                        // Start the operation asynchronously.
+                        *state = State::Busy(spawn_blocking(move || {
+                            inner.line.clear();
+                            let res = inner.stdin.read_line(&mut inner.line);
+                            inner.last_op = Some(Operation::ReadLine(res));
+                            State::Idle(Some(inner))
+                        }));
                     }
                     // Poll the asynchronous operation the stdin is currently blocked on.
                     State::Busy(task) => *state = futures_core::ready!(Pin::new(task).poll(cx)),

src/io/stdout.rs

@@ -1,6 +1,6 @@
+use std::future::Future;
 use std::pin::Pin;
 use std::sync::Mutex;
-use std::future::Future;
 
 use crate::io::{self, Write};
 use crate::task::{spawn_blocking, Context, JoinHandle, Poll};
@@ -30,6 +30,7 @@ use crate::task::{spawn_blocking, Context, JoinHandle, Poll};
 /// #
 /// # Ok(()) }) }
 /// ```
+#[must_use]
 pub fn stdout() -> Stdout {
     Stdout(Mutex::new(State::Idle(Some(Inner {
         stdout: std::io::stdout(),
@@ -150,16 +151,15 @@ impl Write for Stdout {
                     // Check if the operation has completed.
                     if let Some(Operation::Flush(res)) = inner.last_op.take() {
                         return Poll::Ready(res);
-                    } else {
-                        let mut inner = opt.take().unwrap();
-
-                        // Start the operation asynchronously.
-                        *state = State::Busy(spawn_blocking(move || {
-                            let res = std::io::Write::flush(&mut inner.stdout);
-                            inner.last_op = Some(Operation::Flush(res));
-                            State::Idle(Some(inner))
-                        }));
                     }
+                    let mut inner = opt.take().unwrap();
+
+                    // Start the operation asynchronously.
+                    *state = State::Busy(spawn_blocking(move || {
+                        let res = std::io::Write::flush(&mut inner.stdout);
+                        inner.last_op = Some(Operation::Flush(res));
+                        State::Idle(Some(inner))
+                    }));
                 }
                 // Poll the asynchronous operation the stdout is currently blocked on.
                 State::Busy(task) => *state = futures_core::ready!(Pin::new(task).poll(cx)),

src/io/timeout.rs

@@ -67,7 +67,7 @@ where
         let this = self.project();
         match this.future.poll(cx) {
             Poll::Pending => {}
-            other => return other,
+            other @ Poll::Ready(..) => return other,
         }
 
         if this.timeout.poll(cx).is_ready() {

src/net/tcp/listener.rs

@@ -146,6 +146,7 @@ impl TcpListener {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn incoming(&self) -> Incoming<'_> {
         Incoming {
             incoming: Box::pin(self.watcher.incoming()),

src/os/unix/net/listener.rs

@@ -127,6 +127,7 @@ impl UnixListener {
     /// #
     /// # Ok(()) }) }
     /// ```
+    #[must_use]
     pub fn incoming(&self) -> Incoming<'_> {
         Incoming {
             incoming: Box::pin(self.watcher.incoming()),

src/path/ancestors.rs

@@ -21,7 +21,7 @@ use crate::path::Path;
 ///
 /// [`ancestors`]: struct.Path.html#method.ancestors
 /// [`Path`]: struct.Path.html
-#[derive(Copy, Clone, Debug)]
+#[derive(Clone, Debug)]
 pub struct Ancestors<'a> {
     pub(crate) next: Option<&'a Path>,
 }

src/path/components.rs

@@ -42,6 +42,7 @@ impl<'a> Components<'a> {
     ///
     /// assert_eq!(Path::new("foo/bar.txt"), components.as_path());
     /// ```
+    #[must_use]
     pub fn as_path(&self) -> &'a Path {
         self.inner.as_path().into()
     }

src/path/iter.rs

@@ -32,6 +32,7 @@ impl<'a> Iter<'a> {
     ///
     /// assert_eq!(Path::new("foo/bar.txt"), iter.as_path());
     /// ```
+    #[must_use]
     pub fn as_path(&self) -> &'a Path {
         self.inner.as_path()
     }