tokio: remove wildcard in match patterns (#5970)

tokio-rs · Sep 23, 2023 · 707fb4d · 707fb4d
1 parent b161633
commit 707fb4d
Show file tree

Hide file tree

Showing 14 changed files with 180 additions and 198 deletions.
diff --git a/tokio-macros/src/entry.rs b/tokio-macros/src/entry.rs
@@ -126,22 +126,22 @@ impl Configuration {
     }
 
     fn build(&self) -> Result<FinalConfig, syn::Error> {
-        let flavor = self.flavor.unwrap_or(self.default_flavor);
-        use RuntimeFlavor::*;
+        use RuntimeFlavor as F;
 
+        let flavor = self.flavor.unwrap_or(self.default_flavor);
         let worker_threads = match (flavor, self.worker_threads) {
-            (CurrentThread, Some((_, worker_threads_span))) => {
+            (F::CurrentThread, Some((_, worker_threads_span))) => {
                 let msg = format!(
                     "The `worker_threads` option requires the `multi_thread` runtime flavor. Use `#[{}(flavor = \"multi_thread\")]`",
                     self.macro_name(),
                 );
                 return Err(syn::Error::new(worker_threads_span, msg));
             }
-            (CurrentThread, None) => None,
-            (Threaded, worker_threads) if self.rt_multi_thread_available => {
+            (F::CurrentThread, None) => None,
+            (F::Threaded, worker_threads) if self.rt_multi_thread_available => {
                 worker_threads.map(|(val, _span)| val)
             }
-            (Threaded, _) => {
+            (F::Threaded, _) => {
                 let msg = if self.flavor.is_none() {
                     "The default runtime flavor is `multi_thread`, but the `rt-multi-thread` feature is disabled."
                 } else {
@@ -152,14 +152,14 @@ impl Configuration {
         };
 
         let start_paused = match (flavor, self.start_paused) {
-            (Threaded, Some((_, start_paused_span))) => {
+            (F::Threaded, Some((_, start_paused_span))) => {
                 let msg = format!(
                     "The `start_paused` option requires the `current_thread` runtime flavor. Use `#[{}(flavor = \"current_thread\")]`",
                     self.macro_name(),
                 );
                 return Err(syn::Error::new(start_paused_span, msg));
             }
-            (CurrentThread, Some((start_paused, _))) => Some(start_paused),
+            (F::CurrentThread, Some((start_paused, _))) => Some(start_paused),
             (_, None) => None,
         };
 

diff --git a/tokio-stream/src/stream_ext/merge.rs b/tokio-stream/src/stream_ext/merge.rs
@@ -66,25 +66,23 @@ where
     T: Stream,
     U: Stream<Item = T::Item>,
 {
-    use Poll::*;
-
     let mut done = true;
 
     match first.poll_next(cx) {
-        Ready(Some(val)) => return Ready(Some(val)),
-        Ready(None) => {}
-        Pending => done = false,
+        Poll::Ready(Some(val)) => return Poll::Ready(Some(val)),
+        Poll::Ready(None) => {}
+        Poll::Pending => done = false,
     }
 
     match second.poll_next(cx) {
-        Ready(Some(val)) => return Ready(Some(val)),
-        Ready(None) => {}
-        Pending => done = false,
+        Poll::Ready(Some(val)) => return Poll::Ready(Some(val)),
+        Poll::Ready(None) => {}
+        Poll::Pending => done = false,
     }
 
     if done {
-        Ready(None)
+        Poll::Ready(None)
     } else {
-        Pending
+        Poll::Pending
     }
 }
diff --git a/tokio-stream/src/stream_map.rs b/tokio-stream/src/stream_map.rs
@@ -518,17 +518,15 @@ where
 {
     /// Polls the next value, includes the vec entry index
     fn poll_next_entry(&mut self, cx: &mut Context<'_>) -> Poll<Option<(usize, V::Item)>> {
-        use Poll::*;
-
         let start = self::rand::thread_rng_n(self.entries.len() as u32) as usize;
         let mut idx = start;
 
         for _ in 0..self.entries.len() {
             let (_, stream) = &mut self.entries[idx];
 
             match Pin::new(stream).poll_next(cx) {
-                Ready(Some(val)) => return Ready(Some((idx, val))),
-                Ready(None) => {
+                Poll::Ready(Some(val)) => return Poll::Ready(Some((idx, val))),
+                Poll::Ready(None) => {
                     // Remove the entry
                     self.entries.swap_remove(idx);
 
@@ -542,17 +540,17 @@ where
                         idx = idx.wrapping_add(1) % self.entries.len();
                     }
                 }
-                Pending => {
+                Poll::Pending => {
                     idx = idx.wrapping_add(1) % self.entries.len();
                 }
             }
         }
 
         // If the map is empty, then the stream is complete.
         if self.entries.is_empty() {
-            Ready(None)
+            Poll::Ready(None)
         } else {
-            Pending
+            Poll::Pending
         }
     }
 }

diff --git a/tokio-test/src/macros.rs b/tokio-test/src/macros.rs
@@ -22,17 +22,17 @@
 #[macro_export]
 macro_rules! assert_ready {
     ($e:expr) => {{
-        use core::task::Poll::*;
+        use core::task::Poll;
         match $e {
-            Ready(v) => v,
-            Pending => panic!("pending"),
+            Poll::Ready(v) => v,
+            Poll::Pending => panic!("pending"),
         }
     }};
     ($e:expr, $($msg:tt)+) => {{
-        use core::task::Poll::*;
+        use core::task::Poll;
         match $e {
-            Ready(v) => v,
-            Pending => {
+            Poll::Ready(v) => v,
+            Poll::Pending => {
                 panic!("pending; {}", format_args!($($msg)+))
             }
         }
@@ -127,17 +127,17 @@ macro_rules! assert_ready_err {
 #[macro_export]
 macro_rules! assert_pending {
     ($e:expr) => {{
-        use core::task::Poll::*;
+        use core::task::Poll;
         match $e {
-            Pending => {}
-            Ready(v) => panic!("ready; value = {:?}", v),
+            Poll::Pending => {}
+            Poll::Ready(v) => panic!("ready; value = {:?}", v),
         }
     }};
     ($e:expr, $($msg:tt)+) => {{
-        use core::task::Poll::*;
+        use core::task::Poll;
         match $e {
-            Pending => {}
-            Ready(v) => {
+            Poll::Pending => {}
+            Poll::Ready(v) => {
                 panic!("ready; value = {:?}; {}", v, format_args!($($msg)+))
             }
         }

diff --git a/tokio-util/tests/length_delimited.rs b/tokio-util/tests/length_delimited.rs
@@ -12,7 +12,6 @@ use futures::{pin_mut, Sink, Stream};
 use std::collections::VecDeque;
 use std::io;
 use std::pin::Pin;
-use std::task::Poll::*;
 use std::task::{Context, Poll};
 
 macro_rules! mock {
@@ -39,21 +38,21 @@ macro_rules! assert_next_eq {
 macro_rules! assert_next_pending {
     ($io:ident) => {{
         task::spawn(()).enter(|cx, _| match $io.as_mut().poll_next(cx) {
-            Ready(Some(Ok(v))) => panic!("value = {:?}", v),
-            Ready(Some(Err(e))) => panic!("error = {:?}", e),
-            Ready(None) => panic!("done"),
-            Pending => {}
+            Poll::Ready(Some(Ok(v))) => panic!("value = {:?}", v),
+            Poll::Ready(Some(Err(e))) => panic!("error = {:?}", e),
+            Poll::Ready(None) => panic!("done"),
+            Poll::Pending => {}
         });
     }};
 }
 
 macro_rules! assert_next_err {
     ($io:ident) => {{
         task::spawn(()).enter(|cx, _| match $io.as_mut().poll_next(cx) {
-            Ready(Some(Ok(v))) => panic!("value = {:?}", v),
-            Ready(Some(Err(_))) => {}
-            Ready(None) => panic!("done"),
-            Pending => panic!("pending"),
+            Poll::Ready(Some(Ok(v))) => panic!("value = {:?}", v),
+            Poll::Ready(Some(Err(_))) => {}
+            Poll::Ready(None) => panic!("done"),
+            Poll::Pending => panic!("pending"),
         });
     }};
 }
@@ -186,11 +185,11 @@ fn read_single_frame_multi_packet_wait() {
     let io = FramedRead::new(
         mock! {
             data(b"\x00\x00"),
-            Pending,
+            Poll::Pending,
             data(b"\x00\x09abc"),
-            Pending,
+            Poll::Pending,
             data(b"defghi"),
-            Pending,
+            Poll::Pending,
         },
         LengthDelimitedCodec::new(),
     );
@@ -208,15 +207,15 @@ fn read_multi_frame_multi_packet_wait() {
     let io = FramedRead::new(
         mock! {
             data(b"\x00\x00"),
-            Pending,
+            Poll::Pending,
             data(b"\x00\x09abc"),
-            Pending,
+            Poll::Pending,
             data(b"defghi"),
-            Pending,
+            Poll::Pending,
             data(b"\x00\x00\x00\x0312"),
-            Pending,
+            Poll::Pending,
             data(b"3\x00\x00\x00\x0bhello world"),
-            Pending,
+            Poll::Pending,
         },
         LengthDelimitedCodec::new(),
     );
@@ -250,9 +249,9 @@ fn read_incomplete_head() {
 fn read_incomplete_head_multi() {
     let io = FramedRead::new(
         mock! {
-            Pending,
+            Poll::Pending,
             data(b"\x00"),
-            Pending,
+            Poll::Pending,
         },
         LengthDelimitedCodec::new(),
     );
@@ -268,9 +267,9 @@ fn read_incomplete_payload() {
     let io = FramedRead::new(
         mock! {
             data(b"\x00\x00\x00\x09ab"),
-            Pending,
+            Poll::Pending,
             data(b"cd"),
-            Pending,
+            Poll::Pending,
         },
         LengthDelimitedCodec::new(),
     );
@@ -310,7 +309,7 @@ fn read_update_max_frame_len_at_rest() {
 fn read_update_max_frame_len_in_flight() {
     let io = length_delimited::Builder::new().new_read(mock! {
         data(b"\x00\x00\x00\x09abcd"),
-        Pending,
+        Poll::Pending,
         data(b"efghi"),
         data(b"\x00\x00\x00\x09abcdefghi"),
     });
@@ -533,9 +532,9 @@ fn write_single_multi_frame_multi_packet() {
 fn write_single_frame_would_block() {
     let io = FramedWrite::new(
         mock! {
-            Pending,
+            Poll::Pending,
             data(b"\x00\x00"),
-            Pending,
+            Poll::Pending,
             data(b"\x00\x09"),
             data(b"abcdefghi"),
             flush(),
@@ -640,7 +639,7 @@ fn write_update_max_frame_len_in_flight() {
     let io = length_delimited::Builder::new().new_write(mock! {
         data(b"\x00\x00\x00\x06"),
         data(b"ab"),
-        Pending,
+        Poll::Pending,
         data(b"cdef"),
         flush(),
     });
@@ -701,24 +700,22 @@ enum Op {
     Flush,
 }
 
-use self::Op::*;
-
 impl AsyncRead for Mock {
     fn poll_read(
         mut self: Pin<&mut Self>,
         _cx: &mut Context<'_>,
         dst: &mut ReadBuf<'_>,
     ) -> Poll<io::Result<()>> {
         match self.calls.pop_front() {
-            Some(Ready(Ok(Op::Data(data)))) => {
+            Some(Poll::Ready(Ok(Op::Data(data)))) => {
                 debug_assert!(dst.remaining() >= data.len());
                 dst.put_slice(&data);
-                Ready(Ok(()))
+                Poll::Ready(Ok(()))
             }
-            Some(Ready(Ok(_))) => panic!(),
-            Some(Ready(Err(e))) => Ready(Err(e)),
-            Some(Pending) => Pending,
-            None => Ready(Ok(())),
+            Some(Poll::Ready(Ok(_))) => panic!(),
+            Some(Poll::Ready(Err(e))) => Poll::Ready(Err(e)),
+            Some(Poll::Pending) => Poll::Pending,
+            None => Poll::Ready(Ok(())),
         }
     }
 }
@@ -730,31 +727,31 @@ impl AsyncWrite for Mock {
         src: &[u8],
     ) -> Poll<Result<usize, io::Error>> {
         match self.calls.pop_front() {
-            Some(Ready(Ok(Op::Data(data)))) => {
+            Some(Poll::Ready(Ok(Op::Data(data)))) => {
                 let len = data.len();
                 assert!(src.len() >= len, "expect={:?}; actual={:?}", data, src);
                 assert_eq!(&data[..], &src[..len]);
-                Ready(Ok(len))
+                Poll::Ready(Ok(len))
             }
-            Some(Ready(Ok(_))) => panic!(),
-            Some(Ready(Err(e))) => Ready(Err(e)),
-            Some(Pending) => Pending,
-            None => Ready(Ok(0)),
+            Some(Poll::Ready(Ok(_))) => panic!(),
+            Some(Poll::Ready(Err(e))) => Poll::Ready(Err(e)),
+            Some(Poll::Pending) => Poll::Pending,
+            None => Poll::Ready(Ok(0)),
         }
     }
 
     fn poll_flush(mut self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
         match self.calls.pop_front() {
-            Some(Ready(Ok(Op::Flush))) => Ready(Ok(())),
-            Some(Ready(Ok(_))) => panic!(),
-            Some(Ready(Err(e))) => Ready(Err(e)),
-            Some(Pending) => Pending,
-            None => Ready(Ok(())),
+            Some(Poll::Ready(Ok(Op::Flush))) => Poll::Ready(Ok(())),
+            Some(Poll::Ready(Ok(_))) => panic!(),
+            Some(Poll::Ready(Err(e))) => Poll::Ready(Err(e)),
+            Some(Poll::Pending) => Poll::Pending,
+            None => Poll::Ready(Ok(())),
         }
     }
 
     fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Result<(), io::Error>> {
-        Ready(Ok(()))
+        Poll::Ready(Ok(()))
     }
 }
 
@@ -771,9 +768,9 @@ impl From<Vec<u8>> for Op {
 }
 
 fn data(bytes: &[u8]) -> Poll<io::Result<Op>> {
-    Ready(Ok(bytes.into()))
+    Poll::Ready(Ok(bytes.into()))
 }
 
 fn flush() -> Poll<io::Result<Op>> {
-    Ready(Ok(Flush))
+    Poll::Ready(Ok(Op::Flush))
 }