📝 fix cargo clippy warnings

Author: Xudong-Huang

examples/echo_client.rs

@@ -77,7 +77,7 @@ fn main() {
 
     let msg = vec![0; test_msg_len];
 
-    let err = io::Error::new(io::ErrorKind::Other, "can't resolve socket addresses");
+    let err = io::Error::other("can't resolve socket addresses");
     let addr = t!(target_addr.to_socket_addrs())
         .fold(Err(err), |prev, addr| prev.or(Ok(addr)))
         .unwrap();

examples/echo_udp_client.rs

@@ -70,7 +70,7 @@ fn main() {
     let test_conn_num = args.flag_c;
     let test_seconds = args.flag_d;
 
-    let err = io::Error::new(io::ErrorKind::Other, "can't resolve socket addresses");
+    let err = io::Error::other("can't resolve socket addresses");
     let addr = t!(target_addr.to_socket_addrs())
         .fold(Err(err), |prev, addr| prev.or(Ok(addr)))
         .unwrap();

examples/echo_udp_client1.rs

@@ -70,7 +70,7 @@ fn main() {
     let test_conn_num = args.flag_c;
     let test_seconds = args.flag_d;
 
-    let err = io::Error::new(io::ErrorKind::Other, "can't resolve socket addresses");
+    let err = io::Error::other("can't resolve socket addresses");
     let addr = t!(target_addr.to_socket_addrs())
         .fold(Err(err), |prev, addr| prev.or(Ok(addr)))
         .unwrap();

may_queue/src/mpsc_list.rs

@@ -53,7 +53,7 @@ impl<T> Queue<T> {
     pub fn is_empty(&self) -> bool {
         let tail = unsafe { *self.tail.get() };
         // the list is empty
-        self.head.load(Ordering::Acquire) == tail
+        std::ptr::eq(self.head.load(Ordering::Acquire), tail)
     }
 
     /// Pops some data from this queue.
@@ -62,7 +62,7 @@ impl<T> Queue<T> {
             let tail = *self.tail.get();
 
             // the list is empty
-            if self.head.load(Ordering::Acquire) == tail {
+            if std::ptr::eq(self.head.load(Ordering::Acquire), tail) {
                 return None;
             }
 

may_queue/src/mpsc_list_v1.rs

@@ -172,7 +172,7 @@ impl<T> Queue<T> {
             (*node).prev = prev;
             (*prev).next.store(node, Ordering::Release);
             let tail = *self.tail.get();
-            let is_head = tail == prev;
+            let is_head = std::ptr::eq(tail, prev);
             (Entry(ptr::NonNull::new_unchecked(node)), is_head)
         }
     }
@@ -182,7 +182,7 @@ impl<T> Queue<T> {
     pub fn is_empty(&self) -> bool {
         let tail = unsafe { *self.tail.get() };
         // the list is empty
-        self.head.load(Ordering::Acquire) == tail
+        std::ptr::eq(self.head.load(Ordering::Acquire), tail)
     }
 
     /// get the head ref
@@ -192,7 +192,7 @@ impl<T> Queue<T> {
     pub unsafe fn peek(&self) -> Option<&T> {
         let tail = *self.tail.get();
         // the list is empty
-        if self.head.load(Ordering::Acquire) == tail {
+        if std::ptr::eq(self.head.load(Ordering::Acquire), tail) {
             return None;
         }
         // spin until tail next become non-null
@@ -219,7 +219,7 @@ impl<T> Queue<T> {
         unsafe {
             let tail = *self.tail.get();
             // the list is empty
-            if self.head.load(Ordering::Acquire) == tail {
+            if std::ptr::eq(self.head.load(Ordering::Acquire), tail) {
                 return None;
             }
 
@@ -270,7 +270,7 @@ impl<T> Queue<T> {
             let tail = *self.tail.get();
 
             // the list is empty
-            if self.head.load(Ordering::Acquire) == tail {
+            if std::ptr::eq(self.head.load(Ordering::Acquire), tail) {
                 return None;
             }
 

may_queue/src/spmc.rs

@@ -195,7 +195,7 @@ impl<T> Queue<T> {
         loop {
             head = (head as usize & !(1 << 63)) as *mut BlockNode<T>;
             let (block, id) = BlockPtr::unpack(head);
-            if block == tail_block && id >= (push_index & BLOCK_MASK) {
+            if std::ptr::eq(block, tail_block) && id >= (push_index & BLOCK_MASK) {
                 return None;
             }
 
@@ -265,7 +265,7 @@ impl<T> Queue<T> {
         loop {
             head = (head as usize & !(1 << 63)) as *mut BlockNode<T>;
             let (block, id) = BlockPtr::unpack(head);
-            if block == tail_block && id >= (push_index & BLOCK_MASK) {
+            if std::ptr::eq(block, tail_block) && id >= (push_index & BLOCK_MASK) {
                 return None;
             }
 
@@ -336,11 +336,15 @@ impl<T> Queue<T> {
             let (block, id) = BlockPtr::unpack(head);
             let push_id = push_index & BLOCK_MASK;
             // at least leave one element to the owner
-            if block == tail_block && id >= push_id {
+            if std::ptr::eq(block, tail_block) && id >= push_id {
                 return SmallVec::new();
             }
 
-            let new_id = if block != tail_block { 0 } else { push_id };
+            let new_id = if !std::ptr::eq(block, tail_block) {
+                0
+            } else {
+                push_id
+            };
 
             let new_head = if new_id == 0 {
                 (head as usize | (1 << 63)) as *mut BlockNode<T>
@@ -435,7 +439,7 @@ impl<T> Queue<T> {
         let push_index = self.tail.index.load(Ordering::Acquire);
         let tail_block = self.tail.block.load(Ordering::Acquire);
 
-        block == tail_block && id == (push_index & BLOCK_MASK)
+        std::ptr::eq(block, tail_block) && id == (push_index & BLOCK_MASK)
     }
 }
 

may_queue/src/spsc.rs

@@ -310,7 +310,7 @@ impl<T> Drop for Queue<T> {
         #[cfg(feature = "inner_cache")]
         let mut first = self.first.load(Ordering::Relaxed);
         #[cfg(feature = "inner_cache")]
-        while first != tail {
+        while !std::ptr::eq(first, tail) {
             let next = unsafe { &*first }.next.load(Ordering::Relaxed);
             let _ = unsafe { Box::from_raw(first) };
             first = next;

src/cancel.rs

@@ -134,7 +134,7 @@ impl<T: CancelIo> CancelImpl<T> {
             if let Some(mut co) = co.take() {
                 // this is not safe, the kernel may still need to use the overlapped
                 // set the cancel result for the coroutine
-                set_co_para(&mut co, io::Error::new(io::ErrorKind::Other, "Canceled"));
+                set_co_para(&mut co, io::Error::other("Canceled"));
                 get_scheduler().schedule(co);
             }
         }

src/io/sys/unix/net/tcp_stream_connect.rs

@@ -33,7 +33,7 @@ impl TcpStreamConnect {
         // let err = io::Error::new(io::ErrorKind::Other, "no socket addresses resolved");
         addr.to_socket_addrs()?
             .next()
-            .ok_or_else(|| io::Error::new(io::ErrorKind::Other, "no socket addresses resolved"))
+            .ok_or_else(|| io::Error::other("no socket addresses resolved"))
             .and_then(|addr| {
                 let stream = match addr {
                     SocketAddr::V4(..) => Socket::new(Domain::IPV4, Type::STREAM, None)?,

src/yield_now.rs

@@ -23,10 +23,7 @@ pub fn yield_with<T: EventSource>(resource: &T) {
     // if cancel detected in user space
     // no need to get into kernel any more
     if unlikely(cancel.is_canceled()) {
-        co_set_para(::std::io::Error::new(
-            ::std::io::ErrorKind::Other,
-            "Canceled",
-        ));
+        co_set_para(std::io::Error::other("Canceled"));
         return resource.yield_back(cancel);
     }