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 => {}
             }