fix(hashes): improve unsafe block warnings and macro cleanup

- Fix unsafe block warnings in siphash24.rs by properly wrapping unsafe operations
- Improve hash utility functions with better variable naming ($generator instead of $gen)
- Remove unused import in internal_macros.rs for bincode feature

These changes address compiler warnings about unsafe operations and improve
code clarity without changing functionality.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: 2 people

hashes/src/internal_macros.rs

@@ -160,7 +160,6 @@ macro_rules! hash_trait_impls {
         #[cfg(feature = "bincode")]
         impl<'de, $($gen: $gent),*> bincode::BorrowDecode<'de> for Hash<$($gen),*> {
             fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, bincode::error::DecodeError> {
-                use crate::Hash;
                 use std::convert::TryInto;
                 // Decode a borrowed reference to a byte slice
                 let bytes: &[u8] = bincode::BorrowDecode::borrow_decode(decoder)?;

hashes/src/siphash24.rs

@@ -73,11 +73,13 @@ macro_rules! load_int_le {
     ($buf:expr, $i:expr, $int_ty:ident) => {{
         debug_assert!($i + mem::size_of::<$int_ty>() <= $buf.len());
         let mut data = 0 as $int_ty;
-        ptr::copy_nonoverlapping(
-            $buf.get_unchecked($i),
-            &mut data as *mut _ as *mut u8,
-            mem::size_of::<$int_ty>(),
-        );
+        unsafe {
+            ptr::copy_nonoverlapping(
+                $buf.get_unchecked($i),
+                &mut data as *mut _ as *mut u8,
+                mem::size_of::<$int_ty>(),
+            );
+        }
         data.to_le()
     }};
 }
@@ -269,7 +271,7 @@ unsafe fn u8to64_le(buf: &[u8], start: usize, len: usize) -> u64 {
         i += 2
     }
     if i < len {
-        out |= u64::from(*buf.get_unchecked(start + i)) << (i * 8);
+        out |= u64::from(unsafe { *buf.get_unchecked(start + i) }) << (i * 8);
         i += 1;
     }
     debug_assert_eq!(i, len);

hashes/src/util.rs

@@ -18,8 +18,8 @@ macro_rules! hex_fmt_impl(
     ($reverse:expr, $ty:ident) => (
         $crate::hex_fmt_impl!($reverse, $ty, );
     );
-    ($reverse:expr, $ty:ident, $($gen:ident: $gent:ident),*) => (
-        impl<$($gen: $gent),*> $crate::_export::_core::fmt::LowerHex for $ty<$($gen),*> {
+    ($reverse:expr, $ty:ident, $($generator:ident: $gent:ident),*) => (
+        impl<$($generator: $gent),*> $crate::_export::_core::fmt::LowerHex for $ty<$($generator),*> {
             #[inline]
             fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
                 if $reverse {
@@ -30,7 +30,7 @@ macro_rules! hex_fmt_impl(
             }
         }
 
-        impl<$($gen: $gent),*> $crate::_export::_core::fmt::UpperHex for $ty<$($gen),*> {
+        impl<$($generator: $gent),*> $crate::_export::_core::fmt::UpperHex for $ty<$($generator),*> {
             #[inline]
             fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
                 if $reverse {
@@ -41,14 +41,14 @@ macro_rules! hex_fmt_impl(
             }
         }
 
-        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Display for $ty<$($gen),*> {
+        impl<$($generator: $gent),*> $crate::_export::_core::fmt::Display for $ty<$($generator),*> {
             #[inline]
             fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
                 $crate::_export::_core::fmt::LowerHex::fmt(&self, f)
             }
         }
 
-        impl<$($gen: $gent),*> $crate::_export::_core::fmt::Debug for $ty<$($gen),*> {
+        impl<$($generator: $gent),*> $crate::_export::_core::fmt::Debug for $ty<$($generator),*> {
             #[inline]
             fn fmt(&self, f: &mut $crate::_export::_core::fmt::Formatter) -> $crate::_export::_core::fmt::Result {
                 write!(f, "{:#}", self)
@@ -63,14 +63,14 @@ macro_rules! borrow_slice_impl(
     ($ty:ident) => (
         $crate::borrow_slice_impl!($ty, );
     );
-    ($ty:ident, $($gen:ident: $gent:ident),*) => (
-        impl<$($gen: $gent),*> $crate::_export::_core::borrow::Borrow<[u8]> for $ty<$($gen),*>  {
+    ($ty:ident, $($generator:ident: $gent:ident),*) => (
+        impl<$($generator: $gent),*> $crate::_export::_core::borrow::Borrow<[u8]> for $ty<$($generator),*>  {
             fn borrow(&self) -> &[u8] {
                 &self[..]
             }
         }
 
-        impl<$($gen: $gent),*> $crate::_export::_core::convert::AsRef<[u8]> for $ty<$($gen),*>  {
+        impl<$($generator: $gent),*> $crate::_export::_core::convert::AsRef<[u8]> for $ty<$($generator),*>  {
             fn as_ref(&self) -> &[u8] {
                 &self[..]
             }