Clippy fixes

Author: marshallpierce

src/decode.rs

@@ -146,10 +146,10 @@ pub fn decode_engine<E: Engine, T: AsRef<[u8]>>(
 ///}
 ///```
 #[cfg(any(feature = "alloc", feature = "std", test))]
-pub fn decode_engine_vec<'e, 'o, E: Engine, T: AsRef<[u8]>>(
+pub fn decode_engine_vec<E: Engine, T: AsRef<[u8]>>(
     input: T,
-    buffer: &'o mut Vec<u8>,
-    engine: &'e E,
+    buffer: &mut Vec<u8>,
+    engine: &E,
 ) -> Result<(), DecodeError> {
     let input_bytes = input.as_ref();
 
@@ -184,10 +184,10 @@ pub fn decode_engine_vec<'e, 'o, E: Engine, T: AsRef<[u8]>>(
 /// # Panics
 ///
 /// If the slice is not large enough, this will panic.
-pub fn decode_engine_slice<'e, 'o, E: Engine, T: AsRef<[u8]>>(
+pub fn decode_engine_slice<E: Engine, T: AsRef<[u8]>>(
     input: T,
-    output: &'o mut [u8],
-    engine: &'e E,
+    output: &mut [u8],
+    engine: &E,
 ) -> Result<usize, DecodeError> {
     let input_bytes = input.as_ref();
 

src/encode.rs

@@ -151,9 +151,9 @@ pub fn encode_engine_slice<E: Engine, T: AsRef<[u8]>>(
     let encoded_size = encoded_len(input_bytes.len(), engine.config().encode_padding())
         .expect("usize overflow when calculating buffer size");
 
-    let mut b64_output = &mut output_buf[0..encoded_size];
+    let b64_output = &mut output_buf[0..encoded_size];
 
-    encode_with_padding(&input_bytes, &mut b64_output, engine, encoded_size);
+    encode_with_padding(input_bytes, b64_output, engine, encoded_size);
 
     encoded_size
 }

src/engine/fast_portable/decode.rs

@@ -319,13 +319,11 @@ fn decode_chunk(
     decode_table: &[u8; 256],
     output: &mut [u8],
 ) -> Result<(), DecodeError> {
-    let mut accum: u64;
-
     let morsel = decode_table[input[0] as usize];
     if morsel == INVALID_VALUE {
         return Err(DecodeError::InvalidByte(index_at_start_of_input, input[0]));
     }
-    accum = (morsel as u64) << 58;
+    let mut accum: u64 = (morsel as u64) << 58;
 
     let morsel = decode_table[input[1] as usize];
     if morsel == INVALID_VALUE {

src/engine/fast_portable/mod.rs

@@ -27,8 +27,8 @@ impl FastPortable {
     /// if the engine will be used repeatedly.
     pub const fn from(alphabet: &Alphabet, config: FastPortableConfig) -> FastPortable {
         FastPortable {
-            encode_table: encode_table(&alphabet),
-            decode_table: decode_table(&alphabet),
+            encode_table: encode_table(alphabet),
+            decode_table: decode_table(alphabet),
             config,
         }
     }
@@ -194,7 +194,7 @@ pub(crate) const fn encode_table(alphabet: &Alphabet) -> [u8; 64] {
         }
     }
 
-    return encode_table;
+    encode_table
 }
 
 /// Returns a table mapping base64 bytes as the lookup index to either:
@@ -213,7 +213,7 @@ pub(crate) const fn decode_table(alphabet: &Alphabet) -> [u8; 256] {
         index += 1;
     }
 
-    return decode_table;
+    decode_table
 }
 
 #[inline]

src/read/decoder.rs

@@ -90,7 +90,7 @@ impl<'e, E: Engine, R: io::Read> DecoderReader<'e, E, R> {
     /// Returns a Result with the number of (decoded) bytes copied.
     fn flush_decoded_buf(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         debug_assert!(self.decoded_len > 0);
-        debug_assert!(buf.len() > 0);
+        debug_assert!(!buf.is_empty());
 
         let copy_len = cmp::min(self.decoded_len, buf.len());
         debug_assert!(copy_len > 0);
@@ -121,7 +121,7 @@ impl<'e, E: Engine, R: io::Read> DecoderReader<'e, E, R> {
 
         debug_assert!(self.b64_offset + self.b64_len <= BUF_SIZE);
 
-        return Ok(read);
+        Ok(read)
     }
 
     /// Decode the requested number of bytes from the b64 buffer into the provided buffer. It's the
@@ -131,11 +131,11 @@ impl<'e, E: Engine, R: io::Read> DecoderReader<'e, E, R> {
     fn decode_to_buf(&mut self, num_bytes: usize, buf: &mut [u8]) -> io::Result<usize> {
         debug_assert!(self.b64_len >= num_bytes);
         debug_assert!(self.b64_offset + self.b64_len <= BUF_SIZE);
-        debug_assert!(buf.len() > 0);
+        debug_assert!(!buf.is_empty());
 
         let decoded = decode_engine_slice(
             &self.b64_buffer[self.b64_offset..self.b64_offset + num_bytes],
-            &mut buf[..],
+            buf,
             self.engine,
         )
         .map_err(|e| match e {
@@ -183,7 +183,7 @@ impl<'e, E: Engine, R: Read> Read for DecoderReader<'e, E, R> {
     /// Any errors emitted by the delegate reader are returned. Decoding errors due to invalid
     /// base64 are also possible, and will have `io::ErrorKind::InvalidData`.
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
-        if buf.len() == 0 {
+        if buf.is_empty() {
             return Ok(0);
         }