fix inference errors caused by new serde dependency

Author: conradludgate

tokio/src/runtime/tests/queue.rs

@@ -184,7 +184,7 @@ fn stress1() {
             }
 
             cfg_unstable_metrics! {
-                assert_metrics!(stats, steal_count == n as _);
+                assert_metrics!(stats, steal_count == n as u64);
             }
 
             n

tokio/src/signal/unix.rs

@@ -537,8 +537,9 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::unnecessary_cast)]
     fn into_c_int() {
         let value: std::os::raw::c_int = SignalKind::interrupt().into();
-        assert_eq!(value, libc::SIGINT as _);
+        assert_eq!(value, libc::SIGINT as i32);
     }
 }

tokio/tests/io_buf_reader.rs

@@ -87,13 +87,13 @@ async fn test_buffered_reader() {
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 3);
     assert_eq!(buf, [5, 6, 7]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let mut buf = [0, 0];
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 2);
     assert_eq!(buf, [0, 1]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let mut buf = [0];
     let nread = reader.read(&mut buf).await.unwrap();
@@ -105,12 +105,12 @@ async fn test_buffered_reader() {
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 1);
     assert_eq!(buf, [3, 0, 0]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 1);
     assert_eq!(buf, [4, 0, 0]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
 }
@@ -231,13 +231,13 @@ async fn maybe_pending() {
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 3);
     assert_eq!(buf, [5, 6, 7]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let mut buf = [0, 0];
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 2);
     assert_eq!(buf, [0, 1]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let mut buf = [0];
     let nread = reader.read(&mut buf).await.unwrap();
@@ -249,12 +249,12 @@ async fn maybe_pending() {
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 1);
     assert_eq!(buf, [3, 0, 0]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     let nread = reader.read(&mut buf).await.unwrap();
     assert_eq!(nread, 1);
     assert_eq!(buf, [4, 0, 0]);
-    assert_eq!(reader.buffer(), []);
+    assert_eq!(reader.buffer(), [0u8; 0]);
 
     assert_eq!(reader.read(&mut buf).await.unwrap(), 0);
 }
@@ -274,7 +274,7 @@ async fn maybe_pending_buf_read() {
     assert_eq!(v, [0]);
     v.clear();
     reader.read_until(9, &mut v).await.unwrap();
-    assert_eq!(v, []);
+    assert_eq!(v, [0u8; 0]);
 }
 
 // https://github.com/rust-lang/futures-rs/pull/1573#discussion_r281162309

tokio/tests/io_buf_writer.rs

@@ -71,7 +71,7 @@ async fn buf_writer() {
     let mut writer = BufWriter::with_capacity(2, Vec::new());
 
     assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(*writer.get_ref(), [0, 1]);
 
     assert_eq!(writer.write(&[2]).await.unwrap(), 1);
@@ -83,7 +83,7 @@ async fn buf_writer() {
     assert_eq!(*writer.get_ref(), [0, 1]);
 
     writer.flush().await.unwrap();
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(*writer.get_ref(), [0, 1, 2, 3]);
 
     assert_eq!(writer.write(&[4]).await.unwrap(), 1);
@@ -96,23 +96,23 @@ async fn buf_writer() {
     assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5]);
 
     assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]);
 
     assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 
     writer.flush().await.unwrap();
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
 }
 
 #[tokio::test]
 async fn buf_writer_inner_flushes() {
     let mut w = BufWriter::with_capacity(3, Vec::new());
     assert_eq!(w.write(&[0, 1]).await.unwrap(), 2);
-    assert_eq!(*w.get_ref(), []);
+    assert_eq!(*w.get_ref(), [0u8; 0]);
     w.flush().await.unwrap();
     let w = w.into_inner();
     assert_eq!(w, [0, 1]);
@@ -136,7 +136,7 @@ async fn maybe_pending_buf_writer() {
     let mut writer = BufWriter::with_capacity(2, MaybePending::new(Vec::new()));
 
     assert_eq!(writer.write(&[0, 1]).await.unwrap(), 2);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(&writer.get_ref().inner, &[0, 1]);
 
     assert_eq!(writer.write(&[2]).await.unwrap(), 1);
@@ -148,7 +148,7 @@ async fn maybe_pending_buf_writer() {
     assert_eq!(&writer.get_ref().inner, &[0, 1]);
 
     writer.flush().await.unwrap();
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(&writer.get_ref().inner, &[0, 1, 2, 3]);
 
     assert_eq!(writer.write(&[4]).await.unwrap(), 1);
@@ -161,18 +161,18 @@ async fn maybe_pending_buf_writer() {
     assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5]);
 
     assert_eq!(writer.write(&[7, 8]).await.unwrap(), 2);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(writer.get_ref().inner, &[0, 1, 2, 3, 4, 5, 6, 7, 8]);
 
     assert_eq!(writer.write(&[9, 10, 11]).await.unwrap(), 3);
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(
         writer.get_ref().inner,
         &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
     );
 
     writer.flush().await.unwrap();
-    assert_eq!(writer.buffer(), []);
+    assert_eq!(writer.buffer(), [0u8; 0]);
     assert_eq!(
         &writer.get_ref().inner,
         &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
@@ -183,7 +183,7 @@ async fn maybe_pending_buf_writer() {
 async fn maybe_pending_buf_writer_inner_flushes() {
     let mut w = BufWriter::with_capacity(3, MaybePending::new(Vec::new()));
     assert_eq!(w.write(&[0, 1]).await.unwrap(), 2);
-    assert_eq!(&w.get_ref().inner, &[]);
+    assert_eq!(&w.get_ref().inner, &[] as &[u8]);
     w.flush().await.unwrap();
     let w = w.into_inner().inner;
     assert_eq!(w, [0, 1]);

tokio/tests/io_read_until.rs

@@ -20,7 +20,7 @@ async fn read_until() {
     buf.clear();
     let n = assert_ok!(rd.read_until(b' ', &mut buf).await);
     assert_eq!(n, 0);
-    assert_eq!(buf, []);
+    assert_eq!(buf, [0u8; 0]);
 }
 
 #[tokio::test]

tokio/tests/net_unix_pipe.rs

@@ -321,7 +321,7 @@ async fn try_read_write() -> io::Result<()> {
     let writer = pipe::OpenOptions::new().open_sender(&fifo)?;
 
     // Fill the pipe buffer with `try_write`.
-    let mut write_data = Vec::new();
+    let mut write_data = Vec::<u8>::new();
     while writable_by_poll(&writer) {
         match writer.try_write(DATA) {
             Ok(n) => write_data.extend(&DATA[..n]),
@@ -364,7 +364,7 @@ async fn try_read_write_vectored() -> io::Result<()> {
     let write_bufs: Vec<_> = DATA.chunks(3).map(io::IoSlice::new).collect();
 
     // Fill the pipe buffer with `try_write_vectored`.
-    let mut write_data = Vec::new();
+    let mut write_data = Vec::<u8>::new();
     while writable_by_poll(&writer) {
         match writer.try_write_vectored(&write_bufs) {
             Ok(n) => write_data.extend(&DATA[..n]),
@@ -410,7 +410,7 @@ async fn try_read_buf() -> std::io::Result<()> {
     let writer = pipe::OpenOptions::new().open_sender(&fifo)?;
 
     // Fill the pipe buffer with `try_write`.
-    let mut write_data = Vec::new();
+    let mut write_data = Vec::<u8>::new();
     while writable_by_poll(&writer) {
         match writer.try_write(DATA) {
             Ok(n) => write_data.extend(&DATA[..n]),

tokio/tests/rt_unstable_metrics.rs

@@ -302,7 +302,7 @@ fn worker_poll_count_and_time() {
     });
     drop(rt);
     // Account for the `block_on` task
-    let n = (0..metrics.num_workers())
+    let n: u64 = (0..metrics.num_workers())
         .map(|i| metrics.worker_poll_count(i))
         .sum();
 
@@ -358,7 +358,7 @@ fn log_histogram() {
         metrics.poll_time_histogram_bucket_range(118).end,
         Duration::from_nanos(u64::MAX)
     );
-    let n = (0..metrics.num_workers())
+    let n: u64 = (0..metrics.num_workers())
         .flat_map(|i| (0..num_buckets).map(move |j| (i, j)))
         .map(|(worker, bucket)| metrics.poll_time_histogram_bucket_count(worker, bucket))
         .sum();
@@ -463,7 +463,7 @@ fn worker_poll_count_histogram() {
         assert!(metrics.poll_time_histogram_enabled());
         assert_eq!(num_buckets, 3);
 
-        let n = (0..num_workers)
+        let n: u64 = (0..num_workers)
             .flat_map(|i| (0..num_buckets).map(move |j| (i, j)))
             .map(|(worker, bucket)| metrics.poll_time_histogram_bucket_count(worker, bucket))
             .sum();

tokio/tests/time_interval.rs

@@ -467,7 +467,7 @@ async fn stream_with_interval_poll_tick_no_waking() {
     // We expect the stream to stall because it does not reschedule itself on
     // `Poll::Pending` and neither does [tokio::time::Interval] reschedule the
     // task when returning `Poll::Ready`.
-    assert_eq!(items, vec![]);
+    assert_eq!(items, Vec::<u32>::new());
 }
 
 #[tokio::test(start_paused = true)]