Add extra traits for apple datatypes

Author: Susurrus

src/unix/bsd/apple/mod.rs

@@ -482,8 +482,6 @@ s! {
 }
 
 s_no_extra_traits!{
-    // FIXME: https://github.com/rust-lang/libc/issues/1243
-    #[allow(missing_debug_implementations)]
     #[cfg_attr(libc_packedN, repr(packed(4)))]
     pub struct kevent {
         pub ident: ::uintptr_t,
@@ -494,8 +492,6 @@ s_no_extra_traits!{
         pub udata: *mut ::c_void,
     }
 
-    // FIXME: https://github.com/rust-lang/libc/issues/1243
-    #[allow(missing_debug_implementations)]
     #[cfg_attr(libc_packedN, repr(packed(4)))]
     pub struct semid_ds {
         // Note the manpage shows different types than the system header.
@@ -509,8 +505,6 @@ s_no_extra_traits!{
         pub sem_pad3: [::int32_t; 4],
     }
 
-    // FIXME: https://github.com/rust-lang/libc/issues/1243
-    #[allow(missing_debug_implementations)]
     #[cfg_attr(libc_packedN, repr(packed(4)))]
     pub struct shmid_ds {
         pub shm_perm: ipc_perm,
@@ -640,6 +634,123 @@ cfg_if! {
 
 cfg_if! {
     if #[cfg(feature = "extra_traits")] {
+        impl PartialEq for kevent {
+            fn eq(&self, other: &kevent) -> bool {
+                self.ident == other.ident
+                    && self.filter == other.filter
+                    && self.flags == other.flags
+                    && self.fflags == other.fflags
+                    && self.data == other.data
+                    && self.udata == other.udata
+            }
+        }
+        impl Eq for kevent {}
+        impl ::fmt::Debug for kevent {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                f.debug_struct("kevent")
+                    .field("ident", &self.ident)
+                    .field("filter", &self.filter)
+                    .field("flags", &self.flags)
+                    .field("fflags", &self.fflags)
+                    .field("data", &self.data)
+                    .field("udata", &self.udata)
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for kevent {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                self.ident.hash(state);
+                self.filter.hash(state);
+                self.flags.hash(state);
+                self.fflags.hash(state);
+                self.data.hash(state);
+                self.udata.hash(state);
+            }
+        }
+
+        impl PartialEq for semid_ds {
+            fn eq(&self, other: &semid_ds) -> bool {
+                self.sem_perm == other.sem_perm
+                    && self.sem_base == other.sem_base
+                    && self.sem_nsems == other.sem_nsems
+                    && self.sem_otime == other.sem_otime
+                    && self.sem_pad1 == other.sem_pad1
+                    && self.sem_ctime == other.sem_ctime
+                    && self.sem_pad2 == other.sem_pad2
+                    && self.sem_pad3 == other.sem_pad3
+            }
+        }
+        impl Eq for semid_ds {}
+        impl ::fmt::Debug for semid_ds {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                f.debug_struct("semid_ds")
+                    .field("sem_perm", &self.sem_perm)
+                    .field("sem_base", &self.sem_base)
+                    .field("sem_nsems", &self.sem_nsems)
+                    .field("sem_otime", &self.sem_otime)
+                    .field("sem_pad1", &self.sem_pad1)
+                    .field("sem_ctime", &self.sem_ctime)
+                    .field("sem_pad2", &self.sem_pad2)
+                    .field("sem_pad3", &self.sem_pad3)
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for semid_ds {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                self.sem_perm.hash(state);
+                self.sem_base.hash(state);
+                self.sem_nsems.hash(state);
+                self.sem_otime.hash(state);
+                self.sem_pad1.hash(state);
+                self.sem_ctime.hash(state);
+                self.sem_pad2.hash(state);
+                self.sem_pad3.hash(state);
+            }
+        }
+
+        impl PartialEq for shmid_ds {
+            fn eq(&self, other: &shmid_ds) -> bool {
+                self.shm_perm == other.shm_perm
+                    && self.shm_segsz == other.shm_segsz
+                    && self.shm_lpid == other.shm_lpid
+                    && self.shm_cpid == other.shm_cpid
+                    && self.shm_nattch == other.shm_nattch
+                    && self.shm_atime == other.shm_atime
+                    && self.shm_dtime == other.shm_dtime
+                    && self.shm_ctime == other.shm_ctime
+                    && self.shm_internal == other.shm_internal
+            }
+        }
+        impl Eq for shmid_ds {}
+        impl ::fmt::Debug for shmid_ds {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                f.debug_struct("shmid_ds")
+                    .field("shm_perm", &self.shm_perm)
+                    .field("shm_segsz", &self.shm_segsz)
+                    .field("shm_lpid", &self.shm_lpid)
+                    .field("shm_cpid", &self.shm_cpid)
+                    .field("shm_nattch", &self.shm_nattch)
+                    .field("shm_atime", &self.shm_atime)
+                    .field("shm_dtime", &self.shm_dtime)
+                    .field("shm_ctime", &self.shm_ctime)
+                    .field("shm_internal", &self.shm_internal)
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for shmid_ds {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                self.shm_perm.hash(state);
+                self.shm_segsz.hash(state);
+                self.shm_lpid.hash(state);
+                self.shm_cpid.hash(state);
+                self.shm_nattch.hash(state);
+                self.shm_atime.hash(state);
+                self.shm_dtime.hash(state);
+                self.shm_ctime.hash(state);
+                self.shm_internal.hash(state);
+            }
+        }
+
         impl PartialEq for proc_threadinfo {
             fn eq(&self, other: &proc_threadinfo) -> bool {
                 self.pth_user_time == other.pth_user_time
@@ -676,7 +787,6 @@ cfg_if! {
                     .finish()
             }
         }
-
         impl ::hash::Hash for proc_threadinfo {
             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
                 self.pth_user_time.hash(state);