📝 fix cargo clippy for windows

src/coroutine_impl.rs

@@ -13,9 +13,9 @@ use crate::scheduler::get_scheduler;
 use crate::sync::AtomicOption;
 use generator::{Generator, Gn};
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Coroutine framework types
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Coroutine framework types
+////////////////////////////////////////////////////////////////////////////////
 
 pub type EventResult = io::Error;
 
@@ -48,9 +48,9 @@ pub trait EventSource {
     }
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Coroutine destruction
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Coroutine destruction
+////////////////////////////////////////////////////////////////////////////////
 
 pub struct Done;
 
@@ -95,9 +95,9 @@ fn get_co_local(co: &CoroutineImpl) -> *mut CoroutineLocal {
     co.get_local_data() as *mut CoroutineLocal
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Coroutine
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Coroutine
+////////////////////////////////////////////////////////////////////////////////
 
 /// The internal representation of a `Coroutine` handle
 struct Inner {

src/cqueue.rs

@@ -94,9 +94,9 @@ pub struct EventSender<'a> {
     cqueue: &'a Cqueue,
 }
 
-unsafe impl<'a> Send for EventSender<'a> {}
+unsafe impl Send for EventSender<'_> {}
 
-impl<'a> EventSender<'a> {
+impl EventSender<'_> {
     /// get the token
     pub fn get_token(&self) -> usize {
         self.token
@@ -111,7 +111,7 @@ impl<'a> EventSender<'a> {
     }
 }
 
-impl<'a> EventSource for EventSender<'a> {
+impl EventSource for EventSender<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         self.cqueue.ev_queue.push(Event {
             id: self.id,
@@ -130,7 +130,7 @@ impl<'a> EventSource for EventSender<'a> {
     }
 }
 
-impl<'a> Drop for EventSender<'a> {
+impl Drop for EventSender<'_> {
     // when the select coroutine finished will trigger this drop
     fn drop(&mut self) {
         self.cqueue.ev_queue.push(Event {

src/io/sys/windows/miow.rs

@@ -682,7 +682,7 @@ pub struct AcceptAddrs<'a> {
     _data: &'a AcceptAddrsBuf,
 }
 
-impl<'a> AcceptAddrs<'a> {
+impl AcceptAddrs<'_> {
     /// Returns the local socket address contained in this buffer.
     #[allow(dead_code)]
     pub fn local(&self) -> Option<SocketAddr> {

src/io/sys/windows/net/socket_peek.rs

@@ -48,7 +48,7 @@ impl<'a> SocketPeek<'a> {
     }
 }
 
-impl<'a> EventSource for SocketPeek<'a> {
+impl EventSource for SocketPeek<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();
         #[cfg(feature = "io_cancel")]

src/io/sys/windows/net/socket_read.rs

@@ -47,7 +47,7 @@ impl<'a> SocketRead<'a> {
     }
 }
 
-impl<'a> EventSource for SocketRead<'a> {
+impl EventSource for SocketRead<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();
         #[cfg(feature = "io_cancel")]

src/io/sys/windows/net/socket_write.rs

@@ -40,7 +40,7 @@ impl<'a> SocketWrite<'a> {
     }
 }
 
-impl<'a> EventSource for SocketWrite<'a> {
+impl EventSource for SocketWrite<'_> {
     #[allow(clippy::needless_return)]
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();

src/io/sys/windows/net/tcp_listener_accept.rs

@@ -64,7 +64,7 @@ impl<'a> TcpListenerAccept<'a> {
     }
 }
 
-impl<'a> EventSource for TcpListenerAccept<'a> {
+impl EventSource for TcpListenerAccept<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         let _g = self.can_drop.delay_drop();
         let s = get_scheduler();

src/io/sys/windows/net/udp_recv_from.rs

@@ -50,7 +50,7 @@ impl<'a> UdpRecvFrom<'a> {
     }
 }
 
-impl<'a> EventSource for UdpRecvFrom<'a> {
+impl EventSource for UdpRecvFrom<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         let _g = self.can_drop.delay_drop();
         let s = get_scheduler();

src/io/sys/windows/net/udp_send_to.rs

@@ -46,7 +46,7 @@ impl<'a> UdpSendTo<'a> {
     }
 }
 
-impl<'a> EventSource for UdpSendTo<'a> {
+impl EventSource for UdpSendTo<'_> {
     #[allow(clippy::needless_return)]
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();

src/io/sys/windows/pipe/pipe_read.rs

@@ -51,7 +51,7 @@ impl<'a> PipeRead<'a> {
     }
 }
 
-impl<'a> EventSource for PipeRead<'a> {
+impl EventSource for PipeRead<'_> {
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();
         #[cfg(feature = "io_cancel")]

src/io/sys/windows/pipe/pipe_write.rs

@@ -39,7 +39,7 @@ impl<'a> PipeWrite<'a> {
     }
 }
 
-impl<'a> EventSource for PipeWrite<'a> {
+impl EventSource for PipeWrite<'_> {
     #[allow(clippy::needless_return)]
     fn subscribe(&mut self, co: CoroutineImpl) {
         let s = get_scheduler();

src/net/tcp.rs

@@ -459,7 +459,7 @@ pub struct Incoming<'a> {
     listener: &'a TcpListener,
 }
 
-impl<'a> Iterator for Incoming<'a> {
+impl Iterator for Incoming<'_> {
     type Item = io::Result<TcpStream>;
     fn next(&mut self) -> Option<io::Result<TcpStream>> {
         Some(self.listener.accept().map(|p| p.0))

src/park.rs

@@ -178,7 +178,7 @@ impl Park {
     }
 }
 
-impl<'a> Drop for DropGuard<'a> {
+impl Drop for DropGuard<'_> {
     fn drop(&mut self) {
         self.0.wait_kernel.store(false, Ordering::Release);
     }

src/scoped.rs

@@ -81,7 +81,7 @@ where
     ret
 }
 
-impl<'a> fmt::Debug for Scope<'a> {
+impl fmt::Debug for Scope<'_> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "Scope {{ ... }}")
     }
@@ -208,7 +208,7 @@ impl<T> ScopedJoinHandle<T> {
     }
 }
 
-impl<'a> Drop for Scope<'a> {
+impl Drop for Scope<'_> {
     fn drop(&mut self) {
         self.drop_all()
     }

src/sync/atomic_dur.rs

@@ -44,10 +44,5 @@ impl AtomicDuration {
 }
 
 fn dur_to_ms(dur: Duration) -> u64 {
-    // Note that a duration is a (u64, u32) (seconds, nanoseconds) pair
-    const MS_PER_SEC: u64 = 1_000;
-    const NANOS_PER_MILLI: u64 = 1_000_000;
-    let ns = u64::from(dur.subsec_nanos());
-    let ms = (ns + NANOS_PER_MILLI - 1) / NANOS_PER_MILLI;
-    dur.as_secs().saturating_mul(MS_PER_SEC).saturating_add(ms)
+    dur.as_millis() as u64
 }

src/sync/delay_drop.rs

@@ -32,7 +32,7 @@ impl DelayDrop {
     }
 }
 
-impl<'a> Drop for DropGuard<'a> {
+impl Drop for DropGuard<'_> {
     fn drop(&mut self) {
         // kernel would set it to true
         self.0.can_drop.fetch_and(1, Ordering::Release);

src/sync/mpmc.rs

@@ -162,9 +162,9 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
     (Sender::new(a.clone()), Receiver::new(a))
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Sender
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Sender
+////////////////////////////////////////////////////////////////////////////////
 
 impl<T> Sender<T> {
     fn new(inner: Arc<InnerQueue<T>>) -> Sender<T> {
@@ -200,9 +200,9 @@ impl<T> fmt::Debug for Sender<T> {
     }
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Receiver
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Receiver
+////////////////////////////////////////////////////////////////////////////////
 
 impl<T> Receiver<T> {
     fn new(inner: Arc<InnerQueue<T>>) -> Receiver<T> {
@@ -233,15 +233,15 @@ impl<T> Receiver<T> {
     }
 }
 
-impl<'a, T> Iterator for Iter<'a, T> {
+impl<T> Iterator for Iter<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
         self.rx.recv().ok()
     }
 }
 
-impl<'a, T> Iterator for TryIter<'a, T> {
+impl<T> Iterator for TryIter<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {

src/sync/mpsc.rs

@@ -146,9 +146,9 @@ pub fn channel<T>() -> (Sender<T>, Receiver<T>) {
     (Sender::new(a.clone()), Receiver::new(a))
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Sender
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Sender
+////////////////////////////////////////////////////////////////////////////////
 
 impl<T> Sender<T> {
     fn new(inner: Arc<InnerQueue<T>>) -> Sender<T> {
@@ -179,9 +179,9 @@ impl<T> fmt::Debug for Sender<T> {
     }
 }
 
-/// /////////////////////////////////////////////////////////////////////////////
-/// Receiver
-/// /////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+// Receiver
+////////////////////////////////////////////////////////////////////////////////
 
 impl<T> Receiver<T> {
     fn new(inner: Arc<InnerQueue<T>>) -> Receiver<T> {
@@ -237,15 +237,15 @@ impl<T> Receiver<T> {
     }
 }
 
-impl<'a, T> Iterator for Iter<'a, T> {
+impl<T> Iterator for Iter<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
         self.rx.recv().ok()
     }
 }
 
-impl<'a, T> Iterator for TryIter<'a, T> {
+impl<T> Iterator for TryIter<'_, T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {

src/sync/mutex.rs

@@ -190,21 +190,21 @@ impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
     }
 }
 
-impl<'mutex, T: ?Sized> Deref for MutexGuard<'mutex, T> {
+impl<T: ?Sized> Deref for MutexGuard<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &T {
         unsafe { &*self.__lock.data.get() }
     }
 }
 
-impl<'mutex, T: ?Sized> DerefMut for MutexGuard<'mutex, T> {
+impl<T: ?Sized> DerefMut for MutexGuard<'_, T> {
     fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.__lock.data.get() }
     }
 }
 
-impl<'a, T: ?Sized> Drop for MutexGuard<'a, T> {
+impl<T: ?Sized> Drop for MutexGuard<'_, T> {
     #[inline]
     fn drop(&mut self) {
         self.__lock.poison.done(&self.__poison);
@@ -214,7 +214,7 @@ impl<'a, T: ?Sized> Drop for MutexGuard<'a, T> {
     }
 }
 
-impl<'a, T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'a, T> {
+impl<T: ?Sized + fmt::Debug> fmt::Debug for MutexGuard<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("MutexGuard")
             .field("lock", &self.__lock)

src/sync/rwlock.rs

@@ -265,51 +265,51 @@ impl<'rwlock, T: ?Sized> RwLockWriteGuard<'rwlock, T> {
     }
 }
 
-impl<'a, T: fmt::Debug> fmt::Debug for RwLockReadGuard<'a, T> {
+impl<T: fmt::Debug> fmt::Debug for RwLockReadGuard<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("RwLockReadGuard")
             .field("lock", &self.__lock)
             .finish()
     }
 }
 
-impl<'a, T: fmt::Debug> fmt::Debug for RwLockWriteGuard<'a, T> {
+impl<T: fmt::Debug> fmt::Debug for RwLockWriteGuard<'_, T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.debug_struct("RwLockWriteGuard")
             .field("lock", &self.__lock)
             .finish()
     }
 }
 
-impl<'rwlock, T: ?Sized> Deref for RwLockReadGuard<'rwlock, T> {
+impl<T: ?Sized> Deref for RwLockReadGuard<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &T {
         unsafe { &*self.__lock.data.get() }
     }
 }
 
-impl<'rwlock, T: ?Sized> Deref for RwLockWriteGuard<'rwlock, T> {
+impl<T: ?Sized> Deref for RwLockWriteGuard<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &T {
         unsafe { &*self.__lock.data.get() }
     }
 }
 
-impl<'rwlock, T: ?Sized> DerefMut for RwLockWriteGuard<'rwlock, T> {
+impl<T: ?Sized> DerefMut for RwLockWriteGuard<'_, T> {
     fn deref_mut(&mut self) -> &mut T {
         unsafe { &mut *self.__lock.data.get() }
     }
 }
 
-impl<'a, T: ?Sized> Drop for RwLockReadGuard<'a, T> {
+impl<T: ?Sized> Drop for RwLockReadGuard<'_, T> {
     fn drop(&mut self) {
         self.__lock.read_unlock();
     }
 }
 
-impl<'a, T: ?Sized> Drop for RwLockWriteGuard<'a, T> {
+impl<T: ?Sized> Drop for RwLockWriteGuard<'_, T> {
     fn drop(&mut self) {
         self.__lock.poison.done(&self.__poison);
         self.__lock.write_unlock();