Fix cyclic compilation: Use vendored once_cell

Fix #1146

Author: NobodyXu

Cargo.toml

@@ -21,15 +21,14 @@ rust-version = "1.67"
 
 [dependencies]
 jobserver = { version = "0.1.30", default-features = false, optional = true }
-once_cell = { version = "1.19", optional = true }
 
 [target.'cfg(unix)'.dependencies]
 # Don't turn on the feature "std" for this, see https://github.com/rust-lang/cargo/issues/4866
 # which is still an issue with `resolver = "1"`.
 libc = { version = "0.2.62", default-features = false, optional = true }
 
 [features]
-parallel = ["dep:libc", "dep:jobserver", "dep:once_cell"]
+parallel = ["dep:libc", "dep:jobserver"]
 # This is a placeholder feature for people who incorrectly used `cc` with `features = ["jobserver"]`
 # so that they aren't broken. This has never enabled `parallel`, so we won't do that.
 jobserver = []

src/parallel/job_token.rs

@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use crate::Error;
 
-use once_cell::sync::OnceCell;
+use super::once_cell::OnceCell;
 
 pub(crate) struct JobToken(PhantomData<()>);
 
@@ -163,7 +163,7 @@ mod inherited_jobserver {
 
     pub(crate) struct ActiveJobServer<'a> {
         jobserver: &'a JobServer,
-        helper_thread: OnceCell<HelperThread>,
+        helper_thread: OnceCell<Option<HelperThread>>,
     }
 
     impl<'a> ActiveJobServer<'a> {
@@ -183,10 +183,30 @@ mod inherited_jobserver {
                     }
                     Ok(None) => YieldOnce::default().await,
                     Err(err) if err.kind() == io::ErrorKind::Unsupported => {
+                        let mut err = None;
                         // Fallback to creating a help thread with blocking acquire
-                        let helper_thread = self
-                            .helper_thread
-                            .get_or_try_init(|| HelperThread::new(self.jobserver))?;
+                        let helper_thread = self.helper_thread.get_or_init(|| {
+                            match HelperThread::new(self.jobserver) {
+                                Ok(thread) => Some(thread),
+                                Err(error) => {
+                                    err = Some(error);
+                                    None
+                                }
+                            }
+                        });
+
+                        if let Some(err) = err {
+                            return Err(err.into());
+                        }
+
+                        let helper_thread = if let Some(thread) = helper_thread {
+                            thread
+                        } else {
+                            return Err(Error::new(
+                                ErrorKind::JobserverHelpThreadError,
+                                "Creation failed",
+                            ));
+                        };
 
                         match helper_thread.rx.try_recv() {
                             Ok(res) => {

src/parallel/mod.rs

@@ -1,3 +1,4 @@
 pub(crate) mod async_executor;
 pub(crate) mod job_token;
+pub(crate) mod once_cell;
 pub(crate) mod stderr;

src/parallel/once_cell.rs

@@ -0,0 +1,47 @@
+use std::{
+    cell::UnsafeCell,
+    marker::PhantomData,
+    mem::MaybeUninit,
+    panic::{RefUnwindSafe, UnwindSafe},
+    sync::Once,
+};
+
+pub(crate) struct OnceCell<T> {
+    once: Once,
+    value: UnsafeCell<MaybeUninit<T>>,
+    _marker: PhantomData<T>,
+}
+
+impl<T> OnceCell<T> {
+    pub(crate) const fn new() -> Self {
+        Self {
+            once: Once::new(),
+            value: UnsafeCell::new(MaybeUninit::uninit()),
+            _marker: PhantomData,
+        }
+    }
+
+    pub(crate) fn get_or_init(&self, f: impl FnOnce() -> T) -> &T {
+        self.once.call_once_force(|_| {
+            unsafe { &mut *self.value.get() }.write(f());
+        });
+        unsafe { (&*self.value.get()).assume_init_ref() }
+    }
+}
+
+unsafe impl<T: Sync + Send> Sync for OnceCell<T> {}
+unsafe impl<T: Send> Send for OnceCell<T> {}
+
+impl<T: RefUnwindSafe + UnwindSafe> RefUnwindSafe for OnceCell<T> {}
+impl<T: UnwindSafe> UnwindSafe for OnceCell<T> {}
+
+impl<T> Drop for OnceCell<T> {
+    #[inline]
+    fn drop(&mut self) {
+        if self.once.is_completed() {
+            // SAFETY: The cell is initialized and being dropped, so it can't
+            // be accessed again.
+            unsafe { (&mut *self.value.get()).assume_init_drop() };
+        }
+    }
+}