Clippy

Author: kornelski

src/blocksplitter.rs

@@ -89,7 +89,7 @@ fn find_largest_splittable_block(
 
     let mut last = 0;
 
-    for &item in splitpoints.iter() {
+    for &item in splitpoints {
         if done[last] == 0 && item - last > longest {
             found = Some((last, item));
             longest = item - last;
@@ -136,12 +136,12 @@ fn print_block_split_points(lz77: &Lz77Store, lz77splitpoints: &[usize]) {
         "block split points: {} (hex: {})",
         splitpoints
             .iter()
-            .map(|&sp| format!("{}", sp))
+            .map(|&sp| format!("{sp}"))
             .collect::<Vec<_>>()
             .join(" "),
         splitpoints
             .iter()
-            .map(|&sp| format!("{:x}", sp))
+            .map(|&sp| format!("{sp:x}"))
             .collect::<Vec<_>>()
             .join(" ")
     );
@@ -160,7 +160,7 @@ pub fn blocksplit_lz77(lz77: &Lz77Store, maxblocks: u16, splitpoints: &mut Vec<u
     let mut lstart = 0;
     let mut lend = lz77.size();
 
-    while maxblocks != 0 && numblocks < maxblocks as u32 {
+    while maxblocks != 0 && numblocks < u32::from(maxblocks) {
         debug_assert!(lstart < lend);
         let find_minimum_result = find_minimum(
             |i| estimate_cost(lz77, lstart, i) + estimate_cost(lz77, i, lend),
@@ -179,7 +179,7 @@ pub fn blocksplit_lz77(lz77: &Lz77Store, maxblocks: u16, splitpoints: &mut Vec<u
             done[lstart] = 1;
         } else {
             splitpoints.push(llpos);
-            splitpoints.sort();
+            splitpoints.sort_unstable();
             numblocks += 1;
         }
 

src/cache.rs

@@ -19,8 +19,8 @@ pub struct ZopfliLongestMatchCache {
 }
 
 impl ZopfliLongestMatchCache {
-    pub fn new(blocksize: usize) -> ZopfliLongestMatchCache {
-        ZopfliLongestMatchCache {
+    pub fn new(blocksize: usize) -> Self {
+        Self {
             /* length > 0 and dist 0 is invalid combination, which indicates on purpose
             that this cache value is not filled in yet. */
             length: vec![1; blocksize],
@@ -52,7 +52,7 @@ impl ZopfliLongestMatchCache {
         if self.sublen[start + 1] == 0 && self.sublen[start + 2] == 0 {
             return 0; // No sublen cached.
         }
-        self.sublen[start + ((ZOPFLI_CACHE_LENGTH - 1) * 3)] as u32 + 3
+        u32::from(self.sublen[start + ((ZOPFLI_CACHE_LENGTH - 1) * 3)]) + 3
     }
 
     /// Stores sublen array in the cache.
@@ -100,8 +100,8 @@ impl ZopfliLongestMatchCache {
 
         for j in 0..ZOPFLI_CACHE_LENGTH {
             let length = self.sublen[start + (j * 3)] as usize + 3;
-            let dist = self.sublen[start + (j * 3 + 1)] as u16
-                + 256 * self.sublen[start + (j * 3 + 2)] as u16;
+            let dist = u16::from(self.sublen[start + (j * 3 + 1)])
+                + 256 * u16::from(self.sublen[start + (j * 3 + 2)]);
 
             let mut i = prevlength;
             while i <= length {
@@ -178,7 +178,7 @@ impl Cache for ZopfliLongestMatchCache {
             || (sublen.is_some() && max_sublen >= limit as u32);
 
         if limit_ok_for_cache && cache_available {
-            if sublen.is_none() || length_lmcpos as u32 <= max_sublen {
+            if sublen.is_none() || u32::from(length_lmcpos) <= max_sublen {
                 let length = cmp::min(length_lmcpos, limit as u16);
                 let distance;
                 if let Some(ref mut subl) = *sublen {

src/deflate.rs

@@ -46,7 +46,7 @@ impl<W: Write> DeflateEncoder<W> {
     /// Creates a new Zopfli DEFLATE encoder that will operate according to the
     /// specified options.
     pub fn new(options: Options, btype: BlockType, sink: W) -> Self {
-        DeflateEncoder {
+        Self {
             options,
             btype,
             have_chunk: false,
@@ -399,7 +399,7 @@ fn calculate_block_symbol_size_small(
         match item {
             LitLen::Literal(litlens_i) => {
                 debug_assert!(litlens_i < 259);
-                result += ll_lengths[litlens_i as usize]
+                result += ll_lengths[litlens_i as usize];
             }
             LitLen::LengthDist(litlens_i, dists_i) => {
                 debug_assert!(litlens_i < 259);
@@ -829,7 +829,7 @@ fn add_lz77_block<W: Write>(
         return add_non_compressed_block(final_block, in_data, pos, end, bitwise_writer);
     }
 
-    bitwise_writer.add_bit(final_block as u8)?;
+    bitwise_writer.add_bit(u8::from(final_block))?;
 
     let (ll_lengths, d_lengths) = match btype {
         BlockType::Uncompressed => unreachable!(),
@@ -1034,7 +1034,7 @@ fn add_lz77_data<W: Write>(
                 )?;
                 bitwise_writer.add_huffman_bits(d_symbols[ds], d_lengths[ds])?;
                 bitwise_writer.add_bits(
-                    get_dist_extra_bits_value(dist) as u32,
+                    u32::from(get_dist_extra_bits_value(dist)),
                     get_dist_extra_bits(dist) as u32,
                 )?;
                 testlength += litlen;
@@ -1067,7 +1067,7 @@ fn add_lz77_block_auto_type<W: Write>(
     let mut fixedstore = Lz77Store::new();
     if lstart == lend {
         /* Smallest empty block is represented by fixed block */
-        bitwise_writer.add_bits(final_block as u32, 1)?;
+        bitwise_writer.add_bits(u32::from(final_block), 1)?;
         bitwise_writer.add_bits(1, 2)?; /* btype 01 */
         bitwise_writer.add_bits(0, 7)?; /* end symbol has code 0000000 */
         return Ok(());
@@ -1158,7 +1158,7 @@ fn add_all_blocks<W: Write>(
     bitwise_writer: &mut BitwiseWriter<W>,
 ) -> Result<(), Error> {
     let mut last = 0;
-    for &item in splitpoints.iter() {
+    for &item in splitpoints {
         add_lz77_block_auto_type(false, in_data, lz77, last, item, 0, bitwise_writer)?;
         last = item;
     }
@@ -1285,7 +1285,7 @@ fn add_non_compressed_block<W: Write>(
         let blocksize = chunk.len();
         let nlen = !blocksize;
 
-        bitwise_writer.add_bit((final_block && is_final) as u8)?;
+        bitwise_writer.add_bit(u8::from(final_block && is_final))?;
         /* BTYPE 00 */
         bitwise_writer.add_bit(0)?;
         bitwise_writer.add_bit(0)?;
@@ -1311,16 +1311,16 @@ struct BitwiseWriter<W> {
 }
 
 impl<W: Write> BitwiseWriter<W> {
-    fn new(out: W) -> BitwiseWriter<W> {
-        BitwiseWriter {
+    const fn new(out: W) -> Self {
+        Self {
             bit: 0,
             bp: 0,
             len: 0,
             out,
         }
     }
 
-    fn bytes_written(&self) -> usize {
+    const fn bytes_written(&self) -> usize {
         self.len + if self.bp > 0 { 1 } else { 0 }
     }
 
@@ -1399,7 +1399,7 @@ mod test {
 
         set_counts_to_count(&mut counts, count, i, stride);
 
-        assert_eq!(counts, vec![0, 1, 2, 100, 100, 100, 100, 100, 8, 9])
+        assert_eq!(counts, vec![0, 1, 2, 100, 100, 100, 100, 100, 8, 9]);
     }
 
     #[test]

src/hash.rs

@@ -64,10 +64,10 @@ pub struct ZopfliHash {
 }
 
 impl ZopfliHash {
-    pub fn new() -> Box<ZopfliHash> {
+    pub fn new() -> Box<Self> {
         const LAYOUT: Layout = Layout::new::<ZopfliHash>();
 
-        let ptr = NonNull::new(unsafe { alloc(LAYOUT) } as *mut ZopfliHash)
+        let ptr = NonNull::new(unsafe { alloc(LAYOUT) }.cast::<Self>())
             .unwrap_or_else(|| handle_alloc_error(LAYOUT));
 
         unsafe {
@@ -133,11 +133,11 @@ impl ZopfliHash {
     /// must be made on consecutive input characters. Since the hash value exists out
     /// of multiple input bytes, a few warmups with this function are needed initially.
     fn update_val(&mut self, c: u8) {
-        self.hash1.val = ((self.hash1.val << HASH_SHIFT) ^ c as u16) & HASH_MASK;
+        self.hash1.val = ((self.hash1.val << HASH_SHIFT) ^ u16::from(c)) & HASH_MASK;
     }
 
     pub fn update(&mut self, array: &[u8], pos: usize) {
-        let hash_value = array.get(pos + ZOPFLI_MIN_MATCH - 1).cloned().unwrap_or(0);
+        let hash_value = array.get(pos + ZOPFLI_MIN_MATCH - 1).copied().unwrap_or(0);
         self.update_val(hash_value);
 
         let hpos = pos & ZOPFLI_WINDOW_MASK;
@@ -171,7 +171,7 @@ impl ZopfliHash {
             Which::Hash1 => self.hash1.prev_and_hashval[index].hashval,
             Which::Hash2 => self.hash2.prev_and_hashval[index].hashval,
         };
-        hashval.map_or(-1, |hv| hv as i32)
+        hashval.map_or(-1, i32::from)
     }
 
     pub fn val(&self, which: Which) -> u16 {

src/katajainen.rs

@@ -131,7 +131,7 @@ pub fn length_limited_code_lengths(frequencies: &[usize], max_bits: usize) -> Ve
     thing.extract_bit_lengths(max_bits, num_freqs)
 }
 
-impl<'a> Thing<'a> {
+impl Thing<'_> {
     fn boundary_pm(&mut self, index: usize) {
         let num_symbols = self.leaves.len();
 

src/lib.rs

@@ -114,8 +114,8 @@ pub struct Options {
 }
 
 impl Default for Options {
-    fn default() -> Options {
-        Options {
+    fn default() -> Self {
+        Self {
             iteration_count: NonZeroU64::new(15).unwrap(),
             iterations_without_improvement: NonZeroU64::new(u64::MAX).unwrap(),
             maximum_block_splits: 15,

src/lz77.rs

@@ -18,10 +18,10 @@ pub enum LitLen {
 }
 
 impl LitLen {
-    pub fn size(&self) -> usize {
+    pub const fn size(&self) -> usize {
         match *self {
-            LitLen::Literal(_) => 1,
-            LitLen::LengthDist(len, _) => len as usize,
+            Self::Literal(_) => 1,
+            Self::LengthDist(len, _) => len as usize,
         }
     }
 }
@@ -45,8 +45,8 @@ pub struct Lz77Store {
 }
 
 impl Lz77Store {
-    pub fn new() -> Lz77Store {
-        Lz77Store {
+    pub const fn new() -> Self {
+        Self {
             litlens: vec![],
 
             pos: vec![],
@@ -131,7 +131,7 @@ impl Lz77Store {
 
     /// Does LZ77 using an algorithm similar to gzip, with lazy matching, rather than
     /// with the slow but better "squeeze" implementation.
-    /// The result is placed in the Lz77Store.
+    /// The result is placed in the `Lz77Store`.
     /// If instart is larger than 0, it uses values before instart as starting
     /// dictionary.
     pub fn greedy<C: Cache>(&mut self, lmc: &mut C, in_data: &[u8], instart: usize, inend: usize) {
@@ -165,20 +165,20 @@ impl Lz77Store {
                 find_longest_match(lmc, &h, arr, i, inend, instart, ZOPFLI_MAX_MATCH, &mut None);
             dist = longest_match.distance;
             leng = longest_match.length;
-            lengthscore = get_length_score(leng as i32, dist as i32);
+            lengthscore = get_length_score(i32::from(leng), i32::from(dist));
 
             /* Lazy matching. */
             prevlengthscore = get_length_score(prev_length as i32, prev_match as i32);
             if match_available {
                 match_available = false;
                 if lengthscore > prevlengthscore + 1 {
-                    self.lit_len_dist(arr[i - 1] as u16, 0, i - 1);
+                    self.lit_len_dist(u16::from(arr[i - 1]), 0, i - 1);
                     if (lengthscore as usize) >= ZOPFLI_MIN_MATCH
                         && (leng as usize) < ZOPFLI_MAX_MATCH
                     {
                         match_available = true;
-                        prev_length = leng as u32;
-                        prev_match = dist as u32;
+                        prev_length = u32::from(leng);
+                        prev_match = u32::from(dist);
                         i += 1;
                         continue;
                     }
@@ -201,8 +201,8 @@ impl Lz77Store {
                 && (leng as usize) < ZOPFLI_MAX_MATCH
             {
                 match_available = true;
-                prev_length = leng as u32;
-                prev_match = dist as u32;
+                prev_length = u32::from(leng);
+                prev_match = u32::from(dist);
                 i += 1;
                 continue;
             }
@@ -214,7 +214,7 @@ impl Lz77Store {
                 self.lit_len_dist(leng, dist, i);
             } else {
                 leng = 1;
-                self.lit_len_dist(arr[i] as u16, 0, i);
+                self.lit_len_dist(u16::from(arr[i]), 0, i);
             }
             for _ in 1..leng {
                 debug_assert!(i < inend);
@@ -276,7 +276,7 @@ impl Lz77Store {
                 self.lit_len_dist(length, dist, pos);
             } else {
                 length = 1;
-                self.lit_len_dist(arr[pos] as u16, 0, pos);
+                self.lit_len_dist(u16::from(arr[pos]), 0, pos);
             }
 
             debug_assert!(pos + (length as usize) <= inend);
@@ -385,8 +385,8 @@ pub struct LongestMatch {
 }
 
 impl LongestMatch {
-    pub fn new(limit: usize) -> Self {
-        LongestMatch {
+    pub const fn new(limit: usize) -> Self {
+        Self {
             distance: 0,
             length: 0,
             from_cache: false,
@@ -401,7 +401,7 @@ impl LongestMatch {
 /// `scan` is the position to compare; `match` is the earlier position to compare.
 /// `end` is the last possible byte, beyond which to stop looking.
 /// `safe_end` is a few (8) bytes before end, for comparing multiple bytes at once.
-fn get_match(array: &[u8], scan_offset: usize, match_offset: usize, end: usize) -> usize {
+const fn get_match(array: &[u8], scan_offset: usize, match_offset: usize, end: usize) -> usize {
     let mut scan_offset = scan_offset;
     let mut match_offset = match_offset;
     // /* 8 checks at once per array bounds check (usize is 64-bit). */
@@ -505,7 +505,7 @@ fn find_longest_match_loop(
 
         debug_assert!(p < ZOPFLI_WINDOW_SIZE);
         debug_assert_eq!(p, h.prev_at(pp, which_hash));
-        debug_assert_eq!(h.hash_val_at(p, which_hash), h.val(which_hash) as i32);
+        debug_assert_eq!(h.hash_val_at(p, which_hash), i32::from(h.val(which_hash)));
 
         if dist > 0 {
             debug_assert!(pos < size);
@@ -545,7 +545,7 @@ fn find_longest_match_loop(
         /* Switch to the other hash once this will be more efficient. */
         if which_hash == Which::Hash1
             && bestlength >= h.same[hpos] as usize
-            && h.val(Which::Hash2) as i32 == h.hash_val_at(p, Which::Hash2)
+            && i32::from(h.val(Which::Hash2)) == h.hash_val_at(p, Which::Hash2)
         {
             /* Now use the hash that encodes the length and first byte. */
             which_hash = Which::Hash2;
@@ -587,7 +587,7 @@ fn find_longest_match_loop(
 ///  rather unpredictable way
 /// -the first zopfli run, so it affects the chance of the first run being closer
 ///  to the optimal output
-fn get_length_score(length: i32, distance: i32) -> i32 {
+const fn get_length_score(length: i32, distance: i32) -> i32 {
     // At 1024, the distance uses 9+ extra bits and this seems to be the sweet spot
     // on tested files.
     if distance > 1024 {

src/main.rs

@@ -22,18 +22,18 @@ fn main() {
 
     for filename in env::args().skip(1) {
         let file = File::open(&filename)
-            .unwrap_or_else(|why| panic!("couldn't open {}: {}", filename, why));
+            .unwrap_or_else(|why| panic!("couldn't open {filename}: {why}"));
         let filesize = file.metadata().map(|x| x.len()).unwrap() as usize;
 
-        let out_filename = format!("{}{}", filename, extension);
+        let out_filename = format!("{filename}{extension}");
 
         // Attempt to create the output file, panic if the output file could not be opened
         let out_file = File::create(&out_filename)
-            .unwrap_or_else(|why| panic!("couldn't create output file {}: {}", out_filename, why));
+            .unwrap_or_else(|why| panic!("couldn't create output file {out_filename}: {why}"));
         let mut out_file = WriteStatistics::new(out_file);
 
         zopfli::compress(options, output_type, &file, &mut out_file).unwrap_or_else(|why| {
-            panic!("couldn't write to output file {}: {}", out_filename, why)
+            panic!("couldn't write to output file {out_filename}: {why}")
         });
 
         let out_size = out_file.count;
@@ -52,8 +52,8 @@ struct WriteStatistics<W> {
 }
 
 impl<W> WriteStatistics<W> {
-    fn new(inner: W) -> Self {
-        WriteStatistics { inner, count: 0 }
+    const fn new(inner: W) -> Self {
+        Self { inner, count: 0 }
     }
 }