Warn on clippy::use_self

Author: djc

src/client.rs

@@ -31,7 +31,7 @@ impl TlsConnector {
     /// If you want to use 0-RTT,
     /// You must also set `ClientConfig.enable_early_data` to `true`.
     #[cfg(feature = "early-data")]
-    pub fn early_data(mut self, flag: bool) -> TlsConnector {
+    pub fn early_data(mut self, flag: bool) -> Self {
         self.early_data = flag;
         self
     }
@@ -114,8 +114,8 @@ impl TlsConnector {
 }
 
 impl From<Arc<ClientConfig>> for TlsConnector {
-    fn from(inner: Arc<ClientConfig>) -> TlsConnector {
-        TlsConnector {
+    fn from(inner: Arc<ClientConfig>) -> Self {
+        Self {
             inner,
             #[cfg(feature = "early-data")]
             early_data: false,

src/common/handshake.rs

@@ -45,24 +45,24 @@ where
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let this = self.get_mut();
 
-        let mut stream = match mem::replace(this, MidHandshake::End) {
-            MidHandshake::Handshaking(stream) => stream,
-            MidHandshake::SendAlert {
+        let mut stream = match mem::replace(this, Self::End) {
+            Self::Handshaking(stream) => stream,
+            Self::SendAlert {
                 mut io,
                 mut alert,
                 error,
             } => loop {
                 match alert.write(&mut SyncWriteAdapter { io: &mut io, cx }) {
                     Err(e) if e.kind() == io::ErrorKind::WouldBlock => {
-                        *this = MidHandshake::SendAlert { io, error, alert };
+                        *this = Self::SendAlert { io, error, alert };
                         return Poll::Pending;
                     }
                     Err(_) | Ok(0) => return Poll::Ready(Err((error, io))),
                     Ok(_) => {}
                 };
             },
             // Starting the handshake returned an error; fail the future immediately.
-            MidHandshake::Error { io, error } => return Poll::Ready(Err((error, io))),
+            Self::Error { io, error } => return Poll::Ready(Err((error, io))),
             _ => panic!("unexpected polling after handshake"),
         };
 

src/common/mod.rs

@@ -23,33 +23,33 @@ impl TlsState {
     #[inline]
     pub(crate) fn shutdown_read(&mut self) {
         match *self {
-            TlsState::WriteShutdown | TlsState::FullyShutdown => *self = TlsState::FullyShutdown,
-            _ => *self = TlsState::ReadShutdown,
+            Self::WriteShutdown | Self::FullyShutdown => *self = Self::FullyShutdown,
+            _ => *self = Self::ReadShutdown,
         }
     }
 
     #[inline]
     pub(crate) fn shutdown_write(&mut self) {
         match *self {
-            TlsState::ReadShutdown | TlsState::FullyShutdown => *self = TlsState::FullyShutdown,
-            _ => *self = TlsState::WriteShutdown,
+            Self::ReadShutdown | Self::FullyShutdown => *self = Self::FullyShutdown,
+            _ => *self = Self::WriteShutdown,
         }
     }
 
     #[inline]
     pub(crate) fn writeable(&self) -> bool {
-        !matches!(*self, TlsState::WriteShutdown | TlsState::FullyShutdown)
+        !matches!(*self, Self::WriteShutdown | Self::FullyShutdown)
     }
 
     #[inline]
     pub(crate) fn readable(&self) -> bool {
-        !matches!(*self, TlsState::ReadShutdown | TlsState::FullyShutdown)
+        !matches!(*self, Self::ReadShutdown | Self::FullyShutdown)
     }
 
     #[inline]
     #[cfg(feature = "early-data")]
     pub(crate) fn is_early_data(&self) -> bool {
-        matches!(self, TlsState::EarlyData(..))
+        matches!(self, Self::EarlyData(..))
     }
 
     #[inline]

src/lib.rs

@@ -36,7 +36,7 @@
 //!
 //! see <https://github.com/tokio-rs/tls/issues/41>
 
-#![warn(unreachable_pub)]
+#![warn(unreachable_pub, clippy::use_self)]
 
 use std::io;
 #[cfg(unix)]
@@ -150,8 +150,8 @@ where
         buf: &mut ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_read(cx, buf),
-            TlsStream::Server(x) => Pin::new(x).poll_read(cx, buf),
+            Self::Client(x) => Pin::new(x).poll_read(cx, buf),
+            Self::Server(x) => Pin::new(x).poll_read(cx, buf),
         }
     }
 }
@@ -163,16 +163,16 @@ where
     #[inline]
     fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<&[u8]>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_fill_buf(cx),
-            TlsStream::Server(x) => Pin::new(x).poll_fill_buf(cx),
+            Self::Client(x) => Pin::new(x).poll_fill_buf(cx),
+            Self::Server(x) => Pin::new(x).poll_fill_buf(cx),
         }
     }
 
     #[inline]
     fn consume(self: Pin<&mut Self>, amt: usize) {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).consume(amt),
-            TlsStream::Server(x) => Pin::new(x).consume(amt),
+            Self::Client(x) => Pin::new(x).consume(amt),
+            Self::Server(x) => Pin::new(x).consume(amt),
         }
     }
 }
@@ -188,8 +188,8 @@ where
         buf: &[u8],
     ) -> Poll<io::Result<usize>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_write(cx, buf),
-            TlsStream::Server(x) => Pin::new(x).poll_write(cx, buf),
+            Self::Client(x) => Pin::new(x).poll_write(cx, buf),
+            Self::Server(x) => Pin::new(x).poll_write(cx, buf),
         }
     }
 
