Use size_of from the prelude

src/alloc.rs

@@ -468,7 +468,7 @@ impl<T: fmt::Debug> fmt::Debug for AllocOpMap<T> {
 impl ThreadAllocTallyMap {
     #[inline]
     pub const fn new() -> Self {
-        unsafe { std::mem::transmute([0u8; std::mem::size_of::<Self>()]) }
+        unsafe { std::mem::transmute([0u8; size_of::<Self>()]) }
     }
 
     /// Returns `true` if all tallies are 0.
@@ -602,7 +602,7 @@ mod tests {
 
         // Helper to create `ThreadAllocTallyMap` since each operation only
         // changes `buf` by 1 `i32`.
-        let item_tally = ThreadAllocTally { count: 1, size: std::mem::size_of::<i32>() as _ };
+        let item_tally = ThreadAllocTally { count: 1, size: size_of::<i32>() as _ };
         let make_tally_map = |op: AllocOp| {
             ThreadAllocTallyMap::from_fn(|other_op| {
                 if other_op == op {

src/bench/args.rs

@@ -212,7 +212,7 @@ where
     // This can be done multiple times without invoking a `Drop` destructor
     // because it implements `Copy`.
     let bench_impl: B = unsafe {
-        assert_eq!(mem::size_of::<B>(), 0, "benchmark closure expected to be zero-sized");
+        assert_eq!(size_of::<B>(), 0, "benchmark closure expected to be zero-sized");
         mem::zeroed()
     };
 

src/bench/mod.rs

@@ -895,7 +895,7 @@ impl<'a> BenchContext<'a> {
             let sample_start: UntaggedTimestamp;
             let sample_end: UntaggedTimestamp;
 
-            if mem::size_of::<I>() == 0 && (mem::size_of::<O>() == 0 || !mem::needs_drop::<O>()) {
+            if size_of::<I>() == 0 && (size_of::<O>() == 0 || !mem::needs_drop::<O>()) {
                 // Use a range instead of `defer_store` to make the benchmarking
                 // loop cheaper.
 
@@ -928,7 +928,7 @@ impl<'a> BenchContext<'a> {
                 // Drop outputs and inputs.
                 for _ in 0..sample_size {
                     // Output only needs drop if ZST.
-                    if mem::size_of::<O>() == 0 {
+                    if size_of::<O>() == 0 {
                         // SAFETY: Output is a ZST, so we can construct one out
                         // of thin air.
                         unsafe { _ = mem::zeroed::<O>() }

src/counter/mod.rs

@@ -25,7 +25,7 @@
 //! }
 //! ```
 
-use std::{any::Any, mem};
+use std::any::Any;
 
 mod any_counter;
 mod collection;
@@ -129,30 +129,29 @@ impl BytesCount {
         Self { count: count.into_max_uint() }
     }
 
-    /// Counts the size of a type with [`std::mem::size_of`].
+    /// Counts the size of a type with [`size_of`].
     #[inline]
     #[doc(alias = "size_of")]
     pub const fn of<T>() -> Self {
-        Self { count: mem::size_of::<T>() as MaxCountUInt }
+        Self { count: size_of::<T>() as MaxCountUInt }
     }
 
-    /// Counts the size of multiple instances of a type with
-    /// [`std::mem::size_of`].
+    /// Counts the size of multiple instances of a type with [`size_of`].
     #[inline]
     #[doc(alias = "size_of")]
     pub const fn of_many<T>(n: usize) -> Self {
-        match (mem::size_of::<T>() as MaxCountUInt).checked_mul(n as MaxCountUInt) {
+        match (size_of::<T>() as MaxCountUInt).checked_mul(n as MaxCountUInt) {
             Some(count) => Self { count },
             None => panic!("overflow"),
         }
     }
 
-    /// Counts the size of a value with [`std::mem::size_of_val`].
+    /// Counts the size of a value with [`size_of_val`].
     #[inline]
     #[doc(alias = "size_of_val")]
     pub fn of_val<T: ?Sized>(val: &T) -> Self {
         // TODO: Make const, https://github.com/rust-lang/rust/issues/46571
-        Self { count: mem::size_of_val(val) as MaxCountUInt }
+        Self { count: size_of_val(val) as MaxCountUInt }
     }
 
     /// Counts the bytes of [`Iterator::Item`s](Iterator::Item).

src/util/mod.rs

@@ -37,7 +37,7 @@ pub(crate) fn defer<F: FnOnce()>(f: F) -> impl Drop {
 #[inline]
 pub(crate) fn slice_ptr_index<T>(slice: &[T], ptr: *const T) -> usize {
     // Safe pointer `offset_from`.
-    (ptr as usize - slice.as_ptr() as usize) / std::mem::size_of::<T>()
+    (ptr as usize - slice.as_ptr() as usize) / size_of::<T>()
 }
 
 /// Returns the values in the middle of `slice`.

src/util/thread.rs

@@ -54,7 +54,7 @@ impl<T> PThreadKey<T> {
     where
         D: FnOnce(NonNull<T>) + Copy,
     {
-        assert_eq!(std::mem::size_of::<D>(), 0);
+        assert_eq!(size_of::<D>(), 0);
 
         unsafe extern "C" fn dtor<T, D>(ptr: *mut libc::c_void)
         where