Simplify derefs (*foo).bar() into foo.bar()

 \(\*([a-z][a-z0-9_]*)\)\. ->  $1.

And fixed (reverted) a few that didn't compile

Author: danielrh

corrosion/backward_references_hq.rs

@@ -380,8 +380,8 @@ impl<'a> BackwardMatchMut<'a> {
 
 #[inline(always)]
 pub fn InitBackwardMatch(xself: &mut BackwardMatchMut, dist: usize, len: usize) {
-    (*xself).set_distance(dist as u32);
-    (*xself).set_length_and_code((len << 5) as u32);
+    xself.set_distance(dist as u32);
+    xself.set_length_and_code((len << 5) as u32);
 }
 
 macro_rules! LeftChildIndexH10 {
@@ -402,7 +402,7 @@ fn LeftChildIndexH10<AllocU32: Allocator<u32>,
      Params:H10Params>(
     mut xself : &mut H10<AllocU32, Buckets, Params>, pos : usize
 ) -> usize {
-    (2usize).wrapping_mul(pos & (*xself).window_mask_)
+    (2usize).wrapping_mul(pos & xself.window_mask_)
 }
 
 fn RightChildIndexH10<AllocU32: Allocator<u32>,
@@ -411,7 +411,7 @@ fn RightChildIndexH10<AllocU32: Allocator<u32>,
     mut xself : &mut H10<AllocU32, Buckets, Params>, pos : usize
 ) -> usize {
     (2usize).wrapping_mul(
-        pos & (*xself).window_mask_
+        pos & xself.window_mask_
     ).wrapping_add(
         1
     )

corrosion/backward_references_hq_safe.rs

@@ -160,12 +160,12 @@ pub fn BrotliZopfliCreateCommands(
                     dist_cache[0] = distance as i32;
                 }
             }
-            *num_literals = (*num_literals).wrapping_add(insert_length);
+            *num_literals = num_literals.wrapping_add(insert_length);
             pos = pos.wrapping_add(copy_length);
         }
         i = i.wrapping_add(1);
     }
-    *last_insert_len = (*last_insert_len).wrapping_add(num_bytes.wrapping_sub(pos));
+    *last_insert_len = last_insert_len.wrapping_add(num_bytes.wrapping_sub(pos));
 }
 
 #[inline(always)]
@@ -307,7 +307,7 @@ fn InitDictionaryBackwardMatch(
     len: usize,
     len_code: usize,
 ) {
-    (*xself).set_distance(dist as u32);
+    xself.set_distance(dist as u32);
     (*xself)
         .set_length_and_code((len << 5 | if len == len_code { 0usize } else { len_code }) as u32);
 }
@@ -490,7 +490,7 @@ where
 
 #[inline(always)]
 fn BackwardMatchLength(xself: &BackwardMatch) -> usize {
-    ((*xself).length_and_code() >> 5) as usize
+    (xself.length_and_code() >> 5) as usize
 }
 
 #[inline(always)]
