Update formatting (#2585)

gherrit-pr-id: I3cca523354ce3ce6d6dcf6d5c902106f86e445a8

Author: joshlf

.github/workflows/ci.yml

@@ -676,7 +676,13 @@ jobs:
     steps:
       - uses: actions/checkout@eef61447b9ff4aafe5dcd4e0bbf5d482be7e7871 # v4.2.1
       - name: Check Rust formatting
-        run: ./ci/check_fmt.sh
+        run: |
+          set -eo pipefail
+
+          # Required by `ci/check_fmt.sh` as of this writing.
+          rustup install $(./cargo.sh --version nightly) -c rust-src,rustfmt
+
+          ./ci/check_fmt.sh
 
   check_readme:
     needs: generate_cache
@@ -804,7 +810,13 @@ jobs:
         # is `pre-push`. Running all hooks ensures that, if a new hook is added
         # which can't run in CI (at least not using this naive setup), we'll
         # notice and it will remind us to update this test.
-        run: set -e; for hook in ./githooks/*; do $hook; done
+        run: |
+          set -eo pipefail
+
+          # Required by `ci/check_fmt.sh` as of this writing.
+          rustup install $(./cargo.sh --version nightly) -c rust-src,rustfmt
+
+          for hook in ./githooks/*; do $hook; done
 
   # Used to signal to branch protections that all other jobs have succeeded.
   all-jobs-succeed:

ci/check_fmt.sh

@@ -15,4 +15,4 @@ if [[ -z $files ]]
 then
 	exit 1
 fi
-rustfmt --check $files >&2
+./cargo.sh +nightly fmt --check -- $files >&2

rustfmt.toml

@@ -6,7 +6,7 @@
 # This file may not be copied, modified, or distributed except according to
 # those terms.
 
-edition = "2021"
+edition = "2024"
 
 # The "Default" setting has a heuristic which splits lines too aggressively.
 # We are willing to revisit this setting in future versions of rustfmt.
@@ -17,3 +17,6 @@ use_small_heuristics = "Max"
 
 # Prevent carriage returns
 newline_style = "Unix"
+
+imports_granularity = "Crate"
+group_imports = "StdExternalCrate"

src/byte_slice.rs

@@ -15,9 +15,6 @@ use core::{
     ops::{Deref, DerefMut},
 };
 
-#[cfg(doc)]
-use crate::Ref;
-
 // For each trait polyfill, as soon as the corresponding feature is stable, the
 // polyfill import will be unused because method/function resolution will prefer
 // the inherent method/function over a trait method/function. Thus, we suppress
@@ -26,6 +23,8 @@ use crate::Ref;
 // See the documentation on `util::polyfills` for more information.
 #[allow(unused_imports)]
 use crate::util::polyfills::{self, NonNullExt as _, NumExt as _};
+#[cfg(doc)]
+use crate::Ref;
 
 /// A mutable or immutable reference to a byte slice.
 ///

src/error.rs

@@ -115,14 +115,13 @@
 //!         .map_err(|err| err.to_string())
 //! }).join().unwrap();
 //! ```
+#[cfg(zerocopy_core_error_1_81_0)]
+use core::error::Error;
 use core::{
     convert::Infallible,
     fmt::{self, Debug, Write},
     ops::Deref,
 };
-
-#[cfg(zerocopy_core_error_1_81_0)]
-use core::error::Error;
 #[cfg(all(not(zerocopy_core_error_1_81_0), any(feature = "std", test)))]
 use std::error::Error;
 

src/layout.rs

@@ -1289,12 +1289,13 @@ mod tests {
     #[test]
     #[cfg(__ZEROCOPY_INTERNAL_USE_ONLY_NIGHTLY_FEATURES_IN_TESTS)]
     fn test_validate_rust_layout() {
-        use crate::util::testutil::*;
         use core::{
             convert::TryInto as _,
             ptr::{self, NonNull},
         };
 
+        use crate::util::testutil::*;
+
         // This test synthesizes pointers with various metadata and uses Rust's
         // built-in APIs to confirm that Rust makes decisions about type layout
         // which are consistent with what we believe is guaranteed by the

src/lib.rs

@@ -368,13 +368,6 @@ mod split_at;
 // FIXME(#252): If we make this pub, come up with a better name.
 mod wrappers;
 
-pub use crate::byte_slice::*;
-pub use crate::byteorder::*;
-pub use crate::error::*;
-pub use crate::r#ref::*;
-pub use crate::split_at::{Split, SplitAt};
-pub use crate::wrappers::*;
-
 use core::{
     cell::{Cell, UnsafeCell},
     cmp::Ordering,
@@ -390,28 +383,34 @@ use core::{
     ptr::{self, NonNull},
     slice,
 };
-
 #[cfg(feature = "std")]
 use std::io;
 
 use crate::pointer::invariant::{self, BecauseExclusive};
+pub use crate::{
+    byte_slice::*,
+    byteorder::*,
+    error::*,
+    r#ref::*,
+    split_at::{Split, SplitAt},
+    wrappers::*,
+};
 
 #[cfg(any(feature = "alloc", test, kani))]
 extern crate alloc;
 #[cfg(any(feature = "alloc", test))]
 use alloc::{boxed::Box, vec::Vec};
-use util::MetadataOf;
-
 #[cfg(any(feature = "alloc", test))]
 use core::alloc::Layout;
 
-// Used by `TryFromBytes::is_bit_valid`.
-#[doc(hidden)]
-pub use crate::pointer::{invariant::BecauseImmutable, Maybe, Ptr};
+use util::MetadataOf;
+
 // Used by `KnownLayout`.
 #[doc(hidden)]
 pub use crate::layout::*;
-
+// Used by `TryFromBytes::is_bit_valid`.
+#[doc(hidden)]
+pub use crate::pointer::{invariant::BecauseImmutable, Maybe, Ptr};
 // For each trait polyfill, as soon as the corresponding feature is stable, the
 // polyfill import will be unused because method/function resolution will prefer
 // the inherent method/function over a trait method/function. Thus, we suppress
@@ -448,9 +447,6 @@ const _: () = {
 //
 // The "note" provides enough context to make it easy to figure out how to fix
 // the error.
-#[allow(unused)]
-use {FromZeros as FromZeroes, IntoBytes as AsBytes, Ref as LayoutVerified};
-
 /// Implements [`KnownLayout`].
 ///
 /// This derive analyzes various aspects of a type's layout that are needed for
@@ -553,6 +549,8 @@ use {FromZeros as FromZeroes, IntoBytes as AsBytes, Ref as LayoutVerified};
 #[cfg(any(feature = "derive", test))]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub use zerocopy_derive::KnownLayout;
+#[allow(unused)]
+use {FromZeros as FromZeroes, IntoBytes as AsBytes, Ref as LayoutVerified};
 
 /// Indicates that zerocopy can reason about certain aspects of a type's layout.
 ///
@@ -1165,7 +1163,6 @@ const _: () = unsafe {
 #[cfg(any(feature = "derive", test))]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub use zerocopy_derive::FromZeros;
-
 /// Analyzes whether a type is [`Immutable`].
 ///
 /// This derive analyzes, at compile time, whether the annotated type satisfies
@@ -5550,22 +5547,22 @@ pub unsafe trait Unaligned {
         Self: Sized;
 }
 
-/// Derives an optimized [`Hash`] implementation.
+/// Derives optimized [`PartialEq`] and [`Eq`] implementations.
 ///
 /// This derive can be applied to structs and enums implementing both
 /// [`Immutable`] and [`IntoBytes`]; e.g.:
 ///
 /// ```
-/// # use zerocopy_derive::{ByteHash, Immutable, IntoBytes};
-/// #[derive(ByteHash, Immutable, IntoBytes)]
+/// # use zerocopy_derive::{ByteEq, Immutable, IntoBytes};
+/// #[derive(ByteEq, Immutable, IntoBytes)]
 /// #[repr(C)]
 /// struct MyStruct {
 /// # /*
 ///     ...
 /// # */
 /// }
 ///
-/// #[derive(ByteHash, Immutable, IntoBytes)]
+/// #[derive(ByteEq, Immutable, IntoBytes)]
 /// #[repr(u8)]
 /// enum MyEnum {
 /// #   Variant,
@@ -5575,36 +5572,30 @@ pub unsafe trait Unaligned {
 /// }
 /// ```
 ///
-/// The standard library's [`derive(Hash)`][derive@Hash] produces hashes by
-/// individually hashing each field and combining the results. Instead, the
-/// implementations of [`Hash::hash()`] and [`Hash::hash_slice()`] generated by
-/// `derive(ByteHash)` convert the entirety of `self` to a byte slice and hashes
-/// it in a single call to [`Hasher::write()`]. This may have performance
-/// advantages.
-///
-/// [`Hash`]: core::hash::Hash
-/// [`Hash::hash()`]: core::hash::Hash::hash()
-/// [`Hash::hash_slice()`]: core::hash::Hash::hash_slice()
+/// The standard library's [`derive(Eq, PartialEq)`][derive@PartialEq] computes
+/// equality by individually comparing each field. Instead, the implementation
+/// of [`PartialEq::eq`] emitted by `derive(ByteHash)` converts the entirety of
+/// `self` and `other` to byte slices and compares those slices for equality.
+/// This may have performance advantages.
 #[cfg(any(feature = "derive", test))]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-pub use zerocopy_derive::ByteHash;
-
-/// Derives optimized [`PartialEq`] and [`Eq`] implementations.
+pub use zerocopy_derive::ByteEq;
+/// Derives an optimized [`Hash`] implementation.
 ///
 /// This derive can be applied to structs and enums implementing both
 /// [`Immutable`] and [`IntoBytes`]; e.g.:
 ///
 /// ```
-/// # use zerocopy_derive::{ByteEq, Immutable, IntoBytes};
-/// #[derive(ByteEq, Immutable, IntoBytes)]
+/// # use zerocopy_derive::{ByteHash, Immutable, IntoBytes};
+/// #[derive(ByteHash, Immutable, IntoBytes)]
 /// #[repr(C)]
 /// struct MyStruct {
 /// # /*
 ///     ...
 /// # */
 /// }
 ///
-/// #[derive(ByteEq, Immutable, IntoBytes)]
+/// #[derive(ByteHash, Immutable, IntoBytes)]
 /// #[repr(u8)]
 /// enum MyEnum {
 /// #   Variant,
@@ -5614,15 +5605,19 @@ pub use zerocopy_derive::ByteHash;
 /// }
 /// ```
 ///
-/// The standard library's [`derive(Eq, PartialEq)`][derive@PartialEq] computes
-/// equality by individually comparing each field. Instead, the implementation
-/// of [`PartialEq::eq`] emitted by `derive(ByteHash)` converts the entirety of
-/// `self` and `other` to byte slices and compares those slices for equality.
-/// This may have performance advantages.
+/// The standard library's [`derive(Hash)`][derive@Hash] produces hashes by
+/// individually hashing each field and combining the results. Instead, the
+/// implementations of [`Hash::hash()`] and [`Hash::hash_slice()`] generated by
+/// `derive(ByteHash)` convert the entirety of `self` to a byte slice and hashes
+/// it in a single call to [`Hasher::write()`]. This may have performance
+/// advantages.
+///
+/// [`Hash`]: core::hash::Hash
+/// [`Hash::hash()`]: core::hash::Hash::hash()
+/// [`Hash::hash_slice()`]: core::hash::Hash::hash_slice()
 #[cfg(any(feature = "derive", test))]
 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
-pub use zerocopy_derive::ByteEq;
-
+pub use zerocopy_derive::ByteHash;
 /// Implements [`SplitAt`].
 ///
 /// This derive can be applied to structs; e.g.:

src/macros.rs

@@ -1112,10 +1112,10 @@ macro_rules! cryptocorrosion_derive_traits {
 
 #[cfg(test)]
 mod tests {
-    use crate::*;
     use crate::{
         byteorder::native_endian::{U16, U32},
         util::testutil::*,
+        *,
     };
 
     #[derive(KnownLayout, Immutable, FromBytes, IntoBytes, PartialEq, Debug)]

src/pointer/inner.rs

@@ -8,6 +8,8 @@
 
 use core::{marker::PhantomData, mem, ops::Range, ptr::NonNull};
 
+pub use _def::PtrInner;
+
 #[allow(unused_imports)]
 use crate::util::polyfills::NumExt as _;
 use crate::{
@@ -16,8 +18,6 @@ use crate::{
     AlignmentError, CastError, KnownLayout, MetadataOf, SizeError, SplitAt,
 };
 
-pub use _def::PtrInner;
-
 mod _def {
     use super::*;
     /// The inner pointer stored inside a [`Ptr`][crate::Ptr].

src/pointer/ptr.rs

@@ -22,10 +22,9 @@ use crate::{
 
 /// Module used to gate access to [`Ptr`]'s fields.
 mod def {
-    use super::*;
-
     #[cfg(doc)]
     use super::super::invariant;
+    use super::*;
 
     /// A raw pointer with more restrictions.
     ///
@@ -532,9 +531,8 @@ mod _conversions {
 
 /// State transitions between invariants.
 mod _transitions {
-    use crate::pointer::transmute::TryTransmuteFromPtr;
-
     use super::*;
+    use crate::pointer::transmute::TryTransmuteFromPtr;
 
     impl<'a, T, I> Ptr<'a, T, I>
     where