Remove Index implementations

The `Index` trait is not required if we provide the `AsRef` trait. Users
can just call `as_ref()[0]` to get access to the 0th element of a `Hash`.

For times when we take a reference to the whole slice `[..]` using
`as_ref()` is capable and arguably more ergonomic.

From the `Hash` trait remove the trait bound on `Index` and its
associated traits, instead use the trait bound `AsRef` (we already have
a trait bound of `Borrow`).

Fix all uses of `foo[..]` -> `foo.as_ref()`.

Author: tcharding

fuzz/fuzz_targets/ripemd160.rs

@@ -15,7 +15,7 @@ fn do_test(data: &[u8]) {
     rc_engine.input(data);
     rc_engine.result(&mut rc_hash);
 
-    assert_eq!(&our_hash[..], &rc_hash[..]);
+    assert_eq!(our_hash.as_ref(), rc_hash.as_ref());
 }
 
 #[cfg(feature = "honggfuzz")]

fuzz/fuzz_targets/sha1.rs

@@ -15,7 +15,7 @@ fn do_test(data: &[u8]) {
     rc_sha1.input(data);
     rc_sha1.result(&mut rc_hash);
 
-    assert_eq!(&our_hash[..], &rc_hash[..]);
+    assert_eq!(our_hash.as_ref(), rc_hash.as_ref());
 }
 
 #[cfg(feature = "honggfuzz")]

fuzz/fuzz_targets/sha256.rs

@@ -15,7 +15,7 @@ fn do_test(data: &[u8]) {
     rc_engine.input(data);
     rc_engine.result(&mut rc_hash);
 
-    assert_eq!(&our_hash[..], &rc_hash[..]);
+    assert_eq!(our_hash.as_ref(), rc_hash.as_ref());
 }
 
 #[cfg(feature = "honggfuzz")]

fuzz/fuzz_targets/sha512.rs

@@ -15,7 +15,7 @@ fn do_test(data: &[u8]) {
     rc_engine.input(data);
     rc_engine.result(&mut rc_hash);
 
-    assert_eq!(&our_hash[..], &rc_hash[..]);
+    assert_eq!(our_hash.as_ref(), rc_hash.as_ref());
 }
 
 #[cfg(feature = "honggfuzz")]

src/hash160.rs

@@ -21,8 +21,6 @@
 //!
 
 use core::str;
-use core::ops::Index;
-use core::slice::SliceIndex;
 
 use crate::{Error, hex, ripemd160, sha256};
 
@@ -41,15 +39,6 @@ hex_fmt_impl!(LowerHex, Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash);
 
