Fix some clippy warnings

Author: brightly-salty

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