Fix the build with Rust 1.14.0

Author: asomers

src/unix/bsd/freebsdlike/freebsd/mod.rs

@@ -882,12 +882,6 @@ s! {
         pub profhz: ::c_int,
     }
 
-    #[cfg(libc_union)]
-    pub struct __c_anonymous_sigev_thread {
-        pub _function: *mut ::c_void,   // Actually a function pointer
-        pub _attribute: *mut ::pthread_attr_t,
-    }
-
     pub struct __c_anonymous_stailq_entry_devstat {
         pub stqe_next: *mut devstat,
     }
@@ -1325,25 +1319,6 @@ s! {
         pub strchange_instrms: u16,
         pub strchange_outstrms: u16,
     }
-
-    // When sigevent was first added to libc, Rust still didn't support unions.
-    // So the definition only included one of the union's member.  This
-    // structure exists for backwards-compatibility with consumers that still
-    // try to access that one member.
-    #[doc(hidden)]
-    #[deprecated(
-        since = "0.2.127",
-        note = "Use sigevent instead"
-    )]
-    pub struct sigevent_0_2_126 {
-        pub sigev_notify: ::c_int,
-        pub sigev_signo: ::c_int,
-        pub sigev_value: ::sigval,
-        pub sigev_notify_thread_id: ::lwpid_t,
-        #[cfg(target_pointer_width = "64")]
-        __unused1: ::c_int,
-        __unused2: [::c_long; 7]
-    }
 }
 
 s_no_extra_traits! {
@@ -1394,30 +1369,6 @@ s_no_extra_traits! {
         __reserved: [::c_long; 4]
     }
 
-    // Can't correctly impl Debug for unions
-    #[allow(missing_debug_implementations)]
-    #[cfg(libc_union)]
-    pub union __c_anonymous_sigev_un {
-        pub _threadid: ::__lwpid_t,
-        pub _sigev_thread: __c_anonymous_sigev_thread,
-        pub _kevent_flags: ::c_ushort,
-        __spare__: [::c_long; 8],
-    }
-
-    #[cfg(libc_union)]
-    pub struct sigevent {
-        pub sigev_notify: ::c_int,
-        pub sigev_signo: ::c_int,
-        pub sigev_value: ::sigval,
-        pub _sigev_un: __c_anonymous_sigev_un,
-        /// Exists just to prevent the struct from being safely constructed,
-        /// because the Debug, Hash, PartialImpl, and
-        /// Deref<Target=sigevent_0_2_0126> trait impls might read uninitialized
-        /// fields of _sigev_un.  This field may be removed once those trait
-        /// impls are.
-        _private: ()
-    }
-
     pub struct ptsstat {
         #[cfg(any(freebsd12, freebsd13, freebsd14))]
         pub dev: u64,
@@ -1650,7 +1601,79 @@ s_no_extra_traits! {
     }
 }
 
+#[cfg(libc_union)]
+s! {
+    pub struct __c_anonymous_sigev_thread {
+        pub _function: *mut ::c_void,   // Actually a function pointer
+        pub _attribute: *mut ::pthread_attr_t,
+    }
+
+    // When sigevent was first added to libc, Rust still didn't support unions.
+    // So the definition only included one of the union's member.  This
+    // structure exists for backwards-compatibility with consumers that still
+    // try to access that one member.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.2.147",
+        note = "Use sigevent instead"
+    )]
+    pub struct sigevent_0_2_126 {
+        pub sigev_notify: ::c_int,
+        pub sigev_signo: ::c_int,
+        pub sigev_value: ::sigval,
+        pub sigev_notify_thread_id: ::lwpid_t,
+        #[cfg(target_pointer_width = "64")]
+        __unused1: ::c_int,
+        __unused2: [::c_long; 7]
+    }
+}
+
+#[cfg(libc_union)]
+s_no_extra_traits! {
+    // Can't correctly impl Debug for unions
+    #[allow(missing_debug_implementations)]
+    pub union __c_anonymous_sigev_un {
+        pub _threadid: ::__lwpid_t,
+        pub _sigev_thread: __c_anonymous_sigev_thread,
+        pub _kevent_flags: ::c_ushort,
+        __spare__: [::c_long; 8],
+    }
+
+    pub struct sigevent {
+        pub sigev_notify: ::c_int,
+        pub sigev_signo: ::c_int,
+        pub sigev_value: ::sigval,
+        pub _sigev_un: __c_anonymous_sigev_un,
+        /// Exists just to prevent the struct from being safely constructed,
+        /// because the Debug, Hash, PartialImpl, and
+        /// Deref<Target=sigevent_0_2_126> trait impls might read uninitialized
+        /// fields of _sigev_un.  This field may be removed once those trait
+        /// impls are.
+        _private: ()
+    }
+}
+
+#[cfg(not(libc_union))]
+s_no_extra_traits! {
+    pub struct sigevent {
+        pub sigev_notify: ::c_int,
+        pub sigev_signo: ::c_int,
+        pub sigev_value: ::sigval,
+        pub _unused0: ::lwpid_t,
+        #[cfg(target_pointer_width = "64")]
+        __unused1: ::c_int,
+        __unused2: [::c_long; 7],
+        /// Exists just to prevent the struct from being safely constructed,
+        /// because the Debug, Hash, PartialImpl, and
+        /// Deref<Target=sigevent_0_2_126> trait impls might read uninitialized
+        /// fields of _sigev_un.  This field may be removed once those trait
+        /// impls are.
+        _private: ()
+    }
+}
+
 #[allow(deprecated)]
