Use u32 to represent most flags and enum types. (#701)

This makes the types consistent between the linux_raw and libc backends.
And, using unsigned types for flags is more idiomatic for Rust.

To avoid the risk of `as` silently casting away bits, introduce new
`bitcast` and `bitflags_bits` macros which convert their argument to the
needed integer type while only changing its signedness interpretation.

Author: sunfishcode

src/backend/libc/event/epoll.rs

@@ -87,62 +87,64 @@ use core::slice;
 
 bitflags! {
     /// `EPOLL_*` for use with [`new`].
+    #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct CreateFlags: c::c_int {
+    pub struct CreateFlags: u32 {
         /// `EPOLL_CLOEXEC`
-        const CLOEXEC = c::EPOLL_CLOEXEC;
+        const CLOEXEC = bitcast!(c::EPOLL_CLOEXEC);
     }
 }
 
 bitflags! {
     /// `EPOLL*` for use with [`add`].
+    #[repr(transparent)]
     #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct EventFlags: u32 {
         /// `EPOLLIN`
-        const IN = c::EPOLLIN as u32;
+        const IN = bitcast!(c::EPOLLIN);
 
         /// `EPOLLOUT`
-        const OUT = c::EPOLLOUT as u32;
+        const OUT = bitcast!(c::EPOLLOUT);
 
         /// `EPOLLPRI`
-        const PRI = c::EPOLLPRI as u32;
+        const PRI = bitcast!(c::EPOLLPRI);
 
         /// `EPOLLERR`
-        const ERR = c::EPOLLERR as u32;
+        const ERR = bitcast!(c::EPOLLERR);
 
         /// `EPOLLHUP`
-        const HUP = c::EPOLLHUP as u32;
+        const HUP = bitcast!(c::EPOLLHUP);
 
         /// `EPOLLRDNORM`
-        const RDNORM = c::EPOLLRDNORM as u32;
+        const RDNORM = bitcast!(c::EPOLLRDNORM);
 
         /// `EPOLLRDBAND`
-        const RDBAND = c::EPOLLRDBAND as u32;
+        const RDBAND = bitcast!(c::EPOLLRDBAND);
 
         /// `EPOLLWRNORM`
-        const WRNORM = c::EPOLLWRNORM as u32;
+        const WRNORM = bitcast!(c::EPOLLWRNORM);
 
         /// `EPOLLWRBAND`
-        const WRBAND = c::EPOLLWRBAND as u32;
+        const WRBAND = bitcast!(c::EPOLLWRBAND);
 
         /// `EPOLLMSG`
-        const MSG = c::EPOLLMSG as u32;
+        const MSG = bitcast!(c::EPOLLMSG);
 
         /// `EPOLLRDHUP`
-        const RDHUP = c::EPOLLRDHUP as u32;
+        const RDHUP = bitcast!(c::EPOLLRDHUP);
 
         /// `EPOLLET`
-        const ET = c::EPOLLET as u32;
+        const ET = bitcast!(c::EPOLLET);
 
         /// `EPOLLONESHOT`
-        const ONESHOT = c::EPOLLONESHOT as u32;
+        const ONESHOT = bitcast!(c::EPOLLONESHOT);
 
         /// `EPOLLWAKEUP`
-        const WAKEUP = c::EPOLLWAKEUP as u32;
+        const WAKEUP = bitcast!(c::EPOLLWAKEUP);
 
         /// `EPOLLEXCLUSIVE`
         #[cfg(not(target_os = "android"))]
-        const EXCLUSIVE = c::EPOLLEXCLUSIVE as u32;
+        const EXCLUSIVE = bitcast!(c::EPOLLEXCLUSIVE);
     }
 }
 
@@ -155,7 +157,7 @@ bitflags! {
 pub fn create(flags: CreateFlags) -> io::Result<OwnedFd> {
     // SAFETY: We're calling `epoll_create1` via FFI and we know how it
     // behaves.
-    unsafe { ret_owned_fd(c::epoll_create1(flags.bits())) }
+    unsafe { ret_owned_fd(c::epoll_create1(bitflags_bits!(flags))) }
 }
 
 /// `epoll_ctl(self, EPOLL_CTL_ADD, data, event)`—Adds an element to an

src/backend/libc/event/poll_fd.rs

@@ -13,6 +13,7 @@ bitflags! {
     /// `POLL*` flags for use with [`poll`].
     ///
     /// [`poll`]: crate::io::poll
+    #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct PollFlags: c::c_short {
         /// `POLLIN`

src/backend/libc/event/syscalls.rs

@@ -31,7 +31,7 @@ pub(crate) fn eventfd(initval: u32, flags: EventfdFlags) -> io::Result<OwnedFd>
 
     #[cfg(any(target_os = "freebsd", target_os = "illumos"))]
     unsafe {
-        ret_owned_fd(c::eventfd(initval, flags.bits()))
+        ret_owned_fd(c::eventfd(initval, bitflags_bits!(flags)))
     }
 }
 

src/backend/libc/event/types.rs

@@ -6,13 +6,14 @@ bitflags! {
     /// `EFD_*` flags for use with [`eventfd`].
     ///
     /// [`eventfd`]: crate::io::eventfd
+    #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct EventfdFlags: c::c_int {
+    pub struct EventfdFlags: u32 {
         /// `EFD_CLOEXEC`
-        const CLOEXEC = c::EFD_CLOEXEC;
+        const CLOEXEC = bitcast!(c::EFD_CLOEXEC);
         /// `EFD_NONBLOCK`
-        const NONBLOCK = c::EFD_NONBLOCK;
+        const NONBLOCK = bitcast!(c::EFD_NONBLOCK);
         /// `EFD_SEMAPHORE`
-        const SEMAPHORE = c::EFD_SEMAPHORE;
+        const SEMAPHORE = bitcast!(c::EFD_SEMAPHORE);
     }
 }

src/backend/libc/fs/inotify.rs

@@ -10,19 +10,21 @@ bitflags! {
     /// `IN_*` for use with [`inotify_init`].
     ///
     /// [`inotify_init`]: crate::fs::inotify::inotify_init
+    #[repr(transparent)]
     #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-    pub struct CreateFlags: c::c_int {
+    pub struct CreateFlags: u32 {
         /// `IN_CLOEXEC`
-        const CLOEXEC = c::IN_CLOEXEC;
+        const CLOEXEC = bitcast!(c::IN_CLOEXEC);
         /// `IN_NONBLOCK`
-        const NONBLOCK = c::IN_NONBLOCK;
+        const NONBLOCK = bitcast!(c::IN_NONBLOCK);
     }
 }
 
 bitflags! {
     /// `IN*` for use with [`inotify_add_watch`].
     ///
     /// [`inotify_add_watch`]: crate::fs::inotify::inotify_add_watch
+    #[repr(transparent)]
     #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
     pub struct WatchFlags: u32 {
         /// `IN_ACCESS`
@@ -79,7 +81,7 @@ bitflags! {
 #[doc(alias = "inotify_init1")]
 pub fn inotify_init(flags: CreateFlags) -> io::Result<OwnedFd> {
     // SAFETY: `inotify_init1` has no safety preconditions.
-    unsafe { ret_owned_fd(c::inotify_init1(flags.bits())) }
+    unsafe { ret_owned_fd(c::inotify_init1(bitflags_bits!(flags))) }
 }
 
 /// `inotify_add_watch(self, path, flags)`—Adds a watch to inotify