@@ -200,32 +200,32 @@ where
         bufs: &[io::IoSlice<'_>],
     ) -> Poll<io::Result<usize>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_write_vectored(cx, bufs),
-            TlsStream::Server(x) => Pin::new(x).poll_write_vectored(cx, bufs),
+            Self::Client(x) => Pin::new(x).poll_write_vectored(cx, bufs),
+            Self::Server(x) => Pin::new(x).poll_write_vectored(cx, bufs),
         }
     }
 
     #[inline]
     fn is_write_vectored(&self) -> bool {
         match self {
-            TlsStream::Client(x) => x.is_write_vectored(),
-            TlsStream::Server(x) => x.is_write_vectored(),
+            Self::Client(x) => x.is_write_vectored(),
+            Self::Server(x) => x.is_write_vectored(),
         }
     }
 
     #[inline]
     fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_flush(cx),
-            TlsStream::Server(x) => Pin::new(x).poll_flush(cx),
+            Self::Client(x) => Pin::new(x).poll_flush(cx),
+            Self::Server(x) => Pin::new(x).poll_flush(cx),
         }
     }
 
     #[inline]
     fn poll_shutdown(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<io::Result<()>> {
         match self.get_mut() {
-            TlsStream::Client(x) => Pin::new(x).poll_shutdown(cx),
-            TlsStream::Server(x) => Pin::new(x).poll_shutdown(cx),
+            Self::Client(x) => Pin::new(x).poll_shutdown(cx),
+            Self::Server(x) => Pin::new(x).poll_shutdown(cx),
         }
     }
 }

src/server.rs

@@ -21,8 +21,8 @@ pub struct TlsAcceptor {
 }
 
 impl From<Arc<ServerConfig>> for TlsAcceptor {
-    fn from(inner: Arc<ServerConfig>) -> TlsAcceptor {
-        TlsAcceptor { inner }
+    fn from(inner: Arc<ServerConfig>) -> Self {
+        Self { inner }
     }
 }
 

tests/utils.rs

@@ -82,7 +82,7 @@ mod utils {
     impl<S> FlushWrapper<S> {
         #[allow(dead_code)]
         pub(crate) fn new(stream: S) -> Self {
-            FlushWrapper {
+            Self {
                 stream,
                 buf: VecDeque::new(),
                 queued: Vec::new(),