style: Simplify DecodeError description to an enum

Replace the inner `description` field of `DecodeError` from a string to an enum. The enum implements `Display` that produces the same string.

Split the error for `Any::to_msg` into `DecodeAnyError`. This provides better separation between `prost` and `prost-types`.

Author: caspermeijn

prost-types/src/any.rs

@@ -1,5 +1,35 @@
 use super::*;
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DecodeAnyError {
+    Decode(DecodeError),
+    /// Unexpected type URL
+    UnexpectedTypeUrl {
+        actual: String,
+        expected: String,
+    },
+}
+
+impl fmt::Display for DecodeAnyError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            DecodeAnyError::Decode(err) => write!(f, "{err}"),
+            DecodeAnyError::UnexpectedTypeUrl { actual, expected } => {
+                write!(f, "failed to decode Protobuf message: unexpected type URL.type_url: expected type URL: \"{expected}\" (got: \"{actual}\")")
+            }
+        }
+    }
+}
+
+impl From<DecodeError> for DecodeAnyError {
+    fn from(err: DecodeError) -> Self {
+        Self::Decode(err)
+    }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for DecodeAnyError {}
+
 impl Any {
     /// Serialize the given message type `M` as [`Any`].
     pub fn from_msg<M>(msg: &M) -> Result<Self, EncodeError>
@@ -14,7 +44,7 @@ impl Any {
 
     /// Decode the given message type `M` from [`Any`], validating that it has
     /// the expected type URL.
-    pub fn to_msg<M>(&self) -> Result<M, DecodeError>
+    pub fn to_msg<M>(&self) -> Result<M, DecodeAnyError>
     where
         M: Default + Name + Sized,
     {
@@ -25,16 +55,14 @@ impl Any {
             TypeUrl::new(&self.type_url),
         ) {
             if expected == actual {
-                return M::decode(self.value.as_slice());
+                return M::decode(self.value.as_slice()).map_err(DecodeAnyError::from);
             }
         }
 
-        let mut err = DecodeError::new(format!(
-            "expected type URL: \"{}\" (got: \"{}\")",
-            expected_type_url, &self.type_url
-        ));
-        err.push("unexpected type URL", "type_url");
-        Err(err)
+        Err(DecodeAnyError::UnexpectedTypeUrl {
+            actual: self.type_url.clone(),
+            expected: expected_type_url,
+        })
     }
 }
 

prost/src/encoding.rs

@@ -6,14 +6,14 @@
 //! This module is `pub`, but is only for prost internal use. The `prost-derive` crate needs access for its `Message` implementations.
 
 use alloc::collections::BTreeMap;
-use alloc::format;
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::mem;
 use core::str;
 
 use ::bytes::{Buf, BufMut, Bytes};
 
+use crate::error::DecodeErrorKind;
 use crate::DecodeError;
 use crate::Message;
 
@@ -84,7 +84,7 @@ impl DecodeContext {
     #[inline]
     pub(crate) fn limit_reached(&self) -> Result<(), DecodeError> {
         if self.recurse_count == 0 {
-            Err(DecodeError::new("recursion limit reached"))
+            Err(DecodeErrorKind::RecursionLimitReached.into())
         } else {
             Ok(())
         }
@@ -115,13 +115,13 @@ pub fn encode_key(tag: u32, wire_type: WireType, buf: &mut impl BufMut) {
 pub fn decode_key(buf: &mut impl Buf) -> Result<(u32, WireType), DecodeError> {
     let key = decode_varint(buf)?;
     if key > u64::from(u32::MAX) {
-        return Err(DecodeError::new(format!("invalid key value: {key}")));
+        return Err(DecodeErrorKind::InvalidKey { key }.into());
     }
     let wire_type = WireType::try_from(key & 0x07)?;
     let tag = key as u32 >> 3;
 
     if tag < MIN_TAG {
-        return Err(DecodeError::new("invalid tag value: 0"));
+        return Err(DecodeErrorKind::InvalidTag.into());
     }
 
     Ok((tag, wire_type))
@@ -149,7 +149,7 @@ where
     let len = decode_varint(buf)?;
     let remaining = buf.remaining();
     if len > remaining as u64 {
-        return Err(DecodeError::new("buffer underflow"));
+        return Err(DecodeErrorKind::BufferUnderflow.into());
     }
 
     let limit = remaining - len as usize;
@@ -158,7 +158,7 @@ where
     }
 
     if buf.remaining() != limit {
-        return Err(DecodeError::new("delimited length exceeded"));
+        return Err(DecodeErrorKind::DelimitedLengthExceeded.into());
     }
     Ok(())
 }
@@ -180,18 +180,18 @@ pub fn skip_field(
             match inner_wire_type {
                 WireType::EndGroup => {
                     if inner_tag != tag {
-                        return Err(DecodeError::new("unexpected end group tag"));
+                        return Err(DecodeErrorKind::UnexpectedEndGroupTag.into());
                     }
                     break 0;
                 }
                 _ => skip_field(inner_wire_type, inner_tag, buf, ctx.enter_recursion())?,
             }
         },
-        WireType::EndGroup => return Err(DecodeError::new("unexpected end group tag")),
+        WireType::EndGroup => return Err(DecodeErrorKind::UnexpectedEndGroupTag.into()),
     };
 
     if len > buf.remaining() as u64 {
-        return Err(DecodeError::new("buffer underflow"));
+        return Err(DecodeErrorKind::BufferUnderflow.into());
     }
 
     buf.advance(len as usize);
@@ -396,7 +396,7 @@ macro_rules! fixed_width {
             ) -> Result<(), DecodeError> {
                 check_wire_type($wire_type, wire_type)?;
                 if buf.remaining() < $width {
-                    return Err(DecodeError::new("buffer underflow"));
+                    return Err(DecodeErrorKind::BufferUnderflow.into());
                 }
                 *value = buf.$get();
                 Ok(())
@@ -599,9 +599,7 @@ pub mod string {
                     mem::forget(drop_guard);
                     Ok(())
                 }
-                Err(_) => Err(DecodeError::new(
-                    "invalid string value: data is not UTF-8 encoded",
-                )),
+                Err(_) => Err(DecodeErrorKind::InvalidString.into()),
             }
         }
     }
@@ -686,6 +684,8 @@ impl sealed::BytesAdapter for Vec<u8> {
 }
 
 pub mod bytes {
+    use crate::error::DecodeErrorKind;
+
     use super::*;
 
     pub fn encode(tag: u32, value: &impl BytesAdapter, buf: &mut impl BufMut) {
@@ -703,7 +703,7 @@ pub mod bytes {
         check_wire_type(WireType::LengthDelimited, wire_type)?;
         let len = decode_varint(buf)?;
         if len > buf.remaining() as u64 {
-            return Err(DecodeError::new("buffer underflow"));
+            return Err(DecodeErrorKind::BufferUnderflow.into());
         }
         let len = len as usize;
 
@@ -732,7 +732,7 @@ pub mod bytes {
         check_wire_type(WireType::LengthDelimited, wire_type)?;
         let len = decode_varint(buf)?;
         if len > buf.remaining() as u64 {
-            return Err(DecodeError::new("buffer underflow"));
+            return Err(DecodeErrorKind::BufferUnderflow.into());
         }
         let len = len as usize;
 
@@ -866,6 +866,8 @@ pub mod message {
 }
 
 pub mod group {
+    use crate::error::DecodeErrorKind;
+
     use super::*;
 
     pub fn encode<M>(tag: u32, msg: &M, buf: &mut impl BufMut)
@@ -894,7 +896,7 @@ pub mod group {
             let (field_tag, field_wire_type) = decode_key(buf)?;
             if field_wire_type == WireType::EndGroup {
                 if field_tag != tag {
-                    return Err(DecodeError::new("unexpected end group tag"));
+                    return Err(DecodeErrorKind::UnexpectedEndGroupTag.into());
                 }
                 return Ok(());
             }

prost/src/encoding/length_delimiter.rs

@@ -1,3 +1,4 @@
+use crate::error::DecodeErrorKind;
 pub use crate::error::{DecodeError, EncodeError, UnknownEnumValue};
 pub use crate::message::Message;
 pub use crate::name::Name;
@@ -45,9 +46,7 @@ pub fn length_delimiter_len(length: usize) -> usize {
 pub fn decode_length_delimiter(mut buf: impl Buf) -> Result<usize, DecodeError> {
     let length = decode_varint(&mut buf)?;
     if length > usize::MAX as u64 {
-        return Err(DecodeError::new(
-            "length delimiter exceeds maximum usize value",
-        ));
+        return Err(DecodeErrorKind::LengthDelimiterTooLarge.into());
     }
     Ok(length as usize)
 }

prost/src/encoding/varint.rs

@@ -3,7 +3,7 @@ use core::num::NonZeroU64;
 
 use ::bytes::{Buf, BufMut};
 
-use crate::DecodeError;
+use crate::{error::DecodeErrorKind, DecodeError};
 
 /// Encodes an integer value into LEB128 variable length format, and writes it to the buffer.
 /// The buffer must have enough remaining space (maximum 10 bytes).
@@ -38,7 +38,7 @@ pub fn decode_varint(buf: &mut impl Buf) -> Result<u64, DecodeError> {
     let bytes = buf.chunk();
     let len = bytes.len();
     if len == 0 {
-        return Err(DecodeError::new("invalid varint"));
+        return Err(DecodeErrorKind::InvalidVarint.into());
     }
 
     let byte = bytes[0];
@@ -143,7 +143,7 @@ fn decode_varint_slice(bytes: &[u8]) -> Result<(u64, usize), DecodeError> {
 
     // We have overrun the maximum size of a varint (10 bytes) or the final byte caused an overflow.
     // Assume the data is corrupt.
-    Err(DecodeError::new("invalid varint"))
+    Err(DecodeErrorKind::InvalidVarint.into())
 }
 
 /// Decodes a LEB128-encoded variable length integer from the buffer, advancing the buffer as
@@ -163,14 +163,14 @@ fn decode_varint_slow(buf: &mut impl Buf) -> Result<u64, DecodeError> {
             // Check for u64::MAX overflow. See [`ConsumeVarint`][1] for details.
             // [1]: https://github.com/protocolbuffers/protobuf-go/blob/v1.27.1/encoding/protowire/wire.go#L358
             if count == 9 && byte >= 0x02 {
-                return Err(DecodeError::new("invalid varint"));
+                return Err(DecodeErrorKind::InvalidVarint.into());
             } else {
                 return Ok(value);
             }
         }
     }
 
-    Err(DecodeError::new("invalid varint"))
+    Err(DecodeErrorKind::InvalidVarint.into())
 }
 
 #[cfg(test)]

prost/src/encoding/wire_type.rs

@@ -1,5 +1,4 @@
-use crate::DecodeError;
-use alloc::format;
+use crate::{error::DecodeErrorKind, DecodeError};
 
 /// Represent the wire type for protobuf encoding.
 ///
@@ -27,9 +26,7 @@ impl TryFrom<u64> for WireType {
             3 => Ok(WireType::StartGroup),
             4 => Ok(WireType::EndGroup),
             5 => Ok(WireType::ThirtyTwoBit),
-            _ => Err(DecodeError::new(format!(
-                "invalid wire type value: {value}"
-            ))),
+            _ => Err(DecodeErrorKind::InvalidWireType { value }.into()),
         }
     }
 }
@@ -39,9 +36,7 @@ impl TryFrom<u64> for WireType {
 #[inline]
 pub fn check_wire_type(expected: WireType, actual: WireType) -> Result<(), DecodeError> {
     if expected != actual {
-        return Err(DecodeError::new(format!(
-            "invalid wire type: {actual:?} (expected {expected:?})"
-        )));
+        return Err(DecodeErrorKind::UnexpectedWireType { actual, expected }.into());
     }
     Ok(())
 }