Another round of tidy / warning fixes

Author: celinval

Cargo.toml

@@ -60,7 +60,7 @@ exclude = [
   "obj",
 ]
 
-[profile.release.package.rustc-rayon-core]
+[profile.release.package.rustc_thread_pool]
 # The rustc fork of Rayon has deadlock detection code which intermittently
 # causes overflows in the CI (see https://github.com/rust-lang/rust/issues/90227)
 # so we turn overflow checks off for now.

compiler/rustc_data_structures/src/sync.rs

@@ -22,8 +22,6 @@
 //! |                         |                     | `parking_lot::Mutex<T>`         |
 //! | `RwLock<T>`             | `RefCell<T>`        | `parking_lot::RwLock<T>`        |
 //! | `MTLock<T>`        [^1] | `T`                 | `Lock<T>`                       |
-//! |                         |                     |                                 |
-//! | `ParallelIterator`      | `Iterator`          | `rustc_thread_pool::iter::ParallelIterator` |
 //!
 //! [^1]: `MTLock` is similar to `Lock`, but the serial version avoids the cost
 //! of a `RefCell`. This is appropriate when interior mutability is not

compiler/rustc_thread_pool/src/broadcast/mod.rs

@@ -6,7 +6,7 @@ use crate::job::{ArcJob, StackJob};
 use crate::latch::{CountLatch, LatchRef};
 use crate::registry::{Registry, WorkerThread};
 
-mod test;
+mod tests;
 
 /// Executes `op` within every thread in the current threadpool. If this is
 /// called from a non-Rayon thread, it will execute in the global threadpool.
@@ -103,18 +103,18 @@ where
     };
 
     let n_threads = registry.num_threads();
-    let current_thread = WorkerThread::current().as_ref();
+    let current_thread = unsafe { WorkerThread::current().as_ref() };
     let tlv = crate::tlv::get();
     let latch = CountLatch::with_count(n_threads, current_thread);
     let jobs: Vec<_> =
         (0..n_threads).map(|_| StackJob::new(tlv, &f, LatchRef::new(&latch))).collect();
-    let job_refs = jobs.iter().map(|job| job.as_job_ref());
+    let job_refs = jobs.iter().map(|job| unsafe { job.as_job_ref() });
 
     registry.inject_broadcast(job_refs);
 
     // Wait for all jobs to complete, then collect the results, maybe propagating a panic.
     latch.wait(current_thread);
-    jobs.into_iter().map(|job| job.into_result()).collect()
+    jobs.into_iter().map(|job| unsafe { job.into_result() }).collect()
 }
 
 /// Execute `op` on every thread in the pool. It will be executed on each

compiler/rustc_thread_pool/src/compile_fail/quicksort_race1.rs

@@ -7,7 +7,7 @@ fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
 
     let mid = partition(v);
     let (lo, _hi) = v.split_at_mut(mid);
