Auto merge of #67540 - Mark-Simulacrum:fmt-the-world, r=Centril

Format the world

This PR modifies the formatting infrastructure a bit in the first commit (to enable the forgotten 2018 edition), as well as removes most directories from the ignore list in rustfmt.toml. It then follows that up with the second commit which runs `x.py fmt` and formats the entire repository.

We continue to not format the test directory (`src/test`) because of interactions with pretty printing and, in part, because re-blessing all of those files is somewhat harder to review, so is best suited for a follow up PR in my opinion.

8 files changed, 126 insertions, 88 deletions

diff --git a/src/libstd/sys_common/at_exit_imp.rs b/src/libstd/sys_common/at_exit_imp.rs
index cdb72ee872e..6b799db856e 100644
--- a/src/libstd/sys_common/at_exit_imp.rs
+++ b/src/libstd/sys_common/at_exit_imp.rs
@@ -2,8 +2,8 @@
 //!
 //! Documentation can be found on the `rt::at_exit` function.
 
-use crate::ptr;
 use crate::mem;
+use crate::ptr;
 use crate::sys_common::mutex::Mutex;
 
 type Queue = Vec<Box<dyn FnOnce()>>;
@@ -31,7 +31,7 @@ unsafe fn init() -> bool {
         QUEUE = Box::into_raw(state);
     } else if QUEUE == DONE {
         // can't re-init after a cleanup
-        return false
+        return false;
     }
 
     true
diff --git a/src/libstd/sys_common/backtrace.rs b/src/libstd/sys_common/backtrace.rs
index d7296b43fbe..191add2c31b 100644
--- a/src/libstd/sys_common/backtrace.rs
+++ b/src/libstd/sys_common/backtrace.rs
@@ -1,10 +1,9 @@
+use crate::borrow::Cow;
 /// Common code for printing the backtrace in the same way across the different
 /// supported platforms.
-
 use crate::env;
 use crate::fmt;
 use crate::io;
-use crate::borrow::Cow;
 use crate::io::prelude::*;
 use crate::path::{self, Path, PathBuf};
 use crate::sync::atomic::{self, Ordering};
@@ -57,9 +56,7 @@ unsafe fn _print(w: &mut dyn Write, format: PrintFmt) -> io::Result<()> {
     }
     impl fmt::Display for DisplayBacktrace {
         fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-            unsafe {
-                _print_fmt(fmt, self.format)
-            }
+            unsafe { _print_fmt(fmt, self.format) }
         }
     }
     write!(w, "{}", DisplayBacktrace { format })
