From c3b1d2eb6c6cef63b2de2203179088edc9f5e18e Mon Sep 17 00:00:00 2001 From: Bryant Mairs Date: Sun, 10 Mar 2019 08:29:23 -0700 Subject: [PATCH] Add extra traits for all types Derive Clone, Copy, Eq, Hash, and PartialEq for all types. Not all traits are supported by all types, which is why many are missing some. --- CHANGELOG.md | 2 + src/dir.rs | 27 +-- src/fcntl.rs | 5 +- src/ifaddrs.rs | 2 +- src/lib.rs | 2 +- src/mqueue.rs | 13 +- src/poll.rs | 20 +-- src/pty.rs | 5 +- src/sched.rs | 3 +- src/sys/aio.rs | 19 +-- src/sys/epoll.rs | 3 +- src/sys/event.rs | 3 +- src/sys/quota.rs | 3 +- src/sys/select.rs | 3 +- src/sys/sendfile.rs | 2 +- src/sys/signal.rs | 38 +---- src/sys/socket/addr.rs | 345 ++------------------------------------ src/sys/socket/mod.rs | 75 ++------- src/sys/socket/sockopt.rs | 6 +- src/sys/statvfs.rs | 3 +- src/sys/sysinfo.rs | 3 +- src/sys/termios.rs | 3 +- src/sys/time.rs | 42 +---- src/sys/uio.rs | 5 +- src/sys/utsname.rs | 3 +- src/sys/wait.rs | 2 +- src/ucontext.rs | 3 +- 27 files changed, 68 insertions(+), 572 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7e7abf98f2..c9775263b5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,8 @@ This project adheres to [Semantic Versioning](http://semver.org/). ioctl_read_bad!(tcgets, libc::TCGETS, libc::termios); ``` +- Implemented `Clone`, `Copy`, `Debug`, `Eq`, `Hash`, and `PartialEq` for most + types that support them. ([#1035](https://github.com/nix-rust/nix/pull/1035)) ### Changed - Minimum supported Rust version is now 1.25.0 diff --git a/src/dir.rs b/src/dir.rs index 814e9e0c0b..d4fc43a4d0 100644 --- a/src/dir.rs +++ b/src/dir.rs @@ -3,7 +3,7 @@ use errno::Errno; use fcntl::{self, OFlag}; use libc; use std::os::unix::io::{AsRawFd, IntoRawFd, RawFd}; -use std::{ffi, fmt, ptr}; +use std::{ffi, ptr}; use sys; #[cfg(target_os = "linux")] @@ -25,6 +25,7 @@ use libc::{dirent, readdir_r}; /// * returns entries for `.` (current directory) and `..` (parent directory). /// * returns entries' names as a `CStr` (no allocation or conversion beyond whatever libc /// does). +#[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct Dir( // This could be ptr::NonNull once nix requires Rust 1.25. *mut libc::DIR @@ -82,21 +83,13 @@ impl AsRawFd for Dir { } } -impl fmt::Debug for Dir { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Dir") - .field("fd", &self.as_raw_fd()) - .finish() - } -} - impl Drop for Dir { fn drop(&mut self) { unsafe { libc::closedir(self.0) }; } } -#[derive(Debug)] +#[derive(Debug, Eq, Hash, PartialEq)] pub struct Iter<'d>(&'d mut Dir); impl<'d> Iterator for Iter<'d> { @@ -132,10 +125,10 @@ impl<'d> Drop for Iter<'d> { /// A directory entry, similar to `std::fs::DirEntry`. /// /// Note that unlike the std version, this may represent the `.` or `..` entries. -#[derive(Copy, Clone)] +#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)] pub struct Entry(dirent); -#[derive(Copy, Clone, Debug, Eq, PartialEq)] +#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)] pub enum Type { Fifo, CharacterDevice, @@ -198,13 +191,3 @@ impl Entry { } } } - -impl fmt::Debug for Entry { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Entry") - .field("ino", &self.ino()) - .field("file_name", &self.file_name()) - .field("file_type", &self.file_type()) - .finish() - } -} diff --git a/src/fcntl.rs b/src/fcntl.rs index 40f4cf9405..6da62d87ba 100644 --- a/src/fcntl.rs +++ b/src/fcntl.rs @@ -214,7 +214,7 @@ libc_bitflags!( } ); -#[allow(missing_debug_implementations)] +#[derive(Debug, Eq, Hash, PartialEq)] pub enum FcntlArg<'a> { F_DUPFD(RawFd), F_DUPFD_CLOEXEC(RawFd), @@ -277,8 +277,7 @@ pub fn fcntl(fd: RawFd, arg: FcntlArg) -> Result { Errno::result(res) } -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum FlockArg { LockShared, LockExclusive, diff --git a/src/ifaddrs.rs b/src/ifaddrs.rs index 61d36ff4cd..3ae39bea0d 100644 --- a/src/ifaddrs.rs +++ b/src/ifaddrs.rs @@ -15,7 +15,7 @@ use sys::socket::SockAddr; use net::if_::*; /// Describes a single address for an interface as returned by `getifaddrs`. -#[derive(Clone, Eq, Hash, PartialEq, Debug)] +#[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct InterfaceAddress { /// Name of the network interface pub interface_name: String, diff --git a/src/lib.rs b/src/lib.rs index ae3cc73413..e961acae1b 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -97,7 +97,7 @@ pub type Result = result::Result; /// error has a corresponding errno (usually the one from the /// underlying OS) to which it can be mapped in addition to /// implementing other common traits. -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum Error { Sys(Errno), InvalidPath, diff --git a/src/mqueue.rs b/src/mqueue.rs index 87be65321b..b958b71cdd 100644 --- a/src/mqueue.rs +++ b/src/mqueue.rs @@ -29,22 +29,11 @@ libc_bitflags!{ } #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct MqAttr { mq_attr: libc::mq_attr, } -impl PartialEq for MqAttr { - fn eq(&self, other: &MqAttr) -> bool { - let self_attr = self.mq_attr; - let other_attr = other.mq_attr; - self_attr.mq_flags == other_attr.mq_flags && self_attr.mq_maxmsg == other_attr.mq_maxmsg && - self_attr.mq_msgsize == other_attr.mq_msgsize && - self_attr.mq_curmsgs == other_attr.mq_curmsgs - } -} - impl MqAttr { pub fn new(mq_flags: c_long, mq_maxmsg: c_long, diff --git a/src/poll.rs b/src/poll.rs index 160b5bc605..c603611e31 100644 --- a/src/poll.rs +++ b/src/poll.rs @@ -4,7 +4,6 @@ use sys::time::TimeSpec; #[cfg(any(target_os = "android", target_os = "dragonfly", target_os = "freebsd", target_os = "linux"))] use sys::signal::SigSet; use std::os::unix::io::RawFd; -use std::fmt; use libc; use Result; @@ -19,7 +18,7 @@ use errno::Errno; /// After a call to `poll` or `ppoll`, the events that occured can be /// retrieved by calling [`revents()`](#method.revents) on the `PollFd`. #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct PollFd { pollfd: libc::pollfd, } @@ -43,23 +42,6 @@ impl PollFd { } } -impl fmt::Debug for PollFd { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let pfd = self.pollfd; - let mut ds = f.debug_struct("PollFd"); - ds.field("fd", &pfd.fd); - match PollFlags::from_bits(pfd.events) { - None => ds.field("events", &pfd.events), - Some(ef) => ds.field("events", &ef), - }; - match PollFlags::from_bits(pfd.revents) { - None => ds.field("revents", &pfd.revents), - Some(ef) => ds.field("revents", &ef), - }; - ds.finish() - } -} - libc_bitflags! { /// These flags define the different events that can be monitored by `poll` and `ppoll` pub struct PollFlags: libc::c_short { diff --git a/src/pty.rs b/src/pty.rs index 41bd51b68a..db012d8158 100644 --- a/src/pty.rs +++ b/src/pty.rs @@ -18,8 +18,7 @@ use errno::Errno; /// /// This is returned by `openpty`. Note that this type does *not* implement `Drop`, so the user /// must manually close the file descriptors. -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct OpenptyResult { /// The master port in a virtual pty pair pub master: RawFd, @@ -45,7 +44,7 @@ pub struct ForkptyResult { /// While this datatype is a thin wrapper around `RawFd`, it enforces that the available PTY /// functions are given the correct file descriptor. Additionally this type implements `Drop`, /// so that when it's consumed or goes out of scope, it's automatically cleaned-up. -#[derive(Debug)] +#[derive(Clone, Debug, Eq, Hash, PartialEq)] pub struct PtyMaster(RawFd); impl AsRawFd for PtyMaster { diff --git a/src/sched.rs b/src/sched.rs index d381cbb5bb..c4e6ca7a1a 100644 --- a/src/sched.rs +++ b/src/sched.rs @@ -39,8 +39,7 @@ libc_bitflags!{ pub type CloneCb<'a> = Box isize + 'a>; #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct CpuSet { cpu_set: libc::cpu_set_t, } diff --git a/src/sys/aio.rs b/src/sys/aio.rs index c54c2e316e..71ff3129c1 100644 --- a/src/sys/aio.rs +++ b/src/sys/aio.rs @@ -80,7 +80,7 @@ libc_enum! { /// Return values for [`AioCb::cancel`](struct.AioCb.html#method.cancel) and /// [`aio_cancel_all`](fn.aio_cancel_all.html) #[repr(i32)] -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum AioCancelStat { /// All outstanding requests were canceled AioCanceled = libc::AIO_CANCELED, @@ -133,6 +133,7 @@ impl<'a> Debug for Buffer<'a> { /// /// The basic structure used by all aio functions. Each `AioCb` represents one /// I/O request. +#[derive(Debug)] pub struct AioCb<'a> { aiocb: libc::aiocb, /// Tracks whether the buffer pointed to by `libc::aiocb.aio_buf` is mutable @@ -1018,22 +1019,6 @@ pub fn aio_suspend(list: &[&AioCb], timeout: Option) -> Result<()> { }).map(drop) } -impl<'a> Debug for AioCb<'a> { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("AioCb") - .field("aio_fildes", &self.aiocb.aio_fildes) - .field("aio_offset", &self.aiocb.aio_offset) - .field("aio_buf", &self.aiocb.aio_buf) - .field("aio_nbytes", &self.aiocb.aio_nbytes) - .field("aio_lio_opcode", &self.aiocb.aio_lio_opcode) - .field("aio_reqprio", &self.aiocb.aio_reqprio) - .field("aio_sigevent", &SigEvent::from(&self.aiocb.aio_sigevent)) - .field("mutable", &self.mutable) - .field("in_progress", &self.in_progress) - .finish() - } -} - impl<'a> Drop for AioCb<'a> { /// If the `AioCb` has no remaining state in the kernel, just drop it. /// Otherwise, dropping constitutes a resource leak, which is an error diff --git a/src/sys/epoll.rs b/src/sys/epoll.rs index 3ed1dd7240..fef6f4e3ec 100644 --- a/src/sys/epoll.rs +++ b/src/sys/epoll.rs @@ -42,8 +42,7 @@ libc_bitflags!{ } } -#[allow(missing_debug_implementations)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] #[repr(C)] pub struct EpollEvent { event: libc::epoll_event, diff --git a/src/sys/event.rs b/src/sys/event.rs index f1eaa0d155..8cd7372f88 100644 --- a/src/sys/event.rs +++ b/src/sys/event.rs @@ -12,9 +12,8 @@ use std::ptr; use std::mem; // Redefine kevent in terms of programmer-friendly enums and bitfields. -#[derive(Clone, Copy)] #[repr(C)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct KEvent { kevent: libc::kevent, } diff --git a/src/sys/quota.rs b/src/sys/quota.rs index 14c0462929..8946fca221 100644 --- a/src/sys/quota.rs +++ b/src/sys/quota.rs @@ -96,8 +96,7 @@ libc_bitflags!( /// Wrapper type for `if_dqblk` // FIXME: Change to repr(transparent) #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Dqblk(libc::dqblk); impl Default for Dqblk { diff --git a/src/sys/select.rs b/src/sys/select.rs index 95b6b148f6..1b518e29f6 100644 --- a/src/sys/select.rs +++ b/src/sys/select.rs @@ -11,8 +11,7 @@ pub use libc::FD_SETSIZE; // FIXME: Change to repr(transparent) once it's stable #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct FdSet(libc::fd_set); impl FdSet { diff --git a/src/sys/sendfile.rs b/src/sys/sendfile.rs index 1190518d8b..a47d8962f7 100644 --- a/src/sys/sendfile.rs +++ b/src/sys/sendfile.rs @@ -38,7 +38,7 @@ cfg_if! { target_os = "macos"))] { use sys::uio::IoVec; - #[allow(missing_debug_implementations)] + #[derive(Clone, Debug, Eq, Hash, PartialEq)] struct SendfileHeaderTrailer<'a>( libc::sf_hdtr, Option>>, diff --git a/src/sys/signal.rs b/src/sys/signal.rs index a49b273f8a..1013a77fd4 100644 --- a/src/sys/signal.rs +++ b/src/sys/signal.rs @@ -265,8 +265,7 @@ const SIGNALS: [Signal; 31] = [ pub const NSIG: libc::c_int = 32; -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct SignalIterator { next: usize, } @@ -328,8 +327,7 @@ libc_enum! { } } -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct SigSet { sigset: libc::sigset_t } @@ -427,7 +425,7 @@ impl AsRef for SigSet { /// A signal handler. #[allow(unknown_lints)] -#[derive(Debug, Clone, Copy, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum SigHandler { /// Default signal handling. SigDfl, @@ -441,8 +439,7 @@ pub enum SigHandler { } /// Action to take on receipt of a signal. Corresponds to `sigaction`. -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct SigAction { sigaction: libc::sigaction } @@ -683,7 +680,7 @@ pub type type_of_thread_id = libc::pid_t; // sigval is actually a union of a int and a void*. But it's never really used // as a pointer, because neither libc nor the kernel ever dereference it. nix // therefore presents it as an intptr_t, which is how kevent uses it. -#[derive(Clone, Copy, Debug, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum SigevNotify { /// No notification will be delivered SigevNone, @@ -710,7 +707,6 @@ mod sigevent { use libc; use std::mem; use std::ptr; - use std::fmt::{self, Debug}; use super::SigevNotify; #[cfg(any(target_os = "freebsd", target_os = "linux"))] use super::type_of_thread_id; @@ -718,7 +714,7 @@ mod sigevent { /// Used to request asynchronous notification of the completion of certain /// events, such as POSIX AIO and timers. #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct SigEvent { sigevent: libc::sigevent } @@ -788,28 +784,6 @@ mod sigevent { } } - impl Debug for SigEvent { - #[cfg(any(target_os = "freebsd", target_os = "linux"))] - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("SigEvent") - .field("sigev_notify", &self.sigevent.sigev_notify) - .field("sigev_signo", &self.sigevent.sigev_signo) - .field("sigev_value", &self.sigevent.sigev_value.sival_ptr) - .field("sigev_notify_thread_id", - &self.sigevent.sigev_notify_thread_id) - .finish() - } - - #[cfg(not(any(target_os = "freebsd", target_os = "linux")))] - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("SigEvent") - .field("sigev_notify", &self.sigevent.sigev_notify) - .field("sigev_signo", &self.sigevent.sigev_signo) - .field("sigev_value", &self.sigevent.sigev_value.sival_ptr) - .finish() - } - } - impl<'a> From<&'a libc::sigevent> for SigEvent { fn from(sigevent: &libc::sigevent) -> Self { SigEvent{ sigevent: *sigevent } diff --git a/src/sys/socket/addr.rs b/src/sys/socket/addr.rs index fc24bd792b..5f02945a6d 100644 --- a/src/sys/socket/addr.rs +++ b/src/sys/socket/addr.rs @@ -2,7 +2,7 @@ use super::sa_family_t; use {Error, Result, NixPath}; use errno::Errno; use libc; -use std::{fmt, hash, mem, net, ptr, slice}; +use std::{fmt, mem, net, ptr, slice}; use std::ffi::OsStr; use std::path::Path; use std::os::unix::ffi::OsStrExt; @@ -245,7 +245,7 @@ impl AddressFamily { } } -#[derive(Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum InetAddr { V4(libc::sockaddr_in), V6(libc::sockaddr_in6), @@ -331,52 +331,6 @@ impl InetAddr { } } -impl PartialEq for InetAddr { - fn eq(&self, other: &InetAddr) -> bool { - match (*self, *other) { - (InetAddr::V4(ref a), InetAddr::V4(ref b)) => { - a.sin_port == b.sin_port && - a.sin_addr.s_addr == b.sin_addr.s_addr - } - (InetAddr::V6(ref a), InetAddr::V6(ref b)) => { - a.sin6_port == b.sin6_port && - a.sin6_addr.s6_addr == b.sin6_addr.s6_addr && - a.sin6_flowinfo == b.sin6_flowinfo && - a.sin6_scope_id == b.sin6_scope_id - } - _ => false, - } - } -} - -impl Eq for InetAddr { -} - -impl hash::Hash for InetAddr { - fn hash(&self, s: &mut H) { - match *self { - InetAddr::V4(ref a) => { - ( a.sin_family, - a.sin_port, - a.sin_addr.s_addr ).hash(s) - } - InetAddr::V6(ref a) => { - ( a.sin6_family, - a.sin6_port, - &a.sin6_addr.s6_addr, - a.sin6_flowinfo, - a.sin6_scope_id ).hash(s) - } - } - } -} - -impl Clone for InetAddr { - fn clone(&self) -> InetAddr { - *self - } -} - impl fmt::Display for InetAddr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -386,18 +340,12 @@ impl fmt::Display for InetAddr { } } -impl fmt::Debug for InetAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - /* * * ===== IpAddr ===== * */ -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum IpAddr { V4(Ipv4Addr), V6(Ipv6Addr), @@ -442,19 +390,13 @@ impl fmt::Display for IpAddr { } } -impl fmt::Debug for IpAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - /* * * ===== Ipv4Addr ===== * */ -#[derive(Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Ipv4Addr(pub libc::in_addr); impl Ipv4Addr { @@ -487,28 +429,6 @@ impl Ipv4Addr { } } -impl PartialEq for Ipv4Addr { - fn eq(&self, other: &Ipv4Addr) -> bool { - self.0.s_addr == other.0.s_addr - } -} - -impl Eq for Ipv4Addr { -} - -impl hash::Hash for Ipv4Addr { - fn hash(&self, s: &mut H) { - let saddr = self.0.s_addr; - saddr.hash(s) - } -} - -impl Clone for Ipv4Addr { - fn clone(&self) -> Ipv4Addr { - *self - } -} - impl fmt::Display for Ipv4Addr { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let octets = self.octets(); @@ -516,19 +436,13 @@ impl fmt::Display for Ipv4Addr { } } -impl fmt::Debug for Ipv4Addr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - /* * * ===== Ipv6Addr ===== * */ -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Ipv6Addr(pub libc::in6_addr); // Note that IPv6 addresses are stored in big endian order on all architectures. @@ -576,12 +490,6 @@ impl fmt::Display for Ipv6Addr { } } -impl fmt::Debug for Ipv6Addr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - /* * * ===== UnixAddr ===== @@ -596,7 +504,7 @@ impl fmt::Debug for Ipv6Addr { /// does not require that `sun_len` include the terminating null even for normal /// sockets. Note that the actual sockaddr length is greater by /// `offset_of!(libc::sockaddr_un, sun_path)` -#[derive(Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct UnixAddr(pub libc::sockaddr_un, pub usize); impl UnixAddr { @@ -688,27 +596,6 @@ impl UnixAddr { } } -impl PartialEq for UnixAddr { - fn eq(&self, other: &UnixAddr) -> bool { - self.sun_path() == other.sun_path() - } -} - -impl Eq for UnixAddr { -} - -impl hash::Hash for UnixAddr { - fn hash(&self, s: &mut H) { - ( self.0.sun_family, self.sun_path() ).hash(s) - } -} - -impl Clone for UnixAddr { - fn clone(&self) -> UnixAddr { - *self - } -} - impl fmt::Display for UnixAddr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { if self.1 == 0 { @@ -722,12 +609,6 @@ impl fmt::Display for UnixAddr { } } -impl fmt::Debug for UnixAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } -} - /* * * ===== Sock addr ===== @@ -735,7 +616,7 @@ impl fmt::Debug for UnixAddr { */ /// Represents a socket address -#[derive(Copy, Debug)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum SockAddr { Inet(InetAddr), Unix(UnixAddr), @@ -883,68 +764,6 @@ impl SockAddr { } } -impl PartialEq for SockAddr { - fn eq(&self, other: &SockAddr) -> bool { - match (*self, *other) { - (SockAddr::Inet(ref a), SockAddr::Inet(ref b)) => { - a == b - } - (SockAddr::Unix(ref a), SockAddr::Unix(ref b)) => { - a == b - } - #[cfg(any(target_os = "android", target_os = "linux"))] - (SockAddr::Netlink(ref a), SockAddr::Netlink(ref b)) => { - a == b - } - #[cfg(any(target_os = "android", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "linux", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd"))] - (SockAddr::Link(ref a), SockAddr::Link(ref b)) => { - a == b - } - _ => false, - } - } -} - -impl Eq for SockAddr { -} - -impl hash::Hash for SockAddr { - fn hash(&self, s: &mut H) { - match *self { - SockAddr::Inet(ref a) => a.hash(s), - SockAddr::Unix(ref a) => a.hash(s), - #[cfg(any(target_os = "android", target_os = "linux"))] - SockAddr::Netlink(ref a) => a.hash(s), - #[cfg(any(target_os = "android", target_os = "linux"))] - SockAddr::Alg(ref a) => a.hash(s), - #[cfg(any(target_os = "ios", target_os = "macos"))] - SockAddr::SysControl(ref a) => a.hash(s), - #[cfg(any(target_os = "android", - target_os = "dragonfly", - target_os = "freebsd", - target_os = "ios", - target_os = "linux", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd"))] - SockAddr::Link(ref ether_addr) => ether_addr.hash(s) - } - } -} - -impl Clone for SockAddr { - fn clone(&self) -> SockAddr { - *self - } -} - impl fmt::Display for SockAddr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { @@ -974,30 +793,10 @@ pub mod netlink { use ::sys::socket::addr::AddressFamily; use libc::{sa_family_t, sockaddr_nl}; use std::{fmt, mem}; - use std::hash::{Hash, Hasher}; - #[derive(Copy, Clone)] + #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)] pub struct NetlinkAddr(pub sockaddr_nl); - // , PartialEq, Eq, Debug, Hash - impl PartialEq for NetlinkAddr { - fn eq(&self, other: &Self) -> bool { - let (inner, other) = (self.0, other.0); - (inner.nl_family, inner.nl_pid, inner.nl_groups) == - (other.nl_family, other.nl_pid, other.nl_groups) - } - } - - impl Eq for NetlinkAddr {} - - impl Hash for NetlinkAddr { - fn hash(&self, s: &mut H) { - let inner = self.0; - (inner.nl_family, inner.nl_pid, inner.nl_groups).hash(s); - } - } - - impl NetlinkAddr { pub fn new(pid: u32, groups: u32) -> NetlinkAddr { let mut addr: sockaddr_nl = unsafe { mem::zeroed() }; @@ -1022,12 +821,6 @@ pub mod netlink { write!(f, "pid: {} groups: {}", self.pid(), self.groups()) } } - - impl fmt::Debug for NetlinkAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } - } } #[cfg(any(target_os = "android", target_os = "linux"))] @@ -1098,11 +891,13 @@ pub mod sys_control { use ::sys::socket::addr::AddressFamily; use libc::{self, c_uchar}; use std::{fmt, mem}; - use std::hash::{Hash, Hasher}; use std::os::unix::io::RawFd; use {Errno, Error, Result}; + // FIXME: Move type into `libc` #[repr(C)] + #[derive(Clone, Copy)] + #[allow(missing_debug_implementations)] pub struct ctl_ioc_info { pub ctl_id: u32, pub ctl_name: [c_uchar; MAX_KCTL_NAME], @@ -1114,28 +909,10 @@ pub mod sys_control { ioctl_readwrite!(ctl_info, CTL_IOC_MAGIC, CTL_IOC_INFO, ctl_ioc_info); - #[derive(Copy, Clone)] #[repr(C)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct SysControlAddr(pub libc::sockaddr_ctl); - impl PartialEq for SysControlAddr { - fn eq(&self, other: &Self) -> bool { - let (inner, other) = (self.0, other.0); - (inner.sc_id, inner.sc_unit) == - (other.sc_id, other.sc_unit) - } - } - - impl Eq for SysControlAddr {} - - impl Hash for SysControlAddr { - fn hash(&self, s: &mut H) { - let inner = self.0; - (inner.sc_id, inner.sc_unit).hash(s); - } - } - - impl SysControlAddr { pub fn new(id: u32, unit: u32) -> SysControlAddr { let addr = libc::sockaddr_ctl { @@ -1178,27 +955,15 @@ pub mod sys_control { fmt::Debug::fmt(self, f) } } - - impl fmt::Debug for SysControlAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("SysControlAddr") - .field("sc_len", &self.0.sc_len) - .field("sc_family", &self.0.sc_family) - .field("ss_sysaddr", &self.0.ss_sysaddr) - .field("sc_id", &self.0.sc_id) - .field("sc_unit", &self.0.sc_unit) - .finish() - } - } } #[cfg(any(target_os = "android", target_os = "linux"))] mod datalink { - use super::{libc, hash, fmt, AddressFamily}; + use super::{libc, fmt, AddressFamily}; /// Hardware Address - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct LinkAddr(pub libc::sockaddr_ll); impl LinkAddr { @@ -1246,26 +1011,6 @@ mod datalink { } } - impl Eq for LinkAddr {} - - impl PartialEq for LinkAddr { - fn eq(&self, other: &Self) -> bool { - let (a, b) = (self.0, other.0); - (a.sll_family, a.sll_protocol, a.sll_ifindex, a.sll_hatype, - a.sll_pkttype, a.sll_halen, a.sll_addr) == - (b.sll_family, b.sll_protocol, b.sll_ifindex, b.sll_hatype, - b.sll_pkttype, b.sll_halen, b.sll_addr) - } - } - - impl hash::Hash for LinkAddr { - fn hash(&self, s: &mut H) { - let a = self.0; - (a.sll_family, a.sll_protocol, a.sll_ifindex, a.sll_hatype, - a.sll_pkttype, a.sll_halen, a.sll_addr).hash(s); - } - } - impl fmt::Display for LinkAddr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let addr = self.addr(); @@ -1278,12 +1023,6 @@ mod datalink { addr[5]) } } - - impl fmt::Debug for LinkAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } - } } #[cfg(any(target_os = "dragonfly", @@ -1293,10 +1032,10 @@ mod datalink { target_os = "netbsd", target_os = "openbsd"))] mod datalink { - use super::{libc, hash, fmt, AddressFamily}; + use super::{libc, fmt, AddressFamily}; /// Hardware Address - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct LinkAddr(pub libc::sockaddr_dl); impl LinkAddr { @@ -1368,52 +1107,6 @@ mod datalink { } } - impl Eq for LinkAddr {} - - impl PartialEq for LinkAddr { - #[cfg(any(target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd"))] - fn eq(&self, other: &Self) -> bool { - let (a, b) = (self.0, other.0); - (a.sdl_len, a.sdl_family, a.sdl_index, a.sdl_type, - a.sdl_nlen, a.sdl_alen, a.sdl_slen, &a.sdl_data[..]) == - (b.sdl_len, b.sdl_family, b.sdl_index, b.sdl_type, - b.sdl_nlen, b.sdl_alen, b.sdl_slen, &b.sdl_data[..]) - } - - #[cfg(target_os = "dragonfly")] - fn eq(&self, other: &Self) -> bool { - let (a, b) = (self.0, other.0); - (a.sdl_len, a.sdl_family, a.sdl_index, a.sdl_type, a.sdl_nlen, - a.sdl_alen, a.sdl_slen, a.sdl_data, a.sdl_rcf, a.sdl_route) == - (b.sdl_len, b.sdl_family, b.sdl_index, b.sdl_type, b.sdl_nlen, - b.sdl_alen, b.sdl_slen, b.sdl_data, b.sdl_rcf, b.sdl_route) - } - } - - impl hash::Hash for LinkAddr { - #[cfg(any(target_os = "freebsd", - target_os = "ios", - target_os = "macos", - target_os = "netbsd", - target_os = "openbsd"))] - fn hash(&self, s: &mut H) { - let a = self.0; - (a.sdl_len, a.sdl_family, a.sdl_index, a.sdl_type, - a.sdl_nlen, a.sdl_alen, a.sdl_slen, &a.sdl_data[..]).hash(s); - } - - #[cfg(target_os = "dragonfly")] - fn hash(&self, s: &mut H) { - let a = self.0; - (a.sdl_len, a.sdl_family, a.sdl_index, a.sdl_type, a.sdl_nlen, - a.sdl_alen, a.sdl_slen, a.sdl_data, a.sdl_rcf, a.sdl_route).hash(s); - } - } - impl fmt::Display for LinkAddr { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { let addr = self.addr(); @@ -1426,12 +1119,6 @@ mod datalink { addr[5]) } } - - impl fmt::Debug for LinkAddr { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(self, f) - } - } } #[cfg(test)] diff --git a/src/sys/socket/mod.rs b/src/sys/socket/mod.rs index 0ba28358da..493ca1cf0b 100644 --- a/src/sys/socket/mod.rs +++ b/src/sys/socket/mod.rs @@ -5,7 +5,7 @@ use {Error, Result}; use errno::Errno; use libc::{self, c_void, c_int, iovec, socklen_t, size_t, CMSG_FIRSTHDR, CMSG_NXTHDR, CMSG_DATA, CMSG_LEN}; -use std::{fmt, mem, ptr, slice}; +use std::{mem, ptr, slice}; use std::os::unix::io::RawFd; use sys::time::TimeVal; use sys::uio::IoVec; @@ -185,7 +185,7 @@ cfg_if! { /// /// This struct is used with the `SO_PEERCRED` ancillary message for UNIX sockets. #[repr(C)] - #[derive(Clone, Copy)] + #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct UnixCredentials(libc::ucred); impl UnixCredentials { @@ -205,13 +205,6 @@ cfg_if! { } } - impl PartialEq for UnixCredentials { - fn eq(&self, other: &Self) -> bool { - self.0.pid == other.0.pid && self.0.uid == other.0.uid && self.0.gid == other.0.gid - } - } - impl Eq for UnixCredentials {} - impl From for UnixCredentials { fn from(cred: libc::ucred) -> Self { UnixCredentials(cred) @@ -223,16 +216,6 @@ cfg_if! { self.0 } } - - impl fmt::Debug for UnixCredentials { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("UnixCredentials") - .field("pid", &self.0.pid) - .field("uid", &self.0.uid) - .field("gid", &self.0.gid) - .finish() - } - } } } @@ -240,7 +223,7 @@ cfg_if! { /// /// This is a wrapper type around `ip_mreq`. #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct IpMembershipRequest(libc::ip_mreq); impl IpMembershipRequest { @@ -255,32 +238,11 @@ impl IpMembershipRequest { } } -impl PartialEq for IpMembershipRequest { - fn eq(&self, other: &Self) -> bool { - self.0.imr_multiaddr.s_addr == other.0.imr_multiaddr.s_addr - && self.0.imr_interface.s_addr == other.0.imr_interface.s_addr - } -} -impl Eq for IpMembershipRequest {} - -impl fmt::Debug for IpMembershipRequest { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - let mref = &self.0.imr_multiaddr; - let maddr = mref.s_addr; - let iref = &self.0.imr_interface; - let ifaddr = iref.s_addr; - f.debug_struct("IpMembershipRequest") - .field("imr_multiaddr", &maddr) - .field("imr_interface", &ifaddr) - .finish() - } -} - /// Request for ipv6 multicast socket operations /// /// This is a wrapper type around `ipv6_mreq`. #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct Ipv6MembershipRequest(libc::ipv6_mreq); impl Ipv6MembershipRequest { @@ -293,23 +255,6 @@ impl Ipv6MembershipRequest { } } -impl PartialEq for Ipv6MembershipRequest { - fn eq(&self, other: &Self) -> bool { - self.0.ipv6mr_multiaddr.s6_addr == other.0.ipv6mr_multiaddr.s6_addr && - self.0.ipv6mr_interface == other.0.ipv6mr_interface - } -} -impl Eq for Ipv6MembershipRequest {} - -impl fmt::Debug for Ipv6MembershipRequest { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - f.debug_struct("Ipv6MembershipRequest") - .field("ipv6mr_multiaddr", &self.0.ipv6mr_multiaddr.s6_addr) - .field("ipv6mr_interface", &self.0.ipv6mr_interface) - .finish() - } -} - cfg_if! { // Darwin and DragonFly BSD always align struct cmsghdr to 32-bit only. if #[cfg(any(target_os = "dragonfly", target_os = "ios", target_os = "macos"))] { @@ -382,7 +327,7 @@ macro_rules! cmsg_space { /// let cmsg: CmsgSpace<([RawFd; 3], CmsgSpace<[RawFd; 2]>)> = CmsgSpace::new(); /// ``` #[repr(C)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct CmsgSpace { _hdr: cmsghdr, _pad: [align_of_cmsg_data; 0], @@ -415,7 +360,7 @@ impl CmsgBuffer for Vec { } } -#[allow(missing_debug_implementations)] // msghdr isn't Debug +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct RecvMsg<'a> { pub bytes: usize, cmsghdr: Option<&'a cmsghdr>, @@ -435,7 +380,7 @@ impl<'a> RecvMsg<'a> { } } -#[allow(missing_debug_implementations)] // msghdr isn't Debug +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct CmsgIterator<'a> { /// Control message buffer to decode from. Must adhere to cmsg alignment. cmsghdr: Option<&'a cmsghdr>, @@ -474,7 +419,7 @@ impl<'a> Iterator for CmsgIterator<'a> { // alignment issues. // // See https://github.com/nix-rust/nix/issues/999 -#[allow(missing_debug_implementations)] +#[derive(Clone, Debug, Eq, PartialEq)] pub enum ControlMessageOwned { /// Received version of /// [`ControlMessage::ScmRights`][#enum.ControlMessage.html#variant.ScmRights] @@ -675,7 +620,7 @@ impl ControlMessageOwned { /// exhaustively pattern-match it. /// /// [Further reading](http://man7.org/linux/man-pages/man3/cmsg.3.html) -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum ControlMessage<'a> { /// A message of type `SCM_RIGHTS`, containing an array of file /// descriptors passed between processes. @@ -738,7 +683,7 @@ pub enum ControlMessage<'a> { // An opaque structure used to prevent cmsghdr from being a public type #[doc(hidden)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Debug, Eq, PartialEq)] pub struct UnknownCmsg(cmsghdr, Vec); impl<'a> ControlMessage<'a> { diff --git a/src/sys/socket/sockopt.rs b/src/sys/socket/sockopt.rs index 4727698b1d..610bab42f9 100644 --- a/src/sys/socket/sockopt.rs +++ b/src/sys/socket/sockopt.rs @@ -173,7 +173,7 @@ macro_rules! sockopt_impl { }; (GetOnly, $name:ident, $level:path, $flag:path, $ty:ty, $getter:ty) => { - #[derive(Copy, Clone, Debug)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct $name; getsockopt_impl!($name, $level, $flag, $ty, $getter); @@ -184,14 +184,14 @@ macro_rules! sockopt_impl { }; (SetOnly, $name:ident, $level:path, $flag:path, $ty:ty, $setter:ty) => { - #[derive(Copy, Clone, Debug)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct $name; setsockopt_impl!($name, $level, $flag, $ty, $setter); }; (Both, $name:ident, $level:path, $flag:path, $ty:ty, $getter:ty, $setter:ty) => { - #[derive(Copy, Clone, Debug)] + #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct $name; setsockopt_impl!($name, $level, $flag, $ty, $setter); diff --git a/src/sys/statvfs.rs b/src/sys/statvfs.rs index de69ae51f8..e5980369d5 100644 --- a/src/sys/statvfs.rs +++ b/src/sys/statvfs.rs @@ -57,8 +57,7 @@ libc_bitflags!( /// For more information see the [`statvfs(3)` man pages](http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/sys_statvfs.h.html). // FIXME: Replace with repr(transparent) #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct Statvfs(libc::statvfs); impl Statvfs { diff --git a/src/sys/sysinfo.rs b/src/sys/sysinfo.rs index 98ef7bd517..4c8e389888 100644 --- a/src/sys/sysinfo.rs +++ b/src/sys/sysinfo.rs @@ -6,8 +6,7 @@ use Result; use errno::Errno; /// System info structure returned by `sysinfo`. -#[derive(Copy, Clone)] -#[allow(missing_debug_implementations)] // libc::sysinfo doesn't impl Debug +#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq)] pub struct SysInfo(libc::sysinfo); impl SysInfo { diff --git a/src/sys/termios.rs b/src/sys/termios.rs index d8815baa00..c7cdf10b46 100644 --- a/src/sys/termios.rs +++ b/src/sys/termios.rs @@ -176,8 +176,7 @@ use ::unistd::Pid; /// This is a wrapper around the `libc::termios` struct that provides a safe interface for the /// standard fields. The only safe way to obtain an instance of this struct is to extract it from /// an open port using `tcgetattr()`. -#[derive(Clone)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Debug, Eq, PartialEq)] pub struct Termios { inner: RefCell, /// Input mode flags (see `termios.c_iflag` documentation) diff --git a/src/sys/time.rs b/src/sys/time.rs index 4bd3b7808d..3ad57543b1 100644 --- a/src/sys/time.rs +++ b/src/sys/time.rs @@ -45,7 +45,7 @@ pub trait TimeValLike: Sized { } #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct TimeSpec(timespec); const NANOS_PER_SEC: i64 = 1_000_000_000; @@ -67,25 +67,6 @@ impl AsRef for TimeSpec { } } -impl fmt::Debug for TimeSpec { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("TimeSpec") - .field("tv_sec", &self.tv_sec()) - .field("tv_nsec", &self.tv_nsec()) - .finish() - } -} - -impl PartialEq for TimeSpec { - // The implementation of cmp is simplified by assuming that the struct is - // normalized. That is, tv_nsec must always be within [0, 1_000_000_000) - fn eq(&self, other: &TimeSpec) -> bool { - self.tv_sec() == other.tv_sec() && self.tv_nsec() == other.tv_nsec() - } -} - -impl Eq for TimeSpec {} - impl Ord for TimeSpec { // The implementation of cmp is simplified by assuming that the struct is // normalized. That is, tv_nsec must always be within [0, 1_000_000_000) @@ -259,7 +240,7 @@ impl fmt::Display for TimeSpec { #[repr(C)] -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct TimeVal(timeval); const MICROS_PER_SEC: i64 = 1_000_000; @@ -278,25 +259,6 @@ impl AsRef for TimeVal { } } -impl fmt::Debug for TimeVal { - fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { - fmt.debug_struct("TimeVal") - .field("tv_sec", &self.tv_sec()) - .field("tv_usec", &self.tv_usec()) - .finish() - } -} - -impl PartialEq for TimeVal { - // The implementation of cmp is simplified by assuming that the struct is - // normalized. That is, tv_usec must always be within [0, 1_000_000) - fn eq(&self, other: &TimeVal) -> bool { - self.tv_sec() == other.tv_sec() && self.tv_usec() == other.tv_usec() - } -} - -impl Eq for TimeVal {} - impl Ord for TimeVal { // The implementation of cmp is simplified by assuming that the struct is // normalized. That is, tv_usec must always be within [0, 1_000_000) diff --git a/src/sys/uio.rs b/src/sys/uio.rs index 45860be5aa..d089084eed 100644 --- a/src/sys/uio.rs +++ b/src/sys/uio.rs @@ -88,8 +88,7 @@ pub fn pread(fd: RawFd, buf: &mut [u8], offset: off_t) -> Result{ /// and [`process_vm_writev`](fn.process_vm_writev.html). #[cfg(target_os = "linux")] #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct RemoteIoVec { /// The starting address of this slice (`iov_base`). pub base: usize, @@ -160,7 +159,7 @@ pub fn process_vm_readv(pid: ::unistd::Pid, local_iov: &[IoVec<&mut [u8]>], remo } #[repr(C)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct IoVec(libc::iovec, PhantomData); impl IoVec { diff --git a/src/sys/utsname.rs b/src/sys/utsname.rs index e33d0739a0..ab09c7d232 100644 --- a/src/sys/utsname.rs +++ b/src/sys/utsname.rs @@ -4,8 +4,7 @@ use std::ffi::CStr; use std::str::from_utf8_unchecked; #[repr(C)] -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct UtsName(libc::utsname); impl UtsName { diff --git a/src/sys/wait.rs b/src/sys/wait.rs index 3f99757daf..c54f7ec579 100644 --- a/src/sys/wait.rs +++ b/src/sys/wait.rs @@ -55,7 +55,7 @@ libc_bitflags!( /// Note that there are two Linux-specific enum variants, `PtraceEvent` /// and `PtraceSyscall`. Portable code should avoid exhaustively /// matching on `WaitStatus`. -#[derive(Eq, PartialEq, Clone, Copy, Debug)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub enum WaitStatus { /// The process exited normally (as with `exit()` or returning from /// `main`) with the given exit code. This case matches the C macro diff --git a/src/ucontext.rs b/src/ucontext.rs index c94464d570..5e10e7d1f8 100644 --- a/src/ucontext.rs +++ b/src/ucontext.rs @@ -6,8 +6,7 @@ use errno::Errno; use std::mem; use sys::signal::SigSet; -#[derive(Clone, Copy)] -#[allow(missing_debug_implementations)] +#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] pub struct UContext { context: libc::ucontext_t, }