-    rustc_thred_pool::join(|| quick_sort(lo), || quick_sort(lo)); //~ ERROR
+    rustc_thread_pool::join(|| quick_sort(lo), || quick_sort(lo)); //~ ERROR
 }
 
 fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {

compiler/rustc_thread_pool/src/compile_fail/quicksort_race2.rs

@@ -7,7 +7,7 @@ fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
 
     let mid = partition(v);
     let (lo, _hi) = v.split_at_mut(mid);
-    rustc_thred_pool::join(|| quick_sort(lo), || quick_sort(v)); //~ ERROR
+    rustc_thread_pool::join(|| quick_sort(lo), || quick_sort(v)); //~ ERROR
 }
 
 fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {

compiler/rustc_thread_pool/src/compile_fail/quicksort_race3.rs

@@ -7,7 +7,7 @@ fn quick_sort<T:PartialOrd+Send>(v: &mut [T]) {
 
     let mid = partition(v);
     let (_lo, hi) = v.split_at_mut(mid);
-    rustc_thred_pool::join(|| quick_sort(hi), || quick_sort(hi)); //~ ERROR
+    rustc_thread_pool::join(|| quick_sort(hi), || quick_sort(hi)); //~ ERROR
 }
 
 fn partition<T:PartialOrd+Send>(v: &mut [T]) -> usize {

compiler/rustc_thread_pool/src/compile_fail/rc_return.rs

@@ -2,7 +2,7 @@
 
 use std::rc::Rc;
 
-rustc_thred_pool::join(|| Rc::new(22), || ()); //~ ERROR
+rustc_thread_pool::join(|| Rc::new(22), || ()); //~ ERROR
 
 ``` */
 mod left {}
@@ -11,7 +11,7 @@ mod left {}
 
 use std::rc::Rc;
 
-rustc_thred_pool::join(|| (), || Rc::new(23)); //~ ERROR
+rustc_thread_pool::join(|| (), || Rc::new(23)); //~ ERROR
 
 ``` */
 mod right {}

compiler/rustc_thread_pool/src/compile_fail/rc_upvar.rs

@@ -3,7 +3,7 @@
 use std::rc::Rc;
 
 let r = Rc::new(22);
-rustc_thred_pool::join(|| r.clone(), || r.clone());
+rustc_thread_pool::join(|| r.clone(), || r.clone());
 //~^ ERROR
 
 ``` */

compiler/rustc_thread_pool/src/compile_fail/scope_join_bad.rs

@@ -3,7 +3,7 @@
 fn bad_scope<F>(f: F)
     where F: FnOnce(&i32) + Send,
 {
-    rustc_thred_pool::scope(|s| {
+    rustc_thread_pool::scope(|s| {
         let x = 22;
         s.spawn(|_| f(&x)); //~ ERROR `x` does not live long enough
     });
@@ -13,7 +13,7 @@ fn good_scope<F>(f: F)
     where F: FnOnce(&i32) + Send,
 {
     let x = 22;
-    rustc_thred_pool::scope(|s| {
+    rustc_thread_pool::scope(|s| {
         s.spawn(|_| f(&x));
     });
 }

compiler/rustc_thread_pool/src/job.rs

@@ -61,7 +61,7 @@ impl JobRef {
 
     #[inline]
     pub(super) unsafe fn execute(self) {
-        (self.execute_fn)(self.pointer)
+        unsafe { (self.execute_fn)(self.pointer) }
     }
 }
 
@@ -97,7 +97,7 @@ where
     }
 
     pub(super) unsafe fn as_job_ref(&self) -> JobRef {
-        JobRef::new(self)
+        unsafe { JobRef::new(self) }
     }
 
     pub(super) unsafe fn run_inline(self, stolen: bool) -> R {
@@ -116,12 +116,16 @@ where
     R: Send,
 {
     unsafe fn execute(this: *const ()) {
-        let this = &*(this as *const Self);
+        let this = unsafe { &*(this as *const Self) };
         tlv::set(this.tlv);
         let abort = unwind::AbortIfPanic;
-        let func = (*this.func.get()).take().unwrap();
-        (*this.result.get()) = JobResult::call(func);
-        Latch::set(&this.latch);
+        let func = unsafe { (*this.func.get()).take().unwrap() };
+        unsafe {
+            (*this.result.get()) = JobResult::call(func);
+        }
+        unsafe {
+            Latch::set(&this.latch);
+        }
         mem::forget(abort);
     }
 }
@@ -152,7 +156,7 @@ where
     /// lifetimes, so it is up to you to ensure that this JobRef
     /// doesn't outlive any data that it closes over.
     pub(super) unsafe fn into_job_ref(self: Box<Self>) -> JobRef {
-        JobRef::new(Box::into_raw(self))
+        unsafe { JobRef::new(Box::into_raw(self)) }
     }
 
     /// Creates a static `JobRef` from this job.
@@ -169,7 +173,7 @@ where
     BODY: FnOnce() + Send,
 {
     unsafe fn execute(this: *const ()) {
-        let this = Box::from_raw(this as *mut Self);
+        let this = unsafe { Box::from_raw(this as *mut Self) };
         tlv::set(this.tlv);
         (this.job)();
     }
@@ -196,7 +200,7 @@ where
     /// lifetimes, so it is up to you to ensure that this JobRef
     /// doesn't outlive any data that it closes over.
     pub(super) unsafe fn as_job_ref(this: &Arc<Self>) -> JobRef {
-        JobRef::new(Arc::into_raw(Arc::clone(this)))
+        unsafe { JobRef::new(Arc::into_raw(Arc::clone(this))) }
     }
 
     /// Creates a static `JobRef` from this job.
@@ -213,7 +217,7 @@ where
     BODY: Fn() + Send + Sync,
 {
     unsafe fn execute(this: *const ()) {
-        let this = Arc::from_raw(this as *mut Self);
+        let this = unsafe { Arc::from_raw(this as *mut Self) };
         (this.job)();
     }
 }
@@ -254,17 +258,17 @@ impl JobFifo {
         // jobs in a thread's deque may be popped from the back (LIFO) or stolen from the front
         // (FIFO), but either way they will end up popping from the front of this queue.
         self.inner.push(job_ref);
-        JobRef::new(self)
+        unsafe { JobRef::new(self) }
     }
 }
 
 impl Job for JobFifo {
     unsafe fn execute(this: *const ()) {
         // We "execute" a queue by executing its first job, FIFO.
-        let this = &*(this as *const Self);
+        let this = unsafe { &*(this as *const Self) };
         loop {
             match this.inner.steal() {
-                Steal::Success(job_ref) => break job_ref.execute(),
+                Steal::Success(job_ref) => break unsafe { job_ref.execute() },
                 Steal::Empty => panic!("FIFO is empty"),
                 Steal::Retry => {}
             }

compiler/rustc_thread_pool/src/join/mod.rs

@@ -7,7 +7,7 @@ use crate::tlv::{self, Tlv};
 use crate::{FnContext, unwind};
 
 #[cfg(test)]
-mod test;
+mod tests;
 
 /// Takes two closures and *potentially* runs them in parallel. It
 /// returns a pair of the results from those closures.
@@ -41,7 +41,7 @@ mod test;
 /// [the `par_sort` method]: ../rayon/slice/trait.ParallelSliceMut.html#method.par_sort
 ///
 /// ```rust
-/// # use rustc_thred_pool as rayon;
+/// # use rustc_thread_pool as rayon;
 /// let mut v = vec![5, 1, 8, 22, 0, 44];
 /// quick_sort(&mut v);
 /// assert_eq!(v, vec![0, 1, 5, 8, 22, 44]);
@@ -192,7 +192,7 @@ unsafe fn join_recover_from_panic(
     err: Box<dyn Any + Send>,
     tlv: Tlv,
 ) -> ! {
-    worker_thread.wait_until(job_b_latch);
+    unsafe { worker_thread.wait_until(job_b_latch) };
 
     // Restore the TLV since we might have run some jobs overwriting it when waiting for job b.
     tlv::set(tlv);

compiler/rustc_thread_pool/src/latch.rs

@@ -116,7 +116,7 @@ impl CoreLatch {
     /// latch code.
     #[inline]
     unsafe fn set(this: *const Self) -> bool {
-        let old_state = (*this).state.swap(SET, Ordering::AcqRel);
+        let old_state = unsafe { (*this).state.swap(SET, Ordering::AcqRel) };
         old_state == SLEEPING
     }
 
@@ -185,26 +185,26 @@ impl<'r> Latch for SpinLatch<'r> {
     unsafe fn set(this: *const Self) {
         let cross_registry;
 
-        let registry: &Registry = if (*this).cross {
+        let registry: &Registry = if unsafe { (*this).cross } {
             // Ensure the registry stays alive while we notify it.
             // Otherwise, it would be possible that we set the spin
             // latch and the other thread sees it and exits, causing
             // the registry to be deallocated, all before we get a
             // chance to invoke `registry.notify_worker_latch_is_set`.
-            cross_registry = Arc::clone((*this).registry);
+            cross_registry = Arc::clone(unsafe { (*this).registry });
             &cross_registry
         } else {
             // If this is not a "cross-registry" spin-latch, then the
             // thread which is performing `set` is itself ensuring
             // that the registry stays alive. However, that doesn't
             // include this *particular* `Arc` handle if the waiting
             // thread then exits, so we must completely dereference it.
-            (*this).registry
+            unsafe { (*this).registry }
         };
-        let target_worker_index = (*this).target_worker_index;
+        let target_worker_index = unsafe { (*this).target_worker_index };
 
         // NOTE: Once we `set`, the target may proceed and invalidate `this`!
-        if CoreLatch::set(&(*this).core_latch) {
+        if unsafe { CoreLatch::set(&(*this).core_latch) } {
             // Subtle: at this point, we can no longer read from
             // `self`, because the thread owning this spin latch may
             // have awoken and deallocated the latch. Therefore, we
@@ -249,9 +249,9 @@ impl LockLatch {
 impl Latch for LockLatch {
     #[inline]
     unsafe fn set(this: *const Self) {
-        let mut guard = (*this).m.lock().unwrap();
+        let mut guard = unsafe { (*this).m.lock().unwrap() };
         *guard = true;
-        (*this).v.notify_all();
+        unsafe { (*this).v.notify_all() };
     }
 }
 
@@ -286,7 +286,7 @@ impl OnceLatch {
         registry: &Registry,
         target_worker_index: usize,
     ) {
-        if CoreLatch::set(&(*this).core_latch) {
+        if unsafe { CoreLatch::set(&(*this).core_latch) } {
             registry.notify_worker_latch_is_set(target_worker_index);
         }
     }
@@ -384,17 +384,17 @@ impl CountLatch {
 impl Latch for CountLatch {
     #[inline]
     unsafe fn set(this: *const Self) {
-        if (*this).counter.fetch_sub(1, Ordering::SeqCst) == 1 {
+        if unsafe { (*this).counter.fetch_sub(1, Ordering::SeqCst) == 1 } {
             // NOTE: Once we call `set` on the internal `latch`,
             // the target may proceed and invalidate `this`!
-            match (*this).kind {
-                CountLatchKind::Stealing { ref latch, ref registry, worker_index } => {
+            match unsafe { &(*this).kind } {
+                CountLatchKind::Stealing { latch, registry, worker_index } => {
                     let registry = Arc::clone(registry);
-                    if CoreLatch::set(latch) {
-                        registry.notify_worker_latch_is_set(worker_index);
+                    if unsafe { CoreLatch::set(latch) } {
+                        registry.notify_worker_latch_is_set(*worker_index);
                     }
                 }
-                CountLatchKind::Blocking { ref latch } => LockLatch::set(latch),
+                CountLatchKind::Blocking { latch } => unsafe { LockLatch::set(latch) },
             }
         }
     }
@@ -426,6 +426,6 @@ impl<L> Deref for LatchRef<'_, L> {
 impl<L: Latch> Latch for LatchRef<'_, L> {
     #[inline]
     unsafe fn set(this: *const Self) {
-        L::set((*this).inner);
+        unsafe { L::set((*this).inner) };
     }
 }