Merge rayon-rs#1028

1028: Be careful comparing `job_ref.execute_fn` r=cuviper a=cuviper

After rayon-rs#1025, clippy is denying [`fn_address_comparisons`][1], and this
is correct that we can't actually guarantee that the pointer we got from
`as_job_ref` will be the same that we produce in a later `PartialEq`.
It's less worrying that different functions could merge to the same
address, because our `StackJob` will still have different data pointers.

We can keep `Copy + Eq` off of `JobRef` with an opaque `id() -> impl Eq`
instead, so we'll be comparing the exact same captured `fn` pointer.

[1]: https://rust-lang.github.io/rust-clippy/master/index.html#fn_address_comparisons


Co-authored-by: Josh Stone <cuviper@gmail.com>

Author: bors[bot]

rayon-core/src/job.rs

@@ -52,6 +52,13 @@ impl JobRef {
         }
     }
 
+    /// Returns an opaque handle that can be saved and compared,
+    /// without making `JobRef` itself `Copy + Eq`.
+    #[inline]
+    pub(super) fn id(&self) -> impl Eq {
+        (self.pointer, self.execute_fn)
+    }
+
     #[inline]
     pub(super) unsafe fn execute(self) {
         (self.execute_fn)(self.pointer)
@@ -73,17 +80,6 @@ where
     result: UnsafeCell<JobResult<R>>,
 }
 
-impl<L, F, R> PartialEq<JobRef> for StackJob<L, F, R>
-where
-    L: Latch + Sync,
-    F: FnOnce(bool) -> R + Send,
-    R: Send,
-{
-    fn eq(&self, job: &JobRef) -> bool {
-        job.pointer == <*const Self>::cast(self) && job.execute_fn == Self::execute
-    }
-}
-
 impl<L, F, R> StackJob<L, F, R>
 where
     L: Latch + Sync,

rayon-core/src/join/mod.rs

@@ -134,7 +134,9 @@ where
         // done here so that the stack frame can keep it all live
         // long enough.
         let job_b = StackJob::new(call_b(oper_b), SpinLatch::new(worker_thread));
-        worker_thread.push(job_b.as_job_ref());
+        let job_b_ref = job_b.as_job_ref();
+        let job_b_id = job_b_ref.id();
+        worker_thread.push(job_b_ref);
 
         // Execute task a; hopefully b gets stolen in the meantime.
         let status_a = unwind::halt_unwinding(call_a(oper_a, injected));
@@ -150,7 +152,7 @@ where
         // those off to get to it.
         while !job_b.latch.probe() {
             if let Some(job) = worker_thread.take_local_job() {
-                if job_b == job {
+                if job_b_id == job.id() {
                     // Found it! Let's run it.
                     //
                     // Note that this could panic, but it's ok if we unwind here.