tor-bytes: Remove use of arrayref

Part of #872: Now that const generics are in, we have better ways to
express converting slices into array-references.

Cargo.lock

@@ -3793,7 +3793,6 @@ dependencies = [
 name = "tor-bytes"
 version = "0.7.0"
 dependencies = [
- "arrayref",
  "bytes",
  "digest 0.10.7",
  "educe",

crates/tor-bytes/Cargo.toml

@@ -12,7 +12,6 @@ categories = ["parsing", "encoding"]
 repository = "https://gitlab.torproject.org/tpo/core/arti.git/"
 
 [dependencies]
-arrayref = "0.3"
 bytes = "1"
 digest = { version = "0.10.0", features = ["subtle", "mac"] }
 educe = "0.4.6"

crates/tor-bytes/src/impls.rs

@@ -180,8 +180,8 @@ mod ed25519_impls {
     }
     impl Readable for ed25519::PublicKey {
         fn take_from(b: &mut Reader<'_>) -> Result<Self> {
-            let bytes = b.take(32)?;
-            Self::from_bytes(array_ref![bytes, 0, 32])
+            let bytes: [u8; 32] = b.extract()?;
+            Self::from_bytes(&bytes)
                 .map_err(|_| Error::InvalidMessage("Couldn't decode Ed25519 public key".into()))
         }
     }
@@ -194,8 +194,8 @@ mod ed25519_impls {
     }
     impl Readable for ed25519::Ed25519Identity {
         fn take_from(b: &mut Reader<'_>) -> Result<Self> {
-            let bytes = b.take(32)?;
-            Ok(Self::new(*array_ref![bytes, 0, 32]))
+            let bytes: [u8; 32] = b.extract()?;
+            Ok(Self::new(bytes))
         }
     }
     impl Writeable for ed25519::Signature {
@@ -206,8 +206,8 @@ mod ed25519_impls {
     }
     impl Readable for ed25519::Signature {
         fn take_from(b: &mut Reader<'_>) -> Result<Self> {
-            let bytes = b.take(64)?;
-            Self::from_bytes(array_ref![bytes, 0, 64])
+            let bytes: [u8; 64] = b.extract()?;
+            Self::from_bytes(&bytes)
                 .map_err(|_| Error::InvalidMessage("Couldn't decode Ed25519 signature.".into()))
         }
     }
@@ -226,8 +226,8 @@ mod curve25519_impls {
     }
     impl Readable for PublicKey {
         fn take_from(b: &mut Reader<'_>) -> Result<Self> {
-            let bytes = b.take(32)?;
-            Ok((*array_ref![bytes, 0, 32]).into())
+            let bytes: [u8; 32] = b.extract()?;
+            Ok(bytes.into())
         }
     }
     impl Writeable for SharedSecret {

crates/tor-bytes/src/lib.rs

@@ -49,8 +49,6 @@ pub use reader::{Cursor, Reader};
 pub use secretbuf::SecretBuf;
 pub use writer::Writer;
 
-use arrayref::array_ref;
-
 /// Result type returned by this crate for [`Reader`]-related methods.
 pub type Result<T> = std::result::Result<T, Error>;
 /// Result type returned by this crate for [`Writer`]-related methods.

crates/tor-bytes/src/reader.rs

@@ -1,7 +1,6 @@
 //! Internal: Declare the Reader type for tor-bytes
 
 use crate::{Error, Readable, Result};
-use arrayref::array_ref;
 
 /// A type for reading messages from a slice of bytes.
 ///
@@ -182,26 +181,26 @@ impl<'a> Reader<'a> {
     }
     /// Try to consume and return a big-endian u16 from this reader.
     pub fn take_u16(&mut self) -> Result<u16> {
-        let b = self.take(2)?;
-        let r = u16::from_be_bytes(*array_ref![b, 0, 2]);
+        let b: [u8; 2] = self.extract()?;
+        let r = u16::from_be_bytes(b);
         Ok(r)
     }
     /// Try to consume and return a big-endian u32 from this reader.
     pub fn take_u32(&mut self) -> Result<u32> {
-        let b = self.take(4)?;
-        let r = u32::from_be_bytes(*array_ref![b, 0, 4]);
+        let b: [u8; 4] = self.extract()?;
+        let r = u32::from_be_bytes(b);
         Ok(r)
     }
     /// Try to consume and return a big-endian u64 from this reader.
     pub fn take_u64(&mut self) -> Result<u64> {
-        let b = self.take(8)?;
-        let r = u64::from_be_bytes(*array_ref![b, 0, 8]);
+        let b: [u8; 8] = self.extract()?;
+        let r = u64::from_be_bytes(b);
         Ok(r)
     }
     /// Try to consume and return a big-endian u128 from this reader.
     pub fn take_u128(&mut self) -> Result<u128> {
-        let b = self.take(16)?;
-        let r = u128::from_be_bytes(*array_ref![b, 0, 16]);
+        let b: [u8; 16] = self.extract()?;
+        let r = u128::from_be_bytes(b);
         Ok(r)
     }
     /// Try to consume and return bytes from this buffer until we