change LazyLock implementation to use nonpoison::Once

Additionally moves `ExclusiveState` into `sys::sync::once` since it is
no longer needed in the `poison` module.

Author: connortsui20

library/std/src/sync/lazy_lock.rs

@@ -1,16 +1,19 @@
-use super::poison::once::ExclusiveState;
 use crate::cell::UnsafeCell;
 use crate::mem::ManuallyDrop;
 use crate::ops::{Deref, DerefMut};
 use crate::panic::{RefUnwindSafe, UnwindSafe};
-use crate::sync::Once;
+use crate::sync::nonpoison::once::Once;
+use crate::sys::sync::once::ExclusiveState;
 use crate::{fmt, ptr};
 
-// We use the state of a Once as discriminant value. Upon creation, the state is
-// "incomplete" and `f` contains the initialization closure. In the first call to
-// `call_once`, `f` is taken and run. If it succeeds, `value` is set and the state
-// is changed to "complete". If it panics, the Once is poisoned, so none of the
-// two fields is initialized.
+/// We use the state of a Once (the [`ExclusiveState`] enum) as discriminant value.
+///
+/// Upon creation, the state is "incomplete" and `f` contains the initialization closure. In the
+/// first call to `call_once()`, `f` is taken and run. If it succeeds, `value` is set and the state
+/// is changed to "complete". If it panics, the [`Once`] is poisoned, so none of the two fields is
+/// initialized.
+///
+/// [`call_once()`]: Once::call_once
 union Data<T, F> {
     value: ManuallyDrop<T>,
     f: ManuallyDrop<F>,
@@ -63,7 +66,6 @@ union Data<T, F> {
 /// ```
 #[stable(feature = "lazy_cell", since = "1.80.0")]
 pub struct LazyLock<T, F = fn() -> T> {
-    // FIXME(nonpoison_once): if possible, switch to nonpoison version once it is available
     once: Once,
     data: UnsafeCell<Data<T, F>>,
 }

library/std/src/sync/poison/once.rs

@@ -49,12 +49,6 @@ pub struct OnceState {
     pub(crate) inner: sys::OnceState,
 }
 
-pub(crate) enum ExclusiveState {
-    Incomplete,
-    Poisoned,
-    Complete,
-}
-
 /// Initialization value for static [`Once`] values.
 ///
 /// # Examples
@@ -299,26 +293,6 @@ impl Once {
             self.inner.wait(true);
         }
     }
-
-    /// Returns the current state of the `Once` instance.
-    ///
-    /// Since this takes a mutable reference, no initialization can currently
-    /// be running, so the state must be either "incomplete", "poisoned" or
-    /// "complete".
-    #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
-        self.inner.state()
-    }
-
-    /// Sets current state of the `Once` instance.
-    ///
-    /// Since this takes a mutable reference, no initialization can currently
-    /// be running, so the state must be either "incomplete", "poisoned" or
-    /// "complete".
-    #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
-        self.inner.set_state(new_state);
-    }
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]

library/std/src/sys/sync/mod.rs

@@ -1,6 +1,6 @@
 mod condvar;
 mod mutex;
-mod once;
+pub(crate) mod once; // Note that this is exposed for `LazyLock`.
 mod once_box;
 mod rwlock;
 mod thread_parking;

library/std/src/sys/sync/once/futex.rs

@@ -1,7 +1,7 @@
+use super::ExclusiveState;
 use crate::cell::Cell;
 use crate::sync as public;
 use crate::sync::atomic::Ordering::{Acquire, Relaxed, Release};
-use crate::sync::poison::once::ExclusiveState;
 use crate::sys::futex::{Futex, Primitive, futex_wait, futex_wake_all};
 
 // On some platforms, the OS is very nice and handles the waiter queue for us.

library/std/src/sys/sync/once/mod.rs

@@ -7,6 +7,16 @@
 // This also gives us the opportunity to optimize the implementation a bit which
 // should help the fast path on call sites.
 
+// FIXME(nonpoison_once): Is this a good place to put this?
+/// The mode that the `Once` is in.
+///
+/// This type is used in the implementation of [`LazyLock`](crate::sync::LazyLock)
+pub(crate) enum ExclusiveState {
+    Incomplete,
+    Poisoned,
+    Complete,
+}
+
 cfg_if::cfg_if! {
     if #[cfg(any(
         all(target_os = "windows", not(target_vendor="win7")),

library/std/src/sys/sync/once/no_threads.rs

@@ -1,6 +1,6 @@
+use super::ExclusiveState;
 use crate::cell::Cell;
 use crate::sync as public;
-use crate::sync::poison::once::ExclusiveState;
 
 pub struct Once {
     state: Cell<State>,

library/std/src/sys/sync/once/queue.rs

@@ -55,10 +55,10 @@
 //   processor. Because both use acquire ordering such a reordering is not
 //   allowed, so no need for `SeqCst`.
 
+use super::ExclusiveState;
 use crate::cell::Cell;
 use crate::sync::atomic::Ordering::{AcqRel, Acquire, Release};
 use crate::sync::atomic::{Atomic, AtomicBool, AtomicPtr};
-use crate::sync::poison::once::ExclusiveState;
 use crate::thread::{self, Thread};
 use crate::{fmt, ptr, sync as public};