Auto merge of #58208 - taiki-e:libstd-2018, r=Centril

libstd => 2018

Transitions `libstd` to Rust 2018; cc #58099

r? @Centril

22 files changed, 96 insertions, 97 deletions

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<T>() -> ::io::Result<T> {
+pub fn unsupported<T>() -> crate::io::Result<T> {
     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<bool>,
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>`/`[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<isize>,
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::<u32>());
             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);