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,133 @@ 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", unsafe { &self.ident })
+                    .field("filter", unsafe { &self.filter })
+                    .field("flags", unsafe { &self.flags })
+                    .field("fflags", unsafe { &self.fflags })
+                    .field("data", unsafe { &self.data })
+                    .field("udata", unsafe { &self.udata })
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for kevent {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                unsafe {
+                    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 {
+                unsafe {
+                    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", unsafe { &self.sem_perm })
+                    .field("sem_base", unsafe { &self.sem_base })
+                    .field("sem_nsems", unsafe { &self.sem_nsems })
+                    .field("sem_otime", unsafe { &self.sem_otime })
+                    .field("sem_pad1", unsafe { &self.sem_pad1 })
+                    .field("sem_ctime", unsafe { &self.sem_ctime })
+                    .field("sem_pad2", unsafe { &self.sem_pad2 })
+                    .field("sem_pad3", unsafe { &self.sem_pad3 })
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for semid_ds {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                unsafe {
+                    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 {
+                unsafe {
+                    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", unsafe { &self.shm_perm })
+                    .field("shm_segsz", unsafe { &self.shm_segsz })
+                    .field("shm_lpid", unsafe { &self.shm_lpid })
+                    .field("shm_cpid", unsafe { &self.shm_cpid })
+                    .field("shm_nattch", unsafe { &self.shm_nattch })
+                    .field("shm_atime", unsafe { &self.shm_atime })
+                    .field("shm_dtime", unsafe { &self.shm_dtime })
+                    .field("shm_ctime", unsafe { &self.shm_ctime })
+                    .field("shm_internal", unsafe { &self.shm_internal })
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for shmid_ds {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                unsafe {
+                    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 +797,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);