+#[cfg(libc_union)]
 impl ::core::ops::Deref for sigevent {
     type Target = sigevent_0_2_126;
 
@@ -1660,6 +1683,7 @@ impl ::core::ops::Deref for sigevent {
 }
 
 #[allow(deprecated)]
+#[cfg(libc_union)]
 impl ::core::ops::DerefMut for sigevent {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *(self as *mut Self as *mut sigevent_0_2_126) }
@@ -1855,6 +1879,7 @@ cfg_if! {
             }
         }
 
+        #[cfg(libc_union)]
         impl PartialEq for sigevent {
             fn eq(&self, other: &sigevent) -> bool {
                 self.sigev_notify == other.sigev_notify
@@ -1880,13 +1905,22 @@ cfg_if! {
                     }
             }
         }
+        #[cfg(not(libc_union))]
+        impl PartialEq for sigevent {
+            fn eq(&self, other: &sigevent) -> bool {
+                self.sigev_notify == other.sigev_notify
+                    && self.sigev_signo == other.sigev_signo
+                    && self.sigev_value == other.sigev_value
+            }
+        }
         impl Eq for sigevent {}
         impl ::fmt::Debug for sigevent {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 let mut ds = f.debug_struct("sigevent");
                 ds.field("sigev_notify", &self.sigev_notify);
                 ds.field("sigev_signo", &self.sigev_signo);
                 ds.field("sigev_value", &self.sigev_value);
+                #[cfg(libc_union)]
                 // The sigev_notify field indicates which union fields are valid
                 unsafe {
                     match self.sigev_notify {
@@ -1907,6 +1941,7 @@ cfg_if! {
                 self.sigev_notify.hash(state);
                 self.sigev_signo.hash(state);
                 self.sigev_value.hash(state);
+                #[cfg(libc_union)]
                 // The sigev_notify field indicates which union fields are valid
                 unsafe {
                     match self.sigev_notify {

src/unix/linux_like/mod.rs

@@ -16,12 +16,6 @@ impl ::Clone for timezone {
 }
 
 s! {
-    #[cfg(libc_union)]
-    pub struct __c_anonymous_sigev_thread {
-        pub _function: *mut ::c_void,   // Actually a function pointer
-        pub _attribute: *mut ::pthread_attr_t,
-    }
-
     pub struct in_addr {
         pub s_addr: ::in_addr_t,
     }
@@ -214,26 +208,6 @@ s! {
         pub msg_hdr: ::msghdr,
         pub msg_len: ::c_uint,
     }
-
-    // When sigevent was first added to libc, Rust still didn't support unions.
-    // So the definition only included one of the union's member.  This
-    // structure exists for backwards-compatibility with consumers that still
-    // try to access that one member.
-    #[doc(hidden)]
-    #[deprecated(
-        since = "0.2.127",
-        note = "Use sigevent instead"
-    )]
-    pub struct sigevent_0_2_126 {
-        pub sigev_value: ::sigval,
-        pub sigev_signo: ::c_int,
-        pub sigev_notify: ::c_int,
-        pub sigev_notify_thread_id: ::c_int,
-        #[cfg(target_pointer_width = "64")]
-        __unused1: [::c_int; 11],
-        #[cfg(target_pointer_width = "32")]
-        __unused1: [::c_int; 12]
-    }
 }
 
 s_no_extra_traits! {
@@ -273,6 +247,39 @@ s_no_extra_traits! {
         pub domainname: [::c_char; 65]
     }
 
+}
+
+#[cfg(libc_union)]
+s! {
+    pub struct __c_anonymous_sigev_thread {
+        pub _function: *mut ::c_void,   // Actually a function pointer
+        pub _attribute: *mut ::pthread_attr_t,
+    }
+
+    // When sigevent was first added to libc, Rust still didn't support unions.
+    // So the definition only included one of the union's member.  This
+    // structure exists for backwards-compatibility with consumers that still
+    // try to access that one member.
+    #[doc(hidden)]
+    #[deprecated(
+        since = "0.2.127",
+        note = "Use sigevent instead"
+    )]
+    #[cfg(libc_union)]
+    pub struct sigevent_0_2_126 {
+        pub sigev_value: ::sigval,
+        pub sigev_signo: ::c_int,
+        pub sigev_notify: ::c_int,
+        pub sigev_notify_thread_id: ::c_int,
+        #[cfg(target_pointer_width = "64")]
+        __unused1: [::c_int; 11],
+        #[cfg(target_pointer_width = "32")]
+        __unused1: [::c_int; 12]
+    }
+}
+
+#[cfg(libc_union)]
+s_no_extra_traits!{
     // Can't correctly impl Debug for unions
     #[allow(missing_debug_implementations)]
     #[cfg(libc_union)]
@@ -285,22 +292,42 @@ s_no_extra_traits! {
         pub _sigev_thread: __c_anonymous_sigev_thread,
     }
 
-    #[cfg(libc_union)]
     pub struct sigevent {
         pub sigev_value: ::sigval,
         pub sigev_signo: ::c_int,
         pub sigev_notify: ::c_int,
         pub _sigev_un: __c_anonymous_sigev_un,
         /// Exists just to prevent the struct from being safely constructed,
         /// because the Debug, Hash, PartialImpl, and
-        /// Deref<Target=sigevent_0_2_0126> trait impls might read uninitialized
+        /// Deref<Target=sigevent_0_2_126> trait impls might read uninitialized
+        /// fields of _sigev_un.  This field may be removed once those trait
+        /// impls are.
+        _private: ()
+    }
+}
+
+#[cfg(not(libc_union))]
+s_no_extra_traits!{
+    pub struct sigevent {
+        pub sigev_value: ::sigval,
+        pub sigev_signo: ::c_int,
+        pub sigev_notify: ::c_int,
+        __unused0: ::c_int,
+        #[cfg(target_pointer_width = "64")]
+        __unused1: [::c_int; 11],
+        #[cfg(target_pointer_width = "32")]
+        __unused1: [::c_int; 12],
+        /// Exists just to prevent the struct from being safely constructed,
+        /// because the Debug, Hash, PartialImpl, and
+        /// Deref<Target=sigevent_0_2_126> trait impls might read uninitialized
         /// fields of _sigev_un.  This field may be removed once those trait
         /// impls are.
         _private: ()
     }
 }
 
 #[allow(deprecated)]
+#[cfg(libc_union)]
 impl ::core::ops::Deref for sigevent {
     type Target = sigevent_0_2_126;
 
@@ -310,6 +337,7 @@ impl ::core::ops::Deref for sigevent {
 }
 
 #[allow(deprecated)]
+#[cfg(libc_union)]
 impl ::core::ops::DerefMut for sigevent {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *(self as *mut Self as *mut sigevent_0_2_126) }
@@ -460,6 +488,7 @@ cfg_if! {
             }
         }
 
+        #[cfg(libc_union)]
         impl PartialEq for sigevent {
             fn eq(&self, other: &sigevent) -> bool {
                 self.sigev_value == other.sigev_value
@@ -485,13 +514,22 @@ cfg_if! {
                     }
             }
         }
+        #[cfg(not(libc_union))]
+        impl PartialEq for sigevent {
+            fn eq(&self, other: &sigevent) -> bool {
+                self.sigev_value == other.sigev_value
+                    && self.sigev_signo == other.sigev_signo
+                    && self.sigev_notify == other.sigev_notify
+            }
+        }
         impl Eq for sigevent {}
         impl ::fmt::Debug for sigevent {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 let mut ds = f.debug_struct("sigevent");
                 ds.field("sigev_value", &self.sigev_value);
                 ds.field("sigev_signo", &self.sigev_signo);
                 ds.field("sigev_notify", &self.sigev_notify);
+                #[cfg(libc_union)]
                 // The sigev_notify field indicates which union fields are valid
                 unsafe {
                     match self.sigev_notify {
@@ -515,6 +553,7 @@ cfg_if! {
                 self.sigev_value.hash(state);
                 self.sigev_signo.hash(state);
                 self.sigev_notify.hash(state);
+                #[cfg(libc_union)]
                 // The sigev_notify field indicates which union fields are valid
                 unsafe {
                     match self.sigev_notify {