From 93b6d9e086c6910118a57e4332c9448ab550931f Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 11 Feb 2019 04:23:21 +0900 Subject: libstd => 2018 --- src/libstd/sys/cloudabi/abi/cloudabi.rs | 150 ++++++++++----------- src/libstd/sys/cloudabi/args.rs | 2 +- src/libstd/sys/cloudabi/backtrace.rs | 17 +-- src/libstd/sys/cloudabi/condvar.rs | 14 +- src/libstd/sys/cloudabi/mod.rs | 40 +++--- src/libstd/sys/cloudabi/mutex.rs | 10 +- src/libstd/sys/cloudabi/os.rs | 9 +- src/libstd/sys/cloudabi/rwlock.rs | 8 +- src/libstd/sys/cloudabi/shims/args.rs | 2 +- src/libstd/sys/cloudabi/shims/fs.rs | 14 +- src/libstd/sys/cloudabi/shims/mod.rs | 2 +- src/libstd/sys/cloudabi/shims/net.rs | 15 ++- src/libstd/sys/cloudabi/shims/os.rs | 14 +- src/libstd/sys/cloudabi/shims/pipe.rs | 4 +- src/libstd/sys/cloudabi/shims/process.rs | 14 +- src/libstd/sys/cloudabi/stdio.rs | 6 +- src/libstd/sys/cloudabi/thread.rs | 21 ++- src/libstd/sys/cloudabi/time.rs | 6 +- src/libstd/sys/mod.rs | 2 +- src/libstd/sys/redox/args.rs | 17 ++- src/libstd/sys/redox/backtrace/mod.rs | 12 +- src/libstd/sys/redox/backtrace/printing.rs | 2 +- src/libstd/sys/redox/backtrace/tracing.rs | 14 +- src/libstd/sys/redox/condvar.rs | 14 +- src/libstd/sys/redox/ext/ffi.rs | 8 +- src/libstd/sys/redox/ext/fs.rs | 10 +- src/libstd/sys/redox/ext/io.rs | 10 +- src/libstd/sys/redox/ext/net.rs | 14 +- src/libstd/sys/redox/ext/process.rs | 10 +- src/libstd/sys/redox/ext/thread.rs | 4 +- src/libstd/sys/redox/fast_thread_local.rs | 10 +- src/libstd/sys/redox/fd.rs | 8 +- src/libstd/sys/redox/fs.rs | 24 ++-- src/libstd/sys/redox/mod.rs | 12 +- src/libstd/sys/redox/mutex.rs | 8 +- src/libstd/sys/redox/net/dns/answer.rs | 4 +- src/libstd/sys/redox/net/dns/mod.rs | 8 +- src/libstd/sys/redox/net/dns/query.rs | 2 +- src/libstd/sys/redox/net/mod.rs | 20 +-- src/libstd/sys/redox/net/tcp.rs | 18 +-- src/libstd/sys/redox/net/udp.rs | 20 +-- src/libstd/sys/redox/os.rs | 44 +++--- src/libstd/sys/redox/os_str.rs | 17 +-- src/libstd/sys/redox/path.rs | 4 +- src/libstd/sys/redox/pipe.rs | 6 +- src/libstd/sys/redox/process.rs | 35 ++--- src/libstd/sys/redox/stdio.rs | 10 +- src/libstd/sys/redox/thread.rs | 14 +- src/libstd/sys/redox/thread_local.rs | 6 +- src/libstd/sys/redox/time.rs | 11 +- src/libstd/sys/sgx/abi/mod.rs | 4 +- src/libstd/sys/sgx/abi/panic.rs | 6 +- src/libstd/sys/sgx/abi/reloc.rs | 2 +- src/libstd/sys/sgx/abi/tls.rs | 16 +-- src/libstd/sys/sgx/abi/usercalls/alloc.rs | 12 +- src/libstd/sys/sgx/abi/usercalls/mod.rs | 4 +- src/libstd/sys/sgx/abi/usercalls/raw.rs | 6 +- src/libstd/sys/sgx/alloc.rs | 4 +- src/libstd/sys/sgx/args.rs | 10 +- src/libstd/sys/sgx/backtrace.rs | 15 ++- src/libstd/sys/sgx/condvar.rs | 4 +- src/libstd/sys/sgx/ext/arch.rs | 2 +- src/libstd/sys/sgx/ext/ffi.rs | 8 +- src/libstd/sys/sgx/ext/io.rs | 6 +- src/libstd/sys/sgx/fd.rs | 6 +- src/libstd/sys/sgx/fs.rs | 14 +- src/libstd/sys/sgx/mod.rs | 61 ++++----- src/libstd/sys/sgx/net.rs | 18 +-- src/libstd/sys/sgx/os.rs | 24 ++-- src/libstd/sys/sgx/os_str.rs | 17 +-- src/libstd/sys/sgx/path.rs | 4 +- src/libstd/sys/sgx/pipe.rs | 4 +- src/libstd/sys/sgx/process.rs | 14 +- src/libstd/sys/sgx/rwlock.rs | 16 +-- src/libstd/sys/sgx/stdio.rs | 6 +- src/libstd/sys/sgx/thread.rs | 14 +- src/libstd/sys/sgx/time.rs | 2 +- src/libstd/sys/sgx/waitqueue.rs | 24 ++-- src/libstd/sys/unix/alloc.rs | 7 +- src/libstd/sys/unix/android.rs | 10 +- src/libstd/sys/unix/args.rs | 30 ++--- src/libstd/sys/unix/backtrace/mod.rs | 9 +- src/libstd/sys/unix/backtrace/printing/dladdr.rs | 11 +- src/libstd/sys/unix/backtrace/printing/mod.rs | 10 +- .../sys/unix/backtrace/tracing/backtrace_fn.rs | 10 +- src/libstd/sys/unix/backtrace/tracing/gcc_s.rs | 14 +- src/libstd/sys/unix/condvar.rs | 15 +-- src/libstd/sys/unix/ext/ffi.rs | 8 +- src/libstd/sys/unix/ext/fs.rs | 13 +- src/libstd/sys/unix/ext/io.rs | 11 +- src/libstd/sys/unix/ext/net.rs | 36 ++--- src/libstd/sys/unix/ext/process.rs | 12 +- src/libstd/sys/unix/ext/raw.rs | 6 +- src/libstd/sys/unix/ext/thread.rs | 6 +- src/libstd/sys/unix/fast_thread_local.rs | 9 +- src/libstd/sys/unix/fd.rs | 19 +-- src/libstd/sys/unix/fs.rs | 52 +++---- src/libstd/sys/unix/l4re.rs | 18 +-- src/libstd/sys/unix/memchr.rs | 6 +- src/libstd/sys/unix/mod.rs | 47 ++++--- src/libstd/sys/unix/mutex.rs | 6 +- src/libstd/sys/unix/net.rs | 27 ++-- src/libstd/sys/unix/os.rs | 61 ++++----- src/libstd/sys/unix/os_str.rs | 17 +-- src/libstd/sys/unix/path.rs | 4 +- src/libstd/sys/unix/pipe.rs | 13 +- src/libstd/sys/unix/process/process_common.rs | 36 ++--- src/libstd/sys/unix/process/process_fuchsia.rs | 25 ++-- src/libstd/sys/unix/process/process_unix.rs | 23 ++-- src/libstd/sys/unix/process/zircon.rs | 8 +- src/libstd/sys/unix/rand.rs | 24 ++-- src/libstd/sys/unix/rwlock.rs | 5 +- src/libstd/sys/unix/stack_overflow.rs | 12 +- src/libstd/sys/unix/stdio.rs | 7 +- src/libstd/sys/unix/thread.rs | 43 +++--- src/libstd/sys/unix/thread_local.rs | 3 +- src/libstd/sys/unix/time.rs | 28 ++-- src/libstd/sys/unix/weak.rs | 15 +-- src/libstd/sys/wasm/alloc.rs | 8 +- src/libstd/sys/wasm/args.rs | 8 +- src/libstd/sys/wasm/backtrace.rs | 6 +- src/libstd/sys/wasm/condvar.rs | 4 +- src/libstd/sys/wasm/condvar_atomics.rs | 12 +- src/libstd/sys/wasm/fs.rs | 14 +- src/libstd/sys/wasm/mod.rs | 24 ++-- src/libstd/sys/wasm/mutex.rs | 2 +- src/libstd/sys/wasm/mutex_atomics.rs | 10 +- src/libstd/sys/wasm/net.rs | 12 +- src/libstd/sys/wasm/os.rs | 14 +- src/libstd/sys/wasm/os_str.rs | 17 +-- src/libstd/sys/wasm/path.rs | 4 +- src/libstd/sys/wasm/pipe.rs | 4 +- src/libstd/sys/wasm/process.rs | 14 +- src/libstd/sys/wasm/rwlock.rs | 2 +- src/libstd/sys/wasm/rwlock_atomics.rs | 6 +- src/libstd/sys/wasm/stdio.rs | 4 +- src/libstd/sys/wasm/thread.rs | 16 +-- src/libstd/sys/wasm/thread_local.rs | 4 +- src/libstd/sys/wasm/thread_local_atomics.rs | 4 +- src/libstd/sys/wasm/time.rs | 4 +- src/libstd/sys/windows/alloc.rs | 6 +- src/libstd/sys/windows/args.rs | 23 ++-- src/libstd/sys/windows/backtrace/backtrace_gnu.rs | 13 +- src/libstd/sys/windows/backtrace/mod.rs | 13 +- src/libstd/sys/windows/backtrace/printing/mod.rs | 6 +- src/libstd/sys/windows/backtrace/printing/msvc.rs | 19 +-- src/libstd/sys/windows/c.rs | 11 +- src/libstd/sys/windows/compat.rs | 12 +- src/libstd/sys/windows/condvar.rs | 10 +- src/libstd/sys/windows/dynamic_lib.rs | 8 +- src/libstd/sys/windows/ext/ffi.rs | 10 +- src/libstd/sys/windows/ext/fs.rs | 10 +- src/libstd/sys/windows/ext/io.rs | 14 +- src/libstd/sys/windows/ext/process.rs | 8 +- src/libstd/sys/windows/ext/raw.rs | 2 +- src/libstd/sys/windows/ext/thread.rs | 6 +- src/libstd/sys/windows/fast_thread_local.rs | 2 +- src/libstd/sys/windows/fs.rs | 28 ++-- src/libstd/sys/windows/handle.rs | 15 +-- src/libstd/sys/windows/mod.rs | 38 +++--- src/libstd/sys/windows/mutex.rs | 10 +- src/libstd/sys/windows/net.rs | 33 ++--- src/libstd/sys/windows/os.rs | 32 ++--- src/libstd/sys/windows/os_str.rs | 14 +- src/libstd/sys/windows/path.rs | 8 +- src/libstd/sys/windows/pipe.rs | 26 ++-- src/libstd/sys/windows/process.rs | 45 ++++--- src/libstd/sys/windows/rand.rs | 6 +- src/libstd/sys/windows/rwlock.rs | 4 +- src/libstd/sys/windows/stack_overflow.rs | 4 +- src/libstd/sys/windows/stdio.rs | 16 +-- src/libstd/sys/windows/thread.rs | 19 +-- src/libstd/sys/windows/thread_local.rs | 12 +- src/libstd/sys/windows/time.rs | 23 ++-- 174 files changed, 1241 insertions(+), 1243 deletions(-) (limited to 'src/libstd/sys') diff --git a/src/libstd/sys/cloudabi/abi/cloudabi.rs b/src/libstd/sys/cloudabi/abi/cloudabi.rs index 83d45b3547b..2307e2167c5 100644 --- a/src/libstd/sys/cloudabi/abi/cloudabi.rs +++ b/src/libstd/sys/cloudabi/abi/cloudabi.rs @@ -1090,10 +1090,10 @@ pub union auxv_union { #[test] #[cfg(target_pointer_width = "32")] fn auxv_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: auxv = ::core::mem::uninitialized(); + let obj: auxv = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.a_type as *const _ as usize - base, 0); assert_eq!(&obj.union.a_val as *const _ as usize - base, 4); @@ -1103,10 +1103,10 @@ fn auxv_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn auxv_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 16); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 16); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: auxv = ::core::mem::uninitialized(); + let obj: auxv = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.a_type as *const _ as usize - base, 0); assert_eq!(&obj.union.a_val as *const _ as usize - base, 8); @@ -1124,10 +1124,10 @@ pub struct ciovec { #[test] #[cfg(target_pointer_width = "32")] fn ciovec_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: ciovec = ::core::mem::uninitialized(); + let obj: ciovec = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.buf.0 as *const _ as usize - base, 0); assert_eq!(&obj.buf.1 as *const _ as usize - base, 4); @@ -1136,10 +1136,10 @@ fn ciovec_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn ciovec_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 16); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 16); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: ciovec = ::core::mem::uninitialized(); + let obj: ciovec = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.buf.0 as *const _ as usize - base, 0); assert_eq!(&obj.buf.1 as *const _ as usize - base, 8); @@ -1164,10 +1164,10 @@ pub struct dirent { } #[test] fn dirent_layout_test() { - assert_eq!(::core::mem::size_of::(), 24); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 24); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: dirent = ::core::mem::uninitialized(); + let obj: dirent = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.d_next as *const _ as usize - base, 0); assert_eq!(&obj.d_ino as *const _ as usize - base, 8); @@ -1228,10 +1228,10 @@ pub struct event_proc_terminate { } #[test] fn event_layout_test() { - assert_eq!(::core::mem::size_of::(), 32); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 32); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: event = ::core::mem::uninitialized(); + let obj: event = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.userdata as *const _ as usize - base, 0); assert_eq!(&obj.error as *const _ as usize - base, 8); @@ -1262,10 +1262,10 @@ pub struct fdstat { } #[test] fn fdstat_layout_test() { - assert_eq!(::core::mem::size_of::(), 24); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 24); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: fdstat = ::core::mem::uninitialized(); + let obj: fdstat = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.fs_filetype as *const _ as usize - base, 0); assert_eq!(&obj.fs_flags as *const _ as usize - base, 2); @@ -1299,10 +1299,10 @@ pub struct filestat { } #[test] fn filestat_layout_test() { - assert_eq!(::core::mem::size_of::(), 56); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 56); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: filestat = ::core::mem::uninitialized(); + let obj: filestat = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.st_dev as *const _ as usize - base, 0); assert_eq!(&obj.st_ino as *const _ as usize - base, 8); @@ -1325,10 +1325,10 @@ pub struct iovec { #[test] #[cfg(target_pointer_width = "32")] fn iovec_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: iovec = ::core::mem::uninitialized(); + let obj: iovec = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.buf.0 as *const _ as usize - base, 0); assert_eq!(&obj.buf.1 as *const _ as usize - base, 4); @@ -1337,10 +1337,10 @@ fn iovec_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn iovec_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 16); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 16); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: iovec = ::core::mem::uninitialized(); + let obj: iovec = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.buf.0 as *const _ as usize - base, 0); assert_eq!(&obj.buf.1 as *const _ as usize - base, 8); @@ -1360,10 +1360,10 @@ pub struct lookup { } #[test] fn lookup_layout_test() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: lookup = ::core::mem::uninitialized(); + let obj: lookup = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.fd as *const _ as usize - base, 0); assert_eq!(&obj.flags as *const _ as usize - base, 4); @@ -1394,10 +1394,10 @@ pub struct recv_in { #[test] #[cfg(target_pointer_width = "32")] fn recv_in_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 20); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 20); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: recv_in = ::core::mem::uninitialized(); + let obj: recv_in = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.ri_data.0 as *const _ as usize - base, 0); assert_eq!(&obj.ri_data.1 as *const _ as usize - base, 4); @@ -1409,10 +1409,10 @@ fn recv_in_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn recv_in_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 40); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 40); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: recv_in = ::core::mem::uninitialized(); + let obj: recv_in = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.ri_data.0 as *const _ as usize - base, 0); assert_eq!(&obj.ri_data.1 as *const _ as usize - base, 8); @@ -1438,10 +1438,10 @@ pub struct recv_out { #[test] #[cfg(target_pointer_width = "32")] fn recv_out_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 52); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 52); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: recv_out = ::core::mem::uninitialized(); + let obj: recv_out = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.ro_datalen as *const _ as usize - base, 0); assert_eq!(&obj.ro_fdslen as *const _ as usize - base, 4); @@ -1452,10 +1452,10 @@ fn recv_out_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn recv_out_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 64); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 64); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: recv_out = ::core::mem::uninitialized(); + let obj: recv_out = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.ro_datalen as *const _ as usize - base, 0); assert_eq!(&obj.ro_fdslen as *const _ as usize - base, 8); @@ -1480,10 +1480,10 @@ pub struct send_in { #[test] #[cfg(target_pointer_width = "32")] fn send_in_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 20); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 20); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: send_in = ::core::mem::uninitialized(); + let obj: send_in = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.si_data.0 as *const _ as usize - base, 0); assert_eq!(&obj.si_data.1 as *const _ as usize - base, 4); @@ -1495,10 +1495,10 @@ fn send_in_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn send_in_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 40); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 40); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: send_in = ::core::mem::uninitialized(); + let obj: send_in = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.si_data.0 as *const _ as usize - base, 0); assert_eq!(&obj.si_data.1 as *const _ as usize - base, 8); @@ -1518,10 +1518,10 @@ pub struct send_out { #[test] #[cfg(target_pointer_width = "32")] fn send_out_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 4); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 4); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: send_out = ::core::mem::uninitialized(); + let obj: send_out = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.so_datalen as *const _ as usize - base, 0); } @@ -1529,10 +1529,10 @@ fn send_out_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn send_out_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: send_out = ::core::mem::uninitialized(); + let obj: send_out = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.so_datalen as *const _ as usize - base, 0); } @@ -1647,10 +1647,10 @@ pub struct subscription_proc_terminate { #[test] #[cfg(target_pointer_width = "32")] fn subscription_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 56); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 56); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: subscription = ::core::mem::uninitialized(); + let obj: subscription = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.userdata as *const _ as usize - base, 0); assert_eq!(&obj.unused as *const _ as usize - base, 8); @@ -1674,10 +1674,10 @@ fn subscription_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn subscription_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 56); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 56); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: subscription = ::core::mem::uninitialized(); + let obj: subscription = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.userdata as *const _ as usize - base, 0); assert_eq!(&obj.unused as *const _ as usize - base, 8); @@ -1728,10 +1728,10 @@ pub struct tcb { #[test] #[cfg(target_pointer_width = "32")] fn tcb_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 4); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 4); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: tcb = ::core::mem::uninitialized(); + let obj: tcb = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.parent as *const _ as usize - base, 0); } @@ -1739,10 +1739,10 @@ fn tcb_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn tcb_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 8); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 8); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: tcb = ::core::mem::uninitialized(); + let obj: tcb = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.parent as *const _ as usize - base, 0); } @@ -1773,10 +1773,10 @@ pub struct threadattr { #[test] #[cfg(target_pointer_width = "32")] fn threadattr_layout_test_32() { - assert_eq!(::core::mem::size_of::(), 16); - assert_eq!(::core::mem::align_of::(), 4); + assert_eq!(core::mem::size_of::(), 16); + assert_eq!(core::mem::align_of::(), 4); unsafe { - let obj: threadattr = ::core::mem::uninitialized(); + let obj: threadattr = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.entry_point as *const _ as usize - base, 0); assert_eq!(&obj.stack.0 as *const _ as usize - base, 4); @@ -1787,10 +1787,10 @@ fn threadattr_layout_test_32() { #[test] #[cfg(target_pointer_width = "64")] fn threadattr_layout_test_64() { - assert_eq!(::core::mem::size_of::(), 32); - assert_eq!(::core::mem::align_of::(), 8); + assert_eq!(core::mem::size_of::(), 32); + assert_eq!(core::mem::align_of::(), 8); unsafe { - let obj: threadattr = ::core::mem::uninitialized(); + let obj: threadattr = core::mem::uninitialized(); let base = &obj as *const _ as usize; assert_eq!(&obj.entry_point as *const _ as usize - base, 0); assert_eq!(&obj.stack.0 as *const _ as usize - base, 8); diff --git a/src/libstd/sys/cloudabi/args.rs b/src/libstd/sys/cloudabi/args.rs index 4147ffff871..dea562abad3 100644 --- a/src/libstd/sys/cloudabi/args.rs +++ b/src/libstd/sys/cloudabi/args.rs @@ -1,4 +1,4 @@ -pub use sys::cloudabi::shims::args::*; +pub use crate::sys::cloudabi::shims::args::*; #[allow(dead_code)] pub fn init(_: isize, _: *const *const u8) {} diff --git a/src/libstd/sys/cloudabi/backtrace.rs b/src/libstd/sys/cloudabi/backtrace.rs index 72f28550435..a15d2238e55 100644 --- a/src/libstd/sys/cloudabi/backtrace.rs +++ b/src/libstd/sys/cloudabi/backtrace.rs @@ -1,9 +1,10 @@ -use error::Error; -use ffi::CStr; -use intrinsics; -use io; -use libc; -use sys_common::backtrace::Frame; +use crate::error::Error; +use crate::ffi::CStr; +use crate::fmt; +use crate::intrinsics; +use crate::io; +use crate::sys_common::backtrace::Frame; + use unwind as uw; pub struct BacktraceContext; @@ -22,8 +23,8 @@ impl Error for UnwindError { } } -impl ::fmt::Display for UnwindError { - fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { +impl fmt::Display for UnwindError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}: {:?}", self.description(), self.0) } } diff --git a/src/libstd/sys/cloudabi/condvar.rs b/src/libstd/sys/cloudabi/condvar.rs index 758f29653ae..7aa0b0b6f49 100644 --- a/src/libstd/sys/cloudabi/condvar.rs +++ b/src/libstd/sys/cloudabi/condvar.rs @@ -1,10 +1,10 @@ -use cell::UnsafeCell; -use mem; -use sync::atomic::{AtomicU32, Ordering}; -use sys::cloudabi::abi; -use sys::mutex::{self, Mutex}; -use sys::time::checked_dur2intervals; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::mem; +use crate::sync::atomic::{AtomicU32, Ordering}; +use crate::sys::cloudabi::abi; +use crate::sys::mutex::{self, Mutex}; +use crate::sys::time::checked_dur2intervals; +use crate::time::Duration; extern "C" { #[thread_local] diff --git a/src/libstd/sys/cloudabi/mod.rs b/src/libstd/sys/cloudabi/mod.rs index d9bc21861c9..47c90fddd86 100644 --- a/src/libstd/sys/cloudabi/mod.rs +++ b/src/libstd/sys/cloudabi/mod.rs @@ -1,5 +1,5 @@ -use libc; -use mem; +use crate::io::ErrorKind; +use crate::mem; #[path = "../unix/alloc.rs"] pub mod alloc; @@ -32,29 +32,29 @@ pub use self::shims::*; #[allow(dead_code)] pub fn init() {} -pub fn decode_error_kind(errno: i32) -> ::io::ErrorKind { +pub fn decode_error_kind(errno: i32) -> ErrorKind { match errno { - x if x == abi::errno::ACCES as i32 => ::io::ErrorKind::PermissionDenied, - x if x == abi::errno::ADDRINUSE as i32 => ::io::ErrorKind::AddrInUse, - x if x == abi::errno::ADDRNOTAVAIL as i32 => ::io::ErrorKind::AddrNotAvailable, - x if x == abi::errno::AGAIN as i32 => ::io::ErrorKind::WouldBlock, - x if x == abi::errno::CONNABORTED as i32 => ::io::ErrorKind::ConnectionAborted, - x if x == abi::errno::CONNREFUSED as i32 => ::io::ErrorKind::ConnectionRefused, - x if x == abi::errno::CONNRESET as i32 => ::io::ErrorKind::ConnectionReset, - x if x == abi::errno::EXIST as i32 => ::io::ErrorKind::AlreadyExists, - x if x == abi::errno::INTR as i32 => ::io::ErrorKind::Interrupted, - x if x == abi::errno::INVAL as i32 => ::io::ErrorKind::InvalidInput, - x if x == abi::errno::NOENT as i32 => ::io::ErrorKind::NotFound, - x if x == abi::errno::NOTCONN as i32 => ::io::ErrorKind::NotConnected, - x if x == abi::errno::PERM as i32 => ::io::ErrorKind::PermissionDenied, - x if x == abi::errno::PIPE as i32 => ::io::ErrorKind::BrokenPipe, - x if x == abi::errno::TIMEDOUT as i32 => ::io::ErrorKind::TimedOut, - _ => ::io::ErrorKind::Other, + x if x == abi::errno::ACCES as i32 => ErrorKind::PermissionDenied, + x if x == abi::errno::ADDRINUSE as i32 => ErrorKind::AddrInUse, + x if x == abi::errno::ADDRNOTAVAIL as i32 => ErrorKind::AddrNotAvailable, + x if x == abi::errno::AGAIN as i32 => ErrorKind::WouldBlock, + x if x == abi::errno::CONNABORTED as i32 => ErrorKind::ConnectionAborted, + x if x == abi::errno::CONNREFUSED as i32 => ErrorKind::ConnectionRefused, + x if x == abi::errno::CONNRESET as i32 => ErrorKind::ConnectionReset, + x if x == abi::errno::EXIST as i32 => ErrorKind::AlreadyExists, + x if x == abi::errno::INTR as i32 => ErrorKind::Interrupted, + x if x == abi::errno::INVAL as i32 => ErrorKind::InvalidInput, + x if x == abi::errno::NOENT as i32 => ErrorKind::NotFound, + x if x == abi::errno::NOTCONN as i32 => ErrorKind::NotConnected, + x if x == abi::errno::PERM as i32 => ErrorKind::PermissionDenied, + x if x == abi::errno::PIPE as i32 => ErrorKind::BrokenPipe, + x if x == abi::errno::TIMEDOUT as i32 => ErrorKind::TimedOut, + _ => ErrorKind::Other, } } pub unsafe fn abort_internal() -> ! { - ::core::intrinsics::abort(); + core::intrinsics::abort(); } pub use libc::strlen; diff --git a/src/libstd/sys/cloudabi/mutex.rs b/src/libstd/sys/cloudabi/mutex.rs index ae62d8bfdb0..5e191e31d5f 100644 --- a/src/libstd/sys/cloudabi/mutex.rs +++ b/src/libstd/sys/cloudabi/mutex.rs @@ -1,8 +1,8 @@ -use cell::UnsafeCell; -use mem; -use sync::atomic::{AtomicU32, Ordering}; -use sys::cloudabi::abi; -use sys::rwlock::{self, RWLock}; +use crate::cell::UnsafeCell; +use crate::mem; +use crate::sync::atomic::{AtomicU32, Ordering}; +use crate::sys::cloudabi::abi; +use crate::sys::rwlock::{self, RWLock}; extern "C" { #[thread_local] diff --git a/src/libstd/sys/cloudabi/os.rs b/src/libstd/sys/cloudabi/os.rs index 8a6464125de..7db7808a087 100644 --- a/src/libstd/sys/cloudabi/os.rs +++ b/src/libstd/sys/cloudabi/os.rs @@ -1,8 +1,9 @@ -use ffi::CStr; -use libc::{self, c_int}; -use str; +use crate::ffi::CStr; +use crate::str; -pub use sys::cloudabi::shims::os::*; +use libc::c_int; + +pub use crate::sys::cloudabi::shims::os::*; pub fn errno() -> i32 { extern "C" { diff --git a/src/libstd/sys/cloudabi/rwlock.rs b/src/libstd/sys/cloudabi/rwlock.rs index 7f08c2c7869..6da3f3841b6 100644 --- a/src/libstd/sys/cloudabi/rwlock.rs +++ b/src/libstd/sys/cloudabi/rwlock.rs @@ -1,7 +1,7 @@ -use cell::UnsafeCell; -use mem; -use sync::atomic::{AtomicU32, Ordering}; -use sys::cloudabi::abi; +use crate::cell::UnsafeCell; +use crate::mem; +use crate::sync::atomic::{AtomicU32, Ordering}; +use crate::sys::cloudabi::abi; extern "C" { #[thread_local] diff --git a/src/libstd/sys/cloudabi/shims/args.rs b/src/libstd/sys/cloudabi/shims/args.rs index f924a434263..f5cf71caf6c 100644 --- a/src/libstd/sys/cloudabi/shims/args.rs +++ b/src/libstd/sys/cloudabi/shims/args.rs @@ -1,4 +1,4 @@ -use ffi::OsString; +use crate::ffi::OsString; pub struct Args(()); diff --git a/src/libstd/sys/cloudabi/shims/fs.rs b/src/libstd/sys/cloudabi/shims/fs.rs index 3af10a74c7d..56667bef007 100644 --- a/src/libstd/sys/cloudabi/shims/fs.rs +++ b/src/libstd/sys/cloudabi/shims/fs.rs @@ -1,10 +1,10 @@ -use ffi::OsString; -use fmt; -use hash::{Hash, Hasher}; -use io::{self, SeekFrom}; -use path::{Path, PathBuf}; -use sys::time::SystemTime; -use sys::{unsupported, Void}; +use crate::ffi::OsString; +use crate::fmt; +use crate::hash::{Hash, Hasher}; +use crate::io::{self, SeekFrom}; +use crate::path::{Path, PathBuf}; +use crate::sys::time::SystemTime; +use crate::sys::{unsupported, Void}; pub struct File(Void); diff --git a/src/libstd/sys/cloudabi/shims/mod.rs b/src/libstd/sys/cloudabi/shims/mod.rs index 080eac19ceb..fbb5ff55f22 100644 --- a/src/libstd/sys/cloudabi/shims/mod.rs +++ b/src/libstd/sys/cloudabi/shims/mod.rs @@ -1,4 +1,4 @@ -use io; +use crate::io; pub mod args; pub mod env; diff --git a/src/libstd/sys/cloudabi/shims/net.rs b/src/libstd/sys/cloudabi/shims/net.rs index 869a0ef87a7..50d72dc7b24 100644 --- a/src/libstd/sys/cloudabi/shims/net.rs +++ b/src/libstd/sys/cloudabi/shims/net.rs @@ -1,10 +1,11 @@ -use fmt; -use io::{self, IoVec, IoVecMut}; -use net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr}; -use time::Duration; -use sys::{unsupported, Void}; -use convert::TryFrom; - +use crate::fmt; +use crate::io::{self, IoVec, IoVecMut}; +use crate::net::{Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr}; +use crate::time::Duration; +use crate::sys::{unsupported, Void}; +use crate::convert::TryFrom; + +#[allow(unused_extern_crates)] pub extern crate libc as netc; pub struct TcpStream(Void); diff --git a/src/libstd/sys/cloudabi/shims/os.rs b/src/libstd/sys/cloudabi/shims/os.rs index 31cb18ea526..0c4690e12b0 100644 --- a/src/libstd/sys/cloudabi/shims/os.rs +++ b/src/libstd/sys/cloudabi/shims/os.rs @@ -1,10 +1,10 @@ -use error::Error as StdError; -use ffi::{OsStr, OsString}; -use fmt; -use io; -use iter; -use path::{self, PathBuf}; -use sys::{unsupported, Void}; +use crate::error::Error as StdError; +use crate::ffi::{OsStr, OsString}; +use crate::fmt; +use crate::io; +use crate::iter; +use crate::path::{self, PathBuf}; +use crate::sys::{unsupported, Void}; pub fn getcwd() -> io::Result { unsupported() diff --git a/src/libstd/sys/cloudabi/shims/pipe.rs b/src/libstd/sys/cloudabi/shims/pipe.rs index 30ef79dd769..f3debb95047 100644 --- a/src/libstd/sys/cloudabi/shims/pipe.rs +++ b/src/libstd/sys/cloudabi/shims/pipe.rs @@ -1,5 +1,5 @@ -use io; -use sys::Void; +use crate::io; +use crate::sys::Void; pub struct AnonPipe(Void); diff --git a/src/libstd/sys/cloudabi/shims/process.rs b/src/libstd/sys/cloudabi/shims/process.rs index 49b9d5e266e..710c42c1149 100644 --- a/src/libstd/sys/cloudabi/shims/process.rs +++ b/src/libstd/sys/cloudabi/shims/process.rs @@ -1,10 +1,10 @@ -use ffi::OsStr; -use fmt; -use io; -use sys::fs::File; -use sys::pipe::AnonPipe; -use sys::{unsupported, Void}; -use sys_common::process::{CommandEnv, DefaultEnvKey}; +use crate::ffi::OsStr; +use crate::fmt; +use crate::io; +use crate::sys::fs::File; +use crate::sys::pipe::AnonPipe; +use crate::sys::{unsupported, Void}; +use crate::sys_common::process::{CommandEnv, DefaultEnvKey}; //////////////////////////////////////////////////////////////////////////////// // Command diff --git a/src/libstd/sys/cloudabi/stdio.rs b/src/libstd/sys/cloudabi/stdio.rs index 81d79213f61..601563c5b1f 100644 --- a/src/libstd/sys/cloudabi/stdio.rs +++ b/src/libstd/sys/cloudabi/stdio.rs @@ -1,5 +1,5 @@ -use io; -use sys::cloudabi::abi; +use crate::io; +use crate::sys::cloudabi::abi; pub struct Stdin(()); pub struct Stdout(()); @@ -59,7 +59,7 @@ pub fn is_ebadf(err: &io::Error) -> bool { err.raw_os_error() == Some(abi::errno::BADF as i32) } -pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE; +pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE; pub fn panic_output() -> Option { Stderr::new().ok() diff --git a/src/libstd/sys/cloudabi/thread.rs b/src/libstd/sys/cloudabi/thread.rs index 950420420f0..f853346e0e6 100644 --- a/src/libstd/sys/cloudabi/thread.rs +++ b/src/libstd/sys/cloudabi/thread.rs @@ -1,14 +1,13 @@ -use boxed::FnBox; -use cmp; -use ffi::CStr; -use io; -use libc; -use mem; -use ptr; -use sys::cloudabi::abi; -use sys::time::checked_dur2intervals; -use sys_common::thread::*; -use time::Duration; +use crate::boxed::FnBox; +use crate::cmp; +use crate::ffi::CStr; +use crate::io; +use crate::mem; +use crate::ptr; +use crate::sys::cloudabi::abi; +use crate::sys::time::checked_dur2intervals; +use crate::sys_common::thread::*; +use crate::time::Duration; pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; diff --git a/src/libstd/sys/cloudabi/time.rs b/src/libstd/sys/cloudabi/time.rs index 545e3c0ce84..d7502c61eff 100644 --- a/src/libstd/sys/cloudabi/time.rs +++ b/src/libstd/sys/cloudabi/time.rs @@ -1,6 +1,6 @@ -use mem; -use sys::cloudabi::abi; -use time::Duration; +use crate::mem; +use crate::sys::cloudabi::abi; +use crate::time::Duration; const NSEC_PER_SEC: abi::timestamp = 1_000_000_000; diff --git a/src/libstd/sys/mod.rs b/src/libstd/sys/mod.rs index 0a56f4fad6d..5ba9304c09b 100644 --- a/src/libstd/sys/mod.rs +++ b/src/libstd/sys/mod.rs @@ -67,7 +67,7 @@ cfg_if! { pub mod unix_ext {} } else { // On other platforms like Windows document the bare bones of unix - use os::linux as platform; + use crate::os::linux as platform; #[path = "unix/ext/mod.rs"] pub mod unix_ext; } diff --git a/src/libstd/sys/redox/args.rs b/src/libstd/sys/redox/args.rs index 4e51be03f6f..f9e2f5ba311 100644 --- a/src/libstd/sys/redox/args.rs +++ b/src/libstd/sys/redox/args.rs @@ -5,9 +5,9 @@ #![allow(dead_code)] // runtime init functions not used during testing -use ffi::OsString; -use marker::PhantomData; -use vec; +use crate::ffi::OsString; +use crate::marker::PhantomData; +use crate::vec; /// One-time global initialization. pub unsafe fn init(argc: isize, argv: *const *const u8) { imp::init(argc, argv) } @@ -46,14 +46,13 @@ impl DoubleEndedIterator for Args { } mod imp { - use os::unix::prelude::*; - use mem; - use ffi::{CStr, OsString}; - use marker::PhantomData; - use libc; + use crate::os::unix::prelude::*; + use crate::mem; + use crate::ffi::{CStr, OsString}; + use crate::marker::PhantomData; use super::Args; - use sys_common::mutex::Mutex; + use crate::sys_common::mutex::Mutex; static mut GLOBAL_ARGS_PTR: usize = 0; static LOCK: Mutex = Mutex::new(); diff --git a/src/libstd/sys/redox/backtrace/mod.rs b/src/libstd/sys/redox/backtrace/mod.rs index 9a007241073..8ea2783580a 100644 --- a/src/libstd/sys/redox/backtrace/mod.rs +++ b/src/libstd/sys/redox/backtrace/mod.rs @@ -9,13 +9,13 @@ mod tracing; mod printing; pub mod gnu { - use io; - use fs; + use crate::io; + use crate::fs; + use crate::vec::Vec; + use crate::ffi::OsStr; + use crate::os::unix::ffi::OsStrExt; + use crate::io::Read; use libc::c_char; - use vec::Vec; - use ffi::OsStr; - use os::unix::ffi::OsStrExt; - use io::Read; pub fn get_executable_filename() -> io::Result<(Vec, fs::File)> { let mut exefile = fs::File::open("sys:exe")?; diff --git a/src/libstd/sys/redox/backtrace/printing.rs b/src/libstd/sys/redox/backtrace/printing.rs index c50c7154f0c..489eed4562d 100644 --- a/src/libstd/sys/redox/backtrace/printing.rs +++ b/src/libstd/sys/redox/backtrace/printing.rs @@ -1 +1 @@ -pub use sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; +pub use crate::sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; diff --git a/src/libstd/sys/redox/backtrace/tracing.rs b/src/libstd/sys/redox/backtrace/tracing.rs index 59a8c5fab3d..e7a68eadbde 100644 --- a/src/libstd/sys/redox/backtrace/tracing.rs +++ b/src/libstd/sys/redox/backtrace/tracing.rs @@ -1,8 +1,8 @@ -use error::Error; -use io; -use libc; -use sys::backtrace::BacktraceContext; -use sys_common::backtrace::Frame; +use crate::error::Error; +use crate::fmt; +use crate::io; +use crate::sys::backtrace::BacktraceContext; +use crate::sys_common::backtrace::Frame; use unwind as uw; @@ -20,8 +20,8 @@ impl Error for UnwindError { } } -impl ::fmt::Display for UnwindError { - fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { +impl fmt::Display for UnwindError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}: {:?}", self.description(), self.0) } } diff --git a/src/libstd/sys/redox/condvar.rs b/src/libstd/sys/redox/condvar.rs index 5f9eee588c3..a6365cac23e 100644 --- a/src/libstd/sys/redox/condvar.rs +++ b/src/libstd/sys/redox/condvar.rs @@ -1,10 +1,10 @@ -use cell::UnsafeCell; -use intrinsics::{atomic_cxchg, atomic_load, atomic_xadd, atomic_xchg}; -use ptr; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::intrinsics::{atomic_cxchg, atomic_load, atomic_xadd, atomic_xchg}; +use crate::ptr; +use crate::time::Duration; -use sys::mutex::{mutex_unlock, Mutex}; -use sys::syscall::{futex, TimeSpec, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE}; +use crate::sys::mutex::{mutex_unlock, Mutex}; +use crate::sys::syscall::{futex, TimeSpec, FUTEX_WAIT, FUTEX_WAKE, FUTEX_REQUEUE}; pub struct Condvar { lock: UnsafeCell<*mut i32>, @@ -48,7 +48,7 @@ impl Condvar { atomic_xadd(seq, 1); - let _ = futex(seq, FUTEX_REQUEUE, 1, ::usize::MAX, *lock); + let _ = futex(seq, FUTEX_REQUEUE, 1, crate::usize::MAX, *lock); } } diff --git a/src/libstd/sys/redox/ext/ffi.rs b/src/libstd/sys/redox/ext/ffi.rs index 848880d26e8..671498bc390 100644 --- a/src/libstd/sys/redox/ext/ffi.rs +++ b/src/libstd/sys/redox/ext/ffi.rs @@ -2,10 +2,10 @@ #![stable(feature = "rust1", since = "1.0.0")] -use ffi::{OsStr, OsString}; -use mem; -use sys::os_str::Buf; -use sys_common::{FromInner, IntoInner, AsInner}; +use crate::ffi::{OsStr, OsString}; +use crate::mem; +use crate::sys::os_str::Buf; +use crate::sys_common::{FromInner, IntoInner, AsInner}; /// Redox-specific extensions to [`OsString`]. /// diff --git a/src/libstd/sys/redox/ext/fs.rs b/src/libstd/sys/redox/ext/fs.rs index 8b81273f201..53b9dd68f73 100644 --- a/src/libstd/sys/redox/ext/fs.rs +++ b/src/libstd/sys/redox/ext/fs.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs::{self, Permissions, OpenOptions}; -use io; -use path::Path; -use sys; -use sys_common::{FromInner, AsInner, AsInnerMut}; +use crate::fs::{self, Permissions, OpenOptions}; +use crate::io; +use crate::path::Path; +use crate::sys; +use crate::sys_common::{FromInner, AsInner, AsInnerMut}; /// Redox-specific extensions to [`fs::Permissions`]. /// diff --git a/src/libstd/sys/redox/ext/io.rs b/src/libstd/sys/redox/ext/io.rs index 3ee0c6010a7..f431f96c541 100644 --- a/src/libstd/sys/redox/ext/io.rs +++ b/src/libstd/sys/redox/ext/io.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs; -use net; -use sys; -use io; -use sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::fs; +use crate::net; +use crate::sys; +use crate::io; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; /// Raw file descriptors. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/sys/redox/ext/net.rs b/src/libstd/sys/redox/ext/net.rs index 7411b8e068f..2c121787804 100644 --- a/src/libstd/sys/redox/ext/net.rs +++ b/src/libstd/sys/redox/ext/net.rs @@ -2,13 +2,13 @@ //! Unix-specific networking functionality -use fmt; -use io::{self, Error, ErrorKind, Initializer}; -use net::Shutdown; -use os::unix::io::{RawFd, AsRawFd, FromRawFd, IntoRawFd}; -use path::Path; -use time::Duration; -use sys::{cvt, fd::FileDesc, syscall}; +use crate::fmt; +use crate::io::{self, Error, ErrorKind, Initializer}; +use crate::net::Shutdown; +use crate::os::unix::io::{RawFd, AsRawFd, FromRawFd, IntoRawFd}; +use crate::path::Path; +use crate::time::Duration; +use crate::sys::{cvt, fd::FileDesc, syscall}; /// An address associated with a Unix socket. /// diff --git a/src/libstd/sys/redox/ext/process.rs b/src/libstd/sys/redox/ext/process.rs index 020075531dd..e981cb93d44 100644 --- a/src/libstd/sys/redox/ext/process.rs +++ b/src/libstd/sys/redox/ext/process.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use io; -use os::unix::io::{FromRawFd, RawFd, AsRawFd, IntoRawFd}; -use process; -use sys; -use sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; +use crate::io; +use crate::os::unix::io::{FromRawFd, RawFd, AsRawFd, IntoRawFd}; +use crate::process; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; /// Redox-specific extensions to the [`process::Command`] builder, /// diff --git a/src/libstd/sys/redox/ext/thread.rs b/src/libstd/sys/redox/ext/thread.rs index 21b140ad718..629eaef04ce 100644 --- a/src/libstd/sys/redox/ext/thread.rs +++ b/src/libstd/sys/redox/ext/thread.rs @@ -2,8 +2,8 @@ #![stable(feature = "thread_extensions", since = "1.9.0")] -use sys_common::{AsInner, IntoInner}; -use thread::JoinHandle; +use crate::sys_common::{AsInner, IntoInner}; +use crate::thread::JoinHandle; #[stable(feature = "thread_extensions", since = "1.9.0")] #[allow(deprecated)] diff --git a/src/libstd/sys/redox/fast_thread_local.rs b/src/libstd/sys/redox/fast_thread_local.rs index 95263e6f5e3..1202708a476 100644 --- a/src/libstd/sys/redox/fast_thread_local.rs +++ b/src/libstd/sys/redox/fast_thread_local.rs @@ -1,9 +1,9 @@ #![cfg(target_thread_local)] #![unstable(feature = "thread_local_internals", issue = "0")] -use cell::{Cell, UnsafeCell}; -use mem; -use ptr; +use crate::cell::{Cell, UnsafeCell}; +use crate::mem; +use crate::ptr; pub struct Key { @@ -15,7 +15,7 @@ pub struct Key { dtor_running: Cell, } -unsafe impl ::marker::Sync for Key { } +unsafe impl Sync for Key { } impl Key { pub const fn new() -> Key { @@ -57,7 +57,7 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) { // *should* be the case that this loop always terminates because we // provide the guarantee that a TLS key cannot be set after it is // flagged for destruction. - use sys_common::thread_local as os; + use crate::sys_common::thread_local as os; static DTORS: os::StaticKey = os::StaticKey::new(Some(run_dtors)); type List = Vec<(*mut u8, unsafe extern fn(*mut u8))>; diff --git a/src/libstd/sys/redox/fd.rs b/src/libstd/sys/redox/fd.rs index fbf31aae2d0..a42e486db22 100644 --- a/src/libstd/sys/redox/fd.rs +++ b/src/libstd/sys/redox/fd.rs @@ -1,9 +1,9 @@ #![unstable(reason = "not public", issue = "0", feature = "fd")] -use io::{self, Read}; -use mem; -use sys::{cvt, syscall}; -use sys_common::AsInner; +use crate::io::{self, Read}; +use crate::mem; +use crate::sys::{cvt, syscall}; +use crate::sys_common::AsInner; pub struct FileDesc { fd: usize, diff --git a/src/libstd/sys/redox/fs.rs b/src/libstd/sys/redox/fs.rs index 97e5dcebfea..159ee9911bd 100644 --- a/src/libstd/sys/redox/fs.rs +++ b/src/libstd/sys/redox/fs.rs @@ -1,14 +1,14 @@ -use os::unix::prelude::*; - -use ffi::{OsString, OsStr}; -use fmt; -use io::{self, Error, ErrorKind, SeekFrom}; -use path::{Path, PathBuf}; -use sync::Arc; -use sys::fd::FileDesc; -use sys::time::SystemTime; -use sys::{cvt, syscall}; -use sys_common::{AsInner, FromInner}; +use crate::os::unix::prelude::*; + +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::io::{self, Error, ErrorKind, SeekFrom}; +use crate::path::{Path, PathBuf}; +use crate::sync::Arc; +use crate::sys::fd::FileDesc; +use crate::sys::time::SystemTime; +use crate::sys::{cvt, syscall}; +use crate::sys_common::{AsInner, FromInner}; pub struct File(FileDesc); @@ -457,7 +457,7 @@ pub fn canonicalize(p: &Path) -> io::Result { } pub fn copy(from: &Path, to: &Path) -> io::Result { - use fs::{File, set_permissions}; + use crate::fs::{File, set_permissions}; if !from.is_file() { return Err(Error::new(ErrorKind::InvalidInput, "the source path is not an existing regular file")) diff --git a/src/libstd/sys/redox/mod.rs b/src/libstd/sys/redox/mod.rs index c3878349bb3..7f3ac1f1bb5 100644 --- a/src/libstd/sys/redox/mod.rs +++ b/src/libstd/sys/redox/mod.rs @@ -1,6 +1,6 @@ #![allow(dead_code, missing_docs, nonstandard_style)] -use ::io::{ErrorKind}; +use crate::io::ErrorKind; pub use libc::strlen; pub use self::rand::hashmap_random_keys; @@ -64,8 +64,8 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind { } } -pub fn cvt(result: Result) -> ::io::Result { - result.map_err(|err| ::io::Error::from_raw_os_error(err.errno)) +pub fn cvt(result: Result) -> crate::io::Result { + result.map_err(|err| crate::io::Error::from_raw_os_error(err.errno)) } #[doc(hidden)] @@ -83,9 +83,9 @@ macro_rules! impl_is_minus_one { impl_is_minus_one! { i8 i16 i32 i64 isize } -pub fn cvt_libc(t: T) -> ::io::Result { +pub fn cvt_libc(t: T) -> crate::io::Result { if t.is_minus_one() { - Err(::io::Error::last_os_error()) + Err(crate::io::Error::last_os_error()) } else { Ok(t) } @@ -93,5 +93,5 @@ pub fn cvt_libc(t: T) -> ::io::Result { /// On Redox, use an illegal instruction to abort pub unsafe fn abort_internal() -> ! { - ::core::intrinsics::abort(); + core::intrinsics::abort(); } diff --git a/src/libstd/sys/redox/mutex.rs b/src/libstd/sys/redox/mutex.rs index bf39cc48591..59399df0294 100644 --- a/src/libstd/sys/redox/mutex.rs +++ b/src/libstd/sys/redox/mutex.rs @@ -1,8 +1,8 @@ -use cell::UnsafeCell; -use intrinsics::{atomic_cxchg, atomic_xchg}; -use ptr; +use crate::cell::UnsafeCell; +use crate::intrinsics::{atomic_cxchg, atomic_xchg}; +use crate::ptr; -use sys::syscall::{futex, getpid, FUTEX_WAIT, FUTEX_WAKE}; +use crate::sys::syscall::{futex, getpid, FUTEX_WAIT, FUTEX_WAKE}; pub unsafe fn mutex_try_lock(m: *mut i32) -> bool { atomic_cxchg(m, 0, 1).0 == 0 diff --git a/src/libstd/sys/redox/net/dns/answer.rs b/src/libstd/sys/redox/net/dns/answer.rs index c0450c11ed6..e9b406bc685 100644 --- a/src/libstd/sys/redox/net/dns/answer.rs +++ b/src/libstd/sys/redox/net/dns/answer.rs @@ -1,5 +1,5 @@ -use string::String; -use vec::Vec; +use crate::string::String; +use crate::vec::Vec; #[derive(Clone, Debug)] pub struct DnsAnswer { diff --git a/src/libstd/sys/redox/net/dns/mod.rs b/src/libstd/sys/redox/net/dns/mod.rs index 8f0a0610af5..6533e0d5efb 100644 --- a/src/libstd/sys/redox/net/dns/mod.rs +++ b/src/libstd/sys/redox/net/dns/mod.rs @@ -1,10 +1,10 @@ pub use self::answer::DnsAnswer; pub use self::query::DnsQuery; -use slice; -use u16; -use string::String; -use vec::Vec; +use crate::slice; +use crate::u16; +use crate::string::String; +use crate::vec::Vec; mod answer; mod query; diff --git a/src/libstd/sys/redox/net/dns/query.rs b/src/libstd/sys/redox/net/dns/query.rs index dcb554d82de..65fb241b037 100644 --- a/src/libstd/sys/redox/net/dns/query.rs +++ b/src/libstd/sys/redox/net/dns/query.rs @@ -1,4 +1,4 @@ -use string::String; +use crate::string::String; #[derive(Clone, Debug)] pub struct DnsQuery { diff --git a/src/libstd/sys/redox/net/mod.rs b/src/libstd/sys/redox/net/mod.rs index 9e7599aebbb..a172763f613 100644 --- a/src/libstd/sys/redox/net/mod.rs +++ b/src/libstd/sys/redox/net/mod.rs @@ -1,13 +1,13 @@ -use fs::File; -use io::{Error, Read, self}; -use iter::Iterator; -use net::{Ipv4Addr, SocketAddr, SocketAddrV4}; -use str::FromStr; -use string::{String, ToString}; -use sys::syscall::EINVAL; -use time::{self, Duration}; -use vec::{IntoIter, Vec}; -use convert::{TryFrom, TryInto}; +use crate::fs::File; +use crate::io::{Error, Read, self}; +use crate::iter::Iterator; +use crate::net::{Ipv4Addr, SocketAddr, SocketAddrV4}; +use crate::str::FromStr; +use crate::string::{String, ToString}; +use crate::sys::syscall::EINVAL; +use crate::time::{self, Duration}; +use crate::vec::{IntoIter, Vec}; +use crate::convert::{TryFrom, TryInto}; use self::dns::{Dns, DnsQuery}; diff --git a/src/libstd/sys/redox/net/tcp.rs b/src/libstd/sys/redox/net/tcp.rs index abb9f72c324..5081c3de73c 100644 --- a/src/libstd/sys/redox/net/tcp.rs +++ b/src/libstd/sys/redox/net/tcp.rs @@ -1,12 +1,12 @@ -use cmp; -use io::{self, Error, ErrorKind, Result, IoVec, IoVecMut}; -use mem; -use net::{SocketAddr, Shutdown}; -use path::Path; -use sys::fs::{File, OpenOptions}; -use sys::syscall::TimeSpec; -use sys_common::{AsInner, FromInner, IntoInner}; -use time::Duration; +use crate::cmp; +use crate::io::{self, Error, ErrorKind, Result, IoVec, IoVecMut}; +use crate::mem; +use crate::net::{SocketAddr, Shutdown}; +use crate::path::Path; +use crate::sys::fs::{File, OpenOptions}; +use crate::sys::syscall::TimeSpec; +use crate::sys_common::{AsInner, FromInner, IntoInner}; +use crate::time::Duration; use super::{path_to_peer_addr, path_to_local_addr}; diff --git a/src/libstd/sys/redox/net/udp.rs b/src/libstd/sys/redox/net/udp.rs index 2a59b44f093..b1a60b14570 100644 --- a/src/libstd/sys/redox/net/udp.rs +++ b/src/libstd/sys/redox/net/udp.rs @@ -1,13 +1,13 @@ -use cell::UnsafeCell; -use cmp; -use io::{self, Error, ErrorKind, Result}; -use mem; -use net::{SocketAddr, Ipv4Addr, Ipv6Addr}; -use path::Path; -use sys::fs::{File, OpenOptions}; -use sys::syscall::TimeSpec; -use sys_common::{AsInner, FromInner, IntoInner}; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::cmp; +use crate::io::{self, Error, ErrorKind, Result}; +use crate::mem; +use crate::net::{SocketAddr, Ipv4Addr, Ipv6Addr}; +use crate::path::Path; +use crate::sys::fs::{File, OpenOptions}; +use crate::sys::syscall::TimeSpec; +use crate::sys_common::{AsInner, FromInner, IntoInner}; +use crate::time::Duration; use super::{path_to_peer_addr, path_to_local_addr}; diff --git a/src/libstd/sys/redox/os.rs b/src/libstd/sys/redox/os.rs index f7a26c94970..76e43a83b73 100644 --- a/src/libstd/sys/redox/os.rs +++ b/src/libstd/sys/redox/os.rs @@ -2,25 +2,25 @@ #![allow(unused_imports)] // lots of cfg code here -use libc::{self, c_char}; - -use os::unix::prelude::*; - -use error::Error as StdError; -use ffi::{CStr, CString, OsStr, OsString}; -use fmt; -use io::{self, Read, Write}; -use iter; -use marker::PhantomData; -use mem; -use memchr; -use path::{self, PathBuf}; -use ptr; -use slice; -use str; -use sys_common::mutex::Mutex; -use sys::{cvt, cvt_libc, fd, syscall}; -use vec; +use libc::c_char; + +use crate::os::unix::prelude::*; + +use crate::error::Error as StdError; +use crate::ffi::{CStr, CString, OsStr, OsString}; +use crate::fmt; +use crate::io::{self, Read, Write}; +use crate::iter; +use crate::marker::PhantomData; +use crate::mem; +use crate::memchr; +use crate::path::{self, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::str; +use crate::sys_common::mutex::Mutex; +use crate::sys::{cvt, cvt_libc, fd, syscall}; +use crate::vec; extern { #[link_name = "__errno_location"] @@ -107,7 +107,7 @@ impl StdError for JoinPathsError { } pub fn current_exe() -> io::Result { - use fs::File; + use crate::fs::File; let mut file = File::open("sys:exe")?; @@ -218,13 +218,13 @@ pub fn page_size() -> usize { } pub fn temp_dir() -> PathBuf { - ::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| { + crate::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| { PathBuf::from("/tmp") }) } pub fn home_dir() -> Option { - return ::env::var_os("HOME").map(PathBuf::from); + return crate::env::var_os("HOME").map(PathBuf::from); } pub fn exit(code: i32) -> ! { diff --git a/src/libstd/sys/redox/os_str.rs b/src/libstd/sys/redox/os_str.rs index 9d5e084feb2..79b43458d00 100644 --- a/src/libstd/sys/redox/os_str.rs +++ b/src/libstd/sys/redox/os_str.rs @@ -1,14 +1,15 @@ /// The underlying OsString/OsStr implementation on Unix systems: just /// a `Vec`/`[u8]`. -use borrow::Cow; -use fmt; -use str; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner}; -use sys_common::bytestring::debug_fmt_bytestring; +use crate::borrow::Cow; +use crate::fmt; +use crate::str; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner}; +use crate::sys_common::bytestring::debug_fmt_bytestring; + use core::str::lossy::Utf8Lossy; #[derive(Clone, Hash)] diff --git a/src/libstd/sys/redox/path.rs b/src/libstd/sys/redox/path.rs index a7a8b03c8b1..618d61e6fcb 100644 --- a/src/libstd/sys/redox/path.rs +++ b/src/libstd/sys/redox/path.rs @@ -1,5 +1,5 @@ -use ffi::OsStr; -use path::Prefix; +use crate::ffi::OsStr; +use crate::path::Prefix; #[inline] pub fn is_sep_byte(b: u8) -> bool { diff --git a/src/libstd/sys/redox/pipe.rs b/src/libstd/sys/redox/pipe.rs index 9e40eadb237..911ba9c3f65 100644 --- a/src/libstd/sys/redox/pipe.rs +++ b/src/libstd/sys/redox/pipe.rs @@ -1,6 +1,6 @@ -use io; -use sys::{cvt, syscall}; -use sys::fd::FileDesc; +use crate::io; +use crate::sys::{cvt, syscall}; +use crate::sys::fd::FileDesc; //////////////////////////////////////////////////////////////////////////////// // Anonymous pipes diff --git a/src/libstd/sys/redox/process.rs b/src/libstd/sys/redox/process.rs index 81af8eb553d..8830cdf333e 100644 --- a/src/libstd/sys/redox/process.rs +++ b/src/libstd/sys/redox/process.rs @@ -1,20 +1,21 @@ -use env::{split_paths}; -use ffi::{CStr, OsStr}; -use fmt; -use fs::File; -use io::{self, prelude::*, BufReader, Error, ErrorKind, SeekFrom}; +use crate::env::{self, split_paths}; +use crate::ffi::{CStr, OsStr}; +use crate::fmt; +use crate::fs::File; +use crate::io::{self, prelude::*, BufReader, Error, ErrorKind, SeekFrom}; +use crate::os::unix::ffi::OsStrExt; +use crate::path::{Path, PathBuf}; +use crate::ptr; +use crate::sys::ext::fs::MetadataExt; +use crate::sys::ext::io::AsRawFd; +use crate::sys::fd::FileDesc; +use crate::sys::fs::{File as SysFile, OpenOptions}; +use crate::sys::os::{ENV_LOCK, environ}; +use crate::sys::pipe::{self, AnonPipe}; +use crate::sys::{cvt, syscall}; +use crate::sys_common::process::{CommandEnv, DefaultEnvKey}; + use libc::{EXIT_SUCCESS, EXIT_FAILURE}; -use os::unix::ffi::OsStrExt; -use path::{Path, PathBuf}; -use ptr; -use sys::ext::fs::MetadataExt; -use sys::ext::io::AsRawFd; -use sys::fd::FileDesc; -use sys::fs::{File as SysFile, OpenOptions}; -use sys::os::{ENV_LOCK, environ}; -use sys::pipe::{self, AnonPipe}; -use sys::{cvt, syscall}; -use sys_common::process::{CommandEnv, DefaultEnvKey}; //////////////////////////////////////////////////////////////////////////////// // Command @@ -297,7 +298,7 @@ impl Command { let program = if self.program.contains(':') || self.program.contains('/') { Some(PathBuf::from(&self.program)) - } else if let Ok(path_env) = ::env::var("PATH") { + } else if let Ok(path_env) = env::var("PATH") { let mut program = None; for mut path in split_paths(&path_env) { path.push(&self.program); diff --git a/src/libstd/sys/redox/stdio.rs b/src/libstd/sys/redox/stdio.rs index 8571b38cefa..33f5bdbb5d3 100644 --- a/src/libstd/sys/redox/stdio.rs +++ b/src/libstd/sys/redox/stdio.rs @@ -1,6 +1,6 @@ -use io; -use sys::{cvt, syscall}; -use sys::fd::FileDesc; +use crate::io; +use crate::sys::{cvt, syscall}; +use crate::sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); @@ -54,10 +54,10 @@ impl io::Write for Stderr { } pub fn is_ebadf(err: &io::Error) -> bool { - err.raw_os_error() == Some(::sys::syscall::EBADF as i32) + err.raw_os_error() == Some(crate::sys::syscall::EBADF as i32) } -pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE; +pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE; pub fn panic_output() -> Option { Stderr::new().ok() diff --git a/src/libstd/sys/redox/thread.rs b/src/libstd/sys/redox/thread.rs index 18679a7871e..ae0b91b4d6c 100644 --- a/src/libstd/sys/redox/thread.rs +++ b/src/libstd/sys/redox/thread.rs @@ -1,10 +1,10 @@ -use boxed::FnBox; -use ffi::CStr; -use io; -use mem; -use sys_common::thread::start_thread; -use sys::{cvt, syscall}; -use time::Duration; +use crate::boxed::FnBox; +use crate::ffi::CStr; +use crate::io; +use crate::mem; +use crate::sys_common::thread::start_thread; +use crate::sys::{cvt, syscall}; +use crate::time::Duration; pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; diff --git a/src/libstd/sys/redox/thread_local.rs b/src/libstd/sys/redox/thread_local.rs index a1929b94165..4bc8c4d5883 100644 --- a/src/libstd/sys/redox/thread_local.rs +++ b/src/libstd/sys/redox/thread_local.rs @@ -1,8 +1,8 @@ #![allow(dead_code)] // not used on all platforms -use collections::BTreeMap; -use ptr; -use sync::atomic::{AtomicUsize, Ordering}; +use crate::collections::BTreeMap; +use crate::ptr; +use crate::sync::atomic::{AtomicUsize, Ordering}; pub type Key = usize; diff --git a/src/libstd/sys/redox/time.rs b/src/libstd/sys/redox/time.rs index 401b7012aa7..9db3e85ca9c 100644 --- a/src/libstd/sys/redox/time.rs +++ b/src/libstd/sys/redox/time.rs @@ -1,8 +1,9 @@ -use cmp::Ordering; -use fmt; -use sys::{cvt, syscall}; -use time::Duration; -use convert::TryInto; +use crate::cmp::Ordering; +use crate::fmt; +use crate::sys::{cvt, syscall}; +use crate::time::Duration; +use crate::convert::TryInto; + use core::hash::{Hash, Hasher}; const NSEC_PER_SEC: u64 = 1_000_000_000; diff --git a/src/libstd/sys/sgx/abi/mod.rs b/src/libstd/sys/sgx/abi/mod.rs index 509a1990d97..7426f7be9e9 100644 --- a/src/libstd/sys/sgx/abi/mod.rs +++ b/src/libstd/sys/sgx/abi/mod.rs @@ -1,5 +1,5 @@ use core::sync::atomic::{AtomicUsize, Ordering}; -use io::Write; +use crate::io::Write; // runtime features mod reloc; @@ -37,7 +37,7 @@ unsafe extern "C" fn tcs_init(secondary: bool) { }, // We need to wait until the initialization is done. BUSY => while RELOC_STATE.load(Ordering::Acquire) == BUSY { - ::core::arch::x86_64::_mm_pause() + core::arch::x86_64::_mm_pause() }, // Initialization is done. DONE => {}, diff --git a/src/libstd/sys/sgx/abi/panic.rs b/src/libstd/sys/sgx/abi/panic.rs index b2afacc70b8..83411cb5b4c 100644 --- a/src/libstd/sys/sgx/abi/panic.rs +++ b/src/libstd/sys/sgx/abi/panic.rs @@ -1,7 +1,7 @@ use super::usercalls::{alloc::UserRef, self}; -use cmp; -use io::{self, Write}; -use mem; +use crate::cmp; +use crate::io::{self, Write}; +use crate::mem; extern "C" { fn take_debug_panic_buf_ptr() -> *mut u8; diff --git a/src/libstd/sys/sgx/abi/reloc.rs b/src/libstd/sys/sgx/abi/reloc.rs index 4dd41d70bd7..a39841bc36f 100644 --- a/src/libstd/sys/sgx/abi/reloc.rs +++ b/src/libstd/sys/sgx/abi/reloc.rs @@ -1,4 +1,4 @@ -use slice::from_raw_parts; +use crate::slice::from_raw_parts; use super::mem; const R_X86_64_RELATIVE: u32 = 8; diff --git a/src/libstd/sys/sgx/abi/tls.rs b/src/libstd/sys/sgx/abi/tls.rs index e1fc3696845..b2a812c7231 100644 --- a/src/libstd/sys/sgx/abi/tls.rs +++ b/src/libstd/sys/sgx/abi/tls.rs @@ -1,8 +1,8 @@ -use sync::atomic::{AtomicUsize, Ordering}; -use ptr; -use mem; -use cell::Cell; -use num::NonZeroUsize; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::ptr; +use crate::mem; +use crate::cell::Cell; +use crate::num::NonZeroUsize; use self::sync_bitset::*; #[cfg(target_pointer_width="64")] @@ -152,9 +152,9 @@ impl Tls { } mod sync_bitset { - use sync::atomic::{AtomicUsize, Ordering}; - use iter::{Enumerate, Peekable}; - use slice::Iter; + use crate::sync::atomic::{AtomicUsize, Ordering}; + use crate::iter::{Enumerate, Peekable}; + use crate::slice::Iter; use super::{TLS_KEYS_BITSET_SIZE, USIZE_BITS}; /// A bitset that can be used synchronously. diff --git a/src/libstd/sys/sgx/abi/usercalls/alloc.rs b/src/libstd/sys/sgx/abi/usercalls/alloc.rs index 0ccbbbc6501..b787bd1a5ab 100644 --- a/src/libstd/sys/sgx/abi/usercalls/alloc.rs +++ b/src/libstd/sys/sgx/abi/usercalls/alloc.rs @@ -1,11 +1,11 @@ #![allow(unused)] -use ptr::{self, NonNull}; -use mem; -use cell::UnsafeCell; -use slice; -use ops::{Deref, DerefMut, Index, IndexMut, CoerceUnsized}; -use slice::SliceIndex; +use crate::ptr::{self, NonNull}; +use crate::mem; +use crate::cell::UnsafeCell; +use crate::slice; +use crate::ops::{Deref, DerefMut, Index, IndexMut, CoerceUnsized}; +use crate::slice::SliceIndex; use fortanix_sgx_abi::*; use super::super::mem::is_user_range; diff --git a/src/libstd/sys/sgx/abi/usercalls/mod.rs b/src/libstd/sys/sgx/abi/usercalls/mod.rs index 511d6e9e927..7361011e92d 100644 --- a/src/libstd/sys/sgx/abi/usercalls/mod.rs +++ b/src/libstd/sys/sgx/abi/usercalls/mod.rs @@ -1,5 +1,5 @@ -use io::{Error as IoError, Result as IoResult}; -use time::Duration; +use crate::io::{Error as IoError, Result as IoResult}; +use crate::time::Duration; pub(crate) mod alloc; #[macro_use] diff --git a/src/libstd/sys/sgx/abi/usercalls/raw.rs b/src/libstd/sys/sgx/abi/usercalls/raw.rs index 447f20584f8..ad0b6d7b3d8 100644 --- a/src/libstd/sys/sgx/abi/usercalls/raw.rs +++ b/src/libstd/sys/sgx/abi/usercalls/raw.rs @@ -3,8 +3,8 @@ #[unstable(feature = "sgx_platform", issue = "56975")] pub use fortanix_sgx_abi::*; -use ptr::NonNull; -use num::NonZeroU64; +use crate::ptr::NonNull; +use crate::num::NonZeroU64; #[repr(C)] struct UsercallReturn(u64, u64); @@ -35,7 +35,7 @@ pub unsafe fn do_usercall(nr: NonZeroU64, p1: u64, p2: u64, p3: u64, p4: u64, ab type Register = u64; trait RegisterArgument { - fn from_register(Register) -> Self; + fn from_register(_: Register) -> Self; fn into_register(self) -> Register; } diff --git a/src/libstd/sys/sgx/alloc.rs b/src/libstd/sys/sgx/alloc.rs index 95284190bdd..94dc8ec25b5 100644 --- a/src/libstd/sys/sgx/alloc.rs +++ b/src/libstd/sys/sgx/alloc.rs @@ -1,6 +1,4 @@ -extern crate dlmalloc; - -use alloc::{GlobalAlloc, Layout, System}; +use crate::alloc::{GlobalAlloc, Layout, System}; use super::waitqueue::SpinMutex; diff --git a/src/libstd/sys/sgx/args.rs b/src/libstd/sys/sgx/args.rs index bc138a64019..b73bf9213b7 100644 --- a/src/libstd/sys/sgx/args.rs +++ b/src/libstd/sys/sgx/args.rs @@ -1,9 +1,9 @@ -use ffi::OsString; use super::abi::usercalls::{alloc, raw::ByteBuffer}; -use sync::atomic::{AtomicUsize, Ordering}; -use sys::os_str::Buf; -use sys_common::FromInner; -use slice; +use crate::ffi::OsString; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::sys::os_str::Buf; +use crate::sys_common::FromInner; +use crate::slice; static ARGS: AtomicUsize = AtomicUsize::new(0); type ArgsStore = Vec; diff --git a/src/libstd/sys/sgx/backtrace.rs b/src/libstd/sys/sgx/backtrace.rs index 2b8e1da0579..d0361574e39 100644 --- a/src/libstd/sys/sgx/backtrace.rs +++ b/src/libstd/sys/sgx/backtrace.rs @@ -1,9 +1,10 @@ -use io; -use error::Error; -use libc; -use sys_common::backtrace::Frame; +use crate::io; +use crate::error::Error; +use crate::fmt; +use crate::sys_common::backtrace::Frame; +use crate::sys::sgx::abi::mem::image_base; + use unwind as uw; -use sys::sgx::abi::mem::image_base; pub struct BacktraceContext; @@ -21,8 +22,8 @@ impl Error for UnwindError { } } -impl ::fmt::Display for UnwindError { - fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { +impl fmt::Display for UnwindError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}: {:?}", self.description(), self.0) } } diff --git a/src/libstd/sys/sgx/condvar.rs b/src/libstd/sys/sgx/condvar.rs index b42e5490c72..e9a7684f74d 100644 --- a/src/libstd/sys/sgx/condvar.rs +++ b/src/libstd/sys/sgx/condvar.rs @@ -1,5 +1,5 @@ -use sys::mutex::Mutex; -use time::Duration; +use crate::sys::mutex::Mutex; +use crate::time::Duration; use super::waitqueue::{WaitVariable, WaitQueue, SpinMutex}; diff --git a/src/libstd/sys/sgx/ext/arch.rs b/src/libstd/sys/sgx/ext/arch.rs index 97f7d9181a5..53fb371947a 100644 --- a/src/libstd/sys/sgx/ext/arch.rs +++ b/src/libstd/sys/sgx/ext/arch.rs @@ -4,7 +4,7 @@ //! Software Developer's Manual, Volume 3, Chapter 40. #![unstable(feature = "sgx_platform", issue = "56975")] -use mem::MaybeUninit; +use crate::mem::MaybeUninit; /// Wrapper struct to force 16-byte alignment. #[repr(align(16))] diff --git a/src/libstd/sys/sgx/ext/ffi.rs b/src/libstd/sys/sgx/ext/ffi.rs index 7b0ffea49ae..ad7ade9b17d 100644 --- a/src/libstd/sys/sgx/ext/ffi.rs +++ b/src/libstd/sys/sgx/ext/ffi.rs @@ -2,10 +2,10 @@ #![unstable(feature = "sgx_platform", issue = "56975")] -use ffi::{OsStr, OsString}; -use mem; -use sys::os_str::Buf; -use sys_common::{FromInner, IntoInner, AsInner}; +use crate::ffi::{OsStr, OsString}; +use crate::mem; +use crate::sys::os_str::Buf; +use crate::sys_common::{FromInner, IntoInner, AsInner}; /// SGX-specific extensions to [`OsString`]. /// diff --git a/src/libstd/sys/sgx/ext/io.rs b/src/libstd/sys/sgx/ext/io.rs index 1eb269783c5..fc88d10d3ed 100644 --- a/src/libstd/sys/sgx/ext/io.rs +++ b/src/libstd/sys/sgx/ext/io.rs @@ -4,9 +4,9 @@ //! description of [`TryIntoRawFd`](trait.TryIntoRawFd.html) for more details. #![unstable(feature = "sgx_platform", issue = "56975")] -pub use sys::abi::usercalls::raw::Fd as RawFd; -use net; -use sys::{self, AsInner, FromInner, IntoInner, TryIntoInner}; +pub use crate::sys::abi::usercalls::raw::Fd as RawFd; +use crate::net; +use crate::sys::{self, AsInner, FromInner, IntoInner, TryIntoInner}; /// A trait to extract the raw SGX file descriptor from an underlying /// object. diff --git a/src/libstd/sys/sgx/fd.rs b/src/libstd/sys/sgx/fd.rs index 69077728b1a..a9924f55f12 100644 --- a/src/libstd/sys/sgx/fd.rs +++ b/src/libstd/sys/sgx/fd.rs @@ -1,8 +1,8 @@ use fortanix_sgx_abi::Fd; -use io; -use mem; -use sys::{AsInner, FromInner, IntoInner}; +use crate::io; +use crate::mem; +use crate::sys::{AsInner, FromInner, IntoInner}; use super::abi::usercalls; #[derive(Debug)] diff --git a/src/libstd/sys/sgx/fs.rs b/src/libstd/sys/sgx/fs.rs index 8b1c4476bc4..485d2c87fbd 100644 --- a/src/libstd/sys/sgx/fs.rs +++ b/src/libstd/sys/sgx/fs.rs @@ -1,10 +1,10 @@ -use ffi::OsString; -use fmt; -use hash::{Hash, Hasher}; -use io::{self, SeekFrom}; -use path::{Path, PathBuf}; -use sys::time::SystemTime; -use sys::{unsupported, Void}; +use crate::ffi::OsString; +use crate::fmt; +use crate::hash::{Hash, Hasher}; +use crate::io::{self, SeekFrom}; +use crate::path::{Path, PathBuf}; +use crate::sys::time::SystemTime; +use crate::sys::{unsupported, Void}; pub struct File(Void); diff --git a/src/libstd/sys/sgx/mod.rs b/src/libstd/sys/sgx/mod.rs index 403dd61187f..325df7688f3 100644 --- a/src/libstd/sys/sgx/mod.rs +++ b/src/libstd/sys/sgx/mod.rs @@ -3,8 +3,9 @@ //! This module contains the facade (aka platform-specific) implementations of //! OS level functionality for Fortanix SGX. -use os::raw::c_char; -use sync::atomic::{AtomicBool, Ordering}; +use crate::io::ErrorKind; +use crate::os::raw::c_char; +use crate::sync::atomic::{AtomicBool, Ordering}; pub mod abi; mod waitqueue; @@ -41,12 +42,12 @@ pub fn init() { /// This function is used to implement functionality that simply doesn't exist. /// Programs relying on this functionality will need to deal with the error. -pub fn unsupported() -> ::io::Result { +pub fn unsupported() -> crate::io::Result { Err(unsupported_err()) } -pub fn unsupported_err() -> ::io::Error { - ::io::Error::new(::io::ErrorKind::Other, +pub fn unsupported_err() -> crate::io::Error { + crate::io::Error::new(ErrorKind::Other, "operation not supported on SGX yet") } @@ -55,58 +56,58 @@ pub fn unsupported_err() -> ::io::Error { /// returned, the program might very well be able to function normally. This is /// what happens when `SGX_INEFFECTIVE_ERROR` is set to `true`. If it is /// `false`, the behavior is the same as `unsupported`. -pub fn sgx_ineffective(v: T) -> ::io::Result { +pub fn sgx_ineffective(v: T) -> crate::io::Result { static SGX_INEFFECTIVE_ERROR: AtomicBool = AtomicBool::new(false); if SGX_INEFFECTIVE_ERROR.load(Ordering::Relaxed) { - Err(::io::Error::new(::io::ErrorKind::Other, + Err(crate::io::Error::new(ErrorKind::Other, "operation can't be trusted to have any effect on SGX")) } else { Ok(v) } } -pub fn decode_error_kind(code: i32) -> ::io::ErrorKind { +pub fn decode_error_kind(code: i32) -> ErrorKind { use fortanix_sgx_abi::Error; // FIXME: not sure how to make sure all variants of Error are covered if code == Error::NotFound as _ { - ::io::ErrorKind::NotFound + ErrorKind::NotFound } else if code == Error::PermissionDenied as _ { - ::io::ErrorKind::PermissionDenied + ErrorKind::PermissionDenied } else if code == Error::ConnectionRefused as _ { - ::io::ErrorKind::ConnectionRefused + ErrorKind::ConnectionRefused } else if code == Error::ConnectionReset as _ { - ::io::ErrorKind::ConnectionReset + ErrorKind::ConnectionReset } else if code == Error::ConnectionAborted as _ { - ::io::ErrorKind::ConnectionAborted + ErrorKind::ConnectionAborted } else if code == Error::NotConnected as _ { - ::io::ErrorKind::NotConnected + ErrorKind::NotConnected } else if code == Error::AddrInUse as _ { - ::io::ErrorKind::AddrInUse + ErrorKind::AddrInUse } else if code == Error::AddrNotAvailable as _ { - ::io::ErrorKind::AddrNotAvailable + ErrorKind::AddrNotAvailable } else if code == Error::BrokenPipe as _ { - ::io::ErrorKind::BrokenPipe + ErrorKind::BrokenPipe } else if code == Error::AlreadyExists as _ { - ::io::ErrorKind::AlreadyExists + ErrorKind::AlreadyExists } else if code == Error::WouldBlock as _ { - ::io::ErrorKind::WouldBlock + ErrorKind::WouldBlock } else if code == Error::InvalidInput as _ { - ::io::ErrorKind::InvalidInput + ErrorKind::InvalidInput } else if code == Error::InvalidData as _ { - ::io::ErrorKind::InvalidData + ErrorKind::InvalidData } else if code == Error::TimedOut as _ { - ::io::ErrorKind::TimedOut + ErrorKind::TimedOut } else if code == Error::WriteZero as _ { - ::io::ErrorKind::WriteZero + ErrorKind::WriteZero } else if code == Error::Interrupted as _ { - ::io::ErrorKind::Interrupted + ErrorKind::Interrupted } else if code == Error::Other as _ { - ::io::ErrorKind::Other + ErrorKind::Other } else if code == Error::UnexpectedEof as _ { - ::io::ErrorKind::UnexpectedEof + ErrorKind::UnexpectedEof } else { - ::io::ErrorKind::Other + ErrorKind::Other } } @@ -131,9 +132,9 @@ pub unsafe fn abort_internal() -> ! { pub fn hashmap_random_keys() -> (u64, u64) { fn rdrand64() -> u64 { unsafe { - let mut ret: u64 = ::mem::uninitialized(); + let mut ret: u64 = crate::mem::uninitialized(); for _ in 0..10 { - if ::arch::x86_64::_rdrand64_step(&mut ret) == 1 { + if crate::arch::x86_64::_rdrand64_step(&mut ret) == 1 { return ret; } } @@ -143,7 +144,7 @@ pub fn hashmap_random_keys() -> (u64, u64) { (rdrand64(), rdrand64()) } -pub use sys_common::{AsInner, FromInner, IntoInner}; +pub use crate::sys_common::{AsInner, FromInner, IntoInner}; pub trait TryIntoInner: Sized { fn try_into_inner(self) -> Result; diff --git a/src/libstd/sys/sgx/net.rs b/src/libstd/sys/sgx/net.rs index c4c2de43ff7..ab8b2681393 100644 --- a/src/libstd/sys/sgx/net.rs +++ b/src/libstd/sys/sgx/net.rs @@ -1,12 +1,12 @@ -use fmt; -use io::{self, IoVec, IoVecMut}; -use net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr, ToSocketAddrs}; -use time::Duration; -use sys::{unsupported, Void, sgx_ineffective, AsInner, FromInner, IntoInner, TryIntoInner}; -use sys::fd::FileDesc; -use convert::TryFrom; -use error; -use sync::Arc; +use crate::fmt; +use crate::io::{self, IoVec, IoVecMut}; +use crate::net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr, ToSocketAddrs}; +use crate::time::Duration; +use crate::sys::{unsupported, Void, sgx_ineffective, AsInner, FromInner, IntoInner, TryIntoInner}; +use crate::sys::fd::FileDesc; +use crate::convert::TryFrom; +use crate::error; +use crate::sync::Arc; use super::abi::usercalls; diff --git a/src/libstd/sys/sgx/os.rs b/src/libstd/sys/sgx/os.rs index b1e4d371a67..2725e66ce5d 100644 --- a/src/libstd/sys/sgx/os.rs +++ b/src/libstd/sys/sgx/os.rs @@ -1,17 +1,17 @@ use fortanix_sgx_abi::{Error, RESULT_SUCCESS}; -use error::Error as StdError; -use ffi::{OsString, OsStr}; -use fmt; -use io; -use path::{self, PathBuf}; -use str; -use sys::{unsupported, Void, sgx_ineffective, decode_error_kind}; -use collections::HashMap; -use vec; -use sync::Mutex; -use sync::atomic::{AtomicUsize, Ordering}; -use sync::Once; +use crate::error::Error as StdError; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::io; +use crate::path::{self, PathBuf}; +use crate::str; +use crate::sys::{unsupported, Void, sgx_ineffective, decode_error_kind}; +use crate::collections::HashMap; +use crate::vec; +use crate::sync::Mutex; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::sync::Once; pub fn errno() -> i32 { RESULT_SUCCESS diff --git a/src/libstd/sys/sgx/os_str.rs b/src/libstd/sys/sgx/os_str.rs index 9d5e084feb2..79b43458d00 100644 --- a/src/libstd/sys/sgx/os_str.rs +++ b/src/libstd/sys/sgx/os_str.rs @@ -1,14 +1,15 @@ /// The underlying OsString/OsStr implementation on Unix systems: just /// a `Vec`/`[u8]`. -use borrow::Cow; -use fmt; -use str; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner}; -use sys_common::bytestring::debug_fmt_bytestring; +use crate::borrow::Cow; +use crate::fmt; +use crate::str; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner}; +use crate::sys_common::bytestring::debug_fmt_bytestring; + use core::str::lossy::Utf8Lossy; #[derive(Clone, Hash)] diff --git a/src/libstd/sys/sgx/path.rs b/src/libstd/sys/sgx/path.rs index 90b1fa7c97b..1115de1fbe5 100644 --- a/src/libstd/sys/sgx/path.rs +++ b/src/libstd/sys/sgx/path.rs @@ -1,5 +1,5 @@ -use path::Prefix; -use ffi::OsStr; +use crate::path::Prefix; +use crate::ffi::OsStr; #[inline] pub fn is_sep_byte(b: u8) -> bool { diff --git a/src/libstd/sys/sgx/pipe.rs b/src/libstd/sys/sgx/pipe.rs index ac48a6dc033..2582b993b60 100644 --- a/src/libstd/sys/sgx/pipe.rs +++ b/src/libstd/sys/sgx/pipe.rs @@ -1,5 +1,5 @@ -use io; -use sys::Void; +use crate::io; +use crate::sys::Void; pub struct AnonPipe(Void); diff --git a/src/libstd/sys/sgx/process.rs b/src/libstd/sys/sgx/process.rs index 5357d931c73..c49daaa1632 100644 --- a/src/libstd/sys/sgx/process.rs +++ b/src/libstd/sys/sgx/process.rs @@ -1,10 +1,10 @@ -use ffi::OsStr; -use fmt; -use io; -use sys::fs::File; -use sys::pipe::AnonPipe; -use sys::{unsupported, Void}; -use sys_common::process::{CommandEnv, DefaultEnvKey}; +use crate::ffi::OsStr; +use crate::fmt; +use crate::io; +use crate::sys::fs::File; +use crate::sys::pipe::AnonPipe; +use crate::sys::{unsupported, Void}; +use crate::sys_common::process::{CommandEnv, DefaultEnvKey}; //////////////////////////////////////////////////////////////////////////////// // Command diff --git a/src/libstd/sys/sgx/rwlock.rs b/src/libstd/sys/sgx/rwlock.rs index 4dfbe86d14f..372760bbf26 100644 --- a/src/libstd/sys/sgx/rwlock.rs +++ b/src/libstd/sys/sgx/rwlock.rs @@ -1,12 +1,12 @@ -use alloc::{self, Layout}; -use num::NonZeroUsize; -use slice; -use str; +use crate::alloc::{self, Layout}; +use crate::num::NonZeroUsize; +use crate::slice; +use crate::str; use super::waitqueue::{ try_lock_or_false, NotifiedTcs, SpinMutex, SpinMutexGuard, WaitQueue, WaitVariable, }; -use mem; +use crate::mem; pub struct RWLock { readers: SpinMutex>>, @@ -206,7 +206,7 @@ pub unsafe extern "C" fn __rust_print_err(m: *mut u8, s: i32) { #[no_mangle] // NB. used by both libunwind and libpanic_abort pub unsafe extern "C" fn __rust_abort() { - ::sys::abort_internal(); + crate::sys::abort_internal(); } #[no_mangle] @@ -224,8 +224,8 @@ mod tests { use super::*; use core::array::FixedSizeArray; - use mem::MaybeUninit; - use {mem, ptr}; + use crate::mem::MaybeUninit; + use crate::{mem, ptr}; // The below test verifies that the bytes of initialized RWLock are the ones // we use in libunwind. diff --git a/src/libstd/sys/sgx/stdio.rs b/src/libstd/sys/sgx/stdio.rs index 57d66ed9a85..f2c6892bfb7 100644 --- a/src/libstd/sys/sgx/stdio.rs +++ b/src/libstd/sys/sgx/stdio.rs @@ -1,7 +1,7 @@ use fortanix_sgx_abi as abi; -use io; -use sys::fd::FileDesc; +use crate::io; +use crate::sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); @@ -52,7 +52,7 @@ impl io::Write for Stderr { } } -pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE; +pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE; pub fn is_ebadf(err: &io::Error) -> bool { // FIXME: Rust normally maps Unix EBADF to `Other` diff --git a/src/libstd/sys/sgx/thread.rs b/src/libstd/sys/sgx/thread.rs index b4bdb03e61a..13569062ac1 100644 --- a/src/libstd/sys/sgx/thread.rs +++ b/src/libstd/sys/sgx/thread.rs @@ -1,7 +1,7 @@ -use boxed::FnBox; -use ffi::CStr; -use io; -use time::Duration; +use crate::boxed::FnBox; +use crate::ffi::CStr; +use crate::io; +use crate::time::Duration; use super::abi::usercalls; @@ -10,9 +10,9 @@ pub struct Thread(task_queue::JoinHandle); pub const DEFAULT_MIN_STACK_SIZE: usize = 4096; mod task_queue { - use sync::{Mutex, MutexGuard, Once}; - use sync::mpsc; - use boxed::FnBox; + use crate::sync::{Mutex, MutexGuard, Once}; + use crate::sync::mpsc; + use crate::boxed::FnBox; pub type JoinHandle = mpsc::Receiver<()>; diff --git a/src/libstd/sys/sgx/time.rs b/src/libstd/sys/sgx/time.rs index 407fe72b0e6..e4f789c3e36 100644 --- a/src/libstd/sys/sgx/time.rs +++ b/src/libstd/sys/sgx/time.rs @@ -1,4 +1,4 @@ -use time::Duration; +use crate::time::Duration; use super::abi::usercalls; #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] diff --git a/src/libstd/sys/sgx/waitqueue.rs b/src/libstd/sys/sgx/waitqueue.rs index aec643b3175..1dbf2afbf49 100644 --- a/src/libstd/sys/sgx/waitqueue.rs +++ b/src/libstd/sys/sgx/waitqueue.rs @@ -10,8 +10,8 @@ /// recorded in the enclave. The wakeup event state is protected by a spinlock. /// The queue and associated wait state are stored in a `WaitVariable`. -use ops::{Deref, DerefMut}; -use num::NonZeroUsize; +use crate::ops::{Deref, DerefMut}; +use crate::num::NonZeroUsize; use fortanix_sgx_abi::{Tcs, EV_UNPARK, WAIT_INDEFINITE}; use super::abi::usercalls; @@ -211,8 +211,8 @@ impl WaitQueue { /// A doubly-linked list where callers are in charge of memory allocation /// of the nodes in the list. mod unsafe_list { - use ptr::NonNull; - use mem; + use crate::ptr::NonNull; + use crate::mem; pub struct UnsafeListEntry { next: NonNull>, @@ -341,7 +341,7 @@ mod unsafe_list { #[cfg(test)] mod tests { use super::*; - use cell::Cell; + use crate::cell::Cell; unsafe fn assert_empty(list: &mut UnsafeList) { assert!(list.pop().is_none(), "assertion failed: list is not empty"); @@ -404,9 +404,9 @@ mod unsafe_list { /// Trivial spinlock-based implementation of `sync::Mutex`. // FIXME: Perhaps use Intel TSX to avoid locking? mod spin_mutex { - use cell::UnsafeCell; - use sync::atomic::{AtomicBool, Ordering, spin_loop_hint}; - use ops::{Deref, DerefMut}; + use crate::cell::UnsafeCell; + use crate::sync::atomic::{AtomicBool, Ordering, spin_loop_hint}; + use crate::ops::{Deref, DerefMut}; #[derive(Default)] pub struct SpinMutex { @@ -496,8 +496,8 @@ mod spin_mutex { #![allow(deprecated)] use super::*; - use sync::Arc; - use thread; + use crate::sync::Arc; + use crate::thread; #[test] fn sleep() { @@ -519,8 +519,8 @@ mod spin_mutex { #[cfg(test)] mod tests { use super::*; - use sync::Arc; - use thread; + use crate::sync::Arc; + use crate::thread; #[test] fn queue() { diff --git a/src/libstd/sys/unix/alloc.rs b/src/libstd/sys/unix/alloc.rs index 93e8e0e6696..8e8f5017da7 100644 --- a/src/libstd/sys/unix/alloc.rs +++ b/src/libstd/sys/unix/alloc.rs @@ -1,7 +1,6 @@ -use ptr; -use libc; -use sys_common::alloc::{MIN_ALIGN, realloc_fallback}; -use alloc::{GlobalAlloc, Layout, System}; +use crate::ptr; +use crate::sys_common::alloc::{MIN_ALIGN, realloc_fallback}; +use crate::alloc::{GlobalAlloc, Layout, System}; #[stable(feature = "alloc_system_type", since = "1.28.0")] unsafe impl GlobalAlloc for System { diff --git a/src/libstd/sys/unix/android.rs b/src/libstd/sys/unix/android.rs index 986fa27ede6..6774160bb25 100644 --- a/src/libstd/sys/unix/android.rs +++ b/src/libstd/sys/unix/android.rs @@ -21,7 +21,7 @@ use libc::{c_int, c_void, sighandler_t, size_t, ssize_t}; use libc::{ftruncate, pread, pwrite}; -use io; +use crate::io; use super::{cvt, cvt_r}; // The `log2` and `log2f` functions apparently appeared in android-18, or at @@ -49,12 +49,12 @@ use super::{cvt, cvt_r}; #[cfg(not(test))] pub fn log2f32(f: f32) -> f32 { - f.ln() * ::f32::consts::LOG2_E + f.ln() * crate::f32::consts::LOG2_E } #[cfg(not(test))] pub fn log2f64(f: f64) -> f64 { - f.ln() * ::f64::consts::LOG2_E + f.ln() * crate::f64::consts::LOG2_E } // Back in the day [1] the `signal` function was just an inline wrapper @@ -117,7 +117,7 @@ pub fn ftruncate64(fd: c_int, size: u64) -> io::Result<()> { pub unsafe fn cvt_pread64(fd: c_int, buf: *mut c_void, count: size_t, offset: i64) -> io::Result { - use convert::TryInto; + use crate::convert::TryInto; weak!(fn pread64(c_int, *mut c_void, size_t, i64) -> ssize_t); pread64.get().map(|f| cvt(f(fd, buf, count, offset))).unwrap_or_else(|| { if let Ok(o) = offset.try_into() { @@ -133,7 +133,7 @@ pub unsafe fn cvt_pread64(fd: c_int, buf: *mut c_void, count: size_t, offset: i6 pub unsafe fn cvt_pwrite64(fd: c_int, buf: *const c_void, count: size_t, offset: i64) -> io::Result { - use convert::TryInto; + use crate::convert::TryInto; weak!(fn pwrite64(c_int, *const c_void, size_t, i64) -> ssize_t); pwrite64.get().map(|f| cvt(f(fd, buf, count, offset))).unwrap_or_else(|| { if let Ok(o) = offset.try_into() { diff --git a/src/libstd/sys/unix/args.rs b/src/libstd/sys/unix/args.rs index db1c5f4fea5..18de1096df2 100644 --- a/src/libstd/sys/unix/args.rs +++ b/src/libstd/sys/unix/args.rs @@ -5,9 +5,9 @@ #![allow(dead_code)] // runtime init functions not used during testing -use ffi::OsString; -use marker::PhantomData; -use vec; +use crate::ffi::OsString; +use crate::marker::PhantomData; +use crate::vec; /// One-time global initialization. pub unsafe fn init(argc: isize, argv: *const *const u8) { imp::init(argc, argv) } @@ -59,14 +59,13 @@ impl DoubleEndedIterator for Args { target_os = "fuchsia", target_os = "hermit"))] mod imp { - use os::unix::prelude::*; - use ptr; - use ffi::{CStr, OsString}; - use marker::PhantomData; - use libc; + use crate::os::unix::prelude::*; + use crate::ptr; + use crate::ffi::{CStr, OsString}; + use crate::marker::PhantomData; use super::Args; - use sys_common::mutex::Mutex; + use crate::sys_common::mutex::Mutex; static mut ARGC: isize = 0; static mut ARGV: *const *const u8 = ptr::null(); @@ -107,9 +106,8 @@ mod imp { #[cfg(any(target_os = "macos", target_os = "ios"))] mod imp { - use ffi::CStr; - use marker::PhantomData; - use libc; + use crate::ffi::CStr; + use crate::marker::PhantomData; use super::Args; pub unsafe fn init(_argc: isize, _argv: *const *const u8) { @@ -120,7 +118,7 @@ mod imp { #[cfg(target_os = "macos")] pub fn args() -> Args { - use os::unix::prelude::*; + use crate::os::unix::prelude::*; extern { // These functions are in crt_externs.h. fn _NSGetArgc() -> *mut libc::c_int; @@ -155,9 +153,9 @@ mod imp { // res #[cfg(target_os = "ios")] pub fn args() -> Args { - use ffi::OsString; - use mem; - use str; + use crate::ffi::OsString; + use crate::mem; + use crate::str; extern { fn sel_registerName(name: *const libc::c_uchar) -> Sel; diff --git a/src/libstd/sys/unix/backtrace/mod.rs b/src/libstd/sys/unix/backtrace/mod.rs index 79c3e39d8f8..0887e5a4df9 100644 --- a/src/libstd/sys/unix/backtrace/mod.rs +++ b/src/libstd/sys/unix/backtrace/mod.rs @@ -83,8 +83,9 @@ mod printing; #[cfg(not(target_os = "emscripten"))] pub mod gnu { - use io; - use fs; + use crate::io; + use crate::fs; + use libc::c_char; #[cfg(not(any(target_os = "macos", target_os = "ios")))] @@ -94,8 +95,8 @@ pub mod gnu { #[cfg(any(target_os = "macos", target_os = "ios"))] pub fn get_executable_filename() -> io::Result<(Vec, fs::File)> { - use env; - use os::unix::ffi::OsStrExt; + use crate::env; + use crate::os::unix::ffi::OsStrExt; let filename = env::current_exe()?; let file = fs::File::open(&filename)?; diff --git a/src/libstd/sys/unix/backtrace/printing/dladdr.rs b/src/libstd/sys/unix/backtrace/printing/dladdr.rs index 09715db8c1a..cf3bda640e9 100644 --- a/src/libstd/sys/unix/backtrace/printing/dladdr.rs +++ b/src/libstd/sys/unix/backtrace/printing/dladdr.rs @@ -1,9 +1,8 @@ -use io; -use intrinsics; -use ffi::CStr; -use libc; -use sys::backtrace::BacktraceContext; -use sys_common::backtrace::Frame; +use crate::io; +use crate::intrinsics; +use crate::ffi::CStr; +use crate::sys::backtrace::BacktraceContext; +use crate::sys_common::backtrace::Frame; pub fn resolve_symname(frame: Frame, callback: F, diff --git a/src/libstd/sys/unix/backtrace/printing/mod.rs b/src/libstd/sys/unix/backtrace/printing/mod.rs index d0303e6995f..d090caede43 100644 --- a/src/libstd/sys/unix/backtrace/printing/mod.rs +++ b/src/libstd/sys/unix/backtrace/printing/mod.rs @@ -1,8 +1,8 @@ mod dladdr; -use sys::backtrace::BacktraceContext; -use sys_common::backtrace::Frame; -use io; +use crate::sys::backtrace::BacktraceContext; +use crate::sys_common::backtrace::Frame; +use crate::io; #[cfg(target_os = "emscripten")] pub use self::dladdr::resolve_symname; @@ -16,14 +16,14 @@ where } #[cfg(not(target_os = "emscripten"))] -pub use sys_common::gnu::libbacktrace::foreach_symbol_fileline; +pub use crate::sys_common::gnu::libbacktrace::foreach_symbol_fileline; #[cfg(not(target_os = "emscripten"))] pub fn resolve_symname(frame: Frame, callback: F, bc: &BacktraceContext) -> io::Result<()> where F: FnOnce(Option<&str>) -> io::Result<()> { - ::sys_common::gnu::libbacktrace::resolve_symname(frame, |symname| { + crate::sys_common::gnu::libbacktrace::resolve_symname(frame, |symname| { if symname.is_some() { callback(symname) } else { diff --git a/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs b/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs index 236762c5eb5..a628d107ad6 100644 --- a/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs +++ b/src/libstd/sys/unix/backtrace/tracing/backtrace_fn.rs @@ -8,10 +8,10 @@ /// simple to use it should be used only on iOS devices as the only viable /// option. -use io; -use libc; -use sys::backtrace::BacktraceContext; -use sys_common::backtrace::Frame; +use crate::io; +use crate::ptr; +use crate::sys::backtrace::BacktraceContext; +use crate::sys_common::backtrace::Frame; #[inline(never)] // if we know this is a function call, we can skip it when // tracing @@ -20,7 +20,7 @@ pub fn unwind_backtrace(frames: &mut [Frame]) { const FRAME_LEN: usize = 100; assert!(FRAME_LEN >= frames.len()); - let mut raw_frames = [::ptr::null_mut(); FRAME_LEN]; + let mut raw_frames = [ptr::null_mut(); FRAME_LEN]; let nb_frames = unsafe { backtrace(raw_frames.as_mut_ptr(), raw_frames.len() as libc::c_int) } as usize; diff --git a/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs b/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs index 72a7968c514..abbeca0fde6 100644 --- a/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs +++ b/src/libstd/sys/unix/backtrace/tracing/gcc_s.rs @@ -1,8 +1,8 @@ -use error::Error; -use io; -use libc; -use sys::backtrace::BacktraceContext; -use sys_common::backtrace::Frame; +use crate::error::Error; +use crate::fmt; +use crate::io; +use crate::sys::backtrace::BacktraceContext; +use crate::sys_common::backtrace::Frame; use unwind as uw; @@ -20,8 +20,8 @@ impl Error for UnwindError { } } -impl ::fmt::Display for UnwindError { - fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result { +impl fmt::Display for UnwindError { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}: {:?}", self.description(), self.0) } } diff --git a/src/libstd/sys/unix/condvar.rs b/src/libstd/sys/unix/condvar.rs index 3e048d5c6e4..47fb6792f08 100644 --- a/src/libstd/sys/unix/condvar.rs +++ b/src/libstd/sys/unix/condvar.rs @@ -1,7 +1,6 @@ -use cell::UnsafeCell; -use libc; -use sys::mutex::{self, Mutex}; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::sys::mutex::{self, Mutex}; +use crate::time::Duration; pub struct Condvar { inner: UnsafeCell } @@ -41,7 +40,7 @@ impl Condvar { target_os = "android", target_os = "hermit")))] pub unsafe fn init(&mut self) { - use mem; + use crate::mem; let mut attr: libc::pthread_condattr_t = mem::uninitialized(); let r = libc::pthread_condattr_init(&mut attr); assert_eq!(r, 0); @@ -80,7 +79,7 @@ impl Condvar { target_os = "android", target_os = "hermit")))] pub unsafe fn wait_timeout(&self, mutex: &Mutex, dur: Duration) -> bool { - use mem; + use crate::mem; let mut now: libc::timespec = mem::zeroed(); let r = libc::clock_gettime(libc::CLOCK_MONOTONIC, &mut now); @@ -110,8 +109,8 @@ impl Condvar { // https://github.com/llvm-mirror/libcxx/blob/release_35/include/__mutex_base#L367 #[cfg(any(target_os = "macos", target_os = "ios", target_os = "android", target_os = "hermit"))] pub unsafe fn wait_timeout(&self, mutex: &Mutex, mut dur: Duration) -> bool { - use ptr; - use time::Instant; + use crate::ptr; + use crate::time::Instant; // 1000 years let max_dur = Duration::from_secs(1000 * 365 * 86400); diff --git a/src/libstd/sys/unix/ext/ffi.rs b/src/libstd/sys/unix/ext/ffi.rs index d1c3cd82ac5..0c023239815 100644 --- a/src/libstd/sys/unix/ext/ffi.rs +++ b/src/libstd/sys/unix/ext/ffi.rs @@ -2,10 +2,10 @@ #![stable(feature = "rust1", since = "1.0.0")] -use ffi::{OsStr, OsString}; -use mem; -use sys::os_str::Buf; -use sys_common::{FromInner, IntoInner, AsInner}; +use crate::ffi::{OsStr, OsString}; +use crate::mem; +use crate::sys::os_str::Buf; +use crate::sys_common::{FromInner, IntoInner, AsInner}; /// Unix-specific extensions to [`OsString`]. /// diff --git a/src/libstd/sys/unix/ext/fs.rs b/src/libstd/sys/unix/ext/fs.rs index abcce3ab829..d9baac993c4 100644 --- a/src/libstd/sys/unix/ext/fs.rs +++ b/src/libstd/sys/unix/ext/fs.rs @@ -2,13 +2,12 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs::{self, Permissions, OpenOptions}; -use io; -use libc; -use path::Path; -use sys; -use sys_common::{FromInner, AsInner, AsInnerMut}; -use sys::platform::fs::MetadataExt as UnixMetadataExt; +use crate::fs::{self, Permissions, OpenOptions}; +use crate::io; +use crate::path::Path; +use crate::sys; +use crate::sys_common::{FromInner, AsInner, AsInnerMut}; +use crate::sys::platform::fs::MetadataExt as UnixMetadataExt; /// Unix-specific extensions to [`File`]. /// diff --git a/src/libstd/sys/unix/ext/io.rs b/src/libstd/sys/unix/ext/io.rs index 73f4879e4e4..1a0b3b8962b 100644 --- a/src/libstd/sys/unix/ext/io.rs +++ b/src/libstd/sys/unix/ext/io.rs @@ -2,12 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs; -use os::raw; -use sys; -use io; -use sys_common::{AsInner, FromInner, IntoInner}; -use libc; +use crate::fs; +use crate::os::raw; +use crate::sys; +use crate::io; +use crate::sys_common::{AsInner, FromInner, IntoInner}; /// Raw file descriptors. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/sys/unix/ext/net.rs b/src/libstd/sys/unix/ext/net.rs index 4b60ea654c1..4fc79efe7ce 100644 --- a/src/libstd/sys/unix/ext/net.rs +++ b/src/libstd/sys/unix/ext/net.rs @@ -15,19 +15,19 @@ mod libc { pub struct sockaddr_un; } -use ascii; -use ffi::OsStr; -use fmt; -use io::{self, Initializer, IoVec, IoVecMut}; -use mem; -use net::{self, Shutdown}; -use os::unix::ffi::OsStrExt; -use os::unix::io::{RawFd, AsRawFd, FromRawFd, IntoRawFd}; -use path::Path; -use time::Duration; -use sys::{self, cvt}; -use sys::net::Socket; -use sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::ascii; +use crate::ffi::OsStr; +use crate::fmt; +use crate::io::{self, Initializer, IoVec, IoVecMut}; +use crate::mem; +use crate::net::{self, Shutdown}; +use crate::os::unix::ffi::OsStrExt; +use crate::os::unix::io::{RawFd, AsRawFd, FromRawFd, IntoRawFd}; +use crate::path::Path; +use crate::time::Duration; +use crate::sys::{self, cvt}; +use crate::sys::net::Socket; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; #[cfg(any(target_os = "linux", target_os = "android", target_os = "dragonfly", target_os = "freebsd", @@ -1481,11 +1481,11 @@ impl IntoRawFd for UnixDatagram { #[cfg(all(test, not(target_os = "emscripten")))] mod test { - use thread; - use io::{self, ErrorKind}; - use io::prelude::*; - use time::Duration; - use sys_common::io::test::tmpdir; + use crate::thread; + use crate::io::{self, ErrorKind}; + use crate::io::prelude::*; + use crate::time::Duration; + use crate::sys_common::io::test::tmpdir; use super::*; diff --git a/src/libstd/sys/unix/ext/process.rs b/src/libstd/sys/unix/ext/process.rs index b487bb889ba..7ace95edef9 100644 --- a/src/libstd/sys/unix/ext/process.rs +++ b/src/libstd/sys/unix/ext/process.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use io; -use os::unix::io::{FromRawFd, RawFd, AsRawFd, IntoRawFd}; -use process; -use sys; -use sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; +use crate::io; +use crate::os::unix::io::{FromRawFd, RawFd, AsRawFd, IntoRawFd}; +use crate::process; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; /// Unix-specific extensions to the [`process::Command`] builder. /// @@ -209,5 +209,5 @@ impl IntoRawFd for process::ChildStderr { /// Returns the OS-assigned process identifier associated with this process's parent. #[stable(feature = "unix_ppid", since = "1.27.0")] pub fn parent_id() -> u32 { - ::sys::os::getppid() + crate::sys::os::getppid() } diff --git a/src/libstd/sys/unix/ext/raw.rs b/src/libstd/sys/unix/ext/raw.rs index eabb4b02503..75ae54a919a 100644 --- a/src/libstd/sys/unix/ext/raw.rs +++ b/src/libstd/sys/unix/ext/raw.rs @@ -14,10 +14,10 @@ #[doc(inline)] #[stable(feature = "pthread_t", since = "1.8.0")] -pub use sys::platform::raw::pthread_t; +pub use crate::sys::platform::raw::pthread_t; #[doc(inline)] #[stable(feature = "raw_ext", since = "1.1.0")] -pub use sys::platform::raw::{dev_t, ino_t, mode_t, nlink_t, off_t, blksize_t}; +pub use crate::sys::platform::raw::{dev_t, ino_t, mode_t, nlink_t, off_t, blksize_t}; #[doc(inline)] #[stable(feature = "raw_ext", since = "1.1.0")] -pub use sys::platform::raw::{blkcnt_t, time_t}; +pub use crate::sys::platform::raw::{blkcnt_t, time_t}; diff --git a/src/libstd/sys/unix/ext/thread.rs b/src/libstd/sys/unix/ext/thread.rs index 4b3d5e31848..759ef6236e8 100644 --- a/src/libstd/sys/unix/ext/thread.rs +++ b/src/libstd/sys/unix/ext/thread.rs @@ -3,9 +3,9 @@ #![stable(feature = "thread_extensions", since = "1.9.0")] #[allow(deprecated)] -use os::unix::raw::pthread_t; -use sys_common::{AsInner, IntoInner}; -use thread::JoinHandle; +use crate::os::unix::raw::pthread_t; +use crate::sys_common::{AsInner, IntoInner}; +use crate::thread::JoinHandle; #[stable(feature = "thread_extensions", since = "1.9.0")] #[allow(deprecated)] diff --git a/src/libstd/sys/unix/fast_thread_local.rs b/src/libstd/sys/unix/fast_thread_local.rs index 742ffd12b88..17478dce4fe 100644 --- a/src/libstd/sys/unix/fast_thread_local.rs +++ b/src/libstd/sys/unix/fast_thread_local.rs @@ -12,9 +12,8 @@ // Due to rust-lang/rust#18804, make sure this is not generic! #[cfg(any(target_os = "linux", target_os = "fuchsia", target_os = "hermit"))] pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) { - use libc; - use mem; - use sys_common::thread_local::register_dtor_fallback; + use crate::mem; + use crate::sys_common::thread_local::register_dtor_fallback; extern { #[linkage = "extern_weak"] @@ -45,8 +44,8 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) { // _tlv_atexit. #[cfg(target_os = "macos")] pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern fn(*mut u8)) { - use cell::Cell; - use ptr; + use crate::cell::Cell; + use crate::ptr; #[thread_local] static REGISTERED: Cell = Cell::new(false); diff --git a/src/libstd/sys/unix/fd.rs b/src/libstd/sys/unix/fd.rs index 6946b7b5dfa..c274ad26cb1 100644 --- a/src/libstd/sys/unix/fd.rs +++ b/src/libstd/sys/unix/fd.rs @@ -1,12 +1,13 @@ #![unstable(reason = "not public", issue = "0", feature = "fd")] -use cmp; -use io::{self, Read, Initializer, IoVec, IoVecMut}; -use libc::{self, c_int, c_void, ssize_t}; -use mem; -use sync::atomic::{AtomicBool, Ordering}; -use sys::cvt; -use sys_common::AsInner; +use crate::cmp; +use crate::io::{self, Read, Initializer, IoVec, IoVecMut}; +use crate::mem; +use crate::sync::atomic::{AtomicBool, Ordering}; +use crate::sys::cvt; +use crate::sys_common::AsInner; + +use libc::{c_int, c_void, ssize_t}; #[derive(Debug)] pub struct FileDesc { @@ -74,7 +75,7 @@ impl FileDesc { unsafe fn cvt_pread64(fd: c_int, buf: *mut c_void, count: usize, offset: i64) -> io::Result { - use convert::TryInto; + use crate::convert::TryInto; use libc::pread64; // pread64 on emscripten actually takes a 32 bit offset if let Ok(o) = offset.try_into() { @@ -131,7 +132,7 @@ impl FileDesc { unsafe fn cvt_pwrite64(fd: c_int, buf: *const c_void, count: usize, offset: i64) -> io::Result { - use convert::TryInto; + use crate::convert::TryInto; use libc::pwrite64; // pwrite64 on emscripten actually takes a 32 bit offset if let Ok(o) = offset.try_into() { diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs index 5183d6fadd2..3b80b475a93 100644 --- a/src/libstd/sys/unix/fs.rs +++ b/src/libstd/sys/unix/fs.rs @@ -1,17 +1,18 @@ -use os::unix::prelude::*; - -use ffi::{CString, CStr, OsString, OsStr}; -use fmt; -use io::{self, Error, ErrorKind, SeekFrom}; -use libc::{self, c_int, mode_t}; -use mem; -use path::{Path, PathBuf}; -use ptr; -use sync::Arc; -use sys::fd::FileDesc; -use sys::time::SystemTime; -use sys::{cvt, cvt_r}; -use sys_common::{AsInner, FromInner}; +use crate::os::unix::prelude::*; + +use crate::ffi::{CString, CStr, OsString, OsStr}; +use crate::fmt; +use crate::io::{self, Error, ErrorKind, SeekFrom}; +use crate::mem; +use crate::path::{Path, PathBuf}; +use crate::ptr; +use crate::sync::Arc; +use crate::sys::fd::FileDesc; +use crate::sys::time::SystemTime; +use crate::sys::{cvt, cvt_r}; +use crate::sys_common::{AsInner, FromInner}; + +use libc::{c_int, mode_t}; #[cfg(any(target_os = "linux", target_os = "emscripten", target_os = "l4re"))] use libc::{stat64, fstat64, lstat64, off64_t, ftruncate64, lseek64, dirent64, readdir64_r, open64}; @@ -217,6 +218,8 @@ impl Iterator for ReadDir { #[cfg(any(target_os = "solaris", target_os = "fuchsia"))] fn next(&mut self) -> Option> { + use crate::slice; + unsafe { loop { // Although readdir_r(3) would be a correct function to use here because @@ -239,8 +242,8 @@ impl Iterator for ReadDir { let ret = DirEntry { entry: *entry_ptr, - name: ::slice::from_raw_parts(name as *const u8, - namelen as usize).to_owned().into_boxed_slice(), + name: slice::from_raw_parts(name as *const u8, + namelen as usize).to_owned().into_boxed_slice(), dir: self.clone() }; if ret.name_bytes() != b"." && ret.name_bytes() != b".." { @@ -365,9 +368,10 @@ impl DirEntry { target_os = "dragonfly", target_os = "bitrig"))] fn name_bytes(&self) -> &[u8] { + use crate::slice; unsafe { - ::slice::from_raw_parts(self.entry.d_name.as_ptr() as *const u8, - self.entry.d_namlen as usize) + slice::from_raw_parts(self.entry.d_name.as_ptr() as *const u8, + self.entry.d_namlen as usize) } } #[cfg(any(target_os = "android", @@ -475,7 +479,7 @@ impl File { // that we support, so we only do this on Linux currently. #[cfg(target_os = "linux")] fn ensure_cloexec(fd: &FileDesc) -> io::Result<()> { - use sync::atomic::{AtomicUsize, Ordering}; + use crate::sync::atomic::{AtomicUsize, Ordering}; const OPEN_CLOEXEC_UNKNOWN: usize = 0; const OPEN_CLOEXEC_SUPPORTED: usize = 1; @@ -542,7 +546,7 @@ impl File { pub fn truncate(&self, size: u64) -> io::Result<()> { #[cfg(target_os = "android")] - return ::sys::android::ftruncate64(self.0.raw(), size); + return crate::sys::android::ftruncate64(self.0.raw(), size); #[cfg(not(target_os = "android"))] return cvt_r(|| unsafe { @@ -825,7 +829,7 @@ pub fn canonicalize(p: &Path) -> io::Result { #[cfg(not(any(target_os = "linux", target_os = "android")))] pub fn copy(from: &Path, to: &Path) -> io::Result { - use fs::File; + use crate::fs::File; if !from.is_file() { return Err(Error::new(ErrorKind::InvalidInput, "the source path is not an existing regular file")) @@ -842,9 +846,9 @@ pub fn copy(from: &Path, to: &Path) -> io::Result { #[cfg(any(target_os = "linux", target_os = "android"))] pub fn copy(from: &Path, to: &Path) -> io::Result { - use cmp; - use fs::File; - use sync::atomic::{AtomicBool, Ordering}; + use crate::cmp; + use crate::fs::File; + use crate::sync::atomic::{AtomicBool, Ordering}; // Kernel prior to 4.5 don't have copy_file_range // We store the availability in a global to avoid unnecessary syscalls diff --git a/src/libstd/sys/unix/l4re.rs b/src/libstd/sys/unix/l4re.rs index 4775e29fb57..b6e8cc73894 100644 --- a/src/libstd/sys/unix/l4re.rs +++ b/src/libstd/sys/unix/l4re.rs @@ -4,15 +4,15 @@ macro_rules! unimpl { pub mod net { #![allow(warnings)] - use fmt; - use io::{self, IoVec, IoVecMut}; - use libc; - use net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr}; - use sys_common::{AsInner, FromInner, IntoInner}; - use sys::fd::FileDesc; - use time::Duration; - use convert::TryFrom; - + use crate::fmt; + use crate::io::{self, IoVec, IoVecMut}; + use crate::net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr}; + use crate::sys_common::{AsInner, FromInner, IntoInner}; + use crate::sys::fd::FileDesc; + use crate::time::Duration; + use crate::convert::TryFrom; + + #[allow(unused_extern_crates)] pub extern crate libc as netc; pub struct Socket(FileDesc); diff --git a/src/libstd/sys/unix/memchr.rs b/src/libstd/sys/unix/memchr.rs index ec04a22a0d2..1984678bdde 100644 --- a/src/libstd/sys/unix/memchr.rs +++ b/src/libstd/sys/unix/memchr.rs @@ -2,8 +2,6 @@ // Copyright 2015 Andrew Gallant, bluss and Nicolas Koch pub fn memchr(needle: u8, haystack: &[u8]) -> Option { - use libc; - let p = unsafe { libc::memchr( haystack.as_ptr() as *const libc::c_void, @@ -21,8 +19,6 @@ pub fn memrchr(needle: u8, haystack: &[u8]) -> Option { #[cfg(target_os = "linux")] fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option { - use libc; - // GNU's memrchr() will - unlike memchr() - error if haystack is empty. if haystack.is_empty() {return None} let p = unsafe { @@ -40,7 +36,7 @@ pub fn memrchr(needle: u8, haystack: &[u8]) -> Option { #[cfg(not(target_os = "linux"))] fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option { - ::core::slice::memchr::memrchr(needle, haystack) + core::slice::memchr::memrchr(needle, haystack) } memrchr_specific(needle, haystack) diff --git a/src/libstd/sys/unix/mod.rs b/src/libstd/sys/unix/mod.rs index 0de1a223fbd..fbe3444311e 100644 --- a/src/libstd/sys/unix/mod.rs +++ b/src/libstd/sys/unix/mod.rs @@ -1,24 +1,23 @@ #![allow(missing_docs, nonstandard_style)] -use io::ErrorKind; -use libc; - -#[cfg(any(rustdoc, target_os = "linux"))] pub use os::linux as platform; - -#[cfg(all(not(rustdoc), target_os = "android"))] pub use os::android as platform; -#[cfg(all(not(rustdoc), target_os = "bitrig"))] pub use os::bitrig as platform; -#[cfg(all(not(rustdoc), target_os = "dragonfly"))] pub use os::dragonfly as platform; -#[cfg(all(not(rustdoc), target_os = "freebsd"))] pub use os::freebsd as platform; -#[cfg(all(not(rustdoc), target_os = "haiku"))] pub use os::haiku as platform; -#[cfg(all(not(rustdoc), target_os = "ios"))] pub use os::ios as platform; -#[cfg(all(not(rustdoc), target_os = "macos"))] pub use os::macos as platform; -#[cfg(all(not(rustdoc), target_os = "netbsd"))] pub use os::netbsd as platform; -#[cfg(all(not(rustdoc), target_os = "openbsd"))] pub use os::openbsd as platform; -#[cfg(all(not(rustdoc), target_os = "solaris"))] pub use os::solaris as platform; -#[cfg(all(not(rustdoc), target_os = "emscripten"))] pub use os::emscripten as platform; -#[cfg(all(not(rustdoc), target_os = "fuchsia"))] pub use os::fuchsia as platform; -#[cfg(all(not(rustdoc), target_os = "l4re"))] pub use os::linux as platform; -#[cfg(all(not(rustdoc), target_os = "hermit"))] pub use os::hermit as platform; +use crate::io::ErrorKind; + +#[cfg(any(rustdoc, target_os = "linux"))] pub use crate::os::linux as platform; + +#[cfg(all(not(rustdoc), target_os = "android"))] pub use crate::os::android as platform; +#[cfg(all(not(rustdoc), target_os = "bitrig"))] pub use crate::os::bitrig as platform; +#[cfg(all(not(rustdoc), target_os = "dragonfly"))] pub use crate::os::dragonfly as platform; +#[cfg(all(not(rustdoc), target_os = "freebsd"))] pub use crate::os::freebsd as platform; +#[cfg(all(not(rustdoc), target_os = "haiku"))] pub use crate::os::haiku as platform; +#[cfg(all(not(rustdoc), target_os = "ios"))] pub use crate::os::ios as platform; +#[cfg(all(not(rustdoc), target_os = "macos"))] pub use crate::os::macos as platform; +#[cfg(all(not(rustdoc), target_os = "netbsd"))] pub use crate::os::netbsd as platform; +#[cfg(all(not(rustdoc), target_os = "openbsd"))] pub use crate::os::openbsd as platform; +#[cfg(all(not(rustdoc), target_os = "solaris"))] pub use crate::os::solaris as platform; +#[cfg(all(not(rustdoc), target_os = "emscripten"))] pub use crate::os::emscripten as platform; +#[cfg(all(not(rustdoc), target_os = "fuchsia"))] pub use crate::os::fuchsia as platform; +#[cfg(all(not(rustdoc), target_os = "l4re"))] pub use crate::os::linux as platform; +#[cfg(all(not(rustdoc), target_os = "hermit"))] pub use crate::os::hermit as platform; pub use self::rand::hashmap_random_keys; pub use libc::strlen; @@ -82,7 +81,7 @@ pub fn init() { } #[cfg(target_os = "android")] -pub use sys::android::signal; +pub use crate::sys::android::signal; #[cfg(not(target_os = "android"))] pub use libc::signal; @@ -127,15 +126,15 @@ macro_rules! impl_is_minus_one { impl_is_minus_one! { i8 i16 i32 i64 isize } -pub fn cvt(t: T) -> ::io::Result { +pub fn cvt(t: T) -> crate::io::Result { if t.is_minus_one() { - Err(::io::Error::last_os_error()) + Err(crate::io::Error::last_os_error()) } else { Ok(t) } } -pub fn cvt_r(mut f: F) -> ::io::Result +pub fn cvt_r(mut f: F) -> crate::io::Result where T: IsMinusOne, F: FnMut() -> T { @@ -155,5 +154,5 @@ pub fn cvt_r(mut f: F) -> ::io::Result // instruction" that intrinsics::abort would cause, as intrinsics::abort is // implemented as an illegal instruction. pub unsafe fn abort_internal() -> ! { - ::libc::abort() + libc::abort() } diff --git a/src/libstd/sys/unix/mutex.rs b/src/libstd/sys/unix/mutex.rs index 54429dc84b6..b6a22e1962a 100644 --- a/src/libstd/sys/unix/mutex.rs +++ b/src/libstd/sys/unix/mutex.rs @@ -1,6 +1,5 @@ -use cell::UnsafeCell; -use libc; -use mem; +use crate::cell::UnsafeCell; +use crate::mem; pub struct Mutex { inner: UnsafeCell } @@ -74,7 +73,6 @@ impl Mutex { #[inline] #[cfg(target_os = "dragonfly")] pub unsafe fn destroy(&self) { - use libc; let r = libc::pthread_mutex_destroy(self.inner.get()); // On DragonFly pthread_mutex_destroy() returns EINVAL if called on a // mutex that was just initialized with libc::PTHREAD_MUTEX_INITIALIZER. diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index 521d9b42517..8e8cdf837a9 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -1,16 +1,19 @@ -use ffi::CStr; -use io::{self, IoVec, IoVecMut}; -use libc::{self, c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK}; -use mem; -use net::{SocketAddr, Shutdown}; -use str; -use sys::fd::FileDesc; -use sys_common::{AsInner, FromInner, IntoInner}; -use sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr}; -use time::{Duration, Instant}; -use cmp; +use crate::ffi::CStr; +use crate::io::{self, IoVec, IoVecMut}; +use crate::mem; +use crate::net::{SocketAddr, Shutdown}; +use crate::str; +use crate::sys::fd::FileDesc; +use crate::sys_common::{AsInner, FromInner, IntoInner}; +use crate::sys_common::net::{getsockopt, setsockopt, sockaddr_to_addr}; +use crate::time::{Duration, Instant}; +use crate::cmp; + +use libc::{c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK}; pub use sys::{cvt, cvt_r}; + +#[allow(unused_extern_crates)] pub extern crate libc as netc; pub type wrlen_t = size_t; @@ -384,7 +387,7 @@ impl IntoInner for Socket { // believe it's thread-safe). #[cfg(target_env = "gnu")] fn on_resolver_failure() { - use sys; + use crate::sys; // If the version fails to parse, we treat it the same as "not glibc". if let Some(version) = sys::os::glibc_version() { diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs index 58ea190fcc0..e16d50d437b 100644 --- a/src/libstd/sys/unix/os.rs +++ b/src/libstd/sys/unix/os.rs @@ -2,25 +2,26 @@ #![allow(unused_imports)] // lots of cfg code here -use os::unix::prelude::*; - -use error::Error as StdError; -use ffi::{CString, CStr, OsString, OsStr}; -use fmt; -use io; -use iter; -use libc::{self, c_int, c_char, c_void}; -use marker::PhantomData; -use mem; -use memchr; -use path::{self, PathBuf}; -use ptr; -use slice; -use str; -use sys_common::mutex::{Mutex, MutexGuard}; -use sys::cvt; -use sys::fd; -use vec; +use crate::os::unix::prelude::*; + +use crate::error::Error as StdError; +use crate::ffi::{CString, CStr, OsString, OsStr}; +use crate::fmt; +use crate::io; +use crate::iter; +use crate::marker::PhantomData; +use crate::mem; +use crate::memchr; +use crate::path::{self, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::str; +use crate::sys_common::mutex::{Mutex, MutexGuard}; +use crate::sys::cvt; +use crate::sys::fd; +use crate::vec; + +use libc::{c_int, c_char, c_void}; const TMPBUF_SZ: usize = 128; @@ -207,13 +208,13 @@ pub fn current_exe() -> io::Result { libc::KERN_PROC_PATHNAME as c_int, -1 as c_int]; let mut sz = 0; - cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, + cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as libc::c_uint, ptr::null_mut(), &mut sz, ptr::null_mut(), 0))?; if sz == 0 { return Err(io::Error::last_os_error()) } let mut v: Vec = Vec::with_capacity(sz); - cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint, + cvt(libc::sysctl(mib.as_mut_ptr(), mib.len() as libc::c_uint, v.as_mut_ptr() as *mut libc::c_void, &mut sz, ptr::null_mut(), 0))?; if sz == 0 { @@ -230,7 +231,7 @@ pub fn current_exe() -> io::Result { unsafe { let mib = [libc::CTL_KERN, libc::KERN_PROC_ARGS, -1, libc::KERN_PROC_PATHNAME]; let mut path_len: usize = 0; - cvt(libc::sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint, + cvt(libc::sysctl(mib.as_ptr(), mib.len() as libc::c_uint, ptr::null_mut(), &mut path_len, ptr::null(), 0))?; if path_len <= 1 { @@ -238,7 +239,7 @@ pub fn current_exe() -> io::Result { "KERN_PROC_PATHNAME sysctl returned zero-length string")) } let mut path: Vec = Vec::with_capacity(path_len); - cvt(libc::sysctl(mib.as_ptr(), mib.len() as ::libc::c_uint, + cvt(libc::sysctl(mib.as_ptr(), mib.len() as libc::c_uint, path.as_ptr() as *mut libc::c_void, &mut path_len, ptr::null(), 0))?; path.set_len(path_len - 1); // chop off NUL @@ -248,7 +249,7 @@ pub fn current_exe() -> io::Result { fn procfs() -> io::Result { let curproc_exe = path::Path::new("/proc/curproc/exe"); if curproc_exe.is_file() { - return ::fs::read_link(curproc_exe); + return crate::fs::read_link(curproc_exe); } Err(io::Error::new(io::ErrorKind::Other, "/proc/curproc/exe doesn't point to regular file.")) @@ -277,7 +278,7 @@ pub fn current_exe() -> io::Result { } let argv0 = CStr::from_ptr(argv[0]).to_bytes(); if argv0[0] == b'.' || argv0.iter().any(|b| *b == b'/') { - ::fs::canonicalize(OsStr::from_bytes(argv0)) + crate::fs::canonicalize(OsStr::from_bytes(argv0)) } else { Ok(PathBuf::from(OsStr::from_bytes(argv0))) } @@ -286,7 +287,7 @@ pub fn current_exe() -> io::Result { #[cfg(any(target_os = "linux", target_os = "android", target_os = "emscripten"))] pub fn current_exe() -> io::Result { - match ::fs::read_link("/proc/self/exe") { + match crate::fs::read_link("/proc/self/exe") { Err(ref e) if e.kind() == io::ErrorKind::NotFound => { Err(io::Error::new( io::ErrorKind::Other, @@ -373,7 +374,7 @@ pub fn current_exe() -> io::Result { let result = _get_next_image_info(0, &mut cookie, &mut info, mem::size_of::() as i32); if result != 0 { - use io::ErrorKind; + use crate::io::ErrorKind; Err(io::Error::new(ErrorKind::Other, "Error getting executable path")) } else { let name = CStr::from_ptr(info.name.as_ptr()).to_bytes(); @@ -384,7 +385,7 @@ pub fn current_exe() -> io::Result { #[cfg(any(target_os = "fuchsia", target_os = "l4re", target_os = "hermit"))] pub fn current_exe() -> io::Result { - use io::ErrorKind; + use crate::io::ErrorKind; Err(io::Error::new(ErrorKind::Other, "Not yet implemented!")) } @@ -495,7 +496,7 @@ pub fn page_size() -> usize { } pub fn temp_dir() -> PathBuf { - ::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| { + crate::env::var_os("TMPDIR").map(PathBuf::from).unwrap_or_else(|| { if cfg!(target_os = "android") { PathBuf::from("/data/local/tmp") } else { @@ -505,7 +506,7 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option { - return ::env::var_os("HOME").or_else(|| unsafe { + return crate::env::var_os("HOME").or_else(|| unsafe { fallback() }).map(PathBuf::from); diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs index 9d5e084feb2..79b43458d00 100644 --- a/src/libstd/sys/unix/os_str.rs +++ b/src/libstd/sys/unix/os_str.rs @@ -1,14 +1,15 @@ /// The underlying OsString/OsStr implementation on Unix systems: just /// a `Vec`/`[u8]`. -use borrow::Cow; -use fmt; -use str; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner}; -use sys_common::bytestring::debug_fmt_bytestring; +use crate::borrow::Cow; +use crate::fmt; +use crate::str; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner}; +use crate::sys_common::bytestring::debug_fmt_bytestring; + use core::str::lossy::Utf8Lossy; #[derive(Clone, Hash)] diff --git a/src/libstd/sys/unix/path.rs b/src/libstd/sys/unix/path.rs index 2ef78fb2f86..5c062e7c97c 100644 --- a/src/libstd/sys/unix/path.rs +++ b/src/libstd/sys/unix/path.rs @@ -1,5 +1,5 @@ -use path::Prefix; -use ffi::OsStr; +use crate::path::Prefix; +use crate::ffi::OsStr; #[inline] pub fn is_sep_byte(b: u8) -> bool { diff --git a/src/libstd/sys/unix/pipe.rs b/src/libstd/sys/unix/pipe.rs index a746d982c6c..bc3c026adab 100644 --- a/src/libstd/sys/unix/pipe.rs +++ b/src/libstd/sys/unix/pipe.rs @@ -1,9 +1,10 @@ -use io; -use libc::{self, c_int}; -use mem; -use sync::atomic::{AtomicBool, Ordering}; -use sys::fd::FileDesc; -use sys::{cvt, cvt_r}; +use crate::io; +use crate::mem; +use crate::sync::atomic::{AtomicBool, Ordering}; +use crate::sys::fd::FileDesc; +use crate::sys::{cvt, cvt_r}; + +use libc::c_int; //////////////////////////////////////////////////////////////////////////////// // Anonymous pipes diff --git a/src/libstd/sys/unix/process/process_common.rs b/src/libstd/sys/unix/process/process_common.rs index 7fa256e59b2..856d202be03 100644 --- a/src/libstd/sys/unix/process/process_common.rs +++ b/src/libstd/sys/unix/process/process_common.rs @@ -1,15 +1,16 @@ -use os::unix::prelude::*; - -use ffi::{OsString, OsStr, CString, CStr}; -use fmt; -use io; -use libc::{self, c_int, gid_t, uid_t, c_char, EXIT_SUCCESS, EXIT_FAILURE}; -use ptr; -use sys::fd::FileDesc; -use sys::fs::{File, OpenOptions}; -use sys::pipe::{self, AnonPipe}; -use sys_common::process::{CommandEnv, DefaultEnvKey}; -use collections::BTreeMap; +use crate::os::unix::prelude::*; + +use crate::ffi::{OsString, OsStr, CString, CStr}; +use crate::fmt; +use crate::io; +use crate::ptr; +use crate::sys::fd::FileDesc; +use crate::sys::fs::{File, OpenOptions}; +use crate::sys::pipe::{self, AnonPipe}; +use crate::sys_common::process::{CommandEnv, DefaultEnvKey}; +use crate::collections::BTreeMap; + +use libc::{c_int, gid_t, uid_t, c_char, EXIT_SUCCESS, EXIT_FAILURE}; //////////////////////////////////////////////////////////////////////////////// // Command @@ -406,11 +407,10 @@ impl ExitCode { mod tests { use super::*; - use ffi::OsStr; - use mem; - use ptr; - use libc; - use sys::cvt; + use crate::ffi::OsStr; + use crate::mem; + use crate::ptr; + use crate::sys::cvt; macro_rules! t { ($e:expr) => { @@ -443,7 +443,7 @@ mod tests { #[cfg(target_os = "android")] unsafe fn sigaddset(set: *mut libc::sigset_t, signum: libc::c_int) -> libc::c_int { - use slice; + use crate::slice; let raw = slice::from_raw_parts_mut(set as *mut u8, mem::size_of::()); let bit = (signum - 1) as usize; diff --git a/src/libstd/sys/unix/process/process_fuchsia.rs b/src/libstd/sys/unix/process/process_fuchsia.rs index 5582310adbf..7c6be9b0a60 100644 --- a/src/libstd/sys/unix/process/process_fuchsia.rs +++ b/src/libstd/sys/unix/process/process_fuchsia.rs @@ -1,10 +1,11 @@ -use io; -use libc::{self, size_t}; -use mem; -use ptr; +use crate::io; +use crate::mem; +use crate::ptr; -use sys::process::zircon::{Handle, zx_handle_t}; -use sys::process::process_common::*; +use crate::sys::process::zircon::{Handle, zx_handle_t}; +use crate::sys::process::process_common::*; + +use libc::size_t; //////////////////////////////////////////////////////////////////////////////// // Command @@ -44,7 +45,7 @@ impl Command { unsafe fn do_exec(&mut self, stdio: ChildPipes, maybe_envp: Option<&CStringArray>) -> io::Result { - use sys::process::zircon::*; + use crate::sys::process::zircon::*; let envp = match maybe_envp { Some(envp) => envp.as_ptr(), @@ -109,7 +110,7 @@ impl Process { } pub fn kill(&mut self) -> io::Result<()> { - use sys::process::zircon::*; + use crate::sys::process::zircon::*; unsafe { zx_cvt(zx_task_kill(self.handle.raw()))?; } @@ -117,8 +118,8 @@ impl Process { } pub fn wait(&mut self) -> io::Result { - use default::Default; - use sys::process::zircon::*; + use crate::default::Default; + use crate::sys::process::zircon::*; let mut proc_info: zx_info_process_t = Default::default(); let mut actual: size_t = 0; @@ -140,8 +141,8 @@ impl Process { } pub fn try_wait(&mut self) -> io::Result> { - use default::Default; - use sys::process::zircon::*; + use crate::default::Default; + use crate::sys::process::zircon::*; let mut proc_info: zx_info_process_t = Default::default(); let mut actual: size_t = 0; diff --git a/src/libstd/sys/unix/process/process_unix.rs b/src/libstd/sys/unix/process/process_unix.rs index 6fbbbb349b1..220b1fd4531 100644 --- a/src/libstd/sys/unix/process/process_unix.rs +++ b/src/libstd/sys/unix/process/process_unix.rs @@ -1,9 +1,10 @@ -use io::{self, Error, ErrorKind}; -use libc::{self, c_int, gid_t, pid_t, uid_t}; -use ptr; -use sys::cvt; -use sys::process::process_common::*; -use sys; +use crate::io::{self, Error, ErrorKind}; +use crate::ptr; +use crate::sys::cvt; +use crate::sys::process::process_common::*; +use crate::sys; + +use libc::{c_int, gid_t, pid_t, uid_t}; //////////////////////////////////////////////////////////////////////////////// // Command @@ -164,7 +165,7 @@ impl Command { stdio: ChildPipes, maybe_envp: Option<&CStringArray> ) -> io::Error { - use sys::{self, cvt_r}; + use crate::sys::{self, cvt_r}; macro_rules! t { ($e:expr) => (match $e { @@ -207,7 +208,7 @@ impl Command { // emscripten has no signal support. #[cfg(not(any(target_os = "emscripten")))] { - use mem; + use crate::mem; // Reset signal handling so the child process starts in a // standardized state. libstd ignores SIGPIPE, and signal-handling // libraries often set a mask. Child processes inherit ignored @@ -278,8 +279,8 @@ impl Command { fn posix_spawn(&mut self, stdio: &ChildPipes, envp: Option<&CStringArray>) -> io::Result> { - use mem; - use sys; + use crate::mem; + use crate::sys; if self.get_gid().is_some() || self.get_uid().is_some() || @@ -427,7 +428,7 @@ impl Process { } pub fn wait(&mut self) -> io::Result { - use sys::cvt_r; + use crate::sys::cvt_r; if let Some(status) = self.status { return Ok(status) } diff --git a/src/libstd/sys/unix/process/zircon.rs b/src/libstd/sys/unix/process/zircon.rs index 690c745218b..ec715d5490f 100644 --- a/src/libstd/sys/unix/process/zircon.rs +++ b/src/libstd/sys/unix/process/zircon.rs @@ -1,9 +1,9 @@ #![allow(non_camel_case_types, unused)] -use convert::TryInto; -use io; -use os::raw::c_char; -use u64; +use crate::convert::TryInto; +use crate::io; +use crate::os::raw::c_char; +use crate::u64; use libc::{c_int, c_void, size_t}; diff --git a/src/libstd/sys/unix/rand.rs b/src/libstd/sys/unix/rand.rs index f2e17c36738..122f22b37a2 100644 --- a/src/libstd/sys/unix/rand.rs +++ b/src/libstd/sys/unix/rand.rs @@ -1,5 +1,5 @@ -use mem; -use slice; +use crate::mem; +use crate::slice; pub fn hashmap_random_keys() -> (u64, u64) { let mut v = (0, 0); @@ -17,10 +17,8 @@ pub fn hashmap_random_keys() -> (u64, u64) { not(target_os = "freebsd"), not(target_os = "fuchsia")))] mod imp { - use fs::File; - use io::Read; - #[cfg(any(target_os = "linux", target_os = "android"))] - use libc; + use crate::fs::File; + use crate::io::Read; #[cfg(any(target_os = "linux", target_os = "android"))] fn getrandom(buf: &mut [u8]) -> libc::c_long { @@ -34,8 +32,8 @@ mod imp { #[cfg(any(target_os = "linux", target_os = "android"))] fn getrandom_fill_bytes(v: &mut [u8]) -> bool { - use sync::atomic::{AtomicBool, Ordering}; - use sys::os::errno; + use crate::sync::atomic::{AtomicBool, Ordering}; + use crate::sys::os::errno; static GETRANDOM_UNAVAILABLE: AtomicBool = AtomicBool::new(false); if GETRANDOM_UNAVAILABLE.load(Ordering::Relaxed) { @@ -86,8 +84,7 @@ mod imp { #[cfg(target_os = "openbsd")] mod imp { - use libc; - use sys::os::errno; + use crate::sys::os::errno; pub fn fill_bytes(v: &mut [u8]) { // getentropy(2) permits a maximum buffer size of 256 bytes @@ -104,9 +101,9 @@ mod imp { #[cfg(target_os = "ios")] mod imp { - use io; + use crate::io; + use crate::ptr; use libc::{c_int, size_t}; - use ptr; enum SecRandom {} @@ -134,8 +131,7 @@ mod imp { #[cfg(target_os = "freebsd")] mod imp { - use libc; - use ptr; + use crate::ptr; pub fn fill_bytes(v: &mut [u8]) { let mib = [libc::CTL_KERN, libc::KERN_ARND]; diff --git a/src/libstd/sys/unix/rwlock.rs b/src/libstd/sys/unix/rwlock.rs index a068a11993e..e48bfdae610 100644 --- a/src/libstd/sys/unix/rwlock.rs +++ b/src/libstd/sys/unix/rwlock.rs @@ -1,6 +1,5 @@ -use libc; -use cell::UnsafeCell; -use sync::atomic::{AtomicUsize, Ordering}; +use crate::cell::UnsafeCell; +use crate::sync::atomic::{AtomicUsize, Ordering}; pub struct RWLock { inner: UnsafeCell, diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index d6a219a6d57..cfa019634bd 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -1,6 +1,5 @@ #![cfg_attr(test, allow(dead_code))] -use libc; use self::imp::{make_handler, drop_handler}; pub use self::imp::cleanup; @@ -34,8 +33,9 @@ impl Drop for Handler { target_os = "openbsd"))] mod imp { use super::Handler; - use mem; - use ptr; + use crate::mem; + use crate::ptr; + use libc::{sigaltstack, SIGSTKSZ, SS_DISABLE}; use libc::{sigaction, SIGBUS, SIG_DFL, SA_SIGINFO, SA_ONSTACK, sighandler_t}; @@ -44,7 +44,7 @@ mod imp { use libc::{SIGSEGV, PROT_READ, PROT_WRITE, MAP_PRIVATE, MAP_ANON}; use libc::MAP_FAILED; - use sys_common::thread_info; + use crate::sys_common::thread_info; #[cfg(any(target_os = "linux", target_os = "android"))] @@ -87,7 +87,7 @@ mod imp { unsafe extern fn signal_handler(signum: libc::c_int, info: *mut libc::siginfo_t, _data: *mut libc::c_void) { - use sys_common::util::report_overflow; + use crate::sys_common::util::report_overflow; let guard = thread_info::stack_guard().unwrap_or(0..0); let addr = siginfo_si_addr(info); @@ -193,7 +193,7 @@ mod imp { all(target_os = "netbsd", not(target_vendor = "rumprun")), target_os = "openbsd")))] mod imp { - use ptr; + use crate::ptr; pub unsafe fn init() { } diff --git a/src/libstd/sys/unix/stdio.rs b/src/libstd/sys/unix/stdio.rs index 56b75bf9f79..35f163bbdb1 100644 --- a/src/libstd/sys/unix/stdio.rs +++ b/src/libstd/sys/unix/stdio.rs @@ -1,6 +1,5 @@ -use io; -use libc; -use sys::fd::FileDesc; +use crate::io; +use crate::sys::fd::FileDesc; pub struct Stdin(()); pub struct Stdout(()); @@ -57,7 +56,7 @@ pub fn is_ebadf(err: &io::Error) -> bool { err.raw_os_error() == Some(libc::EBADF as i32) } -pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE; +pub const STDIN_BUF_SIZE: usize = crate::sys_common::io::DEFAULT_BUF_SIZE; pub fn panic_output() -> Option { Stderr::new().ok() diff --git a/src/libstd/sys/unix/thread.rs b/src/libstd/sys/unix/thread.rs index e29557f1ba2..feb15e8f585 100644 --- a/src/libstd/sys/unix/thread.rs +++ b/src/libstd/sys/unix/thread.rs @@ -1,14 +1,13 @@ -use boxed::FnBox; -use cmp; -use ffi::CStr; -use io; -use libc; -use mem; -use ptr; -use sys::os; -use time::Duration; - -use sys_common::thread::*; +use crate::boxed::FnBox; +use crate::cmp; +use crate::ffi::CStr; +use crate::io; +use crate::mem; +use crate::ptr; +use crate::sys::os; +use crate::time::Duration; + +use crate::sys_common::thread::*; #[cfg(not(target_os = "l4re"))] pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024; @@ -118,7 +117,7 @@ impl Thread { #[cfg(target_os = "netbsd")] pub fn set_name(name: &CStr) { - use ffi::CString; + use crate::ffi::CString; let cname = CString::new(&b"%s"[..]).unwrap(); unsafe { libc::pthread_setname_np(libc::pthread_self(), cname.as_ptr(), @@ -197,7 +196,7 @@ impl Drop for Thread { not(target_os = "solaris")))] #[cfg_attr(test, allow(dead_code))] pub mod guard { - use ops::Range; + use crate::ops::Range; pub type Guard = Range; pub unsafe fn current() -> Option { None } pub unsafe fn init() -> Option { None } @@ -213,11 +212,11 @@ pub mod guard { target_os = "solaris"))] #[cfg_attr(test, allow(dead_code))] pub mod guard { - use libc; use libc::{mmap, mprotect}; use libc::{PROT_NONE, PROT_READ, PROT_WRITE, MAP_PRIVATE, MAP_ANON, MAP_FAILED, MAP_FIXED}; - use ops::Range; - use sys::os; + + use crate::ops::Range; + use crate::sys::os; // This is initialized in init() and only read from after static mut PAGE_SIZE: usize = 0; @@ -226,7 +225,7 @@ pub mod guard { #[cfg(target_os = "solaris")] unsafe fn get_stack_start() -> Option<*mut libc::c_void> { - let mut current_stack: libc::stack_t = ::mem::zeroed(); + let mut current_stack: libc::stack_t = crate::mem::zeroed(); assert_eq!(libc::stack_getbounds(&mut current_stack), 0); Some(current_stack.ss_sp) } @@ -240,7 +239,7 @@ pub mod guard { #[cfg(any(target_os = "openbsd", target_os = "bitrig"))] unsafe fn get_stack_start() -> Option<*mut libc::c_void> { - let mut current_stack: libc::stack_t = ::mem::zeroed(); + let mut current_stack: libc::stack_t = crate::mem::zeroed(); assert_eq!(libc::pthread_stackseg_np(libc::pthread_self(), &mut current_stack), 0); @@ -259,14 +258,14 @@ pub mod guard { target_os = "linux", target_os = "netbsd", target_os = "l4re"))] unsafe fn get_stack_start() -> Option<*mut libc::c_void> { let mut ret = None; - let mut attr: libc::pthread_attr_t = ::mem::zeroed(); + let mut attr: libc::pthread_attr_t = crate::mem::zeroed(); assert_eq!(libc::pthread_attr_init(&mut attr), 0); #[cfg(target_os = "freebsd")] let e = libc::pthread_attr_get_np(libc::pthread_self(), &mut attr); #[cfg(not(target_os = "freebsd"))] let e = libc::pthread_getattr_np(libc::pthread_self(), &mut attr); if e == 0 { - let mut stackaddr = ::ptr::null_mut(); + let mut stackaddr = crate::ptr::null_mut(); let mut stacksize = 0; assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, &mut stacksize), 0); @@ -357,7 +356,7 @@ pub mod guard { target_os = "linux", target_os = "netbsd", target_os = "l4re"))] pub unsafe fn current() -> Option { let mut ret = None; - let mut attr: libc::pthread_attr_t = ::mem::zeroed(); + let mut attr: libc::pthread_attr_t = crate::mem::zeroed(); assert_eq!(libc::pthread_attr_init(&mut attr), 0); #[cfg(target_os = "freebsd")] let e = libc::pthread_attr_get_np(libc::pthread_self(), &mut attr); @@ -369,7 +368,7 @@ pub mod guard { if guardsize == 0 { panic!("there is no guard page"); } - let mut stackaddr = ::ptr::null_mut(); + let mut stackaddr = crate::ptr::null_mut(); let mut size = 0; assert_eq!(libc::pthread_attr_getstack(&attr, &mut stackaddr, &mut size), 0); diff --git a/src/libstd/sys/unix/thread_local.rs b/src/libstd/sys/unix/thread_local.rs index c171fbce237..ac615b76b36 100644 --- a/src/libstd/sys/unix/thread_local.rs +++ b/src/libstd/sys/unix/thread_local.rs @@ -1,7 +1,6 @@ #![allow(dead_code)] // not used on all platforms -use mem; -use libc; +use crate::mem; pub type Key = libc::pthread_key_t; diff --git a/src/libstd/sys/unix/time.rs b/src/libstd/sys/unix/time.rs index 4a655714f99..cbb0615911a 100644 --- a/src/libstd/sys/unix/time.rs +++ b/src/libstd/sys/unix/time.rs @@ -1,10 +1,10 @@ -use cmp::Ordering; -use libc; -use time::Duration; +use crate::cmp::Ordering; +use crate::time::Duration; + use core::hash::{Hash, Hasher}; pub use self::inner::{Instant, SystemTime, UNIX_EPOCH}; -use convert::TryInto; +use crate::convert::TryInto; const NSEC_PER_SEC: u64 = 1_000_000_000; @@ -113,12 +113,11 @@ impl Hash for Timespec { #[cfg(any(target_os = "macos", target_os = "ios"))] mod inner { - use fmt; - use libc; - use sync::Once; - use sys::cvt; - use sys_common::mul_div_u64; - use time::Duration; + use crate::fmt; + use crate::sync::Once; + use crate::sys::cvt; + use crate::sys_common::mul_div_u64; + use crate::time::Duration; use super::NSEC_PER_SEC; use super::Timespec; @@ -173,7 +172,7 @@ mod inner { impl SystemTime { pub fn now() -> SystemTime { - use ptr; + use crate::ptr; let mut s = libc::timeval { tv_sec: 0, @@ -249,10 +248,9 @@ mod inner { #[cfg(not(any(target_os = "macos", target_os = "ios")))] mod inner { - use fmt; - use libc; - use sys::cvt; - use time::Duration; + use crate::fmt; + use crate::sys::cvt; + use crate::time::Duration; use super::Timespec; diff --git a/src/libstd/sys/unix/weak.rs b/src/libstd/sys/unix/weak.rs index b60e241f10c..9a7691e54bc 100644 --- a/src/libstd/sys/unix/weak.rs +++ b/src/libstd/sys/unix/weak.rs @@ -16,17 +16,15 @@ //! symbol, but that caused Debian to detect an unnecessarily strict versioned //! dependency on libc6 (#23628). -use libc; - -use ffi::CStr; -use marker; -use mem; -use sync::atomic::{AtomicUsize, Ordering}; +use crate::ffi::CStr; +use crate::marker; +use crate::mem; +use crate::sync::atomic::{AtomicUsize, Ordering}; macro_rules! weak { (fn $name:ident($($t:ty),*) -> $ret:ty) => ( - static $name: ::sys::weak::Weak $ret> = - ::sys::weak::Weak::new(concat!(stringify!($name), '\0')); + static $name: crate::sys::weak::Weak $ret> = + crate::sys::weak::Weak::new(concat!(stringify!($name), '\0')); ) } @@ -71,7 +69,6 @@ unsafe fn fetch(name: &str) -> usize { macro_rules! syscall { (fn $name:ident($($arg_name:ident: $t:ty),*) -> $ret:ty) => ( unsafe fn $name($($arg_name: $t),*) -> $ret { - use libc; use super::os; weak! { fn $name($($t),*) -> $ret } diff --git a/src/libstd/sys/wasm/alloc.rs b/src/libstd/sys/wasm/alloc.rs index f082887ce20..b9098548b9c 100644 --- a/src/libstd/sys/wasm/alloc.rs +++ b/src/libstd/sys/wasm/alloc.rs @@ -16,9 +16,7 @@ //! The crate itself provides a global allocator which on wasm has no //! synchronization as there are no threads! -extern crate dlmalloc; - -use alloc::{GlobalAlloc, Layout, System}; +use crate::alloc::{GlobalAlloc, Layout, System}; static mut DLMALLOC: dlmalloc::Dlmalloc = dlmalloc::DLMALLOC_INIT; @@ -51,8 +49,8 @@ unsafe impl GlobalAlloc for System { #[cfg(target_feature = "atomics")] mod lock { - use arch::wasm32; - use sync::atomic::{AtomicI32, Ordering::SeqCst}; + use crate::arch::wasm32; + use crate::sync::atomic::{AtomicI32, Ordering::SeqCst}; static LOCKED: AtomicI32 = AtomicI32::new(0); diff --git a/src/libstd/sys/wasm/args.rs b/src/libstd/sys/wasm/args.rs index cea56091adc..b3c77b86995 100644 --- a/src/libstd/sys/wasm/args.rs +++ b/src/libstd/sys/wasm/args.rs @@ -1,7 +1,7 @@ -use ffi::OsString; -use marker::PhantomData; -use vec; -use sys::ArgsSysCall; +use crate::ffi::OsString; +use crate::marker::PhantomData; +use crate::vec; +use crate::sys::ArgsSysCall; pub unsafe fn init(_argc: isize, _argv: *const *const u8) { // On wasm these should always be null, so there's nothing for us to do here diff --git a/src/libstd/sys/wasm/backtrace.rs b/src/libstd/sys/wasm/backtrace.rs index 52d4a63bb63..7d56b298997 100644 --- a/src/libstd/sys/wasm/backtrace.rs +++ b/src/libstd/sys/wasm/backtrace.rs @@ -1,6 +1,6 @@ -use io; -use sys::unsupported; -use sys_common::backtrace::Frame; +use crate::io; +use crate::sys::unsupported; +use crate::sys_common::backtrace::Frame; pub struct BacktraceContext; diff --git a/src/libstd/sys/wasm/condvar.rs b/src/libstd/sys/wasm/condvar.rs index 22df0f60db5..9c7cc3c63b1 100644 --- a/src/libstd/sys/wasm/condvar.rs +++ b/src/libstd/sys/wasm/condvar.rs @@ -1,5 +1,5 @@ -use sys::mutex::Mutex; -use time::Duration; +use crate::sys::mutex::Mutex; +use crate::time::Duration; pub struct Condvar { } diff --git a/src/libstd/sys/wasm/condvar_atomics.rs b/src/libstd/sys/wasm/condvar_atomics.rs index 099404c75d4..580d2121844 100644 --- a/src/libstd/sys/wasm/condvar_atomics.rs +++ b/src/libstd/sys/wasm/condvar_atomics.rs @@ -1,9 +1,9 @@ -use arch::wasm32; -use cmp; -use mem; -use sync::atomic::{AtomicUsize, Ordering::SeqCst}; -use sys::mutex::Mutex; -use time::Duration; +use crate::arch::wasm32; +use crate::cmp; +use crate::mem; +use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst}; +use crate::sys::mutex::Mutex; +use crate::time::Duration; pub struct Condvar { cnt: AtomicUsize, diff --git a/src/libstd/sys/wasm/fs.rs b/src/libstd/sys/wasm/fs.rs index 8b1c4476bc4..485d2c87fbd 100644 --- a/src/libstd/sys/wasm/fs.rs +++ b/src/libstd/sys/wasm/fs.rs @@ -1,10 +1,10 @@ -use ffi::OsString; -use fmt; -use hash::{Hash, Hasher}; -use io::{self, SeekFrom}; -use path::{Path, PathBuf}; -use sys::time::SystemTime; -use sys::{unsupported, Void}; +use crate::ffi::OsString; +use crate::fmt; +use crate::hash::{Hash, Hasher}; +use crate::io::{self, SeekFrom}; +use crate::path::{Path, PathBuf}; +use crate::sys::time::SystemTime; +use crate::sys::{unsupported, Void}; pub struct File(Void); diff --git a/src/libstd/sys/wasm/mod.rs b/src/libstd/sys/wasm/mod.rs index e71c6bcd7fe..1828cce4e52 100644 --- a/src/libstd/sys/wasm/mod.rs +++ b/src/libstd/sys/wasm/mod.rs @@ -14,12 +14,12 @@ //! compiling for wasm. That way it's a compile time error for something that's //! guaranteed to be a runtime error! -use os::raw::c_char; -use ptr; -use sys::os_str::Buf; -use sys_common::{AsInner, FromInner}; -use ffi::{OsString, OsStr}; -use time::Duration; +use crate::os::raw::c_char; +use crate::ptr; +use crate::sys::os_str::Buf; +use crate::sys_common::{AsInner, FromInner}; +use crate::ffi::{OsString, OsStr}; +use crate::time::Duration; pub mod alloc; pub mod args; @@ -63,17 +63,17 @@ cfg_if! { pub fn init() { } -pub fn unsupported() -> ::io::Result { +pub fn unsupported() -> crate::io::Result { Err(unsupported_err()) } -pub fn unsupported_err() -> ::io::Error { - ::io::Error::new(::io::ErrorKind::Other, +pub fn unsupported_err() -> crate::io::Error { + crate::io::Error::new(crate::io::ErrorKind::Other, "operation not supported on wasm yet") } -pub fn decode_error_kind(_code: i32) -> ::io::ErrorKind { - ::io::ErrorKind::Other +pub fn decode_error_kind(_code: i32) -> crate::io::ErrorKind { + crate::io::ErrorKind::Other } // This enum is used as the storage for a bunch of types which can't actually @@ -168,7 +168,7 @@ impl ExitSysCall { }; unsafe { syscall(SysCallIndex::Exit, &mut call_record); - ::intrinsics::abort(); + crate::intrinsics::abort(); } } } diff --git a/src/libstd/sys/wasm/mutex.rs b/src/libstd/sys/wasm/mutex.rs index cf0a0a8638b..9d713e9b439 100644 --- a/src/libstd/sys/wasm/mutex.rs +++ b/src/libstd/sys/wasm/mutex.rs @@ -1,4 +1,4 @@ -use cell::UnsafeCell; +use crate::cell::UnsafeCell; pub struct Mutex { locked: UnsafeCell, diff --git a/src/libstd/sys/wasm/mutex_atomics.rs b/src/libstd/sys/wasm/mutex_atomics.rs index da03e8fa23f..0e4f3d80aa9 100644 --- a/src/libstd/sys/wasm/mutex_atomics.rs +++ b/src/libstd/sys/wasm/mutex_atomics.rs @@ -1,8 +1,8 @@ -use arch::wasm32; -use cell::UnsafeCell; -use mem; -use sync::atomic::{AtomicUsize, AtomicU32, Ordering::SeqCst}; -use sys::thread; +use crate::arch::wasm32; +use crate::cell::UnsafeCell; +use crate::mem; +use crate::sync::atomic::{AtomicUsize, AtomicU32, Ordering::SeqCst}; +use crate::sys::thread; pub struct Mutex { locked: AtomicUsize, diff --git a/src/libstd/sys/wasm/net.rs b/src/libstd/sys/wasm/net.rs index d9f5d538432..1249832fb09 100644 --- a/src/libstd/sys/wasm/net.rs +++ b/src/libstd/sys/wasm/net.rs @@ -1,9 +1,9 @@ -use fmt; -use io::{self, IoVec, IoVecMut}; -use net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr}; -use time::Duration; -use sys::{unsupported, Void}; -use convert::TryFrom; +use crate::fmt; +use crate::io::{self, IoVec, IoVecMut}; +use crate::net::{SocketAddr, Shutdown, Ipv4Addr, Ipv6Addr}; +use crate::time::Duration; +use crate::sys::{unsupported, Void}; +use crate::convert::TryFrom; pub struct TcpStream(Void); diff --git a/src/libstd/sys/wasm/os.rs b/src/libstd/sys/wasm/os.rs index 9b278dfb9f8..145f9ccd73a 100644 --- a/src/libstd/sys/wasm/os.rs +++ b/src/libstd/sys/wasm/os.rs @@ -1,10 +1,10 @@ -use error::Error as StdError; -use ffi::{OsString, OsStr}; -use fmt; -use io; -use path::{self, PathBuf}; -use str; -use sys::{unsupported, Void, ExitSysCall, GetEnvSysCall, SetEnvSysCall}; +use crate::error::Error as StdError; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::io; +use crate::path::{self, PathBuf}; +use crate::str; +use crate::sys::{unsupported, Void, ExitSysCall, GetEnvSysCall, SetEnvSysCall}; pub fn errno() -> i32 { 0 diff --git a/src/libstd/sys/wasm/os_str.rs b/src/libstd/sys/wasm/os_str.rs index 9d5e084feb2..79b43458d00 100644 --- a/src/libstd/sys/wasm/os_str.rs +++ b/src/libstd/sys/wasm/os_str.rs @@ -1,14 +1,15 @@ /// The underlying OsString/OsStr implementation on Unix systems: just /// a `Vec`/`[u8]`. -use borrow::Cow; -use fmt; -use str; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner}; -use sys_common::bytestring::debug_fmt_bytestring; +use crate::borrow::Cow; +use crate::fmt; +use crate::str; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner}; +use crate::sys_common::bytestring::debug_fmt_bytestring; + use core::str::lossy::Utf8Lossy; #[derive(Clone, Hash)] diff --git a/src/libstd/sys/wasm/path.rs b/src/libstd/sys/wasm/path.rs index 2ef78fb2f86..5c062e7c97c 100644 --- a/src/libstd/sys/wasm/path.rs +++ b/src/libstd/sys/wasm/path.rs @@ -1,5 +1,5 @@ -use path::Prefix; -use ffi::OsStr; +use crate::path::Prefix; +use crate::ffi::OsStr; #[inline] pub fn is_sep_byte(b: u8) -> bool { diff --git a/src/libstd/sys/wasm/pipe.rs b/src/libstd/sys/wasm/pipe.rs index ac48a6dc033..2582b993b60 100644 --- a/src/libstd/sys/wasm/pipe.rs +++ b/src/libstd/sys/wasm/pipe.rs @@ -1,5 +1,5 @@ -use io; -use sys::Void; +use crate::io; +use crate::sys::Void; pub struct AnonPipe(Void); diff --git a/src/libstd/sys/wasm/process.rs b/src/libstd/sys/wasm/process.rs index 5357d931c73..c49daaa1632 100644 --- a/src/libstd/sys/wasm/process.rs +++ b/src/libstd/sys/wasm/process.rs @@ -1,10 +1,10 @@ -use ffi::OsStr; -use fmt; -use io; -use sys::fs::File; -use sys::pipe::AnonPipe; -use sys::{unsupported, Void}; -use sys_common::process::{CommandEnv, DefaultEnvKey}; +use crate::ffi::OsStr; +use crate::fmt; +use crate::io; +use crate::sys::fs::File; +use crate::sys::pipe::AnonPipe; +use crate::sys::{unsupported, Void}; +use crate::sys_common::process::{CommandEnv, DefaultEnvKey}; //////////////////////////////////////////////////////////////////////////////// // Command diff --git a/src/libstd/sys/wasm/rwlock.rs b/src/libstd/sys/wasm/rwlock.rs index 9f172859b7e..a2b07c7fa1f 100644 --- a/src/libstd/sys/wasm/rwlock.rs +++ b/src/libstd/sys/wasm/rwlock.rs @@ -1,4 +1,4 @@ -use cell::UnsafeCell; +use crate::cell::UnsafeCell; pub struct RWLock { mode: UnsafeCell, diff --git a/src/libstd/sys/wasm/rwlock_atomics.rs b/src/libstd/sys/wasm/rwlock_atomics.rs index 404b33bca41..c705568cec9 100644 --- a/src/libstd/sys/wasm/rwlock_atomics.rs +++ b/src/libstd/sys/wasm/rwlock_atomics.rs @@ -1,6 +1,6 @@ -use cell::UnsafeCell; -use sys::mutex::Mutex; -use sys::condvar::Condvar; +use crate::cell::UnsafeCell; +use crate::sys::mutex::Mutex; +use crate::sys::condvar::Condvar; pub struct RWLock { lock: Mutex, diff --git a/src/libstd/sys/wasm/stdio.rs b/src/libstd/sys/wasm/stdio.rs index d7540fd815c..b8899a9c847 100644 --- a/src/libstd/sys/wasm/stdio.rs +++ b/src/libstd/sys/wasm/stdio.rs @@ -1,5 +1,5 @@ -use io; -use sys::{ReadSysCall, WriteSysCall}; +use crate::io; +use crate::sys::{ReadSysCall, WriteSysCall}; pub struct Stdin; pub struct Stdout; diff --git a/src/libstd/sys/wasm/thread.rs b/src/libstd/sys/wasm/thread.rs index c2322088e8e..a65c413119f 100644 --- a/src/libstd/sys/wasm/thread.rs +++ b/src/libstd/sys/wasm/thread.rs @@ -1,8 +1,8 @@ -use boxed::FnBox; -use ffi::CStr; -use io; -use sys::{unsupported, Void}; -use time::Duration; +use crate::boxed::FnBox; +use crate::ffi::CStr; +use crate::io; +use crate::sys::{unsupported, Void}; +use crate::time::Duration; pub struct Thread(Void); @@ -31,8 +31,8 @@ impl Thread { #[cfg(target_feature = "atomics")] pub fn sleep(dur: Duration) { - use arch::wasm32; - use cmp; + use crate::arch::wasm32; + use crate::cmp; // Use an atomic wait to block the current thread artificially with a // timeout listed. Note that we should never be notified (return value @@ -76,7 +76,7 @@ cfg_if! { // you'd like to use them be sure to update that and make sure everyone // agrees what's what. pub fn tcb_get() -> *mut u8 { - use mem; + use crate::mem; assert_eq!(mem::size_of::<*mut u8>(), mem::size_of::()); unsafe { __wbindgen_tcb_get() as *mut u8 } } diff --git a/src/libstd/sys/wasm/thread_local.rs b/src/libstd/sys/wasm/thread_local.rs index c7c385da8c3..29e9854bcfc 100644 --- a/src/libstd/sys/wasm/thread_local.rs +++ b/src/libstd/sys/wasm/thread_local.rs @@ -1,5 +1,5 @@ -use boxed::Box; -use ptr; +use crate::boxed::Box; +use crate::ptr; pub type Key = usize; diff --git a/src/libstd/sys/wasm/thread_local_atomics.rs b/src/libstd/sys/wasm/thread_local_atomics.rs index d1d0af252c8..b408ad0d5c1 100644 --- a/src/libstd/sys/wasm/thread_local_atomics.rs +++ b/src/libstd/sys/wasm/thread_local_atomics.rs @@ -1,5 +1,5 @@ -use sys::thread; -use sync::atomic::{AtomicUsize, Ordering::SeqCst}; +use crate::sys::thread; +use crate::sync::atomic::{AtomicUsize, Ordering::SeqCst}; const MAX_KEYS: usize = 128; static NEXT_KEY: AtomicUsize = AtomicUsize::new(0); diff --git a/src/libstd/sys/wasm/time.rs b/src/libstd/sys/wasm/time.rs index 31798466fed..c1228a1b75e 100644 --- a/src/libstd/sys/wasm/time.rs +++ b/src/libstd/sys/wasm/time.rs @@ -1,5 +1,5 @@ -use time::Duration; -use sys::{TimeSysCall, TimeClock}; +use crate::time::Duration; +use crate::sys::{TimeSysCall, TimeClock}; #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)] pub struct Instant(Duration); diff --git a/src/libstd/sys/windows/alloc.rs b/src/libstd/sys/windows/alloc.rs index 0d7f803c7ee..a33c4019a2e 100644 --- a/src/libstd/sys/windows/alloc.rs +++ b/src/libstd/sys/windows/alloc.rs @@ -1,6 +1,6 @@ -use alloc::{GlobalAlloc, Layout, System}; -use sys::c; -use sys_common::alloc::{MIN_ALIGN, realloc_fallback}; +use crate::alloc::{GlobalAlloc, Layout, System}; +use crate::sys::c; +use crate::sys_common::alloc::{MIN_ALIGN, realloc_fallback}; #[repr(C)] struct Header(*mut u8); diff --git a/src/libstd/sys/windows/args.rs b/src/libstd/sys/windows/args.rs index f6728069109..3f10e6e5983 100644 --- a/src/libstd/sys/windows/args.rs +++ b/src/libstd/sys/windows/args.rs @@ -1,14 +1,15 @@ #![allow(dead_code)] // runtime init functions not used during testing -use os::windows::prelude::*; -use sys::windows::os::current_exe; -use sys::c; -use ffi::OsString; -use fmt; -use vec; +use crate::os::windows::prelude::*; +use crate::sys::windows::os::current_exe; +use crate::sys::c; +use crate::ffi::OsString; +use crate::fmt; +use crate::vec; +use crate::slice; +use crate::path::PathBuf; + use core::iter; -use slice; -use path::PathBuf; pub unsafe fn init(_argc: isize, _argv: *const *const u8) { } @@ -80,7 +81,7 @@ unsafe fn parse_lp_cmd_line OsString>(lp_cmd_line: *const u16, exe_na // "However, if lpCmdLine starts with any amount of whitespace, CommandLineToArgvW // will consider the first argument to be an empty string. Excess whitespace at the // end of lpCmdLine is ignored." - 0...SPACE => { + 0..=SPACE => { ret_val.push(OsString::new()); &cmd_line[1..] }, @@ -192,8 +193,8 @@ impl ExactSizeIterator for Args { #[cfg(test)] mod tests { - use sys::windows::args::*; - use ffi::OsString; + use crate::sys::windows::args::*; + use crate::ffi::OsString; fn chk(string: &str, parts: &[&str]) { let mut wide: Vec = OsString::from(string).encode_wide().collect(); diff --git a/src/libstd/sys/windows/backtrace/backtrace_gnu.rs b/src/libstd/sys/windows/backtrace/backtrace_gnu.rs index e8aa9399742..7ac1f8122f7 100644 --- a/src/libstd/sys/windows/backtrace/backtrace_gnu.rs +++ b/src/libstd/sys/windows/backtrace/backtrace_gnu.rs @@ -1,10 +1,11 @@ -use io; -use sys::c; +use crate::io; +use crate::sys::c; +use crate::path::PathBuf; +use crate::fs::{OpenOptions, File}; +use crate::sys::ext::fs::OpenOptionsExt; +use crate::sys::handle::Handle; + use libc::c_char; -use path::PathBuf; -use fs::{OpenOptions, File}; -use sys::ext::fs::OpenOptionsExt; -use sys::handle::Handle; use super::super::{fill_utf16_buf, os2path, to_u16s, wide_char_to_multi_byte}; fn query_full_process_image_name() -> io::Result { diff --git a/src/libstd/sys/windows/backtrace/mod.rs b/src/libstd/sys/windows/backtrace/mod.rs index 4bda8ac91da..c5b0cc87210 100644 --- a/src/libstd/sys/windows/backtrace/mod.rs +++ b/src/libstd/sys/windows/backtrace/mod.rs @@ -14,13 +14,14 @@ #![allow(deprecated)] // dynamic_lib -use io; +use crate::io; +use crate::mem; +use crate::ptr; +use crate::sys::c; +use crate::sys::dynamic_lib::DynamicLibrary; +use crate::sys_common::backtrace::Frame; + use libc::c_void; -use mem; -use ptr; -use sys::c; -use sys::dynamic_lib::DynamicLibrary; -use sys_common::backtrace::Frame; macro_rules! sym { ($lib:expr, $e:expr, $t:ident) => ( diff --git a/src/libstd/sys/windows/backtrace/printing/mod.rs b/src/libstd/sys/windows/backtrace/printing/mod.rs index d44df7e5f24..9497d51ac17 100644 --- a/src/libstd/sys/windows/backtrace/printing/mod.rs +++ b/src/libstd/sys/windows/backtrace/printing/mod.rs @@ -4,11 +4,11 @@ mod printing; #[cfg(target_env = "gnu")] mod printing { - pub use sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; + pub use crate::sys_common::gnu::libbacktrace::{foreach_symbol_fileline, resolve_symname}; // dummy functions to mirror those present in msvc version. - use sys::dynamic_lib::DynamicLibrary; - use io; + use crate::sys::dynamic_lib::DynamicLibrary; + use crate::io; pub struct PrintingFnsEx {} pub struct PrintingFns64 {} pub fn load_printing_fns_ex(_: &DynamicLibrary) -> io::Result { diff --git a/src/libstd/sys/windows/backtrace/printing/msvc.rs b/src/libstd/sys/windows/backtrace/printing/msvc.rs index b186bb42334..13a1512d0eb 100644 --- a/src/libstd/sys/windows/backtrace/printing/msvc.rs +++ b/src/libstd/sys/windows/backtrace/printing/msvc.rs @@ -1,12 +1,13 @@ -use ffi::CStr; -use io; +use crate::ffi::CStr; +use crate::io; +use crate::mem; +use crate::sys::backtrace::BacktraceContext; +use crate::sys::backtrace::StackWalkVariant; +use crate::sys::c; +use crate::sys::dynamic_lib::DynamicLibrary; +use crate::sys_common::backtrace::Frame; + use libc::{c_char, c_ulong}; -use mem; -use sys::backtrace::BacktraceContext; -use sys::backtrace::StackWalkVariant; -use sys::c; -use sys::dynamic_lib::DynamicLibrary; -use sys_common::backtrace::Frame; // Structs holding printing functions and loaders for them // Two versions depending on whether dbghelp.dll has StackWalkEx or not @@ -190,7 +191,7 @@ where { unsafe { let mut line: c::IMAGEHLP_LINE64 = mem::zeroed(); - line.SizeOfStruct = ::mem::size_of::() as u32; + line.SizeOfStruct = mem::size_of::() as u32; let ret = line_getter( context.handle, diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs index a78b599204b..518eccf754c 100644 --- a/src/libstd/sys/windows/c.rs +++ b/src/libstd/sys/windows/c.rs @@ -4,11 +4,12 @@ #![cfg_attr(test, allow(dead_code))] #![unstable(issue = "0", feature = "windows_c")] -use os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort, c_char}; +use crate::os::raw::{c_int, c_uint, c_ulong, c_long, c_longlong, c_ushort, c_char}; #[cfg(target_arch = "x86_64")] -use os::raw::c_ulonglong; +use crate::os::raw::c_ulonglong; +use crate::ptr; + use libc::{wchar_t, size_t, c_void}; -use ptr; pub use self::FILE_INFO_BY_HANDLE_CLASS::*; pub use self::EXCEPTION_DISPOSITION::*; @@ -65,7 +66,7 @@ pub type PCONDITION_VARIABLE = *mut CONDITION_VARIABLE; pub type PLARGE_INTEGER = *mut c_longlong; pub type PSRWLOCK = *mut SRWLOCK; -pub type SOCKET = ::os::windows::raw::SOCKET; +pub type SOCKET = crate::os::windows::raw::SOCKET; pub type socklen_t = c_int; pub type ADDRESS_FAMILY = USHORT; @@ -450,7 +451,7 @@ pub struct MOUNT_POINT_REPARSE_BUFFER { pub PathBuffer: WCHAR, } -pub type LPPROGRESS_ROUTINE = ::option::Option Option { let mut module: Vec = module.encode_utf16().collect(); @@ -44,14 +44,14 @@ macro_rules! compat_fn { )*) => ($( #[allow(unused_variables)] pub unsafe fn $symbol($($argname: $argtype),*) -> $rettype { - use sync::atomic::{AtomicUsize, Ordering}; - use mem; + use crate::sync::atomic::{AtomicUsize, Ordering}; + use crate::mem; type F = unsafe extern "system" fn($($argtype),*) -> $rettype; static PTR: AtomicUsize = AtomicUsize::new(0); fn load() -> usize { - ::sys::compat::store_func(&PTR, + crate::sys::compat::store_func(&PTR, stringify!($module), stringify!($symbol), fallback as usize) diff --git a/src/libstd/sys/windows/condvar.rs b/src/libstd/sys/windows/condvar.rs index 48d8af73913..62835ea7c94 100644 --- a/src/libstd/sys/windows/condvar.rs +++ b/src/libstd/sys/windows/condvar.rs @@ -1,8 +1,8 @@ -use cell::UnsafeCell; -use sys::c; -use sys::mutex::{self, Mutex}; -use sys::os; -use time::Duration; +use crate::cell::UnsafeCell; +use crate::sys::c; +use crate::sys::mutex::{self, Mutex}; +use crate::sys::os; +use crate::time::Duration; pub struct Condvar { inner: UnsafeCell } diff --git a/src/libstd/sys/windows/dynamic_lib.rs b/src/libstd/sys/windows/dynamic_lib.rs index fa3c5ecb977..b9d5105cb73 100644 --- a/src/libstd/sys/windows/dynamic_lib.rs +++ b/src/libstd/sys/windows/dynamic_lib.rs @@ -1,8 +1,8 @@ -use os::windows::prelude::*; +use crate::os::windows::prelude::*; -use ffi::{CString, OsStr}; -use io; -use sys::c; +use crate::ffi::{CString, OsStr}; +use crate::io; +use crate::sys::c; pub struct DynamicLibrary { handle: c::HMODULE, diff --git a/src/libstd/sys/windows/ext/ffi.rs b/src/libstd/sys/windows/ext/ffi.rs index 6508c0cf447..547b1ef796b 100644 --- a/src/libstd/sys/windows/ext/ffi.rs +++ b/src/libstd/sys/windows/ext/ffi.rs @@ -59,13 +59,13 @@ #![stable(feature = "rust1", since = "1.0.0")] -use ffi::{OsString, OsStr}; -use sys::os_str::Buf; -use sys_common::wtf8::Wtf8Buf; -use sys_common::{FromInner, AsInner}; +use crate::ffi::{OsString, OsStr}; +use crate::sys::os_str::Buf; +use crate::sys_common::wtf8::Wtf8Buf; +use crate::sys_common::{FromInner, AsInner}; #[stable(feature = "rust1", since = "1.0.0")] -pub use sys_common::wtf8::EncodeWide; +pub use crate::sys_common::wtf8::EncodeWide; /// Windows-specific extensions to [`OsString`]. /// diff --git a/src/libstd/sys/windows/ext/fs.rs b/src/libstd/sys/windows/ext/fs.rs index 89038da6295..b6da5950280 100644 --- a/src/libstd/sys/windows/ext/fs.rs +++ b/src/libstd/sys/windows/ext/fs.rs @@ -2,11 +2,11 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs::{self, OpenOptions, Metadata}; -use io; -use path::Path; -use sys; -use sys_common::{AsInnerMut, AsInner}; +use crate::fs::{self, OpenOptions, Metadata}; +use crate::io; +use crate::path::Path; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner}; /// Windows-specific extensions to [`File`]. /// diff --git a/src/libstd/sys/windows/ext/io.rs b/src/libstd/sys/windows/ext/io.rs index fbe0426ce5a..1a7d734b89e 100644 --- a/src/libstd/sys/windows/ext/io.rs +++ b/src/libstd/sys/windows/ext/io.rs @@ -1,12 +1,12 @@ #![stable(feature = "rust1", since = "1.0.0")] -use fs; -use os::windows::raw; -use net; -use sys_common::{self, AsInner, FromInner, IntoInner}; -use sys; -use io; -use sys::c; +use crate::fs; +use crate::os::windows::raw; +use crate::net; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::sys; +use crate::sys::c; +use crate::io; /// Raw HANDLEs. #[stable(feature = "rust1", since = "1.0.0")] diff --git a/src/libstd/sys/windows/ext/process.rs b/src/libstd/sys/windows/ext/process.rs index 15f0fd4e11f..b2e6cdead4f 100644 --- a/src/libstd/sys/windows/ext/process.rs +++ b/src/libstd/sys/windows/ext/process.rs @@ -2,10 +2,10 @@ #![stable(feature = "process_extensions", since = "1.2.0")] -use os::windows::io::{FromRawHandle, RawHandle, AsRawHandle, IntoRawHandle}; -use process; -use sys; -use sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; +use crate::os::windows::io::{FromRawHandle, RawHandle, AsRawHandle, IntoRawHandle}; +use crate::process; +use crate::sys; +use crate::sys_common::{AsInnerMut, AsInner, FromInner, IntoInner}; #[stable(feature = "process_extensions", since = "1.2.0")] impl FromRawHandle for process::Stdio { diff --git a/src/libstd/sys/windows/ext/raw.rs b/src/libstd/sys/windows/ext/raw.rs index 77428d9e774..d2bab272036 100644 --- a/src/libstd/sys/windows/ext/raw.rs +++ b/src/libstd/sys/windows/ext/raw.rs @@ -2,7 +2,7 @@ #![stable(feature = "raw_ext", since = "1.1.0")] -use os::raw::c_void; +use crate::os::raw::c_void; #[stable(feature = "raw_ext", since = "1.1.0")] pub type HANDLE = *mut c_void; #[cfg(target_pointer_width = "32")] diff --git a/src/libstd/sys/windows/ext/thread.rs b/src/libstd/sys/windows/ext/thread.rs index 29d612fedc0..fdc7e7fa32f 100644 --- a/src/libstd/sys/windows/ext/thread.rs +++ b/src/libstd/sys/windows/ext/thread.rs @@ -2,9 +2,9 @@ #![stable(feature = "thread_extensions", since = "1.9.0")] -use os::windows::io::{RawHandle, AsRawHandle, IntoRawHandle}; -use thread; -use sys_common::{AsInner, IntoInner}; +use crate::os::windows::io::{RawHandle, AsRawHandle, IntoRawHandle}; +use crate::thread; +use crate::sys_common::{AsInner, IntoInner}; #[stable(feature = "thread_extensions", since = "1.9.0")] impl AsRawHandle for thread::JoinHandle { diff --git a/src/libstd/sys/windows/fast_thread_local.rs b/src/libstd/sys/windows/fast_thread_local.rs index f8b936b4810..0ccc67e3fd5 100644 --- a/src/libstd/sys/windows/fast_thread_local.rs +++ b/src/libstd/sys/windows/fast_thread_local.rs @@ -1,7 +1,7 @@ #![unstable(feature = "thread_local_internals", issue = "0")] #![cfg(target_thread_local)] -pub use sys_common::thread_local::register_dtor_fallback as register_dtor; +pub use crate::sys_common::thread_local::register_dtor_fallback as register_dtor; pub fn requires_move_before_drop() -> bool { false diff --git a/src/libstd/sys/windows/fs.rs b/src/libstd/sys/windows/fs.rs index 533b8ae9ba2..f19c111f09a 100644 --- a/src/libstd/sys/windows/fs.rs +++ b/src/libstd/sys/windows/fs.rs @@ -1,17 +1,17 @@ -use os::windows::prelude::*; - -use ffi::OsString; -use fmt; -use io::{self, Error, SeekFrom}; -use mem; -use path::{Path, PathBuf}; -use ptr; -use slice; -use sync::Arc; -use sys::handle::Handle; -use sys::time::SystemTime; -use sys::{c, cvt}; -use sys_common::FromInner; +use crate::os::windows::prelude::*; + +use crate::ffi::OsString; +use crate::fmt; +use crate::io::{self, Error, SeekFrom}; +use crate::mem; +use crate::path::{Path, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::sync::Arc; +use crate::sys::handle::Handle; +use crate::sys::time::SystemTime; +use crate::sys::{c, cvt}; +use crate::sys_common::FromInner; use super::to_u16s; diff --git a/src/libstd/sys/windows/handle.rs b/src/libstd/sys/windows/handle.rs index 855efbd3eb5..02549088c87 100644 --- a/src/libstd/sys/windows/handle.rs +++ b/src/libstd/sys/windows/handle.rs @@ -1,13 +1,12 @@ #![unstable(issue = "0", feature = "windows_handle")] -use cmp; -use io::{ErrorKind, Read}; -use io; -use mem; -use ops::Deref; -use ptr; -use sys::c; -use sys::cvt; +use crate::cmp; +use crate::io::{self, ErrorKind, Read}; +use crate::mem; +use crate::ops::Deref; +use crate::ptr; +use crate::sys::c; +use crate::sys::cvt; /// An owned container for `HANDLE` object, closing them on Drop. /// diff --git a/src/libstd/sys/windows/mod.rs b/src/libstd/sys/windows/mod.rs index 56c76a169fe..1425254a2e1 100644 --- a/src/libstd/sys/windows/mod.rs +++ b/src/libstd/sys/windows/mod.rs @@ -1,11 +1,11 @@ #![allow(missing_docs, nonstandard_style)] -use ptr; -use ffi::{OsStr, OsString}; -use io::ErrorKind; -use os::windows::ffi::{OsStrExt, OsStringExt}; -use path::PathBuf; -use time::Duration; +use crate::ptr; +use crate::ffi::{OsStr, OsString}; +use crate::io::ErrorKind; +use crate::os::windows::ffi::{OsStrExt, OsStringExt}; +use crate::path::PathBuf; +use crate::time::Duration; pub use libc::strlen; pub use self::rand::hashmap_random_keys; @@ -76,11 +76,11 @@ pub fn decode_error_kind(errno: i32) -> ErrorKind { } } -pub fn to_u16s>(s: S) -> ::io::Result> { - fn inner(s: &OsStr) -> ::io::Result> { +pub fn to_u16s>(s: S) -> crate::io::Result> { + fn inner(s: &OsStr) -> crate::io::Result> { let mut maybe_result: Vec = s.encode_wide().collect(); if maybe_result.iter().any(|&u| u == 0) { - return Err(::io::Error::new(::io::ErrorKind::InvalidInput, + return Err(crate::io::Error::new(ErrorKind::InvalidInput, "strings passed to WinAPI cannot contain NULs")); } maybe_result.push(0); @@ -103,7 +103,7 @@ pub fn to_u16s>(s: S) -> ::io::Result> { // Once the syscall has completed (errors bail out early) the second closure is // yielded the data which has been read from the syscall. The return value // from this closure is then the return value of the function. -fn fill_utf16_buf(mut f1: F1, f2: F2) -> ::io::Result +fn fill_utf16_buf(mut f1: F1, f2: F2) -> crate::io::Result where F1: FnMut(*mut u16, c::DWORD) -> c::DWORD, F2: FnOnce(&[u16]) -> T { @@ -135,7 +135,7 @@ fn fill_utf16_buf(mut f1: F1, f2: F2) -> ::io::Result c::SetLastError(0); let k = match f1(buf.as_mut_ptr(), n as c::DWORD) { 0 if c::GetLastError() == 0 => 0, - 0 => return Err(::io::Error::last_os_error()), + 0 => return Err(crate::io::Error::last_os_error()), n => n, } as usize; if k == n && c::GetLastError() == c::ERROR_INSUFFICIENT_BUFFER { @@ -158,7 +158,7 @@ fn wide_char_to_multi_byte(code_page: u32, flags: u32, s: &[u16], no_default_char: bool) - -> ::io::Result> { + -> crate::io::Result> { unsafe { let mut size = c::WideCharToMultiByte(code_page, flags, @@ -169,7 +169,7 @@ fn wide_char_to_multi_byte(code_page: u32, ptr::null(), ptr::null_mut()); if size == 0 { - return Err(::io::Error::last_os_error()); + return Err(crate::io::Error::last_os_error()); } let mut buf = Vec::with_capacity(size as usize); @@ -186,10 +186,10 @@ fn wide_char_to_multi_byte(code_page: u32, if no_default_char { &mut used_default_char } else { ptr::null_mut() }); if size == 0 { - return Err(::io::Error::last_os_error()); + return Err(crate::io::Error::last_os_error()); } if no_default_char && used_default_char == c::TRUE { - return Err(::io::Error::new(::io::ErrorKind::InvalidData, + return Err(crate::io::Error::new(crate::io::ErrorKind::InvalidData, "string cannot be converted to requested code page")); } @@ -221,9 +221,9 @@ macro_rules! impl_is_zero { impl_is_zero! { i8 i16 i32 i64 isize u8 u16 u32 u64 usize } -pub fn cvt(i: I) -> ::io::Result { +pub fn cvt(i: I) -> crate::io::Result { if i.is_zero() { - Err(::io::Error::last_os_error()) + Err(crate::io::Error::last_os_error()) } else { Ok(i) } @@ -263,7 +263,7 @@ pub unsafe fn abort_internal() -> ! { #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { asm!("int $$0x29" :: "{ecx}"(7) ::: volatile); // 7 is FAST_FAIL_FATAL_APP_EXIT - ::intrinsics::unreachable(); + crate::intrinsics::unreachable(); } - ::intrinsics::abort(); + crate::intrinsics::abort(); } diff --git a/src/libstd/sys/windows/mutex.rs b/src/libstd/sys/windows/mutex.rs index f690580ae38..1aa910f05c9 100644 --- a/src/libstd/sys/windows/mutex.rs +++ b/src/libstd/sys/windows/mutex.rs @@ -19,11 +19,11 @@ //! CriticalSection is used and we keep track of who's holding the mutex to //! detect recursive locks. -use cell::UnsafeCell; -use mem::{self, MaybeUninit}; -use sync::atomic::{AtomicUsize, Ordering}; -use sys::c; -use sys::compat; +use crate::cell::UnsafeCell; +use crate::mem::{self, MaybeUninit}; +use crate::sync::atomic::{AtomicUsize, Ordering}; +use crate::sys::c; +use crate::sys::compat; pub struct Mutex { lock: AtomicUsize, diff --git a/src/libstd/sys/windows/net.rs b/src/libstd/sys/windows/net.rs index 76be26a9d1a..1231fd55e25 100644 --- a/src/libstd/sys/windows/net.rs +++ b/src/libstd/sys/windows/net.rs @@ -1,26 +1,27 @@ #![unstable(issue = "0", feature = "windows_net")] -use cmp; -use io::{self, Read, IoVec, IoVecMut}; +use crate::cmp; +use crate::io::{self, Read, IoVec, IoVecMut}; +use crate::mem; +use crate::net::{SocketAddr, Shutdown}; +use crate::ptr; +use crate::sync::Once; +use crate::sys::c; +use crate::sys; +use crate::sys_common::{self, AsInner, FromInner, IntoInner}; +use crate::sys_common::net; +use crate::time::Duration; + use libc::{c_int, c_void, c_ulong, c_long}; -use mem; -use net::{SocketAddr, Shutdown}; -use ptr; -use sync::Once; -use sys::c; -use sys; -use sys_common::{self, AsInner, FromInner, IntoInner}; -use sys_common::net; -use time::Duration; pub type wrlen_t = i32; pub mod netc { - pub use sys::c::*; - pub use sys::c::SOCKADDR as sockaddr; - pub use sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage; - pub use sys::c::ADDRINFOA as addrinfo; - pub use sys::c::ADDRESS_FAMILY as sa_family_t; + pub use crate::sys::c::*; + pub use crate::sys::c::SOCKADDR as sockaddr; + pub use crate::sys::c::SOCKADDR_STORAGE_LH as sockaddr_storage; + pub use crate::sys::c::ADDRINFOA as addrinfo; + pub use crate::sys::c::ADDRESS_FAMILY as sa_family_t; } pub struct Socket(c::SOCKET); diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs index 7399dd41a41..5b433ddfb4a 100644 --- a/src/libstd/sys/windows/os.rs +++ b/src/libstd/sys/windows/os.rs @@ -2,18 +2,18 @@ #![allow(nonstandard_style)] -use os::windows::prelude::*; - -use error::Error as StdError; -use ffi::{OsString, OsStr}; -use fmt; -use io; -use os::windows::ffi::EncodeWide; -use path::{self, PathBuf}; -use ptr; -use slice; -use sys::{c, cvt}; -use sys::handle::Handle; +use crate::os::windows::prelude::*; + +use crate::error::Error as StdError; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::io; +use crate::os::windows::ffi::EncodeWide; +use crate::path::{self, PathBuf}; +use crate::ptr; +use crate::slice; +use crate::sys::{c, cvt}; +use crate::sys::handle::Handle; use super::to_u16s; @@ -285,8 +285,8 @@ pub fn temp_dir() -> PathBuf { } pub fn home_dir() -> Option { - ::env::var_os("HOME").or_else(|| { - ::env::var_os("USERPROFILE") + crate::env::var_os("HOME").or_else(|| { + crate::env::var_os("USERPROFILE") }).map(PathBuf::from).or_else(|| unsafe { let me = c::GetCurrentProcess(); let mut token = ptr::null_mut(); @@ -314,8 +314,8 @@ pub fn getpid() -> u32 { #[cfg(test)] mod tests { - use io::Error; - use sys::c; + use crate::io::Error; + use crate::sys::c; // tests `error_string` above #[test] diff --git a/src/libstd/sys/windows/os_str.rs b/src/libstd/sys/windows/os_str.rs index 7e4bcd990b1..8befa66ecdc 100644 --- a/src/libstd/sys/windows/os_str.rs +++ b/src/libstd/sys/windows/os_str.rs @@ -1,13 +1,13 @@ /// The underlying OsString/OsStr implementation on Windows is a /// wrapper around the "WTF-8" encoding; see the `wtf8` module for more. -use borrow::Cow; -use fmt; -use sys_common::wtf8::{Wtf8, Wtf8Buf}; -use mem; -use rc::Rc; -use sync::Arc; -use sys_common::{AsInner, IntoInner, FromInner}; +use crate::borrow::Cow; +use crate::fmt; +use crate::sys_common::wtf8::{Wtf8, Wtf8Buf}; +use crate::mem; +use crate::rc::Rc; +use crate::sync::Arc; +use crate::sys_common::{AsInner, IntoInner, FromInner}; #[derive(Clone, Hash)] pub struct Buf { diff --git a/src/libstd/sys/windows/path.rs b/src/libstd/sys/windows/path.rs index ad1759e84c3..b8532ca9b0d 100644 --- a/src/libstd/sys/windows/path.rs +++ b/src/libstd/sys/windows/path.rs @@ -1,6 +1,6 @@ -use path::Prefix; -use ffi::OsStr; -use mem; +use crate::path::Prefix; +use crate::ffi::OsStr; +use crate::mem; fn os_str_as_u8_slice(s: &OsStr) -> &[u8] { unsafe { mem::transmute(s) } @@ -20,7 +20,7 @@ pub fn is_verbatim_sep(b: u8) -> bool { } pub fn parse_prefix<'a>(path: &'a OsStr) -> Option { - use path::Prefix::*; + use crate::path::Prefix::*; unsafe { // The unsafety here stems from converting between &OsStr and &[u8] // and back. This is safe to do because (1) we only look at ASCII diff --git a/src/libstd/sys/windows/pipe.rs b/src/libstd/sys/windows/pipe.rs index d3b102268f6..07f4f5f0e58 100644 --- a/src/libstd/sys/windows/pipe.rs +++ b/src/libstd/sys/windows/pipe.rs @@ -1,17 +1,17 @@ -use os::windows::prelude::*; +use crate::os::windows::prelude::*; -use ffi::OsStr; -use io; -use mem; -use path::Path; -use ptr; -use slice; -use sync::atomic::Ordering::SeqCst; -use sync::atomic::AtomicUsize; -use sys::c; -use sys::fs::{File, OpenOptions}; -use sys::handle::Handle; -use sys::hashmap_random_keys; +use crate::ffi::OsStr; +use crate::io; +use crate::mem; +use crate::path::Path; +use crate::ptr; +use crate::slice; +use crate::sync::atomic::Ordering::SeqCst; +use crate::sync::atomic::AtomicUsize; +use crate::sys::c; +use crate::sys::fs::{File, OpenOptions}; +use crate::sys::handle::Handle; +use crate::sys::hashmap_random_keys; //////////////////////////////////////////////////////////////////////////////// // Anonymous pipes diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs index 2527168a968..95f061d22bd 100644 --- a/src/libstd/sys/windows/process.rs +++ b/src/libstd/sys/windows/process.rs @@ -1,27 +1,28 @@ #![unstable(feature = "process_internals", issue = "0")] -use collections::BTreeMap; -use env::split_paths; -use env; -use ffi::{OsString, OsStr}; -use fmt; -use fs; -use io::{self, Error, ErrorKind}; +use crate::collections::BTreeMap; +use crate::env::split_paths; +use crate::env; +use crate::ffi::{OsString, OsStr}; +use crate::fmt; +use crate::fs; +use crate::io::{self, Error, ErrorKind}; +use crate::mem; +use crate::os::windows::ffi::OsStrExt; +use crate::path::Path; +use crate::ptr; +use crate::sys::mutex::Mutex; +use crate::sys::c; +use crate::sys::fs::{OpenOptions, File}; +use crate::sys::handle::Handle; +use crate::sys::pipe::{self, AnonPipe}; +use crate::sys::stdio; +use crate::sys::cvt; +use crate::sys_common::{AsInner, FromInner, IntoInner}; +use crate::sys_common::process::{CommandEnv, EnvKey}; +use crate::borrow::Borrow; + use libc::{c_void, EXIT_SUCCESS, EXIT_FAILURE}; -use mem; -use os::windows::ffi::OsStrExt; -use path::Path; -use ptr; -use sys::mutex::Mutex; -use sys::c; -use sys::fs::{OpenOptions, File}; -use sys::handle::Handle; -use sys::pipe::{self, AnonPipe}; -use sys::stdio; -use sys::cvt; -use sys_common::{AsInner, FromInner, IntoInner}; -use sys_common::process::{CommandEnv, EnvKey}; -use borrow::Borrow; //////////////////////////////////////////////////////////////////////////////// // Command @@ -537,7 +538,7 @@ fn make_dirp(d: Option<&OsString>) -> io::Result<(*const u16, Vec)> { #[cfg(test)] mod tests { - use ffi::{OsStr, OsString}; + use crate::ffi::{OsStr, OsString}; use super::make_command_line; #[test] diff --git a/src/libstd/sys/windows/rand.rs b/src/libstd/sys/windows/rand.rs index 4f000dceb2f..0193f4defa1 100644 --- a/src/libstd/sys/windows/rand.rs +++ b/src/libstd/sys/windows/rand.rs @@ -1,6 +1,6 @@ -use io; -use mem; -use sys::c; +use crate::io; +use crate::mem; +use crate::sys::c; pub fn hashmap_random_keys() -> (u64, u64) { let mut v = (0, 0); diff --git a/src/libstd/sys/windows/rwlock.rs b/src/libstd/sys/windows/rwlock.rs index 3cd19470101..ef57562fc3a 100644 --- a/src/libstd/sys/windows/rwlock.rs +++ b/src/libstd/sys/windows/rwlock.rs @@ -1,5 +1,5 @@ -use cell::UnsafeCell; -use sys::c; +use crate::cell::UnsafeCell; +use crate::sys::c; pub struct RWLock { inner: UnsafeCell } diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index 0c7de0bc9e8..d5b7765f9ff 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -1,7 +1,7 @@ #![cfg_attr(test, allow(dead_code))] -use sys_common::util::report_overflow; -use sys::c; +use crate::sys_common::util::report_overflow; +use crate::sys::c; pub struct Handler; diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index 99445f4e0d4..b2beaca41b1 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -1,13 +1,13 @@ #![unstable(issue = "0", feature = "windows_stdio")] -use char::decode_utf16; -use cmp; -use io; -use ptr; -use str; -use sys::c; -use sys::cvt; -use sys::handle::Handle; +use crate::char::decode_utf16; +use crate::cmp; +use crate::io; +use crate::ptr; +use crate::str; +use crate::sys::c; +use crate::sys::cvt; +use crate::sys::handle::Handle; // Don't cache handles but get them fresh for every read/write. This allows us to track changes to // the value over time (such as if a process calls `SetStdHandle` while it's running). See #40490. diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs index bd7cb673a0d..1b0a811f13b 100644 --- a/src/libstd/sys/windows/thread.rs +++ b/src/libstd/sys/windows/thread.rs @@ -1,13 +1,14 @@ -use boxed::FnBox; -use io; -use ffi::CStr; -use mem; +use crate::boxed::FnBox; +use crate::io; +use crate::ffi::CStr; +use crate::mem; +use crate::ptr; +use crate::sys::c; +use crate::sys::handle::Handle; +use crate::sys_common::thread::*; +use crate::time::Duration; + use libc::c_void; -use ptr; -use sys::c; -use sys::handle::Handle; -use sys_common::thread::*; -use time::Duration; use super::to_u16s; diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 50bbd5476b3..4c9734fa0aa 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -1,8 +1,8 @@ -use mem; -use ptr; -use sync::atomic::AtomicPtr; -use sync::atomic::Ordering::SeqCst; -use sys::c; +use crate::mem; +use crate::ptr; +use crate::sync::atomic::AtomicPtr; +use crate::sync::atomic::Ordering::SeqCst; +use crate::sys::c; pub type Key = c::DWORD; pub type Dtor = unsafe extern fn(*mut u8); @@ -211,7 +211,7 @@ unsafe extern "system" fn on_tls_callback(h: c::LPVOID, #[cfg(target_env = "msvc")] unsafe fn reference_tls_used() { extern { static _tls_used: u8; } - ::intrinsics::volatile_load(&_tls_used); + crate::intrinsics::volatile_load(&_tls_used); } #[cfg(not(target_env = "msvc"))] unsafe fn reference_tls_used() {} diff --git a/src/libstd/sys/windows/time.rs b/src/libstd/sys/windows/time.rs index 8a8159af2f1..2c99bca7009 100644 --- a/src/libstd/sys/windows/time.rs +++ b/src/libstd/sys/windows/time.rs @@ -1,9 +1,10 @@ -use cmp::Ordering; -use fmt; -use mem; -use sys::c; -use time::Duration; -use convert::TryInto; +use crate::cmp::Ordering; +use crate::fmt; +use crate::mem; +use crate::sys::c; +use crate::time::Duration; +use crate::convert::TryInto; + use core::hash::{Hash, Hasher}; const NANOS_PER_SEC: u64 = 1_000_000_000; @@ -172,11 +173,11 @@ fn intervals2dur(intervals: u64) -> Duration { mod perf_counter { use super::{NANOS_PER_SEC}; - use sync::Once; - use sys_common::mul_div_u64; - use sys::c; - use sys::cvt; - use time::Duration; + use crate::sync::Once; + use crate::sys_common::mul_div_u64; + use crate::sys::c; + use crate::sys::cvt; + use crate::time::Duration; pub struct PerformanceCounterInstant { ts: c::LARGE_INTEGER -- cgit 1.4.1-3-g733a5 From 0749a04fb64f1423e811c280de8206cdc5715004 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Mon, 11 Feb 2019 04:24:34 +0900 Subject: Fix #[macro_use] extern crate in sys/cloudabi --- src/libstd/sys/cloudabi/abi/bitflags.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) (limited to 'src/libstd/sys') diff --git a/src/libstd/sys/cloudabi/abi/bitflags.rs b/src/libstd/sys/cloudabi/abi/bitflags.rs index f764cc1df5a..306936213ed 100644 --- a/src/libstd/sys/cloudabi/abi/bitflags.rs +++ b/src/libstd/sys/cloudabi/abi/bitflags.rs @@ -25,8 +25,7 @@ // ignore-license #[cfg(feature = "bitflags")] -#[macro_use] -extern crate bitflags; +use bitflags::bitflags; // Minimal implementation of bitflags! in case we can't depend on the bitflags // crate. Only implements `bits()` and a `from_bits_truncate()` that doesn't -- cgit 1.4.1-3-g733a5 From 90dbf59b920054e5808718f4a54323e3653348aa Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Sun, 17 Feb 2019 22:35:20 +0900 Subject: Fix some imports and paths --- src/libstd/lib.rs | 3 --- src/libstd/sys/sgx/abi/usercalls/mod.rs | 2 +- src/libstd/sys/unix/stack_overflow.rs | 1 - src/libstd/sys_common/util.rs | 2 +- 4 files changed, 2 insertions(+), 6 deletions(-) (limited to 'src/libstd/sys') diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index 4883c607ad1..32a168619df 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -344,9 +344,6 @@ extern crate unwind; // testing gives test-std access to real-std lang items and globals. See #2912 #[cfg(test)] extern crate std as realstd; -#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))] -extern crate fortanix_sgx_abi; - // The standard macros that are not built-in to the compiler. #[macro_use] mod macros; diff --git a/src/libstd/sys/sgx/abi/usercalls/mod.rs b/src/libstd/sys/sgx/abi/usercalls/mod.rs index 7361011e92d..d84b6154cbe 100644 --- a/src/libstd/sys/sgx/abi/usercalls/mod.rs +++ b/src/libstd/sys/sgx/abi/usercalls/mod.rs @@ -22,7 +22,7 @@ pub fn read(fd: Fd, buf: &mut [u8]) -> IoResult { #[unstable(feature = "sgx_platform", issue = "56975")] pub fn read_alloc(fd: Fd) -> IoResult> { unsafe { - let userbuf = ByteBuffer { data: ::ptr::null_mut(), len: 0 }; + let userbuf = ByteBuffer { data: crate::ptr::null_mut(), len: 0 }; let mut userbuf = alloc::User::new_from_enclave(&userbuf); raw::read_alloc(fd, userbuf.as_raw_mut_ptr()).from_sgx_result()?; Ok(userbuf.copy_user_buffer()) diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index cfa019634bd..8c60bddc238 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -39,7 +39,6 @@ mod imp { use libc::{sigaltstack, SIGSTKSZ, SS_DISABLE}; use libc::{sigaction, SIGBUS, SIG_DFL, SA_SIGINFO, SA_ONSTACK, sighandler_t}; - use libc; use libc::{mmap, munmap}; use libc::{SIGSEGV, PROT_READ, PROT_WRITE, MAP_PRIVATE, MAP_ANON}; use libc::MAP_FAILED; diff --git a/src/libstd/sys_common/util.rs b/src/libstd/sys_common/util.rs index b547d941f3b..206443a6736 100644 --- a/src/libstd/sys_common/util.rs +++ b/src/libstd/sys_common/util.rs @@ -11,7 +11,7 @@ pub fn dumb_print(args: fmt::Arguments) { // Other platforms should use the appropriate platform-specific mechanism for // aborting the process. If no platform-specific mechanism is available, -// ::intrinsics::abort() may be used instead. The above implementations cover +// crate::intrinsics::abort() may be used instead. The above implementations cover // all targets currently supported by libstd. pub fn abort(args: fmt::Arguments) -> ! { -- cgit 1.4.1-3-g733a5 From aad9e29f52988c55cd8cee2bd181a2e3c9d436a4 Mon Sep 17 00:00:00 2001 From: Taiki Endo Date: Wed, 27 Feb 2019 16:15:56 +0900 Subject: Fix rebase fail --- src/libstd/sys/unix/io.rs | 5 +++-- src/libstd/sys/unix/net.rs | 2 +- src/libstd/sys/windows/io.rs | 6 +++--- src/libstd/sys/windows/stdio.rs | 2 +- 4 files changed, 8 insertions(+), 7 deletions(-) (limited to 'src/libstd/sys') diff --git a/src/libstd/sys/unix/io.rs b/src/libstd/sys/unix/io.rs index 65e4c6e0577..eb3fa470a65 100644 --- a/src/libstd/sys/unix/io.rs +++ b/src/libstd/sys/unix/io.rs @@ -1,6 +1,7 @@ -use marker::PhantomData; +use crate::marker::PhantomData; +use crate::slice; + use libc::{iovec, c_void}; -use slice; #[repr(transparent)] pub struct IoVec<'a> { diff --git a/src/libstd/sys/unix/net.rs b/src/libstd/sys/unix/net.rs index 8e8cdf837a9..7712a41ded4 100644 --- a/src/libstd/sys/unix/net.rs +++ b/src/libstd/sys/unix/net.rs @@ -11,7 +11,7 @@ use crate::cmp; use libc::{c_int, c_void, size_t, sockaddr, socklen_t, EAI_SYSTEM, MSG_PEEK}; -pub use sys::{cvt, cvt_r}; +pub use crate::sys::{cvt, cvt_r}; #[allow(unused_extern_crates)] pub extern crate libc as netc; diff --git a/src/libstd/sys/windows/io.rs b/src/libstd/sys/windows/io.rs index 662e3047923..54dd271c9d6 100644 --- a/src/libstd/sys/windows/io.rs +++ b/src/libstd/sys/windows/io.rs @@ -1,6 +1,6 @@ -use marker::PhantomData; -use slice; -use sys::c; +use crate::marker::PhantomData; +use crate::slice; +use crate::sys::c; #[repr(transparent)] pub struct IoVec<'a> { diff --git a/src/libstd/sys/windows/stdio.rs b/src/libstd/sys/windows/stdio.rs index b2beaca41b1..b1e76b3b755 100644 --- a/src/libstd/sys/windows/stdio.rs +++ b/src/libstd/sys/windows/stdio.rs @@ -201,7 +201,7 @@ fn read_u16s(handle: c::HANDLE, buf: &mut [u16]) -> io::Result { const CTRL_Z: u16 = 0x1A; const CTRL_Z_MASK: c::ULONG = 1 << CTRL_Z; let mut input_control = c::CONSOLE_READCONSOLE_CONTROL { - nLength: ::mem::size_of::() as c::ULONG, + nLength: crate::mem::size_of::() as c::ULONG, nInitialChars: 0, dwCtrlWakeupMask: CTRL_Z_MASK, dwControlKeyState: 0, -- cgit 1.4.1-3-g733a5