style: refactor import layout

.rustfmt.toml

@@ -0,0 +1 @@
+imports_layout = "Vertical"

benches/bench.rs

@@ -1,6 +1,9 @@
 #![expect(missing_docs)] // criterion_group! generates a public bench entrypoint
 
-use criterion::{criterion_group, criterion_main};
+use criterion::{
+    criterion_group,
+    criterion_main,
+};
 
 mod general_ops;
 mod insert_unique_unchecked;

benches/general_ops.rs

@@ -2,13 +2,21 @@
 //! * Hasher: std default (SipHash) and crate default (foldhash).
 //! * Int key distribution: low bit heavy, top bit heavy, and random.
 //! * Task: basic functionality: insert, insert_erase, lookup, lookup_fail, iter
-use criterion::Criterion;
-use hashbrown::DefaultHashBuilder;
-use hashbrown::{HashMap, HashSet};
+
 use std::{
     hash::RandomState,
     hint::black_box,
-    sync::atomic::{self, AtomicUsize},
+    sync::atomic::{
+        self,
+        AtomicUsize,
+    },
+};
+
+use criterion::Criterion;
+use hashbrown::{
+    DefaultHashBuilder,
+    HashMap,
+    HashSet,
 };
 
 const SIZE: usize = 1000;

benches/insert_unique_unchecked.rs

@@ -1,7 +1,9 @@
 //! Compare `insert` and `insert_unique_unchecked` operations performance.
+
+use std::hint::black_box;
+
 use criterion::Criterion;
 use hashbrown::HashMap;
