Format libstd/sys with rustfmt

This commit applies rustfmt with rust-lang/rust's default settings to
files in src/libstd/sys *that are not involved in any currently open PR*
to minimize merge conflicts. THe list of files involved in open PRs was
determined by querying GitHub's GraphQL API with this script:
https://gist.github.com/dtolnay/aa9c34993dc051a4f344d1b10e4487e8

With the list of files from the script in outstanding_files, the
relevant commands were:

    $ find src/libstd/sys -name '*.rs' \
        | xargs rustfmt --edition=2018 --unstable-features --skip-children
    $ rg libstd/sys outstanding_files | xargs git checkout --

Repeating this process several months apart should get us coverage of
most of the rest of the files.

To confirm no funny business:

    $ git checkout $THIS_COMMIT^
    $ git show --pretty= --name-only $THIS_COMMIT \
        | xargs rustfmt --edition=2018 --unstable-features --skip-children
    $ git diff $THIS_COMMIT  # there should be no difference

1 files changed, 34 insertions, 20 deletions

diff --git a/src/libstd/sys/windows/thread.rs b/src/libstd/sys/windows/thread.rs
index ebdf3612e06..c828243a59b 100644
--- a/src/libstd/sys/windows/thread.rs
+++ b/src/libstd/sys/windows/thread.rs
@@ -1,5 +1,5 @@
-use crate::io;
 use crate::ffi::CStr;
+use crate::io;
 use crate::mem;
 use crate::ptr;
 use crate::sys::c;
@@ -14,13 +14,12 @@ use super::to_u16s;
 pub const DEFAULT_MIN_STACK_SIZE: usize = 2 * 1024 * 1024;
 
 pub struct Thread {
-    handle: Handle
+    handle: Handle,
 }
 
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
-    pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>)
-                          -> io::Result<Thread> {
+    pub unsafe fn new(stack: usize, p: Box<dyn FnOnce()>) -> io::Result<Thread> {
         let p = box p;
 
         // FIXME On UNIX, we guard against stack sizes that are too small but
@@ -31,10 +30,14 @@ impl Thread {
         // Round up to the next 64 kB because that's what the NT kernel does,
         // might as well make it explicit.
         let stack_size = (stack + 0xfffe) & (!0xfffe);
-        let ret = c::CreateThread(ptr::null_mut(), stack_size,
-                                  thread_start, &*p as *const _ as *mut _,
-                                  c::STACK_SIZE_PARAM_IS_A_RESERVATION,
-                                  ptr::null_mut());
+        let ret = c::CreateThread(
+            ptr::null_mut(),
+            stack_size,
+            thread_start,
+            &*p as *const _ as *mut _,
+            c::STACK_SIZE_PARAM_IS_A_RESERVATION,
+            ptr::null_mut(),
+        );
 
         return if ret as usize == 0 {
             Err(io::Error::last_os_error())
@@ -44,7 +47,9 @@ impl Thread {
         };
 
         extern "system" fn thread_start(main: *mut c_void) -> c::DWORD {
-            unsafe { start_thread(main as *mut u8); }
+            unsafe {
+                start_thread(main as *mut u8);
+            }
             0
         }
     }
@@ -52,7 +57,9 @@ impl Thread {
     pub fn set_name(name: &CStr) {
         if let Ok(utf8) = name.to_str() {
             if let Ok(utf16) = to_u16s(utf8) {
-                unsafe { c::SetThreadDescription(c::GetCurrentThread(), utf16.as_ptr()); };
+                unsafe {
+                    c::SetThreadDescription(c::GetCurrentThread(), utf16.as_ptr());
+                };
             };
         };
     }
@@ -60,8 +67,7 @@ impl Thread {
     pub fn join(self) {
         let rc = unsafe { c::WaitForSingleObject(self.handle.raw(), c::INFINITE) };
         if rc == c::WAIT_FAILED {
-            panic!("failed to join on thread: {}",
-                   io::Error::last_os_error());
+            panic!("failed to join on thread: {}", io::Error::last_os_error());
         }
     }
 
@@ -69,23 +75,31 @@ impl Thread {
         // This function will return 0 if there are no other threads to execute,
         // but this also means that the yield was useless so this isn't really a
         // case that needs to be worried about.
-        unsafe { c::SwitchToThread(); }
+        unsafe {
+            c::SwitchToThread();
+        }
     }
 
     pub fn sleep(dur: Duration) {
-        unsafe {
-            c::Sleep(super::dur2timeout(dur))
-        }
+        unsafe { c::Sleep(super::dur2timeout(dur)) }
     }
 
-    pub fn handle(&self) -> &Handle { &self.handle }
+    pub fn handle(&self) -> &Handle {
+        &self.handle
+    }
 
-    pub fn into_handle(self) -> Handle { self.handle }
+    pub fn into_handle(self) -> Handle {
+        self.handle
+    }
 }
 
 #[cfg_attr(test, allow(dead_code))]
 pub mod guard {
     pub type Guard = !;
-    pub unsafe fn current() -> Option<Guard> { None }
-    pub unsafe fn init() -> Option<Guard> { None }
+    pub unsafe fn current() -> Option<Guard> {
+        None
+    }
+    pub unsafe fn init() -> Option<Guard> {
+        None
+    }
 }