Remove unused mutable refs

Author: teor2345

crates/subspace-service/src/sync_from_dsn.rs

@@ -307,10 +307,10 @@ where
     // right away.
     // TODO: implement starting from any segment index, and handle the partial block at the end of
     // the last segment.
-    let mut last_processed_segment_index = SegmentIndex::ZERO;
+    let last_processed_segment_index = SegmentIndex::ZERO;
     // TODO: We'll be able to just take finalized block once we are able to decouple pruning from
     //  finality: https://github.com/paritytech/polkadot-sdk/issues/1570
-    let mut last_processed_block_number = info.best_number;
+    let last_processed_block_number = info.best_number;
     let segment_header_downloader = SegmentHeaderDownloader::new(node);
 
     if let Some(reason) = notifications.next().await {
@@ -324,8 +324,8 @@ where
             client,
             piece_getter,
             import_queue_service,
-            &mut last_processed_segment_index,
-            &mut last_processed_block_number,
+            last_processed_segment_index,
+            last_processed_block_number,
             erasure_coding,
         );
         let wait_almost_synced_fut = async {

crates/subspace-service/src/sync_from_dsn/import_blocks.rs

@@ -35,8 +35,8 @@ pub(super) async fn import_blocks_from_dsn<Block, AS, Client, PG, IQS>(
     client: &Client,
     piece_getter: &PG,
     import_queue_service: &mut IQS,
-    last_processed_segment_index: &mut SegmentIndex,
-    last_processed_block_number: &mut <Block::Header as Header>::Number,
+    last_processed_segment_index: SegmentIndex,
+    mut last_processed_block_number: <Block::Header as Header>::Number,
     erasure_coding: &ErasureCoding,
 ) -> Result<u64, Error>
 where
@@ -70,7 +70,7 @@ where
     let mut imported_blocks = 0;
     let mut reconstructor = Arc::new(Mutex::new(Reconstructor::new(erasure_coding.clone())));
     // Start from the first unprocessed segment and process all segments known so far
-    let segment_indices_iter = (*last_processed_segment_index + SegmentIndex::ONE)
+    let segment_indices_iter = (last_processed_segment_index + SegmentIndex::ONE)
         ..=segment_headers_store
             .max_segment_index()
             .expect("Exists, we have inserted segment headers above; qed");
@@ -104,7 +104,7 @@ where
         // We have already processed the last block in this segment, or one higher than it,
         // so it can't change. Resetting the reconstructor loses any partial blocks, so we
         // only reset if the (possibly partial) last block has been processed.
-        if *last_processed_block_number >= last_archived_maybe_partial_block_number {
+        if last_processed_block_number >= last_archived_maybe_partial_block_number {
             debug!(
                 target: LOG_TARGET,
                 %segment_index,
@@ -113,14 +113,13 @@ where
                 %last_archived_block_partial,
                 "Already processed last (possibly partial) block in segment, resetting reconstructor",
             );
-            *last_processed_segment_index = segment_index;
             // Reset reconstructor instance
             reconstructor = Arc::new(Mutex::new(Reconstructor::new(erasure_coding.clone())));
             continue;
         }
         // Just one partial unprocessed block and this was the last segment available, so nothing to
         // import
-        if last_archived_maybe_partial_block_number == *last_processed_block_number + One::one()
+        if last_archived_maybe_partial_block_number == last_processed_block_number + One::one()
             && last_archived_block_partial
             && segment_indices_iter.peek().is_none()
         {
@@ -203,6 +202,7 @@ where
                 }
                 trace!(
                     target: LOG_TARGET,
+                    %segment_index,
                     %block_number,
                     %best_block_number,
                     %just_queued_blocks_count,
@@ -216,7 +216,7 @@ where
             let signed_block =
                 decode_block::<Block>(&block_bytes).map_err(|error| error.to_string())?;
 
-            *last_processed_block_number = block_number;
+            last_processed_block_number = block_number;
 
             // No need to import blocks that are already present, if block is not present it might
             // correspond to a short fork, so we need to import it even if we already have another
@@ -256,8 +256,6 @@ where
             // Import queue handles verification and importing it into the client
             import_queue_service.import_blocks(BlockOrigin::NetworkInitialSync, blocks_to_import);
         }
-
-        *last_processed_segment_index = segment_index;
     }
 
     Ok(imported_blocks)