der: refactor Int*/Uint* types (#881)

Factors these types out of the (now-removed) `bigint` module into the
`int` and `uint` modules respectively, avoiding other code changes and
preserving all tests.

Author: tarcieri

der/src/asn1.rs

@@ -35,7 +35,7 @@ pub use self::{
     context_specific::{ContextSpecific, ContextSpecificRef},
     generalized_time::GeneralizedTime,
     ia5_string::Ia5StringRef,
-    integer::bigint::{IntRef, UintRef},
+    integer::{int::IntRef, uint::UintRef},
     null::Null,
     octet_string::OctetStringRef,
     printable_string::PrintableStringRef,
@@ -54,7 +54,7 @@ pub use self::{
     any::Any,
     bit_string::BitString,
     ia5_string::Ia5String,
-    integer::bigint::{Int, Uint},
+    integer::{int::Int, uint::Uint},
     octet_string::OctetString,
     printable_string::PrintableString,
     set_of::SetOfVec,

der/src/asn1/integer.rs

@@ -1,148 +1,13 @@
 //! ASN.1 `INTEGER` support.
 
-pub(super) mod bigint;
 pub(super) mod int;
 pub(super) mod uint;
 
 use core::{cmp::Ordering, mem};
 
-use crate::{
-    asn1::AnyRef, DecodeValue, EncodeValue, Error, FixedTag, Header, Length, Reader, Result,
-    SliceWriter, Tag, ValueOrd, Writer,
-};
+use crate::{EncodeValue, Result, SliceWriter};
 
-macro_rules! impl_int_encoding {
-    ($($int:ty => $uint:ty),+) => {
-        $(
-            impl<'a> DecodeValue<'a> for $int {
-                fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> {
-                    let mut buf = [0u8; Self::BITS as usize / 8];
-                    let max_length = u32::from(header.length) as usize;
-
-                    if max_length > buf.len() {
-                        return Err(Self::TAG.non_canonical_error());
-                    }
-
-                    let bytes = reader.read_into(&mut buf[..max_length])?;
-
-                    let result = if is_highest_bit_set(bytes) {
-                        <$uint>::from_be_bytes(int::decode_to_array(bytes)?) as $int
-                    } else {
-                        Self::from_be_bytes(uint::decode_to_array(bytes)?)
-                    };
-
-                    // Ensure we compute the same encoded length as the original any value
-                    if header.length != result.value_len()? {
-                        return Err(Self::TAG.non_canonical_error());
-                    }
-
-                    Ok(result)
-                }
-            }
-
-            impl EncodeValue for $int {
-                fn value_len(&self) -> Result<Length> {
-                    if *self < 0 {
-                        int::negative_encoded_len(&(*self as $uint).to_be_bytes())
-                    } else {
-                        uint::encoded_len(&self.to_be_bytes())
-                    }
-                }
-
-                fn encode_value(&self, writer: &mut impl Writer) -> Result<()> {
-                    if *self < 0 {
-                        int::encode_bytes(writer, &(*self as $uint).to_be_bytes())
-                    } else {
-                        uint::encode_bytes(writer, &self.to_be_bytes())
-                    }
-                }
-            }
-
-            impl FixedTag for $int {
-                const TAG: Tag = Tag::Integer;
-            }
-
-            impl ValueOrd for $int {
-                fn value_cmp(&self, other: &Self) -> Result<Ordering> {
-                    value_cmp(*self, *other)
-                }
-            }
-
-            impl TryFrom<AnyRef<'_>> for $int {
-                type Error = Error;
-
-                fn try_from(any: AnyRef<'_>) -> Result<Self> {
-                    any.decode_as()
-                }
-            }
-        )+
-    };
-}
-
-macro_rules! impl_uint_encoding {
-    ($($uint:ty),+) => {
-        $(
-            impl<'a> DecodeValue<'a> for $uint {
-                fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self> {
-                    // Integers always encodes as a signed value, unsigned gets a leading 0x00 that
-                    // needs to be stripped off. We need to provide room for it.
-                    const UNSIGNED_HEADROOM: usize = 1;
-
-                    let mut buf = [0u8; (Self::BITS as usize / 8) + UNSIGNED_HEADROOM];
-                    let max_length = u32::from(header.length) as usize;
-
-                    if max_length > buf.len() {
-                        return Err(Self::TAG.non_canonical_error());
-                    }
-
-                    let bytes = reader.read_into(&mut buf[..max_length])?;
-
-                    let result = Self::from_be_bytes(uint::decode_to_array(bytes)?);
-
-                    // Ensure we compute the same encoded length as the original any value
-                    if header.length != result.value_len()? {
-                        return Err(Self::TAG.non_canonical_error());
-                    }
-
-                    Ok(result)
-                }
-            }
-
-            impl EncodeValue for $uint {
-                fn value_len(&self) -> Result<Length> {
-                    uint::encoded_len(&self.to_be_bytes())
-                }
-
-                fn encode_value(&self, writer: &mut impl Writer) -> Result<()> {
-                    uint::encode_bytes(writer, &self.to_be_bytes())
-                }
-            }
-
-            impl FixedTag for $uint {
-                const TAG: Tag = Tag::Integer;
-            }
-
-            impl ValueOrd for $uint {
-                fn value_cmp(&self, other: &Self) -> Result<Ordering> {
-                    value_cmp(*self, *other)
-                }
-            }
-
-            impl TryFrom<AnyRef<'_>> for $uint {
-                type Error = Error;
-
-                fn try_from(any: AnyRef<'_>) -> Result<Self> {
-                    any.decode_as()
-                }
-            }
-        )+
-    };
-}
-
-impl_int_encoding!(i8 => u8, i16 => u16, i32 => u32, i64 => u64, i128 => u128);
-impl_uint_encoding!(u8, u16, u32, u64, u128);
-
-/// Is the highest bit of the first byte in the slice 1? (if present)
+/// Is the highest bit of the first byte in the slice set to `1`? (if present)
 #[inline]
 fn is_highest_bit_set(bytes: &[u8]) -> bool {
     bytes