-impl<I: SliceIndex<[u8]>> Index<I> for Hash {
-    type Output = I::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        &self.0[index]
-    }
-}
-
 impl str::FromStr for Hash {
     type Err = hex::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -67,10 +56,10 @@ impl crate::Hash for Hash {
 
     fn from_engine(e: sha256::HashEngine) -> Hash {
         let sha2 = sha256::Hash::from_engine(e);
-        let rmd = ripemd160::Hash::hash(&sha2[..]);
+        let rmd = ripemd160::Hash::hash(sha2.as_ref());
 
         let mut ret = [0; 20];
-        ret.copy_from_slice(&rmd[..]);
+        ret.copy_from_slice(rmd.as_ref());
         Hash(ret)
     }
 
@@ -145,7 +134,7 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = hash160::Hash::hash(&test.input[..]);
             assert_eq!(hash, hash160::Hash::from_hex(test.output_str).expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash.as_ref(), &test.output[..]);
             assert_eq!(&hash.to_hex(), &test.output_str);
 
             // Hash through engine, checking that we can input byte by byte

src/hmac.rs

@@ -20,7 +20,7 @@
 //! Hash-based Message Authentication Code (HMAC).
 //!
 
-use core::{borrow, fmt, ops, str};
+use core::{borrow, convert, fmt, str};
 #[cfg(feature = "serde")]
 use serde::{Serialize, Serializer, Deserialize, Deserializer};
 
@@ -81,10 +81,10 @@ impl<T: Hash> HmacEngine<T> {
 
         if key.len() > T::Engine::BLOCK_SIZE {
             let hash = <T as Hash>::hash(key);
-            for (b_i, b_h) in ipad.iter_mut().zip(&hash[..]) {
+            for (b_i, b_h) in ipad.iter_mut().zip(hash.as_ref()) {
                 *b_i ^= *b_h;
             }
-            for (b_o, b_h) in opad.iter_mut().zip(&hash[..]) {
+            for (b_o, b_h) in opad.iter_mut().zip(hash.as_ref()) {
                 *b_o ^= *b_h;
             }
         } else {
@@ -149,44 +149,15 @@ impl<T: Hash> fmt::LowerHex for Hmac<T> {
     }
 }
 
-impl<T: Hash> ops::Index<usize> for Hmac<T> {
-    type Output = u8;
-    fn index(&self, index: usize) -> &u8 {
-        &self.0[index]
-    }
-}
-
-impl<T: Hash> ops::Index<ops::Range<usize>> for Hmac<T> {
-    type Output = [u8];
-    fn index(&self, index: ops::Range<usize>) -> &[u8] {
-        &self.0[index]
-    }
-}
-
-impl<T: Hash> ops::Index<ops::RangeFrom<usize>> for Hmac<T> {
-    type Output = [u8];
-    fn index(&self, index: ops::RangeFrom<usize>) -> &[u8] {
-        &self.0[index]
-    }
-}
-
-impl<T: Hash> ops::Index<ops::RangeTo<usize>> for Hmac<T> {
-    type Output = [u8];
-    fn index(&self, index: ops::RangeTo<usize>) -> &[u8] {
-        &self.0[index]
-    }
-}
-
-impl<T: Hash> ops::Index<ops::RangeFull> for Hmac<T> {
-    type Output = [u8];
-    fn index(&self, index: ops::RangeFull) -> &[u8] {
-        &self.0[index]
+impl<T: Hash> borrow::Borrow<[u8]> for Hmac<T> {
+    fn borrow(&self) -> &[u8] {
+        self.0.borrow()
     }
 }
 
-impl<T: Hash> borrow::Borrow<[u8]> for Hmac<T> {
-    fn borrow(&self) -> &[u8] {
-        &self[..]
+impl<T: Hash> convert::AsRef<[u8]> for Hmac<T> {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
     }
 }
 
@@ -196,7 +167,7 @@ impl<T: Hash> Hash for Hmac<T> {
 
     fn from_engine(mut e: HmacEngine<T>) -> Hmac<T> {
         let ihash = T::from_engine(e.iengine);
-        e.oengine.input(&ihash[..]);
+        e.oengine.input(ihash.as_ref());
         let ohash = T::from_engine(e.oengine);
         Hmac(ohash)
     }
@@ -364,7 +335,7 @@ mod tests {
             let mut engine = HmacEngine::<sha256::Hash>::new(&test.key);
             engine.input(&test.input);
             let hash = Hmac::<sha256::Hash>::from_engine(engine);
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash.as_ref(), &test.output[..]);
             assert_eq!(hash.into_inner()[..].as_ref(), test.output.as_slice());
         }
     }

src/lib.rs

@@ -73,7 +73,7 @@ pub mod siphash24;
 pub mod sha512;
 pub mod cmp;
 
-use core::{borrow, fmt, hash, ops};
+use core::{borrow, convert, fmt, hash};
 
 pub use hmac::{Hmac, HmacEngine};
 pub use error::Error;
@@ -98,14 +98,9 @@ pub trait HashEngine: Clone + Default {
 }
 
 /// Trait which applies to hashes of all types.
-pub trait Hash: Copy + Clone + PartialEq + Eq + PartialOrd + Ord +
-    hash::Hash + fmt::Debug + fmt::Display + fmt::LowerHex +
-    ops::Index<ops::RangeFull, Output = [u8]> +
-    ops::Index<ops::RangeFrom<usize>, Output = [u8]> +
-    ops::Index<ops::RangeTo<usize>, Output = [u8]> +
-    ops::Index<ops::Range<usize>, Output = [u8]> +
-    ops::Index<usize, Output = u8> +
-    borrow::Borrow<[u8]>
+pub trait Hash: Copy + Clone + PartialEq + Eq + PartialOrd + Ord
+    + hash::Hash + fmt::Debug + fmt::Display + fmt::LowerHex
+    + borrow::Borrow<[u8]> + convert::AsRef<[u8]>
 {
     /// A hashing engine which bytes can be serialized into. It is expected
     /// to implement the `io::Write` trait, and to never return errors under
@@ -169,7 +164,7 @@ mod tests {
     fn convert_newtypes() {
         let h1 = TestNewtype::hash(&[]);
         let h2: TestNewtype2 = h1.as_hash().into();
-        assert_eq!(&h1[..], &h2[..]);
+        assert_eq!(h1.as_ref(), h2.as_ref());
 
         let h = sha256d::Hash::hash(&[]);
         let h2: TestNewtype = h.to_string().parse().unwrap();

src/ripemd160.rs

@@ -21,8 +21,6 @@
 //!
 
 use core::{cmp, str};
-use core::ops::Index;
-use core::slice::SliceIndex;
 
 use crate::{Error, HashEngine as _, hex, util};
 
@@ -89,15 +87,6 @@ hex_fmt_impl!(LowerHex, Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash);
 
-impl<I: SliceIndex<[u8]>> Index<I> for Hash {
-    type Output = I::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        &self.0[index]
-    }
-}
-
 impl str::FromStr for Hash {
     type Err = hex::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -527,7 +516,7 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = ripemd160::Hash::hash(&test.input.as_bytes());
             assert_eq!(hash, ripemd160::Hash::from_hex(test.output_str).expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash.as_ref(), &test.output[..]);
             assert_eq!(&hash.to_hex(), &test.output_str);
 
             // Hash through engine, checking that we can input byte by byte

src/serde_macros.rs

@@ -22,7 +22,7 @@ pub mod serde_details {
     use crate::Error;
 
     use core::marker::PhantomData;
-    use core::{fmt, ops, str};
+    use core::{convert, fmt, str};
     use core::str::FromStr;
     struct HexVisitor<ValueT>(PhantomData<ValueT>);
     use serde::{de, Serializer, Deserializer};
@@ -90,8 +90,7 @@ pub mod serde_details {
         Self: Sized
             + FromStr
             + fmt::Display
-            + ops::Index<usize, Output = u8>
-            + ops::Index<ops::RangeFull, Output = [u8]>,
+            + convert::AsRef<[u8]>,
         <Self as FromStr>::Err: fmt::Display,
     {
         /// Size, in bits, of the hash.
@@ -105,7 +104,7 @@ pub mod serde_details {
             if s.is_human_readable() {
                 s.collect_str(self)
             } else {
-                s.serialize_bytes(&self[..])
+                s.serialize_bytes(self.as_ref())
             }
         }
 

src/sha1.rs

@@ -16,8 +16,6 @@
 //!
 
 use core::{cmp, str};
-use core::ops::Index;
-use core::slice::SliceIndex;
 
 use crate::{Error, HashEngine as _, hex, util};
 
@@ -84,15 +82,6 @@ hex_fmt_impl!(LowerHex, Hash);
 serde_impl!(Hash, 20);
 borrow_slice_impl!(Hash);
 
-impl<I: SliceIndex<[u8]>> Index<I> for Hash {
-    type Output = I::Output;
-
-    #[inline]
-    fn index(&self, index: I) -> &Self::Output {
-        &self.0[index]
-    }
-}
-
 impl str::FromStr for Hash {
     type Err = hex::Error;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -253,7 +242,7 @@ mod tests {
             // Hash through high-level API, check hex encoding/decoding
             let hash = sha1::Hash::hash(&test.input.as_bytes());
             assert_eq!(hash, sha1::Hash::from_hex(test.output_str).expect("parse hex"));
-            assert_eq!(&hash[..], &test.output[..]);
+            assert_eq!(hash.as_ref(), &test.output[..]);
             assert_eq!(&hash.to_hex(), &test.output_str);
 
             // Hash through engine, checking that we can input byte by byte