removes the specialization for windows OS

It is not working and I can not figure out why. Since I am not familiar
with developing on windows I might not be the best person to work on
this.

The work removed in this commit might be a useful jumping off point for
anyone else however.

Author: dvdsk

library/std/src/sys/pal/unix/thread.rs

@@ -357,9 +357,10 @@ impl Thread {
 
     #[cfg(any(target_os = "macos", target_os = "ios", target_os = "tvos", target_os = "watchos"))]
     pub fn sleep_until(deadline: crate::time::Instant) {
-        use super::time::Timespec;
         use core::mem::MaybeUninit;
 
+        use super::time::Timespec;
+
         let Timespec { tv_sec, tv_nsec } = deadline.into_inner().into_timespec();
         let nanos = (tv_sec as u64).saturating_mul(1_000_000_000).saturating_add(tv_nsec.0 as u64);
 

library/std/src/sys/pal/windows/thread.rs

@@ -116,25 +116,6 @@ impl Thread {
         }
     }
 
-    pub fn sleep_until(deadline: Instant) {
-        fn high_precision_sleep(deadline: Instant) -> Result<(), ()> {
-            let timer = WaitableTimer::high_resolution()?;
-            timer.set_deadline(deadline.into_inner())?;
-            timer.wait()
-        }
-        // Attempt to use high-precision sleep (Windows 10, version 1803+).
-        // On error fallback to the standard `Sleep` function.
-        // Also preserves the zero duration behaviour of `Sleep`.
-        if high_precision_sleep(deadline).is_ok() {
-            return;
-        }
-
-        let now = Instant::now();
-        if let Some(dur) = deadline.checked_duration_since(now) {
-            unsafe { c::Sleep(super::dur2timeout(dur)) }
-        };
-    }
-
     pub fn handle(&self) -> &Handle {
         &self.handle
     }

library/std/src/sys/pal/windows/time.rs

@@ -248,12 +248,6 @@ impl WaitableTimer {
         let result = unsafe { c::SetWaitableTimer(self.handle, &time, 0, None, null(), c::FALSE) };
         if result != 0 { Ok(()) } else { Err(()) }
     }
-    pub fn set_deadline(&self, deadline: Instant) -> Result<(), ()> {
-        // Convert the Instant to a format similar to FILETIME.
-        let time = checked_dur2intervals(&deadline.t).ok_or(())?;
-        let result = unsafe { c::SetWaitableTimer(self.handle, &time, 0, None, null(), c::FALSE) };
-        if result != 0 { Ok(()) } else { Err(()) }
-    }
     pub fn wait(&self) -> Result<(), ()> {
         let result = unsafe { c::WaitForSingleObject(self.handle, c::INFINITE) };
         if result != c::WAIT_FAILED { Ok(()) } else { Err(()) }

library/std/src/thread/mod.rs

@@ -896,14 +896,12 @@ pub fn sleep(dur: Duration) {
 /// | Illumos   | [clock_nanosleep] (Monotonic Clock)]                                 |
 /// | Darwin    | [mach_wait_until]                                                    |
 /// | WASI      | [subscription_clock]                                                 |
-/// | Windows   | [SetWaitableTimer]                                                   |
 /// | Other     | `sleep_until` uses [`sleep`] and does not issue a syscall itself     |
 ///
 /// [currently]: crate::io#platform-specific-behavior
 /// [clock_nanosleep]: https://linux.die.net/man/3/clock_nanosleep
 /// [subscription_clock]: https://github.com/WebAssembly/WASI/blob/main/legacy/preview1/docs.md#-subscription_clock-record
 /// [mach_wait_until]: https://developer.apple.com/library/archive/technotes/tn2169/_index.html
-/// [SetWaitableTimer]: https://learn.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-setwaitabletimer
 ///
 /// **Disclaimer:** These system calls might change over time.
 ///