rename once::ExclusiveState to OnceExclusiveState

connortsui20 · connortsui20 · commit d985fa13fc9d · 2025-10-17T10:57:39.000-04:00
It is a bit confusing when reading code that uses this type since it is
not immediately obvious that it is specific to `Once`.

Signed-off-by: Connor Tsui &lt;connor.tsui20@gmail.com&gt;
diff --git a/std/src/sync/lazy_lock.rs b/std/src/sync/lazy_lock.rs
@@ -1,4 +1,4 @@
-use super::poison::once::ExclusiveState;
+use super::poison::once::OnceExclusiveState;
 use crate::cell::UnsafeCell;
 use crate::mem::ManuallyDrop;
 use crate::ops::{Deref, DerefMut};
@@ -140,14 +140,18 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
     pub fn into_inner(mut this: Self) -> Result<T, F> {
         let state = this.once.state();
         match state {
-            ExclusiveState::Poisoned => panic_poisoned(),
+            OnceExclusiveState::Poisoned => panic_poisoned(),
             state => {
                 let this = ManuallyDrop::new(this);
                 let data = unsafe { ptr::read(&this.data) }.into_inner();
                 match state {
-                    ExclusiveState::Incomplete => Err(ManuallyDrop::into_inner(unsafe { data.f })),
-                    ExclusiveState::Complete => Ok(ManuallyDrop::into_inner(unsafe { data.value })),
-                    ExclusiveState::Poisoned => unreachable!(),
+                    OnceExclusiveState::Incomplete => {
+                        Err(ManuallyDrop::into_inner(unsafe { data.f }))
+                    }
+                    OnceExclusiveState::Complete => {
+                        Ok(ManuallyDrop::into_inner(unsafe { data.value }))
+                    }
+                    OnceExclusiveState::Poisoned => unreachable!(),
                 }
             }
         }
@@ -189,7 +193,7 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
             impl<T, F> Drop for PoisonOnPanic<'_, T, F> {
                 #[inline]
                 fn drop(&mut self) {
-                    self.0.once.set_state(ExclusiveState::Poisoned);
+                    self.0.once.set_state(OnceExclusiveState::Poisoned);
                 }
             }
 
@@ -200,19 +204,19 @@ impl<T, F: FnOnce() -> T> LazyLock<T, F> {
             let guard = PoisonOnPanic(this);
             let data = f();
             guard.0.data.get_mut().value = ManuallyDrop::new(data);
-            guard.0.once.set_state(ExclusiveState::Complete);
+            guard.0.once.set_state(OnceExclusiveState::Complete);
             core::mem::forget(guard);
             // SAFETY: We put the value there above.
             unsafe { &mut this.data.get_mut().value }
         }
 
         let state = this.once.state();
         match state {
-            ExclusiveState::Poisoned => panic_poisoned(),
+            OnceExclusiveState::Poisoned => panic_poisoned(),
             // SAFETY: The `Once` states we completed the initialization.
-            ExclusiveState::Complete => unsafe { &mut this.data.get_mut().value },
+            OnceExclusiveState::Complete => unsafe { &mut this.data.get_mut().value },
             // SAFETY: The state is `Incomplete`.
-            ExclusiveState::Incomplete => unsafe { really_init_mut(this) },
+            OnceExclusiveState::Incomplete => unsafe { really_init_mut(this) },
         }
     }
 
@@ -293,7 +297,7 @@ impl<T, F> LazyLock<T, F> {
         match state {
             // SAFETY:
             // The closure has been run successfully, so `value` has been initialized.
-            ExclusiveState::Complete => Some(unsafe { &mut this.data.get_mut().value }),
+            OnceExclusiveState::Complete => Some(unsafe { &mut this.data.get_mut().value }),
             _ => None,
         }
     }
