Fix clippy::needless_late_init

Used `cargo clippy -- -A clippy::all -W clippy::needless_late_init` to find all such cases, and manually fix them

Additionally simplified logic in backward_references/hq.rs, and converted while into for loop there

Author: nyurik

src/enc/backward_references/hq.rs

@@ -731,34 +731,31 @@ fn UpdateNodes<AllocF: Allocator<floatX>>(
                                 + i32::from(kDistanceCacheOffset[j]))
                                 as usize;
                             let mut prev_ix: usize = cur_ix.wrapping_sub(backward);
-                            let len: usize;
                             let continuation: u8 = ringbuffer[cur_ix_masked.wrapping_add(best_len)];
                             if cur_ix_masked.wrapping_add(best_len) > ringbuffer_mask {
                                 break 'break29;
                             }
                             if backward > max_distance.wrapping_add(gap) {
                                 break 'continue30;
                             }
-                            if backward <= max_distance {
-                                if prev_ix >= cur_ix {
-                                    break 'continue30;
-                                }
-                                prev_ix &= ringbuffer_mask;
-                                if prev_ix.wrapping_add(best_len) > ringbuffer_mask
-                                    || continuation as i32
-                                        != ringbuffer[(prev_ix.wrapping_add(best_len) as usize)]
-                                            as i32
-                                {
-                                    break 'continue30;
-                                }
-                                len = FindMatchLengthWithLimit(
-                                    &ringbuffer[(prev_ix as usize)..],
-                                    &ringbuffer[cur_ix_masked..],
-                                    max_len,
-                                );
-                            } else {
+                            if backward > max_distance {
+                                break 'continue30;
+                            }
+                            if prev_ix >= cur_ix {
                                 break 'continue30;
                             }
+                            prev_ix &= ringbuffer_mask;
+                            if prev_ix.wrapping_add(best_len) > ringbuffer_mask
+                                || continuation as i32
+                                    != ringbuffer[(prev_ix.wrapping_add(best_len) as usize)] as i32
+                            {
+                                break 'continue30;
+                            }
+                            let len = FindMatchLengthWithLimit(
+                                &ringbuffer[(prev_ix as usize)..],
+                                &ringbuffer[cur_ix_masked..],
+                                max_len,
+                            );
                             {
                                 let dist_cost = base_cost + model.get_distance_cost(j);
                                 for l in best_len.wrapping_add(1)..=len {

src/enc/brotli_bit_stream.rs

@@ -309,13 +309,11 @@ fn process_command_queue<'a, CmdProcessor: interface::CommandProcessor<'a>>(
         let copylen_code = cmd.copy_len_code();
 
         let (prev_dist_index, dist_offset) = cmd.distance_index_and_offset(&params.dist);
-        let final_distance: usize;
-        if prev_dist_index == 0 {
-            final_distance = dist_offset as usize;
+        let final_distance = if prev_dist_index == 0 {
+            dist_offset as usize
         } else {
-            final_distance =
-                (local_dist_cache[prev_dist_index - 1] as isize + dist_offset) as usize;
-        }
+            (local_dist_cache[prev_dist_index - 1] as isize + dist_offset) as usize
+        };
         let copy_len = copylen_code as usize;
         let actual_copy_len: usize;
         let max_distance = min(

src/enc/encode.rs

@@ -1572,15 +1572,14 @@ impl<Alloc: BrotliAlloc> BrotliEncoderStateStruct<Alloc> {
             let delta: u64 = self.unprocessed_input_size();
             let tail: u64 = available_in as u64;
             let limit: u32 = 1u32 << 30;
-            let total: u32;
-            if delta >= u64::from(limit)
+            let total: u32 = if delta >= u64::from(limit)
                 || tail >= u64::from(limit)
                 || delta.wrapping_add(tail) >= u64::from(limit)
             {
-                total = limit;
+                limit
             } else {
-                total = delta.wrapping_add(tail) as u32;
-            }
+                delta.wrapping_add(tail) as u32
+            };
             self.params.size_hint = total as usize;
         }
     }

src/enc/mod.rs

@@ -291,12 +291,11 @@ where
                     }
                 }
             }
-            let op: BrotliEncoderOperation;
-            if available_in == 0 {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_FINISH;
+            let op = if available_in == 0 {
+                BrotliEncoderOperation::BROTLI_OPERATION_FINISH
             } else {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_PROCESS;
-            }
+                BrotliEncoderOperation::BROTLI_OPERATION_PROCESS
+            };
             let result = s.compress_stream(
                 op,
                 &mut available_in,

src/enc/reader.rs

@@ -221,12 +221,11 @@ impl<ErrType, R: CustomRead<ErrType>, BufferType: SliceWrapperMut<u8>, Alloc: Br
                     }
                 }
             }
-            let op: BrotliEncoderOperation;
-            if avail_in == 0 {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_FINISH;
+            let op = if avail_in == 0 {
+                BrotliEncoderOperation::BROTLI_OPERATION_FINISH
             } else {
-                op = BrotliEncoderOperation::BROTLI_OPERATION_PROCESS;
-            }
+                BrotliEncoderOperation::BROTLI_OPERATION_PROCESS
+            };
             let ret = self.state.0.compress_stream(
                 op,
                 &mut avail_in,