Remove the PartialEq and Eq implementations from SigHandler

Because it never worked reliably anyway.  See
https://doc.rust-lang.org/nightly/core/ptr/fn.fn_addr_eq.html for more
info.

Alternatively, we could only remove `Eq` and leave `PartialEq`.  We
would be able to guarantee equality or inequality in most cases, but
would be unable to prove that different handler functions are actually
different.  I think users would find that confusing.

Reported by:	Clippy (unpredictable_function_pointer_comparisons)

Author: asomers

changelog/2642.removed.md

@@ -0,0 +1,8 @@
+Removed `Eq` and `PartialEq` implementations from `SigHandler`, because they
+never worked reliably.  The suggested alternative is `matches!`.  For example:
+```
+let h: SigHandler = ...
+if matches!(h, SigHandler::SigIgn) {
+    ...
+}
+```

src/sys/signal.rs

@@ -753,7 +753,7 @@ impl<'a> IntoIterator for &'a SigSet {
 }
 
 /// A signal handler.
-#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Copy, Debug, Hash)]
 pub enum SigHandler {
     /// Default signal handling.
     SigDfl,

test/sys/test_signal.rs

@@ -112,32 +112,23 @@ fn test_signal() {
 
     unsafe { signal(Signal::SIGINT, SigHandler::SigIgn) }.unwrap();
     raise(Signal::SIGINT).unwrap();
-    assert_eq!(
-        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
-        SigHandler::SigIgn
-    );
+    let h = unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
+    assert!(matches!(h, SigHandler::SigIgn));
 
     let handler = SigHandler::Handler(test_sigaction_handler);
-    assert_eq!(
-        unsafe { signal(Signal::SIGINT, handler) }.unwrap(),
-        SigHandler::SigDfl
-    );
+    let h = unsafe { signal(Signal::SIGINT, handler) }.unwrap();
+    assert!(matches!(h, SigHandler::SigDfl));
     raise(Signal::SIGINT).unwrap();
     assert!(SIGNALED.load(Ordering::Relaxed));
 
+    let h = unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
     #[cfg(not(solarish))]
-    assert_eq!(
-        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
-        handler
-    );
+    assert!(matches!(h, SigHandler::Handler(_)));
 
     // System V based OSes (e.g. illumos and Solaris) always resets the
     // disposition to SIG_DFL prior to calling the signal handler
     #[cfg(solarish)]
-    assert_eq!(
-        unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap(),
-        SigHandler::SigDfl
-    );
+    assert!(matches!(h, SigHandler::SigDfl));
 
     // Restore default signal handler
     unsafe { signal(Signal::SIGINT, SigHandler::SigDfl) }.unwrap();
@@ -307,21 +298,21 @@ fn test_sigaction() {
             action_sig.flags(),
             SaFlags::SA_ONSTACK | SaFlags::SA_RESTART
         );
-        assert_eq!(action_sig.handler(), handler_sig);
+        assert!(matches!(action_sig.handler(), SigHandler::Handler(_)));
 
         mask = action_sig.mask();
         assert!(mask.contains(SIGUSR1));
         assert!(!mask.contains(SIGUSR2));
 
         let handler_act = SigHandler::SigAction(test_sigaction_action);
         let action_act = SigAction::new(handler_act, flags, mask);
-        assert_eq!(action_act.handler(), handler_act);
+        assert!(matches!(action_act.handler(), SigHandler::SigAction(_)));
 
         let action_dfl = SigAction::new(SigHandler::SigDfl, flags, mask);
-        assert_eq!(action_dfl.handler(), SigHandler::SigDfl);
+        assert!(matches!(action_dfl.handler(), SigHandler::SigDfl));
 
         let action_ign = SigAction::new(SigHandler::SigIgn, flags, mask);
-        assert_eq!(action_ign.handler(), SigHandler::SigIgn);
+        assert!(matches!(action_ign.handler(), SigHandler::SigIgn));
     })
     .join()
     .unwrap();