consensus_encoding: rename UnexptectedEof

It is policy that all error types are suffixed with `Error` and live at
the bottom of the file.

Co-authored-by: Tobin C. Harding <me@tobin.cc>

Author: nyonson

consensus_encoding/src/decode/decoders.rs

@@ -4,22 +4,6 @@
 
 use super::Decoder;
 
-/// Not enough bytes given to decoder.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct UnexpectedEof {
-    /// Number of bytes missing to complete decoder.
-    missing: usize,
-}
-
-impl core::fmt::Display for UnexpectedEof {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        write!(f, "not enough bytes for decoder, {} more bytes required", self.missing)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for UnexpectedEof {}
-
 /// A decoder that expects exactly N bytes and returns them as an array.
 pub struct ArrayDecoder<const N: usize> {
     buffer: [u8; N],
@@ -37,7 +21,7 @@ impl<const N: usize> Default for ArrayDecoder<N> {
 
 impl<const N: usize> Decoder for ArrayDecoder<N> {
     type Output = [u8; N];
-    type Error = UnexpectedEof;
+    type Error = UnexpectedEofError;
 
     fn push_bytes(&mut self, bytes: &mut &[u8]) -> Result<bool, Self::Error> {
         let remaining_space = N - self.bytes_written;
@@ -59,7 +43,7 @@ impl<const N: usize> Decoder for ArrayDecoder<N> {
         if self.bytes_written == N {
             Ok(self.buffer)
         } else {
-            Err(UnexpectedEof { missing: N - self.bytes_written })
+            Err(UnexpectedEofError { missing: N - self.bytes_written })
         }
     }
 }
@@ -355,3 +339,19 @@ where
         Ok((first, second, third, fourth, fifth, sixth))
     }
 }
+
+/// Not enough bytes given to decoder.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UnexpectedEofError {
+    /// Number of bytes missing to complete decoder.
+    missing: usize,
+}
+
+impl core::fmt::Display for UnexpectedEofError {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        write!(f, "not enough bytes for decoder, {} more bytes required", self.missing)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for UnexpectedEofError {}

consensus_encoding/src/lib.rs

@@ -23,7 +23,7 @@ mod decode;
 mod encode;
 
 pub use self::decode::decoders::{
-    ArrayDecoder, Decoder2, Decoder3, Decoder4, Decoder6, UnexpectedEof,
+    ArrayDecoder, Decoder2, Decoder3, Decoder4, Decoder6, UnexpectedEofError,
 };
 pub use self::decode::{Decodable, Decoder};
 #[cfg(feature = "alloc")]

consensus_encoding/tests/composition.rs

@@ -4,7 +4,7 @@
 
 use consensus_encoding::{
     ArrayDecoder, ArrayEncoder, Decodable, Decoder, Decoder2, Decoder6, Encodable, Encoder,
-    Encoder2, Encoder6, UnexpectedEof,
+    Encoder2, Encoder6, UnexpectedEofError,
 };
 
 const EMPTY: &[u8] = &[];
@@ -30,11 +30,11 @@ impl Encodable for CompositeData {
 /// A unified error type for [`CompositeDataDecoder`].
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum CompositeError {
-    Eof(UnexpectedEof),
+    Eof(UnexpectedEofError),
 }
 
-impl From<UnexpectedEof> for CompositeError {
-    fn from(eof: UnexpectedEof) -> Self { CompositeError::Eof(eof) }
+impl From<UnexpectedEofError> for CompositeError {
+    fn from(eof: UnexpectedEofError) -> Self { CompositeError::Eof(eof) }
 }
 
 impl core::fmt::Display for CompositeError {
@@ -115,7 +115,7 @@ fn composition_nested() {
     }
     assert_eq!(encoded_bytes, data);
 
-    let mut decoder6: Decoder6<_, _, _, _, _, _, UnexpectedEof> = Decoder6::new(
+    let mut decoder6: Decoder6<_, _, _, _, _, _, UnexpectedEofError> = Decoder6::new(
         ArrayDecoder::<1>::new(),
         ArrayDecoder::<1>::new(),
         ArrayDecoder::<1>::new(),
@@ -139,7 +139,7 @@ fn composition_nested() {
 #[test]
 fn composition_extra_bytes() {
     // Test that Decoder2 consumes exactly what it needs and leaves extra bytes unconsumed.
-    let mut decoder2: Decoder2<_, _, UnexpectedEof> =
+    let mut decoder2: Decoder2<_, _, UnexpectedEofError> =
         Decoder2::new(ArrayDecoder::<2>::new(), ArrayDecoder::<3>::new());
     let mut bytes = &[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08][..];
     let original_len = bytes.len();
@@ -167,22 +167,22 @@ fn composition_error_unification() {
     #[derive(Debug, Clone, PartialEq, Eq)]
     enum NestedError {
         BadChecksum,
-        UnexpectedEof(UnexpectedEof),
+        UnexpectedEof(UnexpectedEofError),
     }
 
-    impl From<UnexpectedEof> for NestedError {
-        fn from(eof: UnexpectedEof) -> Self { NestedError::UnexpectedEof(eof) }
+    impl From<UnexpectedEofError> for NestedError {
+        fn from(eof: UnexpectedEofError) -> Self { NestedError::UnexpectedEof(eof) }
     }
 
     /// Error for top level encoder.
     #[derive(Debug, Clone, PartialEq, Eq)]
     enum TopLevelError {
-        UnexpectedEof(UnexpectedEof),
+        UnexpectedEof(UnexpectedEofError),
         Validation(NestedError),
     }
 
-    impl From<UnexpectedEof> for TopLevelError {
-        fn from(eof: UnexpectedEof) -> Self { TopLevelError::UnexpectedEof(eof) }
+    impl From<UnexpectedEofError> for TopLevelError {
+        fn from(eof: UnexpectedEofError) -> Self { TopLevelError::UnexpectedEof(eof) }
     }
 
     impl From<NestedError> for TopLevelError {

consensus_encoding/tests/decode.rs

@@ -2,7 +2,7 @@
 
 //! Integration tests for decode module.
 
-use consensus_encoding::{ArrayDecoder, Decoder, UnexpectedEof};
+use consensus_encoding::{ArrayDecoder, Decoder, UnexpectedEofError};
 
 const EMPTY: &[u8] = &[];
 
@@ -50,5 +50,5 @@ fn decode_array_insufficient_data_error() {
     assert_eq!(data, EMPTY);
 
     let err = decoder.end().unwrap_err();
-    assert!(matches!(err, UnexpectedEof { .. }));
+    assert!(matches!(err, UnexpectedEofError { .. }));
 }