der: remove generic <T> from Reader::finish

der/src/asn1/any.rs

@@ -73,7 +73,8 @@ impl<'a> AnyRef<'a> {
 
         let mut decoder = SliceReader::new(self.value())?;
         let result = T::decode_value(&mut decoder, header)?;
-        Ok(decoder.finish(result)?)
+        decoder.finish()?;
+        Ok(result)
     }
 
     /// Is this value an ASN.1 `NULL` value?
@@ -91,7 +92,8 @@ impl<'a> AnyRef<'a> {
         self.tag.assert_eq(Tag::Sequence)?;
         let mut reader = SliceReader::new(self.value.as_slice())?;
         let result = f(&mut reader)?;
-        Ok(reader.finish(result)?)
+        reader.finish()?;
+        Ok(result)
     }
 }
 

der/src/decode.rs

@@ -30,7 +30,8 @@ pub trait Decode<'a>: Sized + 'a {
     fn from_ber(bytes: &'a [u8]) -> Result<Self, Self::Error> {
         let mut reader = SliceReader::new_with_encoding_rules(bytes, EncodingRules::Ber)?;
         let result = Self::decode(&mut reader)?;
-        Ok(reader.finish(result)?)
+        reader.finish()?;
+        Ok(result)
     }
 
     /// Parse `Self` from the provided DER-encoded byte slice.
@@ -39,7 +40,8 @@ pub trait Decode<'a>: Sized + 'a {
     fn from_der(bytes: &'a [u8]) -> Result<Self, Self::Error> {
         let mut reader = SliceReader::new(bytes)?;
         let result = Self::decode(&mut reader)?;
-        Ok(reader.finish(result)?)
+        reader.finish()?;
+        Ok(result)
     }
 
     /// Parse `Self` from the provided DER-encoded byte slice.

der/src/document.rs

@@ -187,7 +187,7 @@ impl TryFrom<Vec<u8>> for Document {
     fn try_from(der_bytes: Vec<u8>) -> Result<Self, Error> {
         let mut decoder = SliceReader::new(&der_bytes)?;
         decode_sequence(&mut decoder)?;
-        decoder.finish(())?;
+        decoder.finish()?;
 
         let length = der_bytes.len().try_into()?;
         Ok(Self { der_bytes, length })

der/src/reader.rs

@@ -72,17 +72,17 @@ pub trait Reader<'r>: Sized {
         kind.at(self.position())
     }
 
-    /// Finish decoding, returning the given value if there is no
+    /// Finish decoding, returning `Ok(())` if there is no
     /// remaining data, or an error otherwise
-    fn finish<T>(self, value: T) -> Result<T, Error> {
+    fn finish(self) -> Result<(), Error> {
         if !self.is_finished() {
             Err(ErrorKind::TrailingData {
                 decoded: self.position(),
                 remaining: self.remaining_len(),
             }
             .at(self.position()))
         } else {
-            Ok(value)
+            Ok(())
         }
     }
 

der/src/reader/slice.rs

@@ -104,12 +104,16 @@ impl<'a> Reader<'a> for SliceReader<'a> {
         self.position = nested_reader.position;
         self.failed = nested_reader.failed;
 
-        ret.and_then(|value| {
-            nested_reader.finish(value).map_err(|e| {
-                self.failed = true;
-                e.into()
-            })
-        })
+        match ret {
+            Ok(value) => {
+                nested_reader.finish().map_err(|e| {
+                    self.failed = true;
+                    e.into()
+                })?;
+                Ok(value)
+            }
+            Err(err) => Err(err),
+        }
     }
 
     fn read_slice(&mut self, len: Length) -> Result<&'a [u8], Error> {
@@ -144,7 +148,7 @@ impl<'a> Reader<'a> for SliceReader<'a> {
         kind.at(self.position)
     }
 
-    fn finish<T>(self, value: T) -> Result<T, Error> {
+    fn finish(self) -> Result<(), Error> {
         if self.is_failed() {
             Err(ErrorKind::Failed.at(self.position))
         } else if !self.is_finished() {
@@ -154,7 +158,7 @@ impl<'a> Reader<'a> for SliceReader<'a> {
             }
             .at(self.position))
         } else {
-            Ok(value)
+            Ok(())
         }
     }
 
@@ -218,7 +222,7 @@ mod tests {
         let x = i8::decode(&mut reader).unwrap();
         assert_eq!(42i8, x);
 
-        let err = reader.finish(x).err().unwrap();
+        let err = reader.finish().err().unwrap();
         assert_eq!(Some(Length::from(3u8)), err.position());
 
         assert_eq!(