Merge pull request #84 from DCG-Claude/feat/hashes-module-updates

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

Author: PastaPastaPasta

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()
     }};
 }
@@ -191,7 +193,7 @@ impl crate::HashEngine for HashEngine {
 
         let mut i = needed;
         while i < len - left {
-            let mi = unsafe { load_int_le!(msg, i, u64) };
+            let mi = load_int_le!(msg, i, u64);
 
             self.state.v3 ^= mi;
             HashEngine::c_rounds(&mut self.state);
@@ -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[..]
             }
@@ -588,8 +588,8 @@ pub mod json_hex_string {
     use schemars::schema::{Schema, SchemaObject};
     macro_rules! define_custom_hex {
         ($name:ident, $len:expr) => {
-            pub fn $name(gen: &mut SchemaGenerator) -> Schema {
-                let mut schema: SchemaObject = <String>::json_schema(gen).into();
+            pub fn $name(generator: &mut SchemaGenerator) -> Schema {
+                let mut schema: SchemaObject = <String>::json_schema(generator).into();
                 schema.string = Some(Box::new(schemars::schema::StringValidation {
                     max_length: Some($len * 2),
                     min_length: Some($len * 2),