Merge pull request marshallpierce#184 from marshallpierce/mp/cleanup

Clippy fixes

Author: marshallpierce

.circleci/config.yml

@@ -8,36 +8,51 @@ workflows:
           matrix:
             parameters:
               rust_img: [
-                  # The default rust images (not -slim or -alpine) are based on buildpack-deps. Hopefully this will
-                  # be easier on the CI hosts since presumably those fat lower layers will already be cached, and
-                  # therefore faster than a minimal, customized alpine.
-                  # MSRV
-                  'rust:1.47.0',
-                  # stable
-                  'rust:latest',
-                  'rustlang/rust:nightly'
-                  # would be nice to have beta as well: https://github.com/rust-lang/docker-rust/issues/14
+                # Yes, a single-parameter axis, but means it can be referred to as a cache parameter easily without
+                # duplicating the magic version number throughout this file.
+                # The default rust images (not -slim or -alpine) are based on buildpack-deps. Hopefully this will
+                # be easier on the CI hosts since presumably those fat lower layers will already be cached, and
+                # therefore faster than a minimal, customized alpine.
+                # MSRV
+                'rust:1.47.0'
+              ]
+              # a hacky scheme to work around CircleCI's inability to deal with mutable docker tags, forcing us to
+              # get a nightly or stable toolchain via rustup instead of a mutable docker tag
+              toolchain_override: [
+                '__msrv__', # won't add any other toolchains, just uses what's in the docker image
+                'stable',
+                'nightly'
               ]
 
 jobs:
   build:
     parameters:
       rust_img:
         type: string
+      toolchain_override:
+        type: string
     docker:
       - image: << parameters.rust_img >>
     steps:
       - checkout
       - restore_cache:
-          key: project-cache-v3-<< parameters.rust_img >>-{{ checksum "Cargo.toml" }}
+          key: project-cache-v5-<< parameters.rust_img >>-<< parameters.toolchain_override >>-{{ checksum "Cargo.toml" }}
+      - run:
+          name: Setup toolchain
+          command: |
+            if [[ '<< parameters.toolchain_override >>' != '__msrv__' ]]
+            then
+              rustup toolchain add '<< parameters.toolchain_override >>'
+              rustup default '<< parameters.toolchain_override >>'
+            fi
+      - run:
+          name: Log rustc version
+          command: rustc --version
       - run:
           name: Check formatting
           command: |
             rustup component add rustfmt
             cargo fmt -- --check
-      - run:
-          name: Add arm toolchain
-          command: rustup target add thumbv6m-none-eabi
       - run:
           name: Build all targets
           command: cargo build --all-targets
@@ -47,6 +62,9 @@ jobs:
       - run:
           name: Build with only alloc
           command: cargo build --no-default-features --features alloc
+      - run:
+          name: Add arm toolchain
+          command: rustup target add thumbv6m-none-eabi
       - run:
           name: Build ARM without default features (no_std)
           command: cargo build --target thumbv6m-none-eabi --no-default-features
@@ -60,19 +78,19 @@ jobs:
           name: Build docs
           command: cargo doc --verbose
       - run:
-          name: Confirm a fuzzer can run
+          name: Confirm fuzzers can run
           # TERM=dumb prevents cargo fuzz list from printing with color
           environment:
             TERM: dumb
           command: |
-            if [[ '<< parameters.rust_img >>' = 'rustlang/rust:nightly' ]]
+            if [[ '<< parameters.toolchain_override >>' = 'nightly' ]]
             then
               cargo install cargo-fuzz
               cargo fuzz list | xargs -I FUZZER cargo fuzz run FUZZER -- -max_total_time=1
             fi
 
       - save_cache:
-          key: project-cache-v3-<< parameters.rust_img >>-{{ checksum "Cargo.toml" }}
+          key: project-cache-v5-<< parameters.rust_img >>-<< parameters.toolchain_override >>-{{ checksum "Cargo.toml" }}
           paths:
             # rust docker img doesn't use $HOME/[.cargo,.rustup]
             - /usr/local/cargo

src/alphabet.rs

@@ -1,8 +1,9 @@
 //! Provides [Alphabet] and constants for alphabets commonly used in the wild.
 
 use crate::PAD_BYTE;
+use core::{convert, fmt};
 #[cfg(any(feature = "std", test))]
-use std::{convert, error, fmt};
+use std::error;
 
 const ALPHABET_SIZE: usize = 64;
 
@@ -43,9 +44,6 @@ impl Alphabet {
     /// Create an `Alphabet` from a string of 64 unique printable ASCII bytes.
     ///
     /// The `=` byte is not allowed as it is used for padding.
-    ///
-    /// The `const`-ness of this function isn't useful as of rust 1.54.0 since `const` `unwrap()`,
-    /// etc, haven't shipped yet, but that's [on the roadmap](https://github.com/rust-lang/rust/issues/85194).
     pub const fn from_str(alphabet: &str) -> Result<Self, ParseAlphabetError> {
         let bytes = alphabet.as_bytes();
         if bytes.len() != ALPHABET_SIZE {
@@ -95,7 +93,6 @@ impl Alphabet {
     }
 }
 
-#[cfg(any(feature = "std", test))]
 impl convert::TryFrom<&str> for Alphabet {
     type Error = ParseAlphabetError;
 
@@ -117,7 +114,6 @@ pub enum ParseAlphabetError {
     ReservedByte(u8),
 }
 
-#[cfg(any(feature = "std", test))]
 impl fmt::Display for ParseAlphabetError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {

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);
         }