-use std::hint::black_box;
 
 pub(crate) fn register_benches(c: &mut Criterion) {
     let keys: Vec<String> = (0..1000).map(|i| format!("xxxx{i}yyyy")).collect();

benches/set_ops.rs

@@ -4,6 +4,7 @@
 //!
 //! Each assigning test is done in the configuration that is faster. Cheating, I know.
 //! The exception to this is Sub, because there the result differs. So I made two benchmarks for Sub.
+
 use criterion::Criterion;
 use hashbrown::HashSet;
 

benches/with_capacity.rs

@@ -1,6 +1,7 @@
+use std::hint::black_box;
+
 use criterion::Criterion;
 use hashbrown::HashMap;
-use std::hint::black_box;
 
 type Map<K, V> = HashMap<K, V>;
 

src/alloc.rs

@@ -1,18 +1,28 @@
 #[cfg(test)]
 pub(crate) use self::inner::AllocError;
-pub(crate) use self::inner::{Allocator, Global, do_alloc};
+pub(crate) use self::inner::{
+    Allocator,
+    Global,
+    do_alloc,
+};
 
 // Nightly-case.
 // Use unstable `allocator_api` feature.
 // This is compatible with `allocator-api2` which can be enabled or not.
 // This is used when building for `std`.
 #[cfg(feature = "nightly")]
 mod inner {
-    use core::alloc::Layout;
-    use core::ptr::NonNull;
+    use core::{
+        alloc::Layout,
+        ptr::NonNull,
+    };
+
     #[cfg(test)]
     pub(crate) use stdalloc::alloc::AllocError;
-    pub(crate) use stdalloc::alloc::{Allocator, Global};
+    pub(crate) use stdalloc::alloc::{
+        Allocator,
+        Global,
+    };
 
     pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<[u8]>, ()> {
         match alloc.allocate(layout) {
@@ -30,11 +40,17 @@ mod inner {
 // `core::alloc::Allocator`.
 #[cfg(all(not(feature = "nightly"), feature = "allocator-api2"))]
 mod inner {
+    use core::{
+        alloc::Layout,
+        ptr::NonNull,
+    };
+
     #[cfg(test)]
     pub(crate) use allocator_api2::alloc::AllocError;
-    pub(crate) use allocator_api2::alloc::{Allocator, Global};
-    use core::alloc::Layout;
-    use core::ptr::NonNull;
+    pub(crate) use allocator_api2::alloc::{
+        Allocator,
+        Global,
+    };
 
     pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<[u8]>, ()> {
         match alloc.allocate(layout) {
@@ -54,9 +70,15 @@ mod inner {
 // or `nightly` without disturbing users that don't want to use it.
 #[cfg(not(any(feature = "nightly", feature = "allocator-api2")))]
 mod inner {
-    use core::alloc::Layout;
-    use core::ptr::NonNull;
-    use stdalloc::alloc::{alloc, dealloc};
+    use core::{
+        alloc::Layout,
+        ptr::NonNull,
+    };
+
+    use stdalloc::alloc::{
+        alloc,
+        dealloc,
+    };
 
     #[expect(clippy::missing_safety_doc)] // not exposed outside of this crate
     pub unsafe trait Allocator {

src/control/bitmask.rs

@@ -1,4 +1,9 @@
-use super::group::{BITMASK_ITER_MASK, BITMASK_STRIDE, BitMaskWord, NonZeroBitMaskWord};
+use super::group::{
+    BITMASK_ITER_MASK,
+    BITMASK_STRIDE,
+    BitMaskWord,
+    NonZeroBitMaskWord,
+};
 
 /// A bit mask which contains the result of a `Match` operation on a `Group` and
 /// allows iterating through them.

src/control/group/generic.rs

@@ -1,6 +1,10 @@
-use super::super::{BitMask, Tag};
 use core::ptr;
 
+use super::super::{
+    BitMask,
+    Tag,
+};
+
 // Use the native word size as the group size. Using a 64-bit group size on
 // a 32-bit architecture will just end up being more expensive because
 // shifts and multiplies will need to be emulated.

src/control/group/lsx.rs

@@ -1,7 +1,12 @@
-use super::super::{BitMask, Tag};
-use core::num::NonZeroU16;
+use core::{
+    arch::loongarch64::*,
+    num::NonZeroU16,
+};
 
-use core::arch::loongarch64::*;
+use super::super::{
+    BitMask,
+    Tag,
+};
 
 pub(crate) type BitMaskWord = u16;
 pub(crate) type NonZeroBitMaskWord = NonZeroU16;

src/control/group/mod.rs

@@ -49,4 +49,9 @@ cfg_select! {
     }
 }
 pub(crate) use self::imp::Group;
-pub(super) use self::imp::{BITMASK_ITER_MASK, BITMASK_STRIDE, BitMaskWord, NonZeroBitMaskWord};
+pub(super) use self::imp::{
+    BITMASK_ITER_MASK,
+    BITMASK_STRIDE,
+    BitMaskWord,
+    NonZeroBitMaskWord,
+};

src/control/group/neon.rs

@@ -1,6 +1,12 @@
-use super::super::{BitMask, Tag};
-use core::arch::aarch64 as neon;
-use core::num::NonZeroU64;
+use core::{
+    arch::aarch64 as neon,
+    num::NonZeroU64,
+};
+
+use super::super::{
+    BitMask,
+    Tag,
+};
 
 pub(crate) type BitMaskWord = u64;
 pub(crate) type NonZeroBitMaskWord = NonZeroU64;

src/control/group/sse2.rs

@@ -1,10 +1,13 @@
-use super::super::{BitMask, Tag};
-use core::num::NonZeroU16;
-
 #[cfg(target_arch = "x86")]
 use core::arch::x86;
 #[cfg(target_arch = "x86_64")]
 use core::arch::x86_64 as x86;
+use core::num::NonZeroU16;
+
+use super::super::{
+    BitMask,
+    Tag,
+};
 
 pub(crate) type BitMaskWord = u16;
 pub(crate) type NonZeroBitMaskWord = NonZeroU16;

src/control/mod.rs

@@ -6,5 +6,8 @@ use self::bitmask::BitMask;
 pub(crate) use self::{
     bitmask::BitMaskIter,
     group::Group,
-    tag::{Tag, TagSliceExt},
+    tag::{
+        Tag,
+        TagSliceExt,
+    },
 };

src/control/tag.rs

@@ -1,4 +1,7 @@
-use core::{fmt, mem};
+use core::{
+    fmt,
+    mem,
+};
 
 /// Single tag in a control group.
 #[derive(Copy, Clone, PartialEq, Eq)]

src/external_trait_impls/rayon/helpers.rs

@@ -1,7 +1,10 @@
 use stdalloc::collections::LinkedList;
 use stdalloc::vec::Vec;
 
-use rayon::iter::{IntoParallelIterator, ParallelIterator};
+use rayon::iter::{
+    IntoParallelIterator,
+    ParallelIterator,
+};
 
 /// Helper for collecting parallel iterators to an intermediary
 #[expect(clippy::linkedlist)] // yes, we need linked list here for efficient appending!

src/external_trait_impls/rayon/map.rs

@@ -1,13 +1,35 @@
 //! Rayon extensions for `HashMap`.
 
-use super::raw::{RawIntoParIter, RawParDrain, RawParIter};
-use crate::HashMap;
-use crate::alloc::{Allocator, Global};
-use core::fmt;
-use core::hash::{BuildHasher, Hash};
-use core::marker::PhantomData;
-use rayon::iter::plumbing::UnindexedConsumer;
-use rayon::iter::{FromParallelIterator, IntoParallelIterator, ParallelExtend, ParallelIterator};
+use core::{
+    fmt,
+    hash::{
+        BuildHasher,
+        Hash,
+    },
+    marker::PhantomData,
+};
+
+use rayon::iter::{
+    FromParallelIterator,
+    IntoParallelIterator,
+    ParallelExtend,
+    ParallelIterator,
+    plumbing::UnindexedConsumer,
+};
+
+use crate::{
+    HashMap,
+    alloc::{
+        Allocator,
+        Global,
+    },
+};
+
+use super::raw::{
+    RawIntoParIter,
+    RawParDrain,
+    RawParIter,
+};
 
 /// Parallel iterator over shared references to entries in a map.
 ///
@@ -456,11 +478,19 @@ where
 
 #[cfg(test)]
 mod test_par_map {
-    use core::hash::{Hash, Hasher};
-    use core::sync::atomic::{AtomicUsize, Ordering};
-    use stdalloc::vec::Vec;
+    use core::{
+        hash::{
+            Hash,
+            Hasher,
+        },
+        sync::atomic::{
+            AtomicUsize,
+            Ordering,
+        },
+    };
 
     use rayon::prelude::*;
+    use stdalloc::vec::Vec;
 
     use crate::HashMap;
 

src/external_trait_impls/rayon/raw.rs

@@ -1,12 +1,31 @@
-use crate::alloc::{Allocator, Global};
-use crate::raw::{Bucket, RawIter, RawIterRange, RawTable};
-use crate::scopeguard::guard;
-use core::marker::PhantomData;
-use core::mem;
-use core::ptr::NonNull;
+use core::{
+    marker::PhantomData,
+    mem,
+    ptr::NonNull,
+};
+
 use rayon::iter::{
     ParallelIterator,
-    plumbing::{self, Folder, UnindexedConsumer, UnindexedProducer},
+    plumbing::{
+        self,
+        Folder,
+        UnindexedConsumer,
+        UnindexedProducer,
+    },
+};
+
+use crate::{
+    alloc::{
+        Allocator,
+        Global,
+    },
+    raw::{
+        Bucket,
+        RawIter,
+        RawIterRange,
+        RawTable,
+    },
+    scopeguard::guard,
 };
 
 /// Parallel iterator which returns a raw pointer to every full bucket in the table.