cargo fix --edition=2018

Author: yoshuawuyts

src/handle.rs

@@ -36,7 +36,7 @@ impl Handle {
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
         let mut bytes = 0;
         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
-        ::cvt(unsafe {
+        crate::cvt(unsafe {
             WriteFile(
                 self.0,
                 buf.as_ptr() as *const _,
@@ -51,7 +51,7 @@ impl Handle {
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
         let mut bytes = 0;
         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
-        ::cvt(unsafe {
+        crate::cvt(unsafe {
             ReadFile(
                 self.0,
                 buf.as_mut_ptr() as *mut _,
@@ -90,7 +90,7 @@ impl Handle {
         wait: BOOLEAN,
     ) -> io::Result<Option<usize>> {
         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
-        let res = ::cvt({
+        let res = crate::cvt({
             ReadFile(
                 self.0,
                 buf.as_mut_ptr() as *mut _,
@@ -106,7 +106,7 @@ impl Handle {
         }
 
         let mut bytes = 0;
-        let res = ::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) });
+        let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) });
         match res {
             Ok(_) => Ok(Some(bytes as usize)),
             Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => {
@@ -143,7 +143,7 @@ impl Handle {
         wait: BOOLEAN,
     ) -> io::Result<Option<usize>> {
         let len = cmp::min(buf.len(), <DWORD>::max_value() as usize) as DWORD;
-        let res = ::cvt({
+        let res = crate::cvt({
             WriteFile(
                 self.0,
                 buf.as_ptr() as *const _,
@@ -159,7 +159,7 @@ impl Handle {
         }
 
         let mut bytes = 0;
-        let res = ::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) });
+        let res = crate::cvt({ GetOverlappedResult(self.0, overlapped, &mut bytes, wait as BOOL) });
         match res {
             Ok(_) => Ok(Some(bytes as usize)),
             Err(ref e) if e.raw_os_error() == Some(ERROR_IO_INCOMPLETE as i32) && wait == FALSE => {

src/iocp.rs

@@ -7,13 +7,13 @@ use std::mem;
 use std::os::windows::io::*;
 use std::time::Duration;
 
-use handle::Handle;
+use crate::handle::Handle;
 use winapi::shared::basetsd::*;
 use winapi::shared::ntdef::*;
 use winapi::um::handleapi::*;
 use winapi::um::ioapiset::*;
 use winapi::um::minwinbase::*;
-use Overlapped;
+use crate::Overlapped;
 
 /// A handle to an Windows I/O Completion Port.
 #[derive(Debug)]
@@ -110,7 +110,7 @@ impl CompletionPort {
         let mut bytes = 0;
         let mut token = 0;
         let mut overlapped = 0 as *mut _;
-        let timeout = ::dur2ms(timeout);
+        let timeout = crate::dur2ms(timeout);
         let ret = unsafe {
             GetQueuedCompletionStatus(
                 self.handle.raw(),
@@ -120,7 +120,7 @@ impl CompletionPort {
                 timeout,
             )
         };
-        ::cvt(ret).map(|_| {
+        crate::cvt(ret).map(|_| {
             CompletionStatus(OVERLAPPED_ENTRY {
                 dwNumberOfBytesTransferred: bytes,
                 lpCompletionKey: token,
@@ -149,7 +149,7 @@ impl CompletionPort {
             mem::size_of::<OVERLAPPED_ENTRY>()
         );
         let mut removed = 0;
-        let timeout = ::dur2ms(timeout);
+        let timeout = crate::dur2ms(timeout);
         let len = cmp::min(list.len(), <ULONG>::max_value() as usize) as ULONG;
         let ret = unsafe {
             GetQueuedCompletionStatusEx(
@@ -161,7 +161,7 @@ impl CompletionPort {
                 FALSE as i32,
             )
         };
-        match ::cvt(ret) {
+        match crate::cvt(ret) {
             Ok(_) => Ok(&mut list[..removed as usize]),
             Err(e) => Err(e),
         }
@@ -181,7 +181,7 @@ impl CompletionPort {
                 status.0.lpOverlapped,
             )
         };
-        ::cvt(ret).map(|_| ())
+        crate::cvt(ret).map(|_| ())
     }
 }
 
@@ -273,7 +273,7 @@ mod tests {
     use winapi::shared::basetsd::*;
     use winapi::shared::winerror::*;
 
-    use iocp::{CompletionPort, CompletionStatus};
+    use crate::iocp::{CompletionPort, CompletionStatus};
 
     #[test]
     fn is_send_sync() {

src/lib.rs

@@ -35,7 +35,7 @@ pub mod iocp;
 pub mod net;
 pub mod pipe;
 
-pub use overlapped::Overlapped;
+pub use crate::overlapped::Overlapped;
 
 fn cvt(i: BOOL) -> io::Result<BOOL> {
     if i == 0 {

src/net.rs

@@ -975,10 +975,10 @@ mod tests {
 
     use socket2::{Domain, Socket, Type};
 
-    use iocp::CompletionPort;
-    use net::{AcceptAddrsBuf, TcpListenerExt};
-    use net::{SocketAddrBuf, TcpStreamExt, UdpSocketExt};
-    use Overlapped;
+    use crate::iocp::CompletionPort;
+    use crate::net::{AcceptAddrsBuf, TcpListenerExt};
+    use crate::net::{SocketAddrBuf, TcpStreamExt, UdpSocketExt};
+    use crate::Overlapped;
 
     fn each_ip(f: &mut dyn FnMut(SocketAddr)) {
         f(t!("127.0.0.1:0".parse()));

src/pipe.rs

@@ -9,8 +9,8 @@ use std::os::windows::ffi::*;
 use std::os::windows::io::*;
 use std::time::Duration;
 
-use handle::Handle;
-use overlapped::Overlapped;
+use crate::handle::Handle;
+use crate::overlapped::Overlapped;
 use winapi::shared::minwindef::*;
 use winapi::shared::ntdef::HANDLE;
 use winapi::shared::winerror::*;
@@ -54,7 +54,7 @@ pub struct NamedPipeBuilder {
 pub fn anonymous(buffer_size: u32) -> io::Result<(AnonRead, AnonWrite)> {
     let mut read = 0 as HANDLE;
     let mut write = 0 as HANDLE;
-    ::cvt(unsafe { CreatePipe(&mut read, &mut write, 0 as *mut _, buffer_size) })?;
+    crate::cvt(unsafe { CreatePipe(&mut read, &mut write, 0 as *mut _, buffer_size) })?;
     Ok((AnonRead(Handle::new(read)), AnonWrite(Handle::new(write))))
 }
 
@@ -181,8 +181,8 @@ impl NamedPipe {
 
     fn _wait(addr: &OsStr, timeout: Option<Duration>) -> io::Result<()> {
         let addr = addr.encode_wide().chain(Some(0)).collect::<Vec<_>>();
-        let timeout = ::dur2ms(timeout);
-        ::cvt(unsafe { WaitNamedPipeW(addr.as_ptr(), timeout) }).map(|_| ())
+        let timeout = crate::dur2ms(timeout);
+        crate::cvt(unsafe { WaitNamedPipeW(addr.as_ptr(), timeout) }).map(|_| ())
     }
 
     /// Connects this named pipe to a client, blocking until one becomes
@@ -192,7 +192,7 @@ impl NamedPipe {
     /// client to connect. This can be called immediately after the pipe is
     /// created, or after it has been disconnected from a previous client.
     pub fn connect(&self) -> io::Result<()> {
-        match ::cvt(unsafe { ConnectNamedPipe(self.0.raw(), 0 as *mut _) }) {
+        match crate::cvt(unsafe { ConnectNamedPipe(self.0.raw(), 0 as *mut _) }) {
             Ok(_) => Ok(()),
             Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(()),
             Err(e) => Err(e),
@@ -219,7 +219,7 @@ impl NamedPipe {
     /// valid until the I/O operation is completed, typically via completion
     /// ports and waiting to receive the completion notification on the port.
     pub unsafe fn connect_overlapped(&self, overlapped: *mut OVERLAPPED) -> io::Result<bool> {
-        match ::cvt(ConnectNamedPipe(self.0.raw(), overlapped)) {
+        match crate::cvt(ConnectNamedPipe(self.0.raw(), overlapped)) {
             Ok(_) => Ok(true),
             Err(ref e) if e.raw_os_error() == Some(ERROR_PIPE_CONNECTED as i32) => Ok(true),
             Err(ref e) if e.raw_os_error() == Some(ERROR_IO_PENDING as i32) => Ok(false),
@@ -229,7 +229,7 @@ impl NamedPipe {
 
     /// Disconnects this named pipe from any connected client.
     pub fn disconnect(&self) -> io::Result<()> {
-        ::cvt(unsafe { DisconnectNamedPipe(self.0.raw()) }).map(|_| ())
+        crate::cvt(unsafe { DisconnectNamedPipe(self.0.raw()) }).map(|_| ())
     }
 
     /// Issues an overlapped read operation to occur on this pipe.
@@ -388,7 +388,7 @@ impl<'a> Write for &'a NamedPipe {
         })
     }
     fn flush(&mut self) -> io::Result<()> {
-        ::cvt(unsafe { FlushFileBuffers(self.0.raw()) }).map(|_| ())
+        crate::cvt(unsafe { FlushFileBuffers(self.0.raw()) }).map(|_| ())
     }
 }
 
@@ -528,8 +528,8 @@ mod tests {
     use rand::{thread_rng, Rng};
 
     use super::{anonymous, NamedPipe, NamedPipeBuilder};
-    use iocp::CompletionPort;
-    use Overlapped;
+    use crate::iocp::CompletionPort;
+    use crate::Overlapped;
 
     fn name() -> String {
         let name = thread_rng().gen_ascii_chars().take(30).collect::<String>();