Remove extra traits

Cargo.toml

@@ -17,7 +17,7 @@ Raw FFI bindings to platform libraries like libc.
 rust-version = "1.71.0"
 
 [package.metadata.docs.rs]
-features = ["const-extern-fn", "extra_traits"]
+features = ["const-extern-fn"]
 default-target = "x86_64-unknown-linux-gnu"
 targets = [
     "aarch64-apple-darwin",
@@ -138,7 +138,6 @@ default = ["std"]
 std = []
 align = []
 rustc-dep-of-std = ['align', 'rustc-std-workspace-core']
-extra_traits = []
 const-extern-fn = []
 
 [workspace]

README.md

@@ -40,9 +40,6 @@ libc = "0.2"
   feature to remove this dependency and be able to use `libc` in `#![no_std]`
   crates.
 
-* `extra_traits`: all `struct`s implemented in `libc` are `Copy` and `Clone`.
-  This feature derives `Debug`, `Eq`, `Hash`, and `PartialEq`.
-
 * `const-extern-fn`: Changes some `extern fn`s into `const extern fn`s.
   If you use Rust >= 1.62, this feature is implicitly enabled.
   Otherwise it requires a nightly rustc.

ci/build.sh

@@ -56,16 +56,6 @@ test_target() {
             -Z build-std=core,alloc -vv --target "${TARGET}"
     fi
 
-    # Test that libc builds with the `extra_traits` feature
-    if [ "${NO_STD}" != "1" ]; then
-        cargo "+${RUST}" "${BUILD_CMD}" -vv --no-default-features --target "${TARGET}" \
-            --features extra_traits
-    else
-        RUSTFLAGS="-A improper_ctypes_definitions" cargo "+${RUST}" "${BUILD_CMD}" \
-            -Z build-std=core,alloc -vv --no-default-features \
-            --target "${TARGET}" --features extra_traits
-    fi
-
     # Test the 'const-extern-fn' feature on nightly
     if [ "${RUST}" = "nightly" ]; then
         if [ "${NO_STD}" != "1" ]; then
@@ -77,16 +67,6 @@ test_target() {
                 --target "${TARGET}" --features const-extern-fn
         fi
     fi
-
-    # Also test that it builds with `extra_traits` and default features:
-    if [ "$NO_STD" != "1" ]; then
-        cargo "+${RUST}" "${BUILD_CMD}" -vv --target "${TARGET}" \
-            --features extra_traits
-    else
-        RUSTFLAGS="-A improper_ctypes_definitions" cargo "+${RUST}" "${BUILD_CMD}" \
-            -Z build-std=core,alloc -vv --target "${TARGET}" \
-            --features extra_traits
-    fi
 }
 
 RUST_LINUX_TARGETS="\

ci/run.sh

@@ -101,7 +101,7 @@ if [ "$TARGET" = "s390x-unknown-linux-gnu" ]; then
         continue
       fi
     elif [ "$passed" = "2" ]; then
-      if cargo test --features extra_traits --manifest-path libc-test/Cargo.toml --target "${TARGET}" ${LIBC_CI_ZBUILD_STD+"-Zbuild-std"}; then
+      if cargo test --manifest-path libc-test/Cargo.toml --target "${TARGET}" ${LIBC_CI_ZBUILD_STD+"-Zbuild-std"}; then
         break
       fi
     fi
@@ -114,6 +114,6 @@ else
 
   cargo test --manifest-path libc-test/Cargo.toml --target "${TARGET}" ${LIBC_CI_ZBUILD_STD+"-Zbuild-std"}
 
-  RUST_BACKTRACE=1 cargo test --features extra_traits --manifest-path libc-test/Cargo.toml \
+  RUST_BACKTRACE=1 cargo test --manifest-path libc-test/Cargo.toml \
     --target "${TARGET}" ${LIBC_CI_ZBUILD_STD+"-Zbuild-std"}
 fi

ci/style.rs

@@ -97,7 +97,6 @@ enum State {
 
 fn check_style(file: &str, path: &Path, err: &mut Errors) {
     let mut state = State::Start;
-    let mut s_macros = 0;
     let mut f_macros = 0;
     let mut in_impl = false;
 
@@ -140,9 +139,6 @@ fn check_style(file: &str, path: &Path, err: &mut Errors) {
         } else if line.starts_with("type ") && !in_impl {
             State::Typedefs
         } else if line.starts_with("s! {") {
-            s_macros += 1;
-            State::Structs
-        } else if line.starts_with("s_no_extra_traits! {") {
             // multiple macros of this type are allowed
             State::Structs
         } else if line.starts_with("s_paren! {") {
@@ -175,10 +171,6 @@ fn check_style(file: &str, path: &Path, err: &mut Errors) {
             f_macros += 1;
             err.error(path, i, "multiple f! macros in one module");
         }
-        if s_macros == 2 {
-            s_macros += 1;
-            err.error(path, i, "multiple s! macros in one module");
-        }
 
         state = line_state;
     }

libc-test/Cargo.toml

@@ -24,7 +24,6 @@ ctest2 = "0.4.3"
 default = ["std"]
 std = ["libc/std"]
 align = ["libc/align"]
-extra_traits = ["libc/extra_traits"]
 
 [[test]]
 name = "main"

src/fuchsia/align.rs

@@ -29,9 +29,7 @@ macro_rules! expand_align {
             pub struct pthread_condattr_t {
                 size: [u8; ::__SIZEOF_PTHREAD_CONDATTR_T],
             }
-        }
 
-        s_no_extra_traits! {
             #[cfg_attr(all(target_pointer_width = "32",
                            any(target_arch = "arm",
                                target_arch = "x86_64")),
@@ -68,75 +66,5 @@ macro_rules! expand_align {
                 size: [u8; ::__SIZEOF_PTHREAD_COND_T],
             }
         }
-
-        cfg_if! {
-            if #[cfg(feature = "extra_traits")] {
-                impl PartialEq for pthread_cond_t {
-                    fn eq(&self, other: &pthread_cond_t) -> bool {
-                        self.size
-                            .iter()
-                            .zip(other.size.iter())
-                            .all(|(a,b)| a == b)
-                    }
-                }
-                impl Eq for pthread_cond_t {}
-                impl ::fmt::Debug for pthread_cond_t {
-                    fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
-                        f.debug_struct("pthread_cond_t")
-                            // FIXME: .field("size", &self.size)
-                            .finish()
-                    }
-                }
-                impl ::hash::Hash for pthread_cond_t {
-                    fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
-                        self.size.hash(state);
-                    }
-                }
-
-                impl PartialEq for pthread_mutex_t {
-                    fn eq(&self, other: &pthread_mutex_t) -> bool {
-                        self.size
-                            .iter()
-                            .zip(other.size.iter())
-                            .all(|(a,b)| a == b)
-                    }
-                }
-                impl Eq for pthread_mutex_t {}
-                impl ::fmt::Debug for pthread_mutex_t {
-                    fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
-                        f.debug_struct("pthread_mutex_t")
-                            // FIXME: .field("size", &self.size)
-                            .finish()
-                    }
-                }
-                impl ::hash::Hash for pthread_mutex_t {
-                    fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
-                        self.size.hash(state);
-                    }
-                }
-
-                impl PartialEq for pthread_rwlock_t {
-                    fn eq(&self, other: &pthread_rwlock_t) -> bool {
-                        self.size
-                            .iter()
-                            .zip(other.size.iter())
-                            .all(|(a,b)| a == b)
-                    }
-                }
-                impl Eq for pthread_rwlock_t {}
-                impl ::fmt::Debug for pthread_rwlock_t {
-                    fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
-                        f.debug_struct("pthread_rwlock_t")
-                            // FIXME: .field("size", &self.size)
-                            .finish()
-                    }
-                }
-                impl ::hash::Hash for pthread_rwlock_t {
-                    fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
-                        self.size.hash(state);
-                    }
-                }
-            }
-        }
     };
 }