@@ -68,11 +65,7 @@ unsafe fn _print(w: &mut dyn Write, format: PrintFmt) -> io::Result<()> {
 unsafe fn _print_fmt(fmt: &mut fmt::Formatter<'_>, print_fmt: PrintFmt) -> fmt::Result {
     // Always 'fail' to get the cwd when running under Miri -
     // this allows Miri to display backtraces in isolation mode
-    let cwd = if !cfg!(miri) {
-        env::current_dir().ok()
-    } else {
-        None
-    };
+    let cwd = if !cfg!(miri) { env::current_dir().ok() } else { None };
 
     let mut print_path = move |fmt: &mut fmt::Formatter<'_>, bows: BytesOrWideString<'_>| {
         output_filename(fmt, bows, print_fmt, cwd.as_ref())
@@ -206,9 +199,7 @@ pub fn output_filename(
             Cow::Owned(crate::ffi::OsString::from_wide(wide).into())
         }
         #[cfg(not(windows))]
-        BytesOrWideString::Wide(_wide) => {
-            Path::new("<unknown>").into()
-        }
+        BytesOrWideString::Wide(_wide) => Path::new("<unknown>").into(),
     };
     if print_fmt == PrintFmt::Short && file.is_absolute() {
         if let Some(cwd) = cwd {
diff --git a/src/libstd/sys_common/condvar.rs b/src/libstd/sys_common/condvar.rs
index fc59c8356f4..f9611bc6f7b 100644
--- a/src/libstd/sys_common/condvar.rs
+++ b/src/libstd/sys_common/condvar.rs
@@ -1,6 +1,6 @@
-use crate::time::Duration;
-use crate::sys_common::mutex::{self, Mutex};
 use crate::sys::condvar as imp;
+use crate::sys_common::mutex::{self, Mutex};
+use crate::time::Duration;
 
 /// An OS-based condition variable.
 ///
@@ -15,22 +15,30 @@ impl Condvar {
     ///
     /// Behavior is undefined if the condition variable is moved after it is
     /// first used with any of the functions below.
-    pub const fn new() -> Condvar { Condvar(imp::Condvar::new()) }
+    pub const fn new() -> Condvar {
+        Condvar(imp::Condvar::new())
+    }
 
     /// Prepares the condition variable for use.
     ///
     /// This should be called once the condition variable is at a stable memory
     /// address.
     #[inline]
-    pub unsafe fn init(&mut self) { self.0.init() }
+    pub unsafe fn init(&mut self) {
+        self.0.init()
+    }
 
     /// Signals one waiter on this condition variable to wake up.
     #[inline]
-    pub unsafe fn notify_one(&self) { self.0.notify_one() }
+    pub unsafe fn notify_one(&self) {
+        self.0.notify_one()
+    }
 
     /// Awakens all current waiters on this condition variable.
     #[inline]
-    pub unsafe fn notify_all(&self) { self.0.notify_all() }
+    pub unsafe fn notify_all(&self) {
+        self.0.notify_all()
+    }
 
     /// Waits for a signal on the specified mutex.
     ///
@@ -38,7 +46,9 @@ impl Condvar {
     /// Behavior is also undefined if more than one mutex is used concurrently
     /// on this condition variable.
     #[inline]
-    pub unsafe fn wait(&self, mutex: &Mutex) { self.0.wait(mutex::raw(mutex)) }
+    pub unsafe fn wait(&self, mutex: &Mutex) {
+        self.0.wait(mutex::raw(mutex))
+    }
 
     /// Waits for a signal on the specified mutex with a timeout duration
     /// specified by `dur` (a relative time into the future).
@@ -56,5 +66,7 @@ impl Condvar {
     /// Behavior is undefined if there are current or will be future users of
     /// this condition variable.
     #[inline]
-    pub unsafe fn destroy(&self) { self.0.destroy() }
+    pub unsafe fn destroy(&self) {
+        self.0.destroy()
+    }
 }
diff --git a/src/libstd/sys_common/mod.rs b/src/libstd/sys_common/mod.rs
index 8912aed9255..ca8c63d62a6 100644
--- a/src/libstd/sys_common/mod.rs
+++ b/src/libstd/sys_common/mod.rs
@@ -23,26 +23,32 @@ macro_rules! rtabort {
 }
 
 macro_rules! rtassert {
-    ($e:expr) => (if !$e {
-        rtabort!(concat!("assertion failed: ", stringify!($e)));
-    })
+    ($e:expr) => {
+        if !$e {
+            rtabort!(concat!("assertion failed: ", stringify!($e)));
+        }
+    };
 }
 
 #[allow(unused_macros)] // not used on all platforms
 macro_rules! rtunwrap {
-    ($ok:ident, $e:expr) => (match $e {
-        $ok(v) => v,
-        ref err => {
-            let err = err.as_ref().map(|_|()); // map Ok/Some which might not be Debug
-            rtabort!(concat!("unwrap failed: ", stringify!($e), " = {:?}"), err)
-        },
-    })
+    ($ok:ident, $e:expr) => {
+        match $e {
+            $ok(v) => v,
+            ref err => {
+                let err = err.as_ref().map(|_| ()); // map Ok/Some which might not be Debug
+                rtabort!(concat!("unwrap failed: ", stringify!($e), " = {:?}"), err)
+            }
+        }
+    };
 }
 
 pub mod alloc;
 pub mod at_exit_imp;
 pub mod backtrace;
+pub mod bytestring;
 pub mod condvar;
+pub mod fs;
 pub mod io;
 pub mod mutex;
 #[cfg(any(doc, // see `mod os`, docs are generated for multiple platforms
@@ -54,6 +60,7 @@ pub mod mutex;
           all(target_vendor = "fortanix", target_env = "sgx")))]
 pub mod os_str_bytes;
 pub mod poison;
+pub mod process;
 pub mod remutex;
 pub mod rwlock;
 pub mod thread;
@@ -61,9 +68,6 @@ pub mod thread_info;
 pub mod thread_local;
 pub mod util;
 pub mod wtf8;
-pub mod bytestring;
-pub mod process;
-pub mod fs;
 
 cfg_if::cfg_if! {
     if #[cfg(any(target_os = "cloudabi",
@@ -114,7 +118,7 @@ pub trait FromInner<Inner> {
 /// that the closure could not be registered, meaning that it is not scheduled
 /// to be run.
 pub fn at_exit<F: FnOnce() + Send + 'static>(f: F) -> Result<(), ()> {
-    if at_exit_imp::push(Box::new(f)) {Ok(())} else {Err(())}
+    if at_exit_imp::push(Box::new(f)) { Ok(()) } else { Err(()) }
 }
 
 /// One-time runtime cleanup.
@@ -142,6 +146,5 @@ pub fn mul_div_u64(value: u64, numer: u64, denom: u64) -> u64 {
 
 #[test]
 fn test_muldiv() {
-    assert_eq!(mul_div_u64( 1_000_000_000_001, 1_000_000_000, 1_000_000),
-               1_000_000_000_001_000);
+    assert_eq!(mul_div_u64(1_000_000_000_001, 1_000_000_000, 1_000_000), 1_000_000_000_001_000);
 }
diff --git a/src/libstd/sys_common/mutex.rs b/src/libstd/sys_common/mutex.rs
index 28d85949ffa..899fc6a7235 100644
--- a/src/libstd/sys_common/mutex.rs
+++ b/src/libstd/sys_common/mutex.rs
@@ -17,7 +17,9 @@ impl Mutex {
     /// Also, until `init` is called, behavior is undefined if this
     /// mutex is ever used reentrantly, i.e., `raw_lock` or `try_lock`
     /// are called by the thread currently holding the lock.
-    pub const fn new() -> Mutex { Mutex(imp::Mutex::new()) }
+    pub const fn new() -> Mutex {
+        Mutex(imp::Mutex::new())
+    }
 
     /// Prepare the mutex for use.
     ///
@@ -26,14 +28,18 @@ impl Mutex {
     /// Calling it in parallel with or after any operation (including another
     /// `init()`) is undefined behavior.
     #[inline]
-    pub unsafe fn init(&mut self) { self.0.init() }
+    pub unsafe fn init(&mut self) {
+        self.0.init()
+    }
 
     /// Locks the mutex blocking the current thread until it is available.
     ///
     /// Behavior is undefined if the mutex has been moved between this and any
     /// previous function call.
     #[inline]
-    pub unsafe fn raw_lock(&self) { self.0.lock() }
+    pub unsafe fn raw_lock(&self) {
+        self.0.lock()
+    }
 
     /// Calls raw_lock() and then returns an RAII guard to guarantee the mutex
     /// will be unlocked.
@@ -49,7 +55,9 @@ impl Mutex {
     /// Behavior is undefined if the mutex has been moved between this and any
     /// previous function call.
     #[inline]
-    pub unsafe fn try_lock(&self) -> bool { self.0.try_lock() }
+    pub unsafe fn try_lock(&self) -> bool {
+        self.0.try_lock()
+    }
 
     /// Unlocks the mutex.
     ///
@@ -59,18 +67,24 @@ impl Mutex {
     /// Consider switching from the pair of raw_lock() and raw_unlock() to
     /// lock() whenever possible.
     #[inline]
-    pub unsafe fn raw_unlock(&self) { self.0.unlock() }
+    pub unsafe fn raw_unlock(&self) {
+        self.0.unlock()
+    }
 
     /// Deallocates all resources associated with this mutex.
     ///
     /// Behavior is undefined if there are current or will be future users of
     /// this mutex.
     #[inline]
-    pub unsafe fn destroy(&self) { self.0.destroy() }
+    pub unsafe fn destroy(&self) {
+        self.0.destroy()
+    }
 }
 
 // not meant to be exported to the outside world, just the containing module
-pub fn raw(mutex: &Mutex) -> &imp::Mutex { &mutex.0 }
+pub fn raw(mutex: &Mutex) -> &imp::Mutex {
+    &mutex.0
+}
 
 #[must_use]
 /// A simple RAII utility for the above Mutex without the poisoning semantics.
@@ -79,6 +93,8 @@ pub struct MutexGuard<'a>(&'a imp::Mutex);
 impl Drop for MutexGuard<'_> {
     #[inline]
     fn drop(&mut self) {
-        unsafe { self.0.unlock(); }
+        unsafe {
+            self.0.unlock();
+        }
     }
 }
diff --git a/src/libstd/sys_common/remutex.rs b/src/libstd/sys_common/remutex.rs
index f08b13c4aa2..a1ad44a3666 100644
--- a/src/libstd/sys_common/remutex.rs
+++ b/src/libstd/sys_common/remutex.rs
@@ -1,9 +1,9 @@
 use crate::fmt;
 use crate::marker;
 use crate::ops::Deref;
-use crate::sys_common::poison::{self, TryLockError, TryLockResult, LockResult};
+use crate::panic::{RefUnwindSafe, UnwindSafe};
 use crate::sys::mutex as sys;
-use crate::panic::{UnwindSafe, RefUnwindSafe};
+use crate::sys_common::poison::{self, LockResult, TryLockError, TryLockResult};
 
 /// A re-entrant mutual exclusion
 ///
@@ -22,7 +22,6 @@ unsafe impl<T: Send> Sync for ReentrantMutex<T> {}
 impl<T> UnwindSafe for ReentrantMutex<T> {}
 impl<T> RefUnwindSafe for ReentrantMutex<T> {}
 
-
 /// An RAII implementation of a "scoped lock" of a mutex. When this structure is
 /// dropped (falls out of scope), the lock will be unlocked.
 ///
@@ -45,7 +44,6 @@ pub struct ReentrantMutexGuard<'a, T: 'a> {
 
 impl<T> !marker::Send for ReentrantMutexGuard<'_, T> {}
 
-
 impl<T> ReentrantMutex<T> {
     /// Creates a new reentrant mutex in an unlocked state.
     pub fn new(t: T) -> ReentrantMutex<T> {
@@ -113,7 +111,7 @@ impl<T: fmt::Debug + 'static> fmt::Debug for ReentrantMutex<T> {
             Ok(guard) => f.debug_struct("ReentrantMutex").field("data", &*guard).finish(),
             Err(TryLockError::Poisoned(err)) => {
                 f.debug_struct("ReentrantMutex").field("data", &**err.get_ref()).finish()
-            },
+            }
             Err(TryLockError::WouldBlock) => {
                 struct LockedPlaceholder;
                 impl fmt::Debug for LockedPlaceholder {
@@ -129,13 +127,10 @@ impl<T: fmt::Debug + 'static> fmt::Debug for ReentrantMutex<T> {
 }
 
 impl<'mutex, T> ReentrantMutexGuard<'mutex, T> {
-    fn new(lock: &'mutex ReentrantMutex<T>)
-            -> LockResult<ReentrantMutexGuard<'mutex, T>> {
-        poison::map_result(lock.poison.borrow(), |guard| {
-            ReentrantMutexGuard {
-                __lock: lock,
-                __poison: guard,
-            }
+    fn new(lock: &'mutex ReentrantMutex<T>) -> LockResult<ReentrantMutexGuard<'mutex, T>> {
+        poison::map_result(lock.poison.borrow(), |guard| ReentrantMutexGuard {
+            __lock: lock,
+            __poison: guard,
         })
     }
 }
@@ -158,12 +153,11 @@ impl<T> Drop for ReentrantMutexGuard<'_, T> {
     }
 }
 
-
 #[cfg(all(test, not(target_os = "emscripten")))]
 mod tests {
-    use crate::sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};
     use crate::cell::RefCell;
     use crate::sync::Arc;
+    use crate::sys_common::remutex::{ReentrantMutex, ReentrantMutexGuard};
     use crate::thread;
 
     #[test]
@@ -209,7 +203,9 @@ mod tests {
         thread::spawn(move || {
             let lock = m2.try_lock();
             assert!(lock.is_err());
-        }).join().unwrap();
+        })
+        .join()
+        .unwrap();
         let _lock3 = m.try_lock().unwrap();
     }
 
@@ -224,14 +220,15 @@ mod tests {
     fn poison_works() {
         let m = Arc::new(ReentrantMutex::new(RefCell::new(0)));
         let mc = m.clone();
-        let result = thread::spawn(move ||{
+        let result = thread::spawn(move || {
             let lock = mc.lock().unwrap();
             *lock.borrow_mut() = 1;
             let lock2 = mc.lock().unwrap();
             *lock.borrow_mut() = 2;
             let _answer = Answer(lock2);
             panic!("What the answer to my lifetimes dilemma is?");
-        }).join();
+        })
+        .join();
         assert!(result.is_err());
         let r = m.lock().err().unwrap().into_inner();
         assert_eq!(*r.borrow(), 42);
diff --git a/src/libstd/sys_common/rwlock.rs b/src/libstd/sys_common/rwlock.rs
index 0b1a092de54..3705d641a1b 100644
--- a/src/libstd/sys_common/rwlock.rs
+++ b/src/libstd/sys_common/rwlock.rs
@@ -12,7 +12,9 @@ impl RWLock {
     ///
     /// Behavior is undefined if the reader-writer lock is moved after it is
     /// first used with any of the functions below.
-    pub const fn new() -> RWLock { RWLock(imp::RWLock::new()) }
+    pub const fn new() -> RWLock {
+        RWLock(imp::RWLock::new())
+    }
 
     /// Acquires shared access to the underlying lock, blocking the current
     /// thread to do so.
@@ -20,7 +22,9 @@ impl RWLock {
     /// Behavior is undefined if the rwlock has been moved between this and any
     /// previous method call.
     #[inline]
-    pub unsafe fn read(&self) { self.0.read() }
+    pub unsafe fn read(&self) {
+        self.0.read()
+    }
 
     /// Attempts to acquire shared access to this lock, returning whether it
     /// succeeded or not.
@@ -30,7 +34,9 @@ impl RWLock {
     /// Behavior is undefined if the rwlock has been moved between this and any
     /// previous method call.
     #[inline]
-    pub unsafe fn try_read(&self) -> bool { self.0.try_read() }
+    pub unsafe fn try_read(&self) -> bool {
+        self.0.try_read()
+    }
 
     /// Acquires write access to the underlying lock, blocking the current thread
     /// to do so.
@@ -38,7 +44,9 @@ impl RWLock {
     /// Behavior is undefined if the rwlock has been moved between this and any
     /// previous method call.
     #[inline]
-    pub unsafe fn write(&self) { self.0.write() }
+    pub unsafe fn write(&self) {
+        self.0.write()
+    }
 
     /// Attempts to acquire exclusive access to this lock, returning whether it
     /// succeeded or not.
@@ -48,25 +56,33 @@ impl RWLock {
     /// Behavior is undefined if the rwlock has been moved between this and any
     /// previous method call.
     #[inline]
-    pub unsafe fn try_write(&self) -> bool { self.0.try_write() }
+    pub unsafe fn try_write(&self) -> bool {
+        self.0.try_write()
+    }
 
     /// Unlocks previously acquired shared access to this lock.
     ///
     /// Behavior is undefined if the current thread does not have shared access.
     #[inline]
-    pub unsafe fn read_unlock(&self) { self.0.read_unlock() }
+    pub unsafe fn read_unlock(&self) {
+        self.0.read_unlock()
+    }
 
     /// Unlocks previously acquired exclusive access to this lock.
     ///
     /// Behavior is undefined if the current thread does not currently have
     /// exclusive access.
     #[inline]
-    pub unsafe fn write_unlock(&self) { self.0.write_unlock() }
+    pub unsafe fn write_unlock(&self) {
+        self.0.write_unlock()
+    }
 
     /// Destroys OS-related resources with this RWLock.
     ///
     /// Behavior is undefined if there are any currently active users of this
     /// lock.
     #[inline]
-    pub unsafe fn destroy(&self) { self.0.destroy() }
+    pub unsafe fn destroy(&self) {
+        self.0.destroy()
+    }
 }
diff --git a/src/libstd/sys_common/thread_local.rs b/src/libstd/sys_common/thread_local.rs
index 9596911fd48..756b8d044a2 100644
--- a/src/libstd/sys_common/thread_local.rs
+++ b/src/libstd/sys_common/thread_local.rs
@@ -81,7 +81,7 @@ pub struct StaticKey {
     ///
     /// See `Key::new` for information about when the destructor runs and how
     /// it runs.
-    dtor: Option<unsafe extern fn(*mut u8)>,
+    dtor: Option<unsafe extern "C" fn(*mut u8)>,
 }
 
 /// A type for a safely managed OS-based TLS slot.
@@ -115,11 +115,8 @@ pub struct Key {
 pub const INIT: StaticKey = StaticKey::new(None);
 
 impl StaticKey {
-    pub const fn new(dtor: Option<unsafe extern fn(*mut u8)>) -> StaticKey {
-        StaticKey {
-            key: atomic::AtomicUsize::new(0),
-            dtor,
-        }
+    pub const fn new(dtor: Option<unsafe extern "C" fn(*mut u8)>) -> StaticKey {
+        StaticKey { key: atomic::AtomicUsize::new(0), dtor }
     }
 
     /// Gets the value associated with this TLS key
@@ -127,20 +124,24 @@ impl StaticKey {
     /// This will lazily allocate a TLS key from the OS if one has not already
     /// been allocated.
     #[inline]
-    pub unsafe fn get(&self) -> *mut u8 { imp::get(self.key()) }
+    pub unsafe fn get(&self) -> *mut u8 {
+        imp::get(self.key())
+    }
 
     /// Sets this TLS key to a new value.
     ///
     /// This will lazily allocate a TLS key from the OS if one has not already
     /// been allocated.
     #[inline]
-    pub unsafe fn set(&self, val: *mut u8) { imp::set(self.key(), val) }
+    pub unsafe fn set(&self, val: *mut u8) {
+        imp::set(self.key(), val)
+    }
 
     #[inline]
     unsafe fn key(&self) -> imp::Key {
         match self.key.load(Ordering::Relaxed) {
             0 => self.lazy_init() as imp::Key,
-            n => n as imp::Key
+            n => n as imp::Key,
         }
     }
 
@@ -161,7 +162,7 @@ impl StaticKey {
                 self.key.store(key, Ordering::SeqCst);
             }
             rtassert!(key != 0);
-            return key
+            return key;
         }
 
         // POSIX allows the key created here to be 0, but the compare_and_swap
@@ -186,7 +187,10 @@ impl StaticKey {
             // The CAS succeeded, so we've created the actual key
             0 => key as usize,
             // If someone beat us to the punch, use their key instead
-            n => { imp::destroy(key); n }
+            n => {
+                imp::destroy(key);
+                n
+            }
         }
     }
 }
@@ -204,7 +208,7 @@ impl Key {
     /// Note that the destructor will not be run when the `Key` goes out of
     /// scope.
     #[inline]
-    pub fn new(dtor: Option<unsafe extern fn(*mut u8)>) -> Key {
+    pub fn new(dtor: Option<unsafe extern "C" fn(*mut u8)>) -> Key {
         Key { key: unsafe { imp::create(dtor) } }
     }
 
@@ -229,8 +233,7 @@ impl Drop for Key {
     }
 }
 
-pub unsafe fn register_dtor_fallback(t: *mut u8,
-                                     dtor: unsafe extern fn(*mut u8)) {
+pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     // The fallback implementation uses a vanilla OS-based TLS key to track
     // the list of destructors that need to be run for this thread. The key
     // then has its own destructor which runs all the other destructors.
@@ -242,7 +245,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8,
     // flagged for destruction.
 
     static DTORS: StaticKey = StaticKey::new(Some(run_dtors));
-    type List = Vec<(*mut u8, unsafe extern fn(*mut u8))>;
+    type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
     if DTORS.get().is_null() {
         let v: Box<List> = box Vec::new();
         DTORS.set(Box::into_raw(v) as *mut u8);
@@ -250,7 +253,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8,
     let list: &mut List = &mut *(DTORS.get() as *mut List);
     list.push((t, dtor));
 
-    unsafe extern fn run_dtors(mut ptr: *mut u8) {
+    unsafe extern "C" fn run_dtors(mut ptr: *mut u8) {
         while !ptr.is_null() {
             let list: Box<List> = Box::from_raw(ptr as *mut List);
             for (ptr, dtor) in list.into_iter() {