der: add const ::new to Length, BytesRef, AnyRef (#1713)

* feat: add const ::new to Length, BytesRef, AnyRef

docs: Length::new_usize

* fix clippy u32 truncation

Author: dishmaker

der/src/asn1/any.rs

@@ -40,9 +40,11 @@ impl<'a> AnyRef<'a> {
     };
 
     /// Create a new [`AnyRef`] from the provided [`Tag`] and DER bytes.
-    pub fn new(tag: Tag, bytes: &'a [u8]) -> Result<Self, Error> {
-        let value = BytesRef::new(bytes).map_err(|_| ErrorKind::Length { tag })?;
-        Ok(Self { tag, value })
+    pub const fn new(tag: Tag, bytes: &'a [u8]) -> Result<Self, Error> {
+        match BytesRef::new(bytes) {
+            Ok(value) => Ok(Self { tag, value }),
+            Err(_) => Err(Error::from_kind(ErrorKind::Length { tag })),
+        }
     }
 
     /// Infallible creation of an [`AnyRef`] from a [`BytesRef`].

der/src/bytes_ref.rs

@@ -28,11 +28,14 @@ impl<'a> BytesRef<'a> {
 
     /// Create a new [`BytesRef`], ensuring that the provided `slice` value
     /// is shorter than `Length::max()`.
-    pub fn new(slice: &'a [u8]) -> Result<Self> {
-        Ok(Self {
-            length: Length::try_from(slice.len())?,
-            inner: slice,
-        })
+    pub const fn new(slice: &'a [u8]) -> Result<Self> {
+        match Length::new_usize(slice.len()) {
+            Ok(length) => Ok(Self {
+                length,
+                inner: slice,
+            }),
+            Err(err) => Err(err),
+        }
     }
 
     /// Borrow the inner byte slice

der/src/error.rs

@@ -26,12 +26,19 @@ pub struct Error {
 
 impl Error {
     /// Create a new [`Error`].
-    pub fn new(kind: ErrorKind, position: Length) -> Error {
+    pub const fn new(kind: ErrorKind, position: Length) -> Error {
         Error {
             kind,
             position: Some(position),
         }
     }
+    /// Create a new [`Error`], without known position.
+    pub(crate) const fn from_kind(kind: ErrorKind) -> Error {
+        Error {
+            kind,
+            position: None,
+        }
+    }
 
     /// Create a new [`ErrorKind::Incomplete`] for the given length.
     ///
@@ -86,10 +93,7 @@ impl fmt::Display for Error {
 
 impl From<ErrorKind> for Error {
     fn from(kind: ErrorKind) -> Error {
-        Error {
-            kind,
-            position: None,
-        }
+        Error::from_kind(kind)
     }
 }
 

der/src/length.rs

@@ -44,6 +44,18 @@ impl Length {
         Self(value as u32)
     }
 
+    /// Create a new [`Length`] for any value which fits inside the length type.
+    ///
+    /// This function is const-safe and therefore useful for [`Length`] constants.
+    #[allow(clippy::cast_possible_truncation)]
+    pub(crate) const fn new_usize(len: usize) -> Result<Self> {
+        if len > (u32::MAX as usize) {
+            Err(Error::from_kind(ErrorKind::Overflow))
+        } else {
+            Ok(Length(len as u32))
+        }
+    }
+
     /// Is this length equal to zero?
     pub fn is_zero(self) -> bool {
         self == Self::ZERO
@@ -192,9 +204,7 @@ impl TryFrom<usize> for Length {
     type Error = Error;
 
     fn try_from(len: usize) -> Result<Length> {
-        u32::try_from(len)
-            .map_err(|_| ErrorKind::Overflow)?
-            .try_into()
+        Length::new_usize(len)
     }
 }