@@ -720,7 +720,7 @@ fn UpdateZopfliNode(
 
 #[inline(always)]
 fn BackwardMatchLengthCode(xself: &BackwardMatch) -> usize {
-    let code: usize = ((*xself).length_and_code() & 31u32) as usize;
+    let code: usize = (xself.length_and_code() & 31u32) as usize;
     if code != 0 {
         code
     } else {
@@ -1144,7 +1144,7 @@ pub fn BrotliCreateZopfliBackwardReferences<
         return;
     }
     BrotliInitZopfliNodes(nodes.slice_mut(), num_bytes.wrapping_add(1));
-    *num_commands = (*num_commands).wrapping_add(BrotliZopfliComputeShortestPath(
+    *num_commands = num_commands.wrapping_add(BrotliZopfliComputeShortestPath(
         alloc,
         dictionary,
         num_bytes,
@@ -1503,7 +1503,7 @@ pub fn BrotliCreateHqZopfliBackwardReferences<
             }
             let num_found_matches: usize = FindAllMatchesH10(
                 hasher,
-                dictionary, //&(*params).dictionary ,
+                dictionary, //&params.dictionary ,
                 ringbuffer,
                 ringbuffer_mask,
                 pos,
@@ -1598,7 +1598,7 @@ pub fn BrotliCreateHqZopfliBackwardReferences<
                     ringbuffer,
                     ringbuffer_mask,
                     commands,
-                    (*num_commands).wrapping_sub(orig_num_commands),
+                    num_commands.wrapping_sub(orig_num_commands),
                     orig_last_insert_len,
                 );
             }
@@ -1613,7 +1613,7 @@ pub fn BrotliCreateHqZopfliBackwardReferences<
             {
                 *i = *j;
             }
-            *num_commands = (*num_commands).wrapping_add(ZopfliIterate(
+            *num_commands = num_commands.wrapping_add(ZopfliIterate(
                 num_bytes,
                 position,
                 ringbuffer,

src/enc/backward_references/hash_to_binary_tree.rs

@@ -1407,7 +1407,7 @@ impl<
                         * self.specialization.get_k_hash_mul())
                         & self.specialization.get_hash_mask();
                     let key = mixed_word >> shift;
-                    let minor_ix: usize = chunk_id & self.specialization.block_mask() as usize; //   *num_ref as usize & (*self).specialization.block_mask() as usize; //GIGANTIC HAX: overwrite firsst option
+                    let minor_ix: usize = chunk_id & self.specialization.block_mask() as usize; //   *num_ref as usize & self.specialization.block_mask() as usize; //GIGANTIC HAX: overwrite firsst option
                     let offset: usize =
                         minor_ix + (key << self.specialization.block_bits()) as usize;
                     buckets[offset] = (ix_offset + i) as u32;
@@ -2501,7 +2501,7 @@ fn CreateBackwardReferences<AH: AnyHasher>(
                     distance_code,
                 );
             }
-            *num_literals = (*num_literals).wrapping_add(insert_length);
+            *num_literals = num_literals.wrapping_add(insert_length);
             insert_length = 0usize;
             hasher.StoreRange(
                 ringbuffer,
@@ -2537,7 +2537,7 @@ fn CreateBackwardReferences<AH: AnyHasher>(
     }
     insert_length = insert_length.wrapping_add(pos_end.wrapping_sub(position));
     *last_insert_len = insert_length;
-    *num_commands = (*num_commands).wrapping_add(new_commands_count);
+    *num_commands = num_commands.wrapping_add(new_commands_count);
 }
 pub fn BrotliCreateBackwardReferences<
     Alloc: alloc::Allocator<u16>

src/enc/backward_references/hq.rs

@@ -250,19 +250,19 @@ pub fn BrotliPopulationCost<HistogramType: SliceWrapper<u32> + CostAccessors>(
     static kTwoSymbolHistogramCost: super::util::floatX = 20i32 as super::util::floatX;
     static kThreeSymbolHistogramCost: super::util::floatX = 28i32 as super::util::floatX;
     static kFourSymbolHistogramCost: super::util::floatX = 37i32 as super::util::floatX;
-    let data_size: usize = (*histogram).slice().len();
+    let data_size: usize = histogram.slice().len();
     let mut count: i32 = 0i32;
     let mut s: [usize; 5] = [0; 5];
 
     let mut bits: super::util::floatX = 0.0 as super::util::floatX;
     let mut i: usize;
-    if (*histogram).total_count() == 0usize {
+    if histogram.total_count() == 0usize {
         return kOneSymbolHistogramCost;
     }
     i = 0usize;
     'break1: while i < data_size {
         {
-            if (*histogram).slice()[i] > 0u32 {
+            if histogram.slice()[i] > 0u32 {
                 s[count as usize] = i;
                 count += 1;
                 if count > 4i32 {
@@ -278,12 +278,12 @@ pub fn BrotliPopulationCost<HistogramType: SliceWrapper<u32> + CostAccessors>(
         return kOneSymbolHistogramCost;
     }
     if count == 2i32 {
-        return kTwoSymbolHistogramCost + (*histogram).total_count() as super::util::floatX;
+        return kTwoSymbolHistogramCost + histogram.total_count() as super::util::floatX;
     }
     if count == 3i32 {
-        let histo0: u32 = (*histogram).slice()[s[0]];
-        let histo1: u32 = (*histogram).slice()[s[1]];
-        let histo2: u32 = (*histogram).slice()[s[2]];
+        let histo0: u32 = histogram.slice()[s[0]];
+        let histo1: u32 = histogram.slice()[s[1]];
+        let histo2: u32 = histogram.slice()[s[2]];
         let histomax: u32 = brotli_max_uint32_t(histo0, brotli_max_uint32_t(histo1, histo2));
         return kThreeSymbolHistogramCost
             + (2u32).wrapping_mul(histo0.wrapping_add(histo1).wrapping_add(histo2))
@@ -296,7 +296,7 @@ pub fn BrotliPopulationCost<HistogramType: SliceWrapper<u32> + CostAccessors>(
         i = 0usize;
         while i < 4usize {
             {
-                histo[i] = (*histogram).slice()[s[i]];
+                histo[i] = histogram.slice()[s[i]];
             }
             i = i.wrapping_add(1);
         }
@@ -327,18 +327,18 @@ pub fn BrotliPopulationCost<HistogramType: SliceWrapper<u32> + CostAccessors>(
         // vectorization failed: it's faster to do things inline than split into two loops
         let mut nnz: usize = 0;
         let mut depth_histo = [0u32; 18];
-        let total_count = (*histogram).total_count() as super::util::floatX;
-        let log2total = FastLog2((*histogram).total_count() as u64);
+        let total_count = histogram.total_count() as super::util::floatX;
+        let log2total = FastLog2(histogram.total_count() as u64);
         i = 0usize;
         while i < data_size {
-            if (*histogram).slice()[i] > 0u32 {
+            if histogram.slice()[i] > 0u32 {
                 let nnz_val = &mut nnz_data.slice_mut()[nnz >> 3];
                 nnz_val[nnz & 7] = histogram.slice()[i] as i32;
                 i += 1;
                 nnz += 1;
             } else {
                 let mut reps: u32 = 1;
-                for hd in (*histogram).slice()[i + 1..data_size].iter() {
+                for hd in histogram.slice()[i + 1..data_size].iter() {
                     if *hd != 0 {
                         break;
                     }
@@ -368,7 +368,7 @@ pub fn BrotliPopulationCost<HistogramType: SliceWrapper<u32> + CostAccessors>(
     } else {
         let mut max_depth: usize = 1;
         let mut depth_histo = [0u32; 18];
-        let log2total: super::util::floatX = FastLog2((*histogram).total_count() as u64); // 64 bit here
+        let log2total: super::util::floatX = FastLog2(histogram.total_count() as u64); // 64 bit here
         let mut reps: u32 = 0;
         for histo in histogram.slice()[..data_size].iter() {
             if *histo != 0 {

src/enc/backward_references/mod.rs

@@ -170,7 +170,7 @@ fn CopyLiteralsToByteArray(
 }
 
 fn MyRand(seed: &mut u32) -> u32 {
-    *seed = (*seed).wrapping_mul(16807);
+    *seed = seed.wrapping_mul(16807);
     if *seed == 0u32 {
         *seed = 1u32;
     }
@@ -804,36 +804,36 @@ fn ClusterBlocks<
     <Alloc as Allocator<u32>>::free_cell(alloc, core::mem::take(&mut clusters));
     <Alloc as Allocator<HistogramType>>::free_cell(alloc, core::mem::take(&mut all_histograms));
     {
-        if (*split).types_alloc_size() < num_blocks {
-            let mut _new_size: usize = if (*split).types_alloc_size() == 0usize {
+        if split.types_alloc_size() < num_blocks {
+            let mut _new_size: usize = if split.types_alloc_size() == 0usize {
                 num_blocks
             } else {
-                (*split).types_alloc_size()
+                split.types_alloc_size()
             };
             while _new_size < num_blocks {
                 _new_size = _new_size.wrapping_mul(2);
             }
             let mut new_array = <Alloc as Allocator<u8>>::alloc_cell(alloc, _new_size);
-            new_array.slice_mut()[..(*split).types_alloc_size()]
-                .clone_from_slice(&split.types.slice()[..(*split).types_alloc_size()]);
+            new_array.slice_mut()[..split.types_alloc_size()]
+                .clone_from_slice(&split.types.slice()[..split.types_alloc_size()]);
             <Alloc as Allocator<u8>>::free_cell(
                 alloc,
                 core::mem::replace(&mut split.types, new_array),
             );
         }
     }
     {
-        if (*split).lengths_alloc_size() < num_blocks {
-            let mut _new_size: usize = if (*split).lengths_alloc_size() == 0usize {
+        if split.lengths_alloc_size() < num_blocks {
+            let mut _new_size: usize = if split.lengths_alloc_size() == 0usize {
                 num_blocks
             } else {
-                (*split).lengths_alloc_size()
+                split.lengths_alloc_size()
             };
             while _new_size < num_blocks {
                 _new_size = _new_size.wrapping_mul(2);
             }
             let mut new_array = <Alloc as Allocator<u32>>::alloc_cell(alloc, _new_size);
-            new_array.slice_mut()[..(*split).lengths_alloc_size()]
+            new_array.slice_mut()[..split.lengths_alloc_size()]
                 .clone_from_slice(split.lengths.slice());
             <Alloc as Allocator<u32>>::free_cell(
                 alloc,
@@ -904,38 +904,38 @@ fn SplitByteVector<
         return;
     } else if length < kMinLengthForBlockSplitting {
         {
-            if (*split).types_alloc_size() < split.num_blocks.wrapping_add(1) {
-                let mut _new_size: usize = if (*split).types_alloc_size() == 0usize {
+            if split.types_alloc_size() < split.num_blocks.wrapping_add(1) {
+                let mut _new_size: usize = if split.types_alloc_size() == 0usize {
                     split.num_blocks.wrapping_add(1)
                 } else {
-                    (*split).types_alloc_size()
+                    split.types_alloc_size()
                 };
 
                 while _new_size < split.num_blocks.wrapping_add(1) {
                     _new_size = _new_size.wrapping_mul(2);
                 }
                 let mut new_array = <Alloc as Allocator<u8>>::alloc_cell(alloc, _new_size);
-                new_array.slice_mut()[..(*split).types_alloc_size()]
-                    .clone_from_slice(&split.types.slice()[..(*split).types_alloc_size()]);
+                new_array.slice_mut()[..split.types_alloc_size()]
+                    .clone_from_slice(&split.types.slice()[..split.types_alloc_size()]);
                 <Alloc as Allocator<u8>>::free_cell(
                     alloc,
                     core::mem::replace(&mut split.types, new_array),
                 );
             }
         }
         {
-            if (*split).lengths_alloc_size() < split.num_blocks.wrapping_add(1) {
-                let mut _new_size: usize = if (*split).lengths_alloc_size() == 0usize {
+            if split.lengths_alloc_size() < split.num_blocks.wrapping_add(1) {
+                let mut _new_size: usize = if split.lengths_alloc_size() == 0usize {
                     split.num_blocks.wrapping_add(1)
                 } else {
-                    (*split).lengths_alloc_size()
+                    split.lengths_alloc_size()
                 };
                 while _new_size < split.num_blocks.wrapping_add(1) {
                     _new_size = _new_size.wrapping_mul(2);
                 }
                 let mut new_array = <Alloc as Allocator<u32>>::alloc_cell(alloc, _new_size);
-                new_array.slice_mut()[..(*split).lengths_alloc_size()]
-                    .clone_from_slice(&split.lengths.slice()[..(*split).lengths_alloc_size()]);
+                new_array.slice_mut()[..split.lengths_alloc_size()]
+                    .clone_from_slice(&split.lengths.slice()[..split.lengths_alloc_size()]);
                 <Alloc as Allocator<u32>>::free_cell(
                     alloc,
                     core::mem::replace(&mut split.lengths, new_array),

src/enc/bit_cost.rs

@@ -1900,7 +1900,7 @@ fn RunLengthCodeZeros(
         if v[i] != 0u32 {
             v[*out_size] = (v[i]).wrapping_add(*max_run_length_prefix);
             i = i.wrapping_add(1);
-            *out_size = (*out_size).wrapping_add(1);
+            *out_size = out_size.wrapping_add(1);
         } else {
             let mut reps: u32 = 1u32;
             let mut k: usize;
@@ -1917,7 +1917,7 @@ fn RunLengthCodeZeros(
                     let run_length_prefix: u32 = Log2FloorNonZero(reps as (u64));
                     let extra_bits: u32 = reps.wrapping_sub(1u32 << run_length_prefix);
                     v[*out_size] = run_length_prefix.wrapping_add(extra_bits << 9);
-                    *out_size = (*out_size).wrapping_add(1);
+                    *out_size = out_size.wrapping_add(1);
                     {
                         {
                             break;
@@ -1927,7 +1927,7 @@ fn RunLengthCodeZeros(
                     let extra_bits: u32 = (1u32 << max_prefix).wrapping_sub(1);
                     v[*out_size] = max_prefix.wrapping_add(extra_bits << 9);
                     reps = reps.wrapping_sub((2u32 << max_prefix).wrapping_sub(1));
-                    *out_size = (*out_size).wrapping_add(1);
+                    *out_size = out_size.wrapping_add(1);
                 }
             }
         }
@@ -2227,7 +2227,7 @@ fn CleanupBlockEncoder<Alloc: alloc::Allocator<u8> + alloc::Allocator<u16>>(
 }
 
 pub fn JumpToByteBoundary(storage_ix: &mut usize, storage: &mut [u8]) {
-    *storage_ix = (*storage_ix).wrapping_add(7u32 as usize) & !7u32 as usize;
+    *storage_ix = storage_ix.wrapping_add(7u32 as usize) & !7u32 as usize;
     storage[(*storage_ix >> 3)] = 0u8;
 }
 
@@ -3042,10 +3042,10 @@ pub fn BrotliStoreUncompressedMetaBlock<Cb, Alloc: BrotliAlloc>(
     JumpToByteBoundary(storage_ix, storage);
     let dst_start0 = (*storage_ix >> 3);
     storage[dst_start0..(dst_start0 + input0.len())].clone_from_slice(input0);
-    *storage_ix = (*storage_ix).wrapping_add(input0.len() << 3);
+    *storage_ix = storage_ix.wrapping_add(input0.len() << 3);
     let dst_start1 = (*storage_ix >> 3);
     storage[dst_start1..(dst_start1 + input1.len())].clone_from_slice(input1);
-    *storage_ix = (*storage_ix).wrapping_add(input1.len() << 3);
+    *storage_ix = storage_ix.wrapping_add(input1.len() << 3);
     BrotliWriteBitsPrepareStorage(*storage_ix, storage);
     if params.log_meta_block && !suppress_meta_block_logging {
         let cmds = [Command {

src/enc/block_splitter.rs

@@ -116,12 +116,12 @@ fn BrotliCompareAndPushToQueue<
                 /* Replace the top of the queue if needed. */
                 if *num_pairs < max_num_pairs {
                     pairs[*num_pairs] = pairs[0];
-                    *num_pairs = (*num_pairs).wrapping_add(1);
+                    *num_pairs = num_pairs.wrapping_add(1);
                 }
                 pairs[0] = p;
             } else if *num_pairs < max_num_pairs {
                 pairs[*num_pairs] = p;
-                *num_pairs = (*num_pairs).wrapping_add(1);
+                *num_pairs = num_pairs.wrapping_add(1);
             }
         }
     }
@@ -279,12 +279,12 @@ pub fn BrotliHistogramBitCostDistance<
     candidate: &HistogramType,
     scratch_space: &mut HistogramType::i32vec,
 ) -> super::util::floatX {
-    if (*histogram).total_count() == 0usize {
+    if histogram.total_count() == 0usize {
         0.0 as super::util::floatX
     } else {
         let mut tmp: HistogramType = histogram.clone();
         HistogramAddHistogram(&mut tmp, candidate);
-        BrotliPopulationCost(&tmp, scratch_space) - (*candidate).bit_cost()
+        BrotliPopulationCost(&tmp, scratch_space) - candidate.bit_cost()
     }
 }