@@ -332,11 +336,13 @@ impl<T, F> LazyLock<T, F> {
 impl<T, F> Drop for LazyLock<T, F> {
     fn drop(&mut self) {
         match self.once.state() {
-            ExclusiveState::Incomplete => unsafe { ManuallyDrop::drop(&mut self.data.get_mut().f) },
-            ExclusiveState::Complete => unsafe {
+            OnceExclusiveState::Incomplete => unsafe {
+                ManuallyDrop::drop(&mut self.data.get_mut().f)
+            },
+            OnceExclusiveState::Complete => unsafe {
                 ManuallyDrop::drop(&mut self.data.get_mut().value)
             },
-            ExclusiveState::Poisoned => {}
+            OnceExclusiveState::Poisoned => {}
         }
     }
 }
diff --git a/std/src/sync/poison/once.rs b/std/src/sync/poison/once.rs
@@ -49,7 +49,9 @@ pub struct OnceState {
     pub(crate) inner: sys::OnceState,
 }
 
-pub(crate) enum ExclusiveState {
+/// Used for the internal implementation of `sys::sync::once` on different platforms and the
+/// [`LazyLock`](crate::sync::LazyLock) implementation.
+pub(crate) enum OnceExclusiveState {
     Incomplete,
     Poisoned,
     Complete,
@@ -310,7 +312,7 @@ impl Once {
     /// be running, so the state must be either "incomplete", "poisoned" or
     /// "complete".
     #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
+    pub(crate) fn state(&mut self) -> OnceExclusiveState {
         self.inner.state()
     }
 
@@ -320,7 +322,7 @@ impl Once {
     /// be running, so the state must be either "incomplete", "poisoned" or
     /// "complete".
     #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
+    pub(crate) fn set_state(&mut self, new_state: OnceExclusiveState) {
         self.inner.set_state(new_state);
     }
 }
diff --git a/std/src/sys/sync/once/futex.rs b/std/src/sys/sync/once/futex.rs
@@ -1,7 +1,7 @@
 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::sync::poison::once::OnceExclusiveState;
 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.
@@ -83,21 +83,21 @@ impl Once {
     }
 
     #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
+    pub(crate) fn state(&mut self) -> OnceExclusiveState {
         match *self.state_and_queued.get_mut() {
-            INCOMPLETE => ExclusiveState::Incomplete,
-            POISONED => ExclusiveState::Poisoned,
-            COMPLETE => ExclusiveState::Complete,
+            INCOMPLETE => OnceExclusiveState::Incomplete,
+            POISONED => OnceExclusiveState::Poisoned,
+            COMPLETE => OnceExclusiveState::Complete,
             _ => unreachable!("invalid Once state"),
         }
     }
 
     #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
+    pub(crate) fn set_state(&mut self, new_state: OnceExclusiveState) {
         *self.state_and_queued.get_mut() = match new_state {
-            ExclusiveState::Incomplete => INCOMPLETE,
-            ExclusiveState::Poisoned => POISONED,
-            ExclusiveState::Complete => COMPLETE,
+            OnceExclusiveState::Incomplete => INCOMPLETE,
+            OnceExclusiveState::Poisoned => POISONED,
+            OnceExclusiveState::Complete => COMPLETE,
         };
     }
 
diff --git a/std/src/sys/sync/once/no_threads.rs b/std/src/sys/sync/once/no_threads.rs
@@ -1,6 +1,6 @@
 use crate::cell::Cell;
 use crate::sync as public;
-use crate::sync::poison::once::ExclusiveState;
+use crate::sync::poison::once::OnceExclusiveState;
 
 pub struct Once {
     state: Cell<State>,
@@ -45,21 +45,21 @@ impl Once {
     }
 
     #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
+    pub(crate) fn state(&mut self) -> OnceExclusiveState {
         match self.state.get() {
-            State::Incomplete => ExclusiveState::Incomplete,
-            State::Poisoned => ExclusiveState::Poisoned,
-            State::Complete => ExclusiveState::Complete,
+            State::Incomplete => OnceExclusiveState::Incomplete,
+            State::Poisoned => OnceExclusiveState::Poisoned,
+            State::Complete => OnceExclusiveState::Complete,
             _ => unreachable!("invalid Once state"),
         }
     }
 
     #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
+    pub(crate) fn set_state(&mut self, new_state: OnceExclusiveState) {
         self.state.set(match new_state {
-            ExclusiveState::Incomplete => State::Incomplete,
-            ExclusiveState::Poisoned => State::Poisoned,
-            ExclusiveState::Complete => State::Complete,
+            OnceExclusiveState::Incomplete => State::Incomplete,
+            OnceExclusiveState::Poisoned => State::Poisoned,
+            OnceExclusiveState::Complete => State::Complete,
         });
     }
 
diff --git a/std/src/sys/sync/once/queue.rs b/std/src/sys/sync/once/queue.rs
@@ -58,7 +58,7 @@
 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::sync::poison::once::OnceExclusiveState;
 use crate::thread::{self, Thread};
 use crate::{fmt, ptr, sync as public};
 
@@ -131,21 +131,21 @@ impl Once {
     }
 
     #[inline]
-    pub(crate) fn state(&mut self) -> ExclusiveState {
+    pub(crate) fn state(&mut self) -> OnceExclusiveState {
         match self.state_and_queue.get_mut().addr() {
-            INCOMPLETE => ExclusiveState::Incomplete,
-            POISONED => ExclusiveState::Poisoned,
-            COMPLETE => ExclusiveState::Complete,
+            INCOMPLETE => OnceExclusiveState::Incomplete,
+            POISONED => OnceExclusiveState::Poisoned,
+            COMPLETE => OnceExclusiveState::Complete,
             _ => unreachable!("invalid Once state"),
         }
     }
 
     #[inline]
-    pub(crate) fn set_state(&mut self, new_state: ExclusiveState) {
+    pub(crate) fn set_state(&mut self, new_state: OnceExclusiveState) {
         *self.state_and_queue.get_mut() = match new_state {
-            ExclusiveState::Incomplete => ptr::without_provenance_mut(INCOMPLETE),
-            ExclusiveState::Poisoned => ptr::without_provenance_mut(POISONED),
-            ExclusiveState::Complete => ptr::without_provenance_mut(COMPLETE),
+            OnceExclusiveState::Incomplete => ptr::without_provenance_mut(INCOMPLETE),
+            OnceExclusiveState::Poisoned => ptr::without_provenance_mut(POISONED),
+            OnceExclusiveState::Complete => ptr::without_provenance_mut(COMPLETE),
